?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (4288): Clean out a zillion sparse warnings in pvrusb2
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / media / video / pvrusb2 / pvrusb2-ioread.c
blobf7a2e225a002543287f171d00a91589b0877bcb6
1 /*
2 *
3 * $Id$
4 *
5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22 #include "pvrusb2-ioread.h"
23 #include "pvrusb2-debug.h"
24 #include <linux/errno.h>
25 #include <linux/string.h>
26 #include <linux/slab.h>
27 #include <linux/mutex.h>
28 #include <asm/uaccess.h>
29
30 #define BUFFER_COUNT 32
31 #define BUFFER_SIZE PAGE_ALIGN(0x4000)
32
33 struct pvr2_ioread {
34 struct pvr2_stream *stream;
35 char *buffer_storage[BUFFER_COUNT];
36 char *sync_key_ptr;
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
44
45 /* State relevant to current buffer being read */
46 struct pvr2_buffer *c_buf;
47 char *c_data_ptr;
48 unsigned int c_data_len;
49 unsigned int c_data_offs;
50 struct mutex mutex;
51 };
52
53 static int pvr2_ioread_init(struct pvr2_ioread *cp)
54 {
55 unsigned int idx;
56
57 cp->stream = NULL;
58 mutex_init(&cp->mutex);
59
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;
63 }
64
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]);
70 }
71 return -ENOMEM;
72 }
73 return 0;
74 }
75
76 static void pvr2_ioread_done(struct pvr2_ioread *cp)
77 {
78 unsigned int idx;
79
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]);
84 }
85 }
86
87 struct pvr2_ioread *pvr2_ioread_create(void)
88 {
89 struct pvr2_ioread *cp;
90 cp = kmalloc(sizeof(*cp),GFP_KERNEL);
91 if (!cp) return NULL;
92 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_create id=%p",cp);
93 memset(cp,0,sizeof(*cp));
94 if (pvr2_ioread_init(cp) < 0) {
95 kfree(cp);
96 return NULL;
97 }
98 return cp;
99 }
100
101 void pvr2_ioread_destroy(struct pvr2_ioread *cp)
102 {
103 if (!cp) return;
104 pvr2_ioread_done(cp);
105 pvr2_trace(PVR2_TRACE_STRUCT,"pvr2_ioread_destroy id=%p",cp);
106 if (cp->sync_key_ptr) {
107 kfree(cp->sync_key_ptr);
108 cp->sync_key_ptr = NULL;
109 }
110 kfree(cp);
111 }
112
113 void pvr2_ioread_set_sync_key(struct pvr2_ioread *cp,
114 const char *sync_key_ptr,
115 unsigned int sync_key_len)
116 {
117 if (!cp) return;
118
119 if (!sync_key_ptr) sync_key_len = 0;
120 if ((sync_key_len == cp->sync_key_len) &&
121 ((!sync_key_len) ||
122 (!memcmp(sync_key_ptr,cp->sync_key_ptr,sync_key_len)))) return;
123
124 if (sync_key_len != cp->sync_key_len) {
125 if (cp->sync_key_ptr) {
126 kfree(cp->sync_key_ptr);
127 cp->sync_key_ptr = NULL;
128 }
129 cp->sync_key_len = 0;
130 if (sync_key_len) {
131 cp->sync_key_ptr = kmalloc(sync_key_len,GFP_KERNEL);
132 if (cp->sync_key_ptr) {
133 cp->sync_key_len = sync_key_len;
134 }
135 }
136 }
137 if (!cp->sync_key_len) return;
138 memcpy(cp->sync_key_ptr,sync_key_ptr,cp->sync_key_len);
139 }
140
141 static void pvr2_ioread_stop(struct pvr2_ioread *cp)
142 {
143 if (!(cp->enabled)) return;
144 pvr2_trace(PVR2_TRACE_START_STOP,
145 "/*---TRACE_READ---*/ pvr2_ioread_stop id=%p",cp);
146 pvr2_stream_kill(cp->stream);
147 cp->c_buf = NULL;
148 cp->c_data_ptr = NULL;
149 cp->c_data_len = 0;
150 cp->c_data_offs = 0;
151 cp->enabled = 0;
152 cp->stream_running = 0;
153 cp->spigot_open = 0;
154 if (cp->sync_state) {
155 pvr2_trace(PVR2_TRACE_DATA_FLOW,
156 "/*---TRACE_READ---*/ sync_state <== 0");
157 cp->sync_state = 0;
158 }
159 }
160
161 static int pvr2_ioread_start(struct pvr2_ioread *cp)
162 {
163 int stat;
164 struct pvr2_buffer *bp;
165 if (cp->enabled) return 0;
166 if (!(cp->stream)) return 0;
167 pvr2_trace(PVR2_TRACE_START_STOP,
168 "/*---TRACE_READ---*/ pvr2_ioread_start id=%p",cp);
169 while ((bp = pvr2_stream_get_idle_buffer(cp->stream)) != 0) {
170 stat = pvr2_buffer_queue(bp);
171 if (stat < 0) {
172 pvr2_trace(PVR2_TRACE_DATA_FLOW,
173 "/*---TRACE_READ---*/"
174 " pvr2_ioread_start id=%p"
175 " error=%d",
176 cp,stat);
177 pvr2_ioread_stop(cp);
178 return stat;
179 }
180 }
181 cp->enabled = !0;
182 cp->c_buf = NULL;
183 cp->c_data_ptr = NULL;
184 cp->c_data_len = 0;
185 cp->c_data_offs = 0;
186 cp->stream_running = 0;
187 if (cp->sync_key_len) {
188 pvr2_trace(PVR2_TRACE_DATA_FLOW,
189 "/*---TRACE_READ---*/ sync_state <== 1");
190 cp->sync_state = 1;
191 cp->sync_trashed_count = 0;
192 cp->sync_buf_offs = 0;
193 }
194 cp->spigot_open = 0;
195 return 0;
196 }
197
198 struct pvr2_stream *pvr2_ioread_get_stream(struct pvr2_ioread *cp)
199 {
200 return cp->stream;
201 }
202
203 int pvr2_ioread_setup(struct pvr2_ioread *cp,struct pvr2_stream *sp)
204 {
205 int ret;
206 unsigned int idx;
207 struct pvr2_buffer *bp;
208
209 mutex_lock(&cp->mutex); do {
210 if (cp->stream) {
211 pvr2_trace(PVR2_TRACE_START_STOP,
212 "/*---TRACE_READ---*/"
213 " pvr2_ioread_setup (tear-down) id=%p",cp);
214 pvr2_ioread_stop(cp);
215 pvr2_stream_kill(cp->stream);
216 pvr2_stream_set_buffer_count(cp->stream,0);
217 cp->stream = NULL;
218 }
219 if (sp) {
220 pvr2_trace(PVR2_TRACE_START_STOP,
221 "/*---TRACE_READ---*/"
222 " pvr2_ioread_setup (setup) id=%p",cp);
223 pvr2_stream_kill(sp);
224 ret = pvr2_stream_set_buffer_count(sp,BUFFER_COUNT);
225 if (ret < 0) return ret;
226 for (idx = 0; idx < BUFFER_COUNT; idx++) {
227 bp = pvr2_stream_get_buffer(sp,idx);
228 pvr2_buffer_set_buffer(bp,
229 cp->buffer_storage[idx],
230 BUFFER_SIZE);
231 }
232 cp->stream = sp;
233 }
234 } while (0); mutex_unlock(&cp->mutex);
235
236 return 0;
237 }
238
239 int pvr2_ioread_set_enabled(struct pvr2_ioread *cp,int fl)
240 {
241 int ret = 0;
242 if ((!fl) == (!(cp->enabled))) return ret;
243
244 mutex_lock(&cp->mutex); do {
245 if (fl) {
246 ret = pvr2_ioread_start(cp);
247 } else {
248 pvr2_ioread_stop(cp);
249 }
250 } while (0); mutex_unlock(&cp->mutex);
251 return ret;
252 }
253
254
255 static int pvr2_ioread_get_buffer(struct pvr2_ioread *cp)
256 {
257 int stat;
258
259 while (cp->c_data_len <= cp->c_data_offs) {
260 if (cp->c_buf) {
261 // Flush out current buffer first.
262 stat = pvr2_buffer_queue(cp->c_buf);
263 if (stat < 0) {
264 // Streaming error...
265 pvr2_trace(PVR2_TRACE_DATA_FLOW,
266 "/*---TRACE_READ---*/"
267 " pvr2_ioread_read id=%p"
268 " queue_error=%d",
269 cp,stat);
270 pvr2_ioread_stop(cp);
271 return 0;
272 }
273 cp->c_buf = NULL;
274 cp->c_data_ptr = NULL;
275 cp->c_data_len = 0;
276 cp->c_data_offs = 0;
277 }
278 // Now get a freshly filled buffer.
279 cp->c_buf = pvr2_stream_get_ready_buffer(cp->stream);
280 if (!cp->c_buf) break; // Nothing ready; done.
281 cp->c_data_len = pvr2_buffer_get_count(cp->c_buf);
282 if (!cp->c_data_len) {
283 // Nothing transferred. Was there an error?
284 stat = pvr2_buffer_get_status(cp->c_buf);
285 if (stat < 0) {
286 // Streaming error...
287 pvr2_trace(PVR2_TRACE_DATA_FLOW,
288 "/*---TRACE_READ---*/"
289 " pvr2_ioread_read id=%p"
290 " buffer_error=%d",
291 cp,stat);
292 pvr2_ioread_stop(cp);
293 // Give up.
294 return 0;
295 }
296 // Start over...
297 continue;
298 }
299 cp->c_data_offs = 0;
300 cp->c_data_ptr = cp->buffer_storage[
301 pvr2_buffer_get_id(cp->c_buf)];
302 }
303 return !0;
304 }
305
306 static void pvr2_ioread_filter(struct pvr2_ioread *cp)
307 {
308 unsigned int idx;
309 if (!cp->enabled) return;
310 if (cp->sync_state != 1) return;
311
312 // Search the stream for our synchronization key. This is made
313 // complicated by the fact that in order to be honest with
314 // ourselves here we must search across buffer boundaries...
315 mutex_lock(&cp->mutex); while (1) {
316 // Ensure we have a buffer
317 if (!pvr2_ioread_get_buffer(cp)) break;
318 if (!cp->c_data_len) break;
319
320 // Now walk the buffer contents until we match the key or
321 // run out of buffer data.
322 for (idx = cp->c_data_offs; idx < cp->c_data_len; idx++) {
323 if (cp->sync_buf_offs >= cp->sync_key_len) break;
324 if (cp->c_data_ptr[idx] ==
325 cp->sync_key_ptr[cp->sync_buf_offs]) {
326 // Found the next key byte
327 (cp->sync_buf_offs)++;
328 } else {
329 // Whoops, mismatched. Start key over...
330 cp->sync_buf_offs = 0;
331 }
332 }
333
334 // Consume what we've walked through
335 cp->c_data_offs += idx;
336 cp->sync_trashed_count += idx;
337
338 // If we've found the key, then update state and get out.
339 if (cp->sync_buf_offs >= cp->sync_key_len) {
340 cp->sync_trashed_count -= cp->sync_key_len;
341 pvr2_trace(PVR2_TRACE_DATA_FLOW,
342 "/*---TRACE_READ---*/"
343 " sync_state <== 2 (skipped %u bytes)",
344 cp->sync_trashed_count);
345 cp->sync_state = 2;
346 cp->sync_buf_offs = 0;
347 break;
348 }
349
350 if (cp->c_data_offs < cp->c_data_len) {
351 // Sanity check - should NEVER get here
352 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
353 "ERROR: pvr2_ioread filter sync problem"
354 " 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
357 // loop.
358 break;
359 }
360
361 continue; // (for clarity)
362 } mutex_unlock(&cp->mutex);
363 }
364
365 int pvr2_ioread_avail(struct pvr2_ioread *cp)
366 {
367 int ret;
368 if (!(cp->enabled)) {
369 // Stream is not enabled; so this is an I/O error
370 return -EIO;
371 }
372
373 if (cp->sync_state == 1) {
374 pvr2_ioread_filter(cp);
375 if (cp->sync_state == 1) return -EAGAIN;
376 }
377
378 ret = 0;
379 if (cp->stream_running) {
380 if (!pvr2_stream_get_ready_count(cp->stream)) {
381 // No data available at all right now.
382 ret = -EAGAIN;
383 }
384 } else {
385 if (pvr2_stream_get_ready_count(cp->stream) < BUFFER_COUNT/2) {
386 // Haven't buffered up enough yet; try again later
387 ret = -EAGAIN;
388 }
389 }
390
391 if ((!(cp->spigot_open)) != (!(ret == 0))) {
392 cp->spigot_open = (ret == 0);
393 pvr2_trace(PVR2_TRACE_DATA_FLOW,
394 "/*---TRACE_READ---*/ data is %s",
395 cp->spigot_open ? "available" : "pending");
396 }
397
398 return ret;
399 }
400
401 int pvr2_ioread_read(struct pvr2_ioread *cp,void __user *buf,unsigned int cnt)
402 {
403 unsigned int copied_cnt;
404 unsigned int bcnt;
405 const char *src;
406 int stat;
407 int ret = 0;
408 unsigned int req_cnt = cnt;
409
410 if (!cnt) {
411 pvr2_trace(PVR2_TRACE_TRAP,
412 "/*---TRACE_READ---*/ pvr2_ioread_read id=%p"
413 " ZERO Request? Returning zero.",cp);
414 return 0;
415 }
416
417 stat = pvr2_ioread_avail(cp);
418 if (stat < 0) return stat;
419
420 cp->stream_running = !0;
421
422 mutex_lock(&cp->mutex); do {
423
424 // Suck data out of the buffers and copy to the user
425 copied_cnt = 0;
426 if (!buf) cnt = 0;
427 while (1) {
428 if (!pvr2_ioread_get_buffer(cp)) {
429 ret = -EIO;
430 break;
431 }
432
433 if (!cnt) break;
434
435 if (cp->sync_state == 2) {
436 // We're repeating the sync key data into
437 // the stream.
438 src = cp->sync_key_ptr + cp->sync_buf_offs;
439 bcnt = cp->sync_key_len - cp->sync_buf_offs;
440 } else {
441 // Normal buffer copy
442 src = cp->c_data_ptr + cp->c_data_offs;
443 bcnt = cp->c_data_len - cp->c_data_offs;
444 }
445
446 if (!bcnt) break;
447
448 // Don't run past user's buffer
449 if (bcnt > cnt) bcnt = cnt;
450
451 if (copy_to_user(buf,src,bcnt)) {
452 // User supplied a bad pointer?
453 // Give up - this *will* cause data
454 // to be lost.
455 ret = -EFAULT;
456 break;
457 }
458 cnt -= bcnt;
459 buf += bcnt;
460 copied_cnt += bcnt;
461
462 if (cp->sync_state == 2) {
463 // Update offset inside sync key that we're
464 // repeating back out.
465 cp->sync_buf_offs += bcnt;
466 if (cp->sync_buf_offs >= cp->sync_key_len) {
467 // Consumed entire key; switch mode
468 // to normal.
469 pvr2_trace(PVR2_TRACE_DATA_FLOW,
470 "/*---TRACE_READ---*/"
471 " sync_state <== 0");
472 cp->sync_state = 0;
473 }
474 } else {
475 // Update buffer offset.
476 cp->c_data_offs += bcnt;
477 }
478 }
479
480 } while (0); mutex_unlock(&cp->mutex);
481
482 if (!ret) {
483 if (copied_cnt) {
484 // If anything was copied, return that count
485 ret = copied_cnt;
486 } else {
487 // Nothing copied; suggest to caller that another
488 // attempt should be tried again later
489 ret = -EAGAIN;
490 }
491 }
492
493 pvr2_trace(PVR2_TRACE_DATA_FLOW,
494 "/*---TRACE_READ---*/ pvr2_ioread_read"
495 " id=%p request=%d result=%d",
496 cp,req_cnt,ret);
497 return ret;
498 }
499
500
501 /*
502 Stuff for Emacs to see, in order to encourage consistent editing style:
503 *** Local Variables: ***
504 *** mode: c ***
505 *** fill-column: 75 ***
506 *** tab-width: 8 ***
507 *** c-basic-offset: 8 ***
508 *** End: ***
509 */
Community contributions to the Openmoko Kernel