?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / media / usb / pvrusb2 / pvrusb2-io.c
blob6d153fc23ec2e14b98d5e1bbb6f88ff94913f178
1 /*
2 *
3 *
4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
5 *
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
9 *
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.
14 *
15 */
16
17 #include "pvrusb2-io.h"
18 #include "pvrusb2-debug.h"
19 #include <linux/errno.h>
20 #include <linux/string.h>
21 #include <linux/slab.h>
22 #include <linux/mutex.h>
23
24 static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state);
25
26 #define BUFFER_SIG 0x47653271
27
28 // #define SANITY_CHECK_BUFFERS
29
30
31 #ifdef SANITY_CHECK_BUFFERS
32 #define BUFFER_CHECK(bp) do { \
33 if ((bp)->signature != BUFFER_SIG) { \
34 pvr2_trace(PVR2_TRACE_ERROR_LEGS, \
35 "Buffer %p is bad at %s:%d", \
36 (bp), __FILE__, __LINE__); \
37 pvr2_buffer_describe(bp, "BadSig"); \
38 BUG(); \
39 } \
40 } while (0)
41 #else
42 #define BUFFER_CHECK(bp) do {} while (0)
43 #endif
44
45 struct pvr2_stream {
46 /* Buffers queued for reading */
47 struct list_head queued_list;
48 unsigned int q_count;
49 unsigned int q_bcount;
50 /* Buffers with retrieved data */
51 struct list_head ready_list;
52 unsigned int r_count;
53 unsigned int r_bcount;
54 /* Buffers available for use */
55 struct list_head idle_list;
56 unsigned int i_count;
57 unsigned int i_bcount;
58 /* Pointers to all buffers */
59 struct pvr2_buffer **buffers;
60 /* Array size of buffers */
61 unsigned int buffer_slot_count;
62 /* Total buffers actually in circulation */
63 unsigned int buffer_total_count;
64 /* Designed number of buffers to be in circulation */
65 unsigned int buffer_target_count;
66 /* Executed when ready list become non-empty */
67 pvr2_stream_callback callback_func;
68 void *callback_data;
69 /* Context for transfer endpoint */
70 struct usb_device *dev;
71 int endpoint;
72 /* Overhead for mutex enforcement */
73 spinlock_t list_lock;
74 struct mutex mutex;
75 /* Tracking state for tolerating errors */
76 unsigned int fail_count;
77 unsigned int fail_tolerance;
78
79 unsigned int buffers_processed;
80 unsigned int buffers_failed;
81 unsigned int bytes_processed;
82 };
83
84 struct pvr2_buffer {
85 int id;
86 int signature;
87 enum pvr2_buffer_state state;
88 void *ptr; /* Pointer to storage area */
89 unsigned int max_count; /* Size of storage area */
90 unsigned int used_count; /* Amount of valid data in storage area */
91 int status; /* Transfer result status */
92 struct pvr2_stream *stream;
93 struct list_head list_overhead;
94 struct urb *purb;
95 };
96
97 static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state st)
98 {
99 switch (st) {
100 case pvr2_buffer_state_none: return "none";
101 case pvr2_buffer_state_idle: return "idle";
102 case pvr2_buffer_state_queued: return "queued";
103 case pvr2_buffer_state_ready: return "ready";
104 }
105 return "unknown";
106 }
107
108 #ifdef SANITY_CHECK_BUFFERS
109 static void pvr2_buffer_describe(struct pvr2_buffer *bp, const char *msg)
110 {
111 pvr2_trace(PVR2_TRACE_INFO,
112 "buffer%s%s %p state=%s id=%d status=%d stream=%p purb=%p sig=0x%x",
113 (msg ? " " : ""),
114 (msg ? msg : ""),
115 bp,
116 (bp ? pvr2_buffer_state_decode(bp->state) : "(invalid)"),
117 (bp ? bp->id : 0),
118 (bp ? bp->status : 0),
119 (bp ? bp->stream : NULL),
120 (bp ? bp->purb : NULL),
121 (bp ? bp->signature : 0));
122 }
123 #endif /* SANITY_CHECK_BUFFERS */
124
125 static void pvr2_buffer_remove(struct pvr2_buffer *bp)
126 {
127 unsigned int *cnt;
128 unsigned int *bcnt;
129 unsigned int ccnt;
130 struct pvr2_stream *sp = bp->stream;
131 switch (bp->state) {
132 case pvr2_buffer_state_idle:
133 cnt = &sp->i_count;
134 bcnt = &sp->i_bcount;
135 ccnt = bp->max_count;
136 break;
137 case pvr2_buffer_state_queued:
138 cnt = &sp->q_count;
139 bcnt = &sp->q_bcount;
140 ccnt = bp->max_count;
141 break;
142 case pvr2_buffer_state_ready:
143 cnt = &sp->r_count;
144 bcnt = &sp->r_bcount;
145 ccnt = bp->used_count;
146 break;
147 default:
148 return;
149 }
150 list_del_init(&bp->list_overhead);
151 (*cnt)--;
152 (*bcnt) -= ccnt;
153 pvr2_trace(PVR2_TRACE_BUF_FLOW,
154 "/*---TRACE_FLOW---*/ bufferPool %8s dec cap=%07d cnt=%02d",
155 pvr2_buffer_state_decode(bp->state), *bcnt, *cnt);
156 bp->state = pvr2_buffer_state_none;
157 }
158
159 static void pvr2_buffer_set_none(struct pvr2_buffer *bp)
160 {
161 unsigned long irq_flags;
162 struct pvr2_stream *sp;
163 BUFFER_CHECK(bp);
164 sp = bp->stream;
165 pvr2_trace(PVR2_TRACE_BUF_FLOW,
166 "/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
167 bp,
168 pvr2_buffer_state_decode(bp->state),
169 pvr2_buffer_state_decode(pvr2_buffer_state_none));
170 spin_lock_irqsave(&sp->list_lock, irq_flags);
171 pvr2_buffer_remove(bp);
172 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
173 }
174
175 static int pvr2_buffer_set_ready(struct pvr2_buffer *bp)
176 {
177 int fl;
178 unsigned long irq_flags;
179 struct pvr2_stream *sp;
180 BUFFER_CHECK(bp);
181 sp = bp->stream;
182 pvr2_trace(PVR2_TRACE_BUF_FLOW,
183 "/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
184 bp,
185 pvr2_buffer_state_decode(bp->state),
186 pvr2_buffer_state_decode(pvr2_buffer_state_ready));
187 spin_lock_irqsave(&sp->list_lock, irq_flags);
188 fl = (sp->r_count == 0);
189 pvr2_buffer_remove(bp);
190 list_add_tail(&bp->list_overhead, &sp->ready_list);
191 bp->state = pvr2_buffer_state_ready;
192 (sp->r_count)++;
193 sp->r_bcount += bp->used_count;
194 pvr2_trace(PVR2_TRACE_BUF_FLOW,
195 "/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
196 pvr2_buffer_state_decode(bp->state),
197 sp->r_bcount, sp->r_count);
198 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
199 return fl;
200 }
201
202 static void pvr2_buffer_set_idle(struct pvr2_buffer *bp)
203 {
204 unsigned long irq_flags;
205 struct pvr2_stream *sp;
206 BUFFER_CHECK(bp);
207 sp = bp->stream;
208 pvr2_trace(PVR2_TRACE_BUF_FLOW,
209 "/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
210 bp,
211 pvr2_buffer_state_decode(bp->state),
212 pvr2_buffer_state_decode(pvr2_buffer_state_idle));
213 spin_lock_irqsave(&sp->list_lock, irq_flags);
214 pvr2_buffer_remove(bp);
215 list_add_tail(&bp->list_overhead, &sp->idle_list);
216 bp->state = pvr2_buffer_state_idle;
217 (sp->i_count)++;
218 sp->i_bcount += bp->max_count;
219 pvr2_trace(PVR2_TRACE_BUF_FLOW,
220 "/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
221 pvr2_buffer_state_decode(bp->state),
222 sp->i_bcount, sp->i_count);
223 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
224 }
225
226 static void pvr2_buffer_set_queued(struct pvr2_buffer *bp)
227 {
228 unsigned long irq_flags;
229 struct pvr2_stream *sp;
230 BUFFER_CHECK(bp);
231 sp = bp->stream;
232 pvr2_trace(PVR2_TRACE_BUF_FLOW,
233 "/*---TRACE_FLOW---*/ bufferState %p %6s --> %6s",
234 bp,
235 pvr2_buffer_state_decode(bp->state),
236 pvr2_buffer_state_decode(pvr2_buffer_state_queued));
237 spin_lock_irqsave(&sp->list_lock, irq_flags);
238 pvr2_buffer_remove(bp);
239 list_add_tail(&bp->list_overhead, &sp->queued_list);
240 bp->state = pvr2_buffer_state_queued;
241 (sp->q_count)++;
242 sp->q_bcount += bp->max_count;
243 pvr2_trace(PVR2_TRACE_BUF_FLOW,
244 "/*---TRACE_FLOW---*/ bufferPool %8s inc cap=%07d cnt=%02d",
245 pvr2_buffer_state_decode(bp->state),
246 sp->q_bcount, sp->q_count);
247 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
248 }
249
250 static void pvr2_buffer_wipe(struct pvr2_buffer *bp)
251 {
252 if (bp->state == pvr2_buffer_state_queued) {
253 usb_kill_urb(bp->purb);
254 }
255 }
256
257 static int pvr2_buffer_init(struct pvr2_buffer *bp,
258 struct pvr2_stream *sp,
259 unsigned int id)
260 {
261 memset(bp, 0, sizeof(*bp));
262 bp->signature = BUFFER_SIG;
263 bp->id = id;
264 pvr2_trace(PVR2_TRACE_BUF_POOL,
265 "/*---TRACE_FLOW---*/ bufferInit %p stream=%p", bp, sp);
266 bp->stream = sp;
267 bp->state = pvr2_buffer_state_none;
268 INIT_LIST_HEAD(&bp->list_overhead);
269 bp->purb = usb_alloc_urb(0, GFP_KERNEL);
270 if (! bp->purb) return -ENOMEM;
271 #ifdef SANITY_CHECK_BUFFERS
272 pvr2_buffer_describe(bp, "create");
273 #endif
274 return 0;
275 }
276
277 static void pvr2_buffer_done(struct pvr2_buffer *bp)
278 {
279 #ifdef SANITY_CHECK_BUFFERS
280 pvr2_buffer_describe(bp, "delete");
281 #endif
282 pvr2_buffer_wipe(bp);
283 pvr2_buffer_set_none(bp);
284 bp->signature = 0;
285 bp->stream = NULL;
286 usb_free_urb(bp->purb);
287 pvr2_trace(PVR2_TRACE_BUF_POOL, "/*---TRACE_FLOW---*/ bufferDone %p",
288 bp);
289 }
290
291 static int pvr2_stream_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
292 {
293 int ret;
294 unsigned int scnt;
295
296 /* Allocate buffers pointer array in multiples of 32 entries */
297 if (cnt == sp->buffer_total_count) return 0;
298
299 pvr2_trace(PVR2_TRACE_BUF_POOL,
300 "/*---TRACE_FLOW---*/ poolResize stream=%p cur=%d adj=%+d",
301 sp,
302 sp->buffer_total_count,
303 cnt-sp->buffer_total_count);
304
305 scnt = cnt & ~0x1f;
306 if (cnt > scnt) scnt += 0x20;
307
308 if (cnt > sp->buffer_total_count) {
309 if (scnt > sp->buffer_slot_count) {
310 struct pvr2_buffer **nb;
311
312 nb = kmalloc_array(scnt, sizeof(*nb), GFP_KERNEL);
313 if (!nb) return -ENOMEM;
314 if (sp->buffer_slot_count) {
315 memcpy(nb, sp->buffers,
316 sp->buffer_slot_count * sizeof(*nb));
317 kfree(sp->buffers);
318 }
319 sp->buffers = nb;
320 sp->buffer_slot_count = scnt;
321 }
322 while (sp->buffer_total_count < cnt) {
323 struct pvr2_buffer *bp;
324 bp = kmalloc(sizeof(*bp), GFP_KERNEL);
325 if (!bp) return -ENOMEM;
326 ret = pvr2_buffer_init(bp, sp, sp->buffer_total_count);
327 if (ret) {
328 kfree(bp);
329 return -ENOMEM;
330 }
331 sp->buffers[sp->buffer_total_count] = bp;
332 (sp->buffer_total_count)++;
333 pvr2_buffer_set_idle(bp);
334 }
335 } else {
336 while (sp->buffer_total_count > cnt) {
337 struct pvr2_buffer *bp;
338 bp = sp->buffers[sp->buffer_total_count - 1];
339 /* Paranoia */
340 sp->buffers[sp->buffer_total_count - 1] = NULL;
341 (sp->buffer_total_count)--;
342 pvr2_buffer_done(bp);
343 kfree(bp);
344 }
345 if (scnt < sp->buffer_slot_count) {
346 struct pvr2_buffer **nb = NULL;
347 if (scnt) {
348 nb = kmemdup(sp->buffers, scnt * sizeof(*nb),
349 GFP_KERNEL);
350 if (!nb) return -ENOMEM;
351 }
352 kfree(sp->buffers);
353 sp->buffers = nb;
354 sp->buffer_slot_count = scnt;
355 }
356 }
357 return 0;
358 }
359
360 static int pvr2_stream_achieve_buffer_count(struct pvr2_stream *sp)
361 {
362 struct pvr2_buffer *bp;
363 unsigned int cnt;
364
365 if (sp->buffer_total_count == sp->buffer_target_count) return 0;
366
367 pvr2_trace(PVR2_TRACE_BUF_POOL,
368 "/*---TRACE_FLOW---*/ poolCheck stream=%p cur=%d tgt=%d",
369 sp, sp->buffer_total_count, sp->buffer_target_count);
370
371 if (sp->buffer_total_count < sp->buffer_target_count) {
372 return pvr2_stream_buffer_count(sp, sp->buffer_target_count);
373 }
374
375 cnt = 0;
376 while ((sp->buffer_total_count - cnt) > sp->buffer_target_count) {
377 bp = sp->buffers[sp->buffer_total_count - (cnt + 1)];
378 if (bp->state != pvr2_buffer_state_idle) break;
379 cnt++;
380 }
381 if (cnt) {
382 pvr2_stream_buffer_count(sp, sp->buffer_total_count - cnt);
383 }
384
385 return 0;
386 }
387
388 static void pvr2_stream_internal_flush(struct pvr2_stream *sp)
389 {
390 struct list_head *lp;
391 struct pvr2_buffer *bp1;
392 while ((lp = sp->queued_list.next) != &sp->queued_list) {
393 bp1 = list_entry(lp, struct pvr2_buffer, list_overhead);
394 pvr2_buffer_wipe(bp1);
395 /* At this point, we should be guaranteed that no
396 completion callback may happen on this buffer. But it's
397 possible that it might have completed after we noticed
398 it but before we wiped it. So double check its status
399 here first. */
400 if (bp1->state != pvr2_buffer_state_queued) continue;
401 pvr2_buffer_set_idle(bp1);
402 }
403 if (sp->buffer_total_count != sp->buffer_target_count) {
404 pvr2_stream_achieve_buffer_count(sp);
405 }
406 }
407
408 static void pvr2_stream_init(struct pvr2_stream *sp)
409 {
410 spin_lock_init(&sp->list_lock);
411 mutex_init(&sp->mutex);
412 INIT_LIST_HEAD(&sp->queued_list);
413 INIT_LIST_HEAD(&sp->ready_list);
414 INIT_LIST_HEAD(&sp->idle_list);
415 }
416
417 static void pvr2_stream_done(struct pvr2_stream *sp)
418 {
419 mutex_lock(&sp->mutex); do {
420 pvr2_stream_internal_flush(sp);
421 pvr2_stream_buffer_count(sp, 0);
422 } while (0); mutex_unlock(&sp->mutex);
423 }
424
425 static void buffer_complete(struct urb *urb)
426 {
427 struct pvr2_buffer *bp = urb->context;
428 struct pvr2_stream *sp;
429 unsigned long irq_flags;
430 BUFFER_CHECK(bp);
431 sp = bp->stream;
432 bp->used_count = 0;
433 bp->status = 0;
434 pvr2_trace(PVR2_TRACE_BUF_FLOW,
435 "/*---TRACE_FLOW---*/ bufferComplete %p stat=%d cnt=%d",
436 bp, urb->status, urb->actual_length);
437 spin_lock_irqsave(&sp->list_lock, irq_flags);
438 if ((!(urb->status)) ||
439 (urb->status == -ENOENT) ||
440 (urb->status == -ECONNRESET) ||
441 (urb->status == -ESHUTDOWN)) {
442 (sp->buffers_processed)++;
443 sp->bytes_processed += urb->actual_length;
444 bp->used_count = urb->actual_length;
445 if (sp->fail_count) {
446 pvr2_trace(PVR2_TRACE_TOLERANCE,
447 "stream %p transfer ok - fail count reset",
448 sp);
449 sp->fail_count = 0;
450 }
451 } else if (sp->fail_count < sp->fail_tolerance) {
452 // We can tolerate this error, because we're below the
453 // threshold...
454 (sp->fail_count)++;
455 (sp->buffers_failed)++;
456 pvr2_trace(PVR2_TRACE_TOLERANCE,
457 "stream %p ignoring error %d - fail count increased to %u",
458 sp, urb->status, sp->fail_count);
459 } else {
460 (sp->buffers_failed)++;
461 bp->status = urb->status;
462 }
463 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
464 pvr2_buffer_set_ready(bp);
465 if (sp->callback_func) {
466 sp->callback_func(sp->callback_data);
467 }
468 }
469
470 struct pvr2_stream *pvr2_stream_create(void)
471 {
472 struct pvr2_stream *sp;
473 sp = kzalloc(sizeof(*sp), GFP_KERNEL);
474 if (!sp) return sp;
475 pvr2_trace(PVR2_TRACE_INIT, "pvr2_stream_create: sp=%p", sp);
476 pvr2_stream_init(sp);
477 return sp;
478 }
479
480 void pvr2_stream_destroy(struct pvr2_stream *sp)
481 {
482 if (!sp) return;
483 pvr2_trace(PVR2_TRACE_INIT, "pvr2_stream_destroy: sp=%p", sp);
484 pvr2_stream_done(sp);
485 kfree(sp);
486 }
487
488 void pvr2_stream_setup(struct pvr2_stream *sp,
489 struct usb_device *dev,
490 int endpoint,
491 unsigned int tolerance)
492 {
493 mutex_lock(&sp->mutex); do {
494 pvr2_stream_internal_flush(sp);
495 sp->dev = dev;
496 sp->endpoint = endpoint;
497 sp->fail_tolerance = tolerance;
498 } while (0); mutex_unlock(&sp->mutex);
499 }
500
501 void pvr2_stream_set_callback(struct pvr2_stream *sp,
502 pvr2_stream_callback func,
503 void *data)
504 {
505 unsigned long irq_flags;
506 mutex_lock(&sp->mutex);
507 do {
508 spin_lock_irqsave(&sp->list_lock, irq_flags);
509 sp->callback_data = data;
510 sp->callback_func = func;
511 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
512 } while (0);
513 mutex_unlock(&sp->mutex);
514 }
515
516 void pvr2_stream_get_stats(struct pvr2_stream *sp,
517 struct pvr2_stream_stats *stats,
518 int zero_counts)
519 {
520 unsigned long irq_flags;
521 spin_lock_irqsave(&sp->list_lock, irq_flags);
522 if (stats) {
523 stats->buffers_in_queue = sp->q_count;
524 stats->buffers_in_idle = sp->i_count;
525 stats->buffers_in_ready = sp->r_count;
526 stats->buffers_processed = sp->buffers_processed;
527 stats->buffers_failed = sp->buffers_failed;
528 stats->bytes_processed = sp->bytes_processed;
529 }
530 if (zero_counts) {
531 sp->buffers_processed = 0;
532 sp->buffers_failed = 0;
533 sp->bytes_processed = 0;
534 }
535 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
536 }
537
538 /* Query / set the nominal buffer count */
539 int pvr2_stream_get_buffer_count(struct pvr2_stream *sp)
540 {
541 return sp->buffer_target_count;
542 }
543
544 int pvr2_stream_set_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
545 {
546 int ret;
547 if (sp->buffer_target_count == cnt) return 0;
548 mutex_lock(&sp->mutex);
549 do {
550 sp->buffer_target_count = cnt;
551 ret = pvr2_stream_achieve_buffer_count(sp);
552 } while (0);
553 mutex_unlock(&sp->mutex);
554 return ret;
555 }
556
557 struct pvr2_buffer *pvr2_stream_get_idle_buffer(struct pvr2_stream *sp)
558 {
559 struct list_head *lp = sp->idle_list.next;
560 if (lp == &sp->idle_list) return NULL;
561 return list_entry(lp, struct pvr2_buffer, list_overhead);
562 }
563
564 struct pvr2_buffer *pvr2_stream_get_ready_buffer(struct pvr2_stream *sp)
565 {
566 struct list_head *lp = sp->ready_list.next;
567 if (lp == &sp->ready_list) return NULL;
568 return list_entry(lp, struct pvr2_buffer, list_overhead);
569 }
570
571 struct pvr2_buffer *pvr2_stream_get_buffer(struct pvr2_stream *sp, int id)
572 {
573 if (id < 0) return NULL;
574 if (id >= sp->buffer_total_count) return NULL;
575 return sp->buffers[id];
576 }
577
578 int pvr2_stream_get_ready_count(struct pvr2_stream *sp)
579 {
580 return sp->r_count;
581 }
582
583 void pvr2_stream_kill(struct pvr2_stream *sp)
584 {
585 struct pvr2_buffer *bp;
586 mutex_lock(&sp->mutex);
587 do {
588 pvr2_stream_internal_flush(sp);
589 while ((bp = pvr2_stream_get_ready_buffer(sp)) != NULL) {
590 pvr2_buffer_set_idle(bp);
591 }
592 if (sp->buffer_total_count != sp->buffer_target_count) {
593 pvr2_stream_achieve_buffer_count(sp);
594 }
595 } while (0);
596 mutex_unlock(&sp->mutex);
597 }
598
599 int pvr2_buffer_queue(struct pvr2_buffer *bp)
600 {
601 #undef SEED_BUFFER
602 #ifdef SEED_BUFFER
603 unsigned int idx;
604 unsigned int val;
605 #endif
606 int ret = 0;
607 struct pvr2_stream *sp;
608 if (!bp) return -EINVAL;
609 sp = bp->stream;
610 mutex_lock(&sp->mutex);
611 do {
612 pvr2_buffer_wipe(bp);
613 if (!sp->dev) {
614 ret = -EIO;
615 break;
616 }
617 pvr2_buffer_set_queued(bp);
618 #ifdef SEED_BUFFER
619 for (idx = 0; idx < (bp->max_count) / 4; idx++) {
620 val = bp->id << 24;
621 val |= idx;
622 ((unsigned int *)(bp->ptr))[idx] = val;
623 }
624 #endif
625 bp->status = -EINPROGRESS;
626 usb_fill_bulk_urb(bp->purb, // struct urb *urb
627 sp->dev, // struct usb_device *dev
628 // endpoint (below)
629 usb_rcvbulkpipe(sp->dev, sp->endpoint),
630 bp->ptr, // void *transfer_buffer
631 bp->max_count, // int buffer_length
632 buffer_complete,
633 bp);
634 usb_submit_urb(bp->purb, GFP_KERNEL);
635 } while (0);
636 mutex_unlock(&sp->mutex);
637 return ret;
638 }
639
640 int pvr2_buffer_set_buffer(struct pvr2_buffer *bp, void *ptr, unsigned int cnt)
641 {
642 int ret = 0;
643 unsigned long irq_flags;
644 struct pvr2_stream *sp;
645 if (!bp) return -EINVAL;
646 sp = bp->stream;
647 mutex_lock(&sp->mutex);
648 do {
649 spin_lock_irqsave(&sp->list_lock, irq_flags);
650 if (bp->state != pvr2_buffer_state_idle) {
651 ret = -EPERM;
652 } else {
653 bp->ptr = ptr;
654 bp->stream->i_bcount -= bp->max_count;
655 bp->max_count = cnt;
656 bp->stream->i_bcount += bp->max_count;
657 pvr2_trace(PVR2_TRACE_BUF_FLOW,
658 "/*---TRACE_FLOW---*/ bufferPool %8s cap cap=%07d cnt=%02d",
659 pvr2_buffer_state_decode(
660 pvr2_buffer_state_idle),
661 bp->stream->i_bcount, bp->stream->i_count);
662 }
663 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
664 } while (0);
665 mutex_unlock(&sp->mutex);
666 return ret;
667 }
668
669 unsigned int pvr2_buffer_get_count(struct pvr2_buffer *bp)
670 {
671 return bp->used_count;
672 }
673
674 int pvr2_buffer_get_status(struct pvr2_buffer *bp)
675 {
676 return bp->status;
677 }
678
679 int pvr2_buffer_get_id(struct pvr2_buffer *bp)
680 {
681 return bp->id;
682 }
Linux with added FPC-III support