Lines Matching defs:sp
120 struct pvr2_stream *sp = bp->stream;
123 cnt = &sp->i_count;
124 bcnt = &sp->i_bcount;
128 cnt = &sp->q_count;
129 bcnt = &sp->q_bcount;
133 cnt = &sp->r_count;
134 bcnt = &sp->r_bcount;
152 struct pvr2_stream *sp;
154 sp = bp->stream;
160 spin_lock_irqsave(&sp->list_lock, irq_flags);
162 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
169 struct pvr2_stream *sp;
171 sp = bp->stream;
177 spin_lock_irqsave(&sp->list_lock, irq_flags);
178 fl = (sp->r_count == 0);
180 list_add_tail(&bp->list_overhead, &sp->ready_list);
182 (sp->r_count)++;
183 sp->r_bcount += bp->used_count;
187 sp->r_bcount, sp->r_count);
188 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
195 struct pvr2_stream *sp;
197 sp = bp->stream;
203 spin_lock_irqsave(&sp->list_lock, irq_flags);
205 list_add_tail(&bp->list_overhead, &sp->idle_list);
207 (sp->i_count)++;
208 sp->i_bcount += bp->max_count;
212 sp->i_bcount, sp->i_count);
213 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
219 struct pvr2_stream *sp;
221 sp = bp->stream;
227 spin_lock_irqsave(&sp->list_lock, irq_flags);
229 list_add_tail(&bp->list_overhead, &sp->queued_list);
231 (sp->q_count)++;
232 sp->q_bcount += bp->max_count;
236 sp->q_bcount, sp->q_count);
237 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
248 struct pvr2_stream *sp,
255 "/*---TRACE_FLOW---*/ bufferInit %p stream=%p", bp, sp);
256 bp->stream = sp;
281 static int pvr2_stream_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
287 if (cnt == sp->buffer_total_count) return 0;
291 sp,
292 sp->buffer_total_count,
293 cnt-sp->buffer_total_count);
298 if (cnt > sp->buffer_total_count) {
299 if (scnt > sp->buffer_slot_count) {
304 if (sp->buffer_slot_count) {
305 memcpy(nb, sp->buffers,
306 sp->buffer_slot_count * sizeof(*nb));
307 kfree(sp->buffers);
309 sp->buffers = nb;
310 sp->buffer_slot_count = scnt;
312 while (sp->buffer_total_count < cnt) {
316 ret = pvr2_buffer_init(bp, sp, sp->buffer_total_count);
321 sp->buffers[sp->buffer_total_count] = bp;
322 (sp->buffer_total_count)++;
326 while (sp->buffer_total_count > cnt) {
328 bp = sp->buffers[sp->buffer_total_count - 1];
330 sp->buffers[sp->buffer_total_count - 1] = NULL;
331 (sp->buffer_total_count)--;
335 if (scnt < sp->buffer_slot_count) {
338 nb = kmemdup_array(sp->buffers, scnt, sizeof(*nb),
342 kfree(sp->buffers);
343 sp->buffers = nb;
344 sp->buffer_slot_count = scnt;
350 static int pvr2_stream_achieve_buffer_count(struct pvr2_stream *sp)
355 if (sp->buffer_total_count == sp->buffer_target_count) return 0;
359 sp, sp->buffer_total_count, sp->buffer_target_count);
361 if (sp->buffer_total_count < sp->buffer_target_count) {
362 return pvr2_stream_buffer_count(sp, sp->buffer_target_count);
366 while ((sp->buffer_total_count - cnt) > sp->buffer_target_count) {
367 bp = sp->buffers[sp->buffer_total_count - (cnt + 1)];
372 pvr2_stream_buffer_count(sp, sp->buffer_total_count - cnt);
378 static void pvr2_stream_internal_flush(struct pvr2_stream *sp)
382 while ((lp = sp->queued_list.next) != &sp->queued_list) {
393 if (sp->buffer_total_count != sp->buffer_target_count) {
394 pvr2_stream_achieve_buffer_count(sp);
398 static void pvr2_stream_init(struct pvr2_stream *sp)
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);
407 static void pvr2_stream_done(struct pvr2_stream *sp)
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);
418 struct pvr2_stream *sp;
421 sp = bp->stream;
427 spin_lock_irqsave(&sp->list_lock, irq_flags);
432 (sp->buffers_processed)++;
433 sp->bytes_processed += urb->actual_length;
435 if (sp->fail_count) {
438 sp);
439 sp->fail_count = 0;
441 } else if (sp->fail_count < sp->fail_tolerance) {
444 (sp->fail_count)++;
445 (sp->buffers_failed)++;
448 sp, urb->status, sp->fail_count);
450 (sp->buffers_failed)++;
453 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
455 if (sp->callback_func) {
456 sp->callback_func(sp->callback_data);
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;
470 void pvr2_stream_destroy(struct pvr2_stream *sp)
472 if (!sp) return;
473 pvr2_trace(PVR2_TRACE_INIT, "pvr2_stream_destroy: sp=%p", sp);
474 pvr2_stream_done(sp);
475 kfree(sp);
478 void pvr2_stream_setup(struct pvr2_stream *sp,
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);
491 void pvr2_stream_set_callback(struct pvr2_stream *sp,
496 mutex_lock(&sp->mutex);
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);
503 mutex_unlock(&sp->mutex);
506 void pvr2_stream_get_stats(struct pvr2_stream *sp,
511 spin_lock_irqsave(&sp->list_lock, irq_flags);
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;
521 sp->buffers_processed = 0;
522 sp->buffers_failed = 0;
523 sp->bytes_processed = 0;
525 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
529 int pvr2_stream_get_buffer_count(struct pvr2_stream *sp)
531 return sp->buffer_target_count;
534 int pvr2_stream_set_buffer_count(struct pvr2_stream *sp, unsigned int cnt)
537 if (sp->buffer_target_count == cnt) return 0;
538 mutex_lock(&sp->mutex);
540 sp->buffer_target_count = cnt;
541 ret = pvr2_stream_achieve_buffer_count(sp);
543 mutex_unlock(&sp->mutex);
547 struct pvr2_buffer *pvr2_stream_get_idle_buffer(struct pvr2_stream *sp)
549 struct list_head *lp = sp->idle_list.next;
550 if (lp == &sp->idle_list) return NULL;
554 struct pvr2_buffer *pvr2_stream_get_ready_buffer(struct pvr2_stream *sp)
556 struct list_head *lp = sp->ready_list.next;
557 if (lp == &sp->ready_list) return NULL;
561 struct pvr2_buffer *pvr2_stream_get_buffer(struct pvr2_stream *sp, int id)
564 if (id >= sp->buffer_total_count) return NULL;
565 return sp->buffers[id];
568 int pvr2_stream_get_ready_count(struct pvr2_stream *sp)
570 return sp->r_count;
573 void pvr2_stream_kill(struct pvr2_stream *sp)
576 mutex_lock(&sp->mutex);
578 pvr2_stream_internal_flush(sp);
579 while ((bp = pvr2_stream_get_ready_buffer(sp)) != NULL) {
582 if (sp->buffer_total_count != sp->buffer_target_count) {
583 pvr2_stream_achieve_buffer_count(sp);
586 mutex_unlock(&sp->mutex);
597 struct pvr2_stream *sp;
599 sp = bp->stream;
600 mutex_lock(&sp->mutex);
603 if (!sp->dev) {
617 sp->dev, // struct usb_device *dev
619 usb_rcvbulkpipe(sp->dev, sp->endpoint),
626 mutex_unlock(&sp->mutex);
634 struct pvr2_stream *sp;
636 sp = bp->stream;
637 mutex_lock(&sp->mutex);
639 spin_lock_irqsave(&sp->list_lock, irq_flags);
653 spin_unlock_irqrestore(&sp->list_lock, irq_flags);
655 mutex_unlock(&sp->mutex);