4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include "pvrusb2-ioread.h"
22 #include "pvrusb2-debug.h"
23 #include <linux/errno.h>
24 #include <linux/string.h>
26 #include <linux/slab.h>
27 #include <linux/mutex.h>
28 #include <asm/uaccess.h>
30 #define BUFFER_COUNT 32
31 #define BUFFER_SIZE PAGE_ALIGN(0x4000)
34 struct pvr2_stream *stream;
35 char *buffer_storage[BUFFER_COUNT];
37 unsigned int sync_key_len;
38 unsigned int sync_buf_offs;
39 unsigned int sync_state;
40 unsigned int sync_trashed_count;
41 int enabled; // Streaming is on
42 int spigot_open; // OK to pass data to client
43 int stream_running; // Passing data to client now
45 /* State relevant to current buffer being read */
46 struct pvr2_buffer *c_buf;
48 unsigned int c_data_len;
49 unsigned int c_data_offs;
53 static int pvr2_ioread_init(struct pvr2_ioread *cp)
58 mutex_init(&cp->mutex);
60 for (idx = 0; idx < BUFFER_COUNT; idx++) {
61 cp->buffer_storage[idx] = kmalloc(BUFFER_SIZE,GFP_KERNEL);
62 if (!(cp->buffer_storage[idx])) break;
65 if (idx < BUFFER_COUNT) {
66 // An allocation appears to have failed
67 for (idx = 0; idx < BUFFER_COUNT; idx++) {
68 if (!(cp->buffer_storage[idx])) continue;
69 kfree(cp->buffer_storage[idx]);
76 static void pvr2_ioread_done(struct pvr2_ioread *cp)
80 pvr2_ioread_setup(cp,NULL);
81 for (idx = 0; idx < BUFFER_COUNT; idx++) {
82 if (!(cp->buffer_storage[idx])) continue;
83 kfree(cp->buffer_storage[idx]);
87 struct pvr2_ioread *pvr2_ioread_create(void)
89 struct pvr2_ioread *cp;
90 cp = kzalloc(sizeof(*cp),GFP_KERNEL);
92 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
93 if (pvr2_ioread_init(cp) < 0) {
100 void pvr2_ioread_destroy(struct pvr2_ioread *cp)
103 pvr2_ioread_done(cp);
104 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp);
105 if (cp->sync_key_ptr) {
106 kfree(cp->sync_key_ptr);
107 cp->sync_key_ptr = NULL;
112 void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp,
113 const char *sync_key_ptr,
114 unsigned int sync_key_len)
118 if (!sync_key_ptr) sync_key_len = 0;
119 if ((sync_key_len == cp->sync_key_len) &&
121 (!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return;
123 if (sync_key_len != cp->sync_key_len) {
124 if (cp->sync_key_ptr) {
125 kfree(cp->sync_key_ptr);
126 cp->sync_key_ptr = NULL;
128 cp->sync_key_len = 0;
130 cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL);
131 if (cp->sync_key_ptr) {
132 cp->sync_key_len = sync_key_len;
136 if (!cp->sync_key_len) return;
137 memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len);
140 static void pvr2_ioread_stop(struct pvr2_ioread *cp)
142 if (!(cp->enabled)) return;
143 pvr2_trace(PVR2_TRACE_START_STOP,
144 "/*---TRACE_READ---*/ pvr2_ioread_stop id=%p",cp);
145 pvr2_stream_kill(cp->stream);
147 cp->c_data_ptr = NULL;
151 cp->stream_running = 0;
153 if (cp->sync_state) {
154 pvr2_trace(PVR2_TRACE_DATA_FLOW,
155 "/*---TRACE_READ---*/ sync_state <== 0");
160 static int pvr2_ioread_start(struct pvr2_ioread *cp)
163 struct pvr2_buffer *bp;
164 if (cp->enabled) return 0;
165 if (!(cp->stream)) return 0;
166 pvr2_trace(PVR2_TRACE_START_STOP,
167 "/*---TRACE_READ---*/ pvr2_ioread_start id=%p",cp);
168 while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != NULL) {
169 stat = pvr2_buffer_queue(bp);
171 pvr2_trace(PVR2_TRACE_DATA_FLOW,
172 "/*---TRACE_READ---*/ pvr2_ioread_start id=%p error=%d",
174 pvr2_ioread_stop(cp);
180 cp->c_data_ptr = NULL;
183 cp->stream_running = 0;
184 if (cp->sync_key_len) {
185 pvr2_trace(PVR2_TRACE_DATA_FLOW,
186 "/*---TRACE_READ---*/ sync_state <== 1");
188 cp->sync_trashed_count = 0;
189 cp->sync_buf_offs = 0;
195 struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp)
200 int pvr2_ioread_setup(struct pvr2_ioread *cp,struct pvr2_stream *sp)
204 struct pvr2_buffer *bp;
206 mutex_lock(&cp->mutex);
209 pvr2_trace(PVR2_TRACE_START_STOP,
210 "/*---TRACE_READ---*/ pvr2_ioread_setup (tear-down) id=%p",
212 pvr2_ioread_stop(cp);
213 pvr2_stream_kill(cp->stream);
214 if (pvr2_stream_get_buffer_count(cp->stream)) {
215 pvr2_stream_set_buffer_count(cp->stream,0);
220 pvr2_trace(PVR2_TRACE_START_STOP,
221 "/*---TRACE_READ---*/ pvr2_ioread_setup (setup) id=%p",
223 pvr2_stream_kill(sp);
224 ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT);
226 mutex_unlock(&cp->mutex);
229 for (idx = 0; idx < BUFFER_COUNT; idx++) {
230 bp = pvr2_stream_get_buffer(sp,idx);
231 pvr2_buffer_set_buffer(bp,
232 cp->buffer_storage[idx],
238 mutex_unlock(&cp->mutex);
243 int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl)
246 if ((!fl) == (!(cp->enabled))) return ret;
248 mutex_lock(&cp->mutex);
251 ret = pvr2_ioread_start(cp);
253 pvr2_ioread_stop(cp);
256 mutex_unlock(&cp->mutex);
260 static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp)
264 while (cp->c_data_len <= cp->c_data_offs) {
266 // Flush out current buffer first.
267 stat = pvr2_buffer_queue(cp->c_buf);
269 // Streaming error...
270 pvr2_trace(PVR2_TRACE_DATA_FLOW,
271 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p queue_error=%d",
273 pvr2_ioread_stop(cp);
277 cp->c_data_ptr = NULL;
281 // Now get a freshly filled buffer.
282 cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream);
283 if (!cp->c_buf) break; // Nothing ready; done.
284 cp->c_data_len = pvr2_buffer_get_count(cp->c_buf);
285 if (!cp->c_data_len) {
286 // Nothing transferred. Was there an error?
287 stat = pvr2_buffer_get_status(cp->c_buf);
289 // Streaming error...
290 pvr2_trace(PVR2_TRACE_DATA_FLOW,
291 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p buffer_error=%d",
293 pvr2_ioread_stop(cp);
301 cp->c_data_ptr = cp->buffer_storage[
302 pvr2_buffer_get_id(cp->c_buf)];
307 static void pvr2_ioread_filter(struct pvr2_ioread *cp)
310 if (!cp->enabled) return;
311 if (cp->sync_state != 1) return;
313 // Search the stream for our synchronization key. This is made
314 // complicated by the fact that in order to be honest with
315 // ourselves here we must search across buffer boundaries...
316 mutex_lock(&cp->mutex);
318 // Ensure we have a buffer
319 if (!pvr2_ioread_get_buffer(cp)) break;
320 if (!cp->c_data_len) break;
322 // Now walk the buffer contents until we match the key or
323 // run out of buffer data.
324 for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) {
325 if (cp->sync_buf_offs >= cp->sync_key_len) break;
326 if (cp->c_data_ptr[idx] ==
327 cp->sync_key_ptr[cp->sync_buf_offs]) {
328 // Found the next key byte
329 (cp->sync_buf_offs)++;
331 // Whoops, mismatched. Start key over...
332 cp->sync_buf_offs = 0;
336 // Consume what we've walked through
337 cp->c_data_offs += idx;
338 cp->sync_trashed_count += idx;
340 // If we've found the key, then update state and get out.
341 if (cp->sync_buf_offs >= cp->sync_key_len) {
342 cp->sync_trashed_count -= cp->sync_key_len;
343 pvr2_trace(PVR2_TRACE_DATA_FLOW,
344 "/*---TRACE_READ---*/ sync_state <== 2 (skipped %u bytes)",
345 cp->sync_trashed_count);
347 cp->sync_buf_offs = 0;
351 if (cp->c_data_offs < cp->c_data_len) {
352 // Sanity check - should NEVER get here
353 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
354 "ERROR: pvr2_ioread filter sync problem len=%u offs=%u",
355 cp->c_data_len,cp->c_data_offs);
356 // Get out so we don't get stuck in an infinite
361 continue; // (for clarity)
363 mutex_unlock(&cp->mutex);
366 int pvr2_ioread_avail(struct pvr2_ioread *cp)
369 if (!(cp->enabled)) {
370 // Stream is not enabled; so this is an I/O error
374 if (cp->sync_state == 1) {
375 pvr2_ioread_filter(cp);
376 if (cp->sync_state == 1) return -EAGAIN;
380 if (cp->stream_running) {
381 if (!pvr2_stream_get_ready_count(cp->stream)) {
382 // No data available at all right now.
386 if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) {
387 // Haven't buffered up enough yet; try again later
392 if ((!(cp->spigot_open)) != (!(ret == 0))) {
393 cp->spigot_open = (ret == 0);
394 pvr2_trace(PVR2_TRACE_DATA_FLOW,
395 "/*---TRACE_READ---*/ data is %s",
396 cp->spigot_open ? "available" : "pending");
402 int pvr2_ioread_read(struct pvr2_ioread *cp,void __user *buf,unsigned int cnt)
404 unsigned int copied_cnt;
409 unsigned int req_cnt = cnt;
412 pvr2_trace(PVR2_TRACE_TRAP,
413 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p ZERO Request? Returning zero.",
418 stat = pvr2_ioread_avail(cp);
419 if (stat < 0) return stat;
421 cp->stream_running = !0;
423 mutex_lock(&cp->mutex);
426 // Suck data out of the buffers and copy to the user
430 if (!pvr2_ioread_get_buffer(cp)) {
437 if (cp->sync_state == 2) {
438 // We're repeating the sync key data into
440 src = cp->sync_key_ptr + cp->sync_buf_offs;
441 bcnt = cp->sync_key_len - cp->sync_buf_offs;
443 // Normal buffer copy
444 src = cp->c_data_ptr + cp->c_data_offs;
445 bcnt = cp->c_data_len - cp->c_data_offs;
450 // Don't run past user's buffer
451 if (bcnt > cnt) bcnt = cnt;
453 if (copy_to_user(buf,src,bcnt)) {
454 // User supplied a bad pointer?
455 // Give up - this *will* cause data
464 if (cp->sync_state == 2) {
465 // Update offset inside sync key that we're
466 // repeating back out.
467 cp->sync_buf_offs += bcnt;
468 if (cp->sync_buf_offs >= cp->sync_key_len) {
469 // Consumed entire key; switch mode
471 pvr2_trace(PVR2_TRACE_DATA_FLOW,
472 "/*---TRACE_READ---*/ sync_state <== 0");
476 // Update buffer offset.
477 cp->c_data_offs += bcnt;
482 mutex_unlock(&cp->mutex);
486 // If anything was copied, return that count
489 // Nothing copied; suggest to caller that another
490 // attempt should be tried again later
495 pvr2_trace(PVR2_TRACE_DATA_FLOW,
496 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p request=%d result=%d",