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