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