Merge branch 'x86/crashdump' into x86/urgent
[linux-2.6] / drivers / media / video / pvrusb2 / pvrusb2-io.c
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   */