Release 4.7 drivers/media/usb/pvrusb2/pvrusb2-io.c

/*
 *
 *
 *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "pvrusb2-io.h"
#include "pvrusb2-debug.h"
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/mutex.h>

static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state);


#define BUFFER_SIG 0x47653271

// #define SANITY_CHECK_BUFFERS


#ifdef SANITY_CHECK_BUFFERS

#define BUFFER_CHECK(bp) do { \
        if ((bp)->signature != BUFFER_SIG) { \
                pvr2_trace(PVR2_TRACE_ERROR_LEGS, \
                "Buffer %p is bad at %s:%d", \
                (bp),__FILE__,__LINE__); \
                pvr2_buffer_describe(bp,"BadSig"); \
                BUG(); \
        } \
} while (0)
#else

#define BUFFER_CHECK(bp) do {} while(0)
#endif


struct pvr2_stream {
	/* Buffers queued for reading */
	
struct list_head queued_list;
	
unsigned int q_count;
	
unsigned int q_bcount;
	/* Buffers with retrieved data */
	
struct list_head ready_list;
	
unsigned int r_count;
	
unsigned int r_bcount;
	/* Buffers available for use */
	
struct list_head idle_list;
	
unsigned int i_count;
	
unsigned int i_bcount;
	/* Pointers to all buffers */
	
struct pvr2_buffer **buffers;
	/* Array size of buffers */
	
unsigned int buffer_slot_count;
	/* Total buffers actually in circulation */
	
unsigned int buffer_total_count;
	/* Designed number of buffers to be in circulation */
	
unsigned int buffer_target_count;
	/* Executed when ready list become non-empty */
	
pvr2_stream_callback callback_func;
	
void *callback_data;
	/* Context for transfer endpoint */
	
struct usb_device *dev;
	
int endpoint;
	/* Overhead for mutex enforcement */
	
spinlock_t list_lock;
	
struct mutex mutex;
	/* Tracking state for tolerating errors */
	
unsigned int fail_count;
	
unsigned int fail_tolerance;

	
unsigned int buffers_processed;
	
unsigned int buffers_failed;
	
unsigned int bytes_processed;
};


struct pvr2_buffer {
	
int id;
	
int signature;
	
enum pvr2_buffer_state state;
	
void *ptr;               /* Pointer to storage area */
	
unsigned int max_count;  /* Size of storage area */
	
unsigned int used_count; /* Amount of valid data in storage area */
	
int status;              /* Transfer result status */
	
struct pvr2_stream *stream;
	
struct list_head list_overhead;
	
struct urb *purb;
};



static const char *pvr2_buffer_state_decode(enum pvr2_buffer_state st)
{
	switch (st) {
	case pvr2_buffer_state_none: return "none";
	case pvr2_buffer_state_idle: return "idle";
	case pvr2_buffer_state_queued: return "queued";
	case pvr2_buffer_state_ready: return "ready";
	}
	return "unknown";
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
44
97.78%
1
50.00%
adrian bunk
adrian bunk
1
2.22%
1
50.00%
Total
45
100.00%
2
100.00%

#ifdef SANITY_CHECK_BUFFERS


static void pvr2_buffer_describe(struct pvr2_buffer *bp,const char *msg)
{
	pvr2_trace(PVR2_TRACE_INFO,
		   "buffer%s%s %p state=%s id=%d status=%d"
		   " stream=%p purb=%p sig=0x%x",
		   (msg ? " " : ""),
		   (msg ? msg : ""),
		   bp,
		   (bp ? pvr2_buffer_state_decode(bp->state) : "(invalid)"),
		   (bp ? bp->id : 0),
		   (bp ? bp->status : 0),
		   (bp ? bp->stream : NULL),
		   (bp ? bp->purb : NULL),
		   (bp ? bp->signature : 0));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
104
99.05%
2
66.67%
adrian bunk
adrian bunk
1
0.95%
1
33.33%
Total
105
100.00%
3
100.00%

#endif  /*  SANITY_CHECK_BUFFERS  */



static void pvr2_buffer_remove(struct pvr2_buffer *bp)
{
	unsigned int *cnt;
	unsigned int *bcnt;
	unsigned int ccnt;
	struct pvr2_stream *sp = bp->stream;
	switch (bp->state) {
	case pvr2_buffer_state_idle:
		cnt = &sp->i_count;
		bcnt = &sp->i_bcount;
		ccnt = bp->max_count;
		break;
	case pvr2_buffer_state_queued:
		cnt = &sp->q_count;
		bcnt = &sp->q_bcount;
		ccnt = bp->max_count;
		break;
	case pvr2_buffer_state_ready:
		cnt = &sp->r_count;
		bcnt = &sp->r_bcount;
		ccnt = bp->used_count;
		break;
	default:
		return;
	}
	list_del_init(&bp->list_overhead);
	(*cnt)--;
	(*bcnt) -= ccnt;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/"
		   " bufferPool     %8s dec cap=%07d cnt=%02d",
		   pvr2_buffer_state_decode(bp->state),*bcnt,*cnt);
	bp->state = pvr2_buffer_state_none;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
164
100.00%
1
100.00%
Total
164
100.00%
1
100.00%



static void pvr2_buffer_set_none(struct pvr2_buffer *bp)
{
	unsigned long irq_flags;
	struct pvr2_stream *sp;
	BUFFER_CHECK(bp);
	sp = bp->stream;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/ bufferState    %p %6s --> %6s",
		   bp,
		   pvr2_buffer_state_decode(bp->state),
		   pvr2_buffer_state_decode(pvr2_buffer_state_none));
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	pvr2_buffer_remove(bp);
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
77
100.00%
1
100.00%
Total
77
100.00%
1
100.00%



static int pvr2_buffer_set_ready(struct pvr2_buffer *bp)
{
	int fl;
	unsigned long irq_flags;
	struct pvr2_stream *sp;
	BUFFER_CHECK(bp);
	sp = bp->stream;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/ bufferState    %p %6s --> %6s",
		   bp,
		   pvr2_buffer_state_decode(bp->state),
		   pvr2_buffer_state_decode(pvr2_buffer_state_ready));
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	fl = (sp->r_count == 0);
	pvr2_buffer_remove(bp);
	list_add_tail(&bp->list_overhead,&sp->ready_list);
	bp->state = pvr2_buffer_state_ready;
	(sp->r_count)++;
	sp->r_bcount += bp->used_count;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/"
		   " bufferPool     %8s inc cap=%07d cnt=%02d",
		   pvr2_buffer_state_decode(bp->state),
		   sp->r_bcount,sp->r_count);
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
	return fl;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
150
100.00%
1
100.00%
Total
150
100.00%
1
100.00%



static void pvr2_buffer_set_idle(struct pvr2_buffer *bp)
{
	unsigned long irq_flags;
	struct pvr2_stream *sp;
	BUFFER_CHECK(bp);
	sp = bp->stream;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/ bufferState    %p %6s --> %6s",
		   bp,
		   pvr2_buffer_state_decode(bp->state),
		   pvr2_buffer_state_decode(pvr2_buffer_state_idle));
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	pvr2_buffer_remove(bp);
	list_add_tail(&bp->list_overhead,&sp->idle_list);
	bp->state = pvr2_buffer_state_idle;
	(sp->i_count)++;
	sp->i_bcount += bp->max_count;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/"
		   " bufferPool     %8s inc cap=%07d cnt=%02d",
		   pvr2_buffer_state_decode(bp->state),
		   sp->i_bcount,sp->i_count);
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
134
100.00%
1
100.00%
Total
134
100.00%
1
100.00%



static void pvr2_buffer_set_queued(struct pvr2_buffer *bp)
{
	unsigned long irq_flags;
	struct pvr2_stream *sp;
	BUFFER_CHECK(bp);
	sp = bp->stream;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/ bufferState    %p %6s --> %6s",
		   bp,
		   pvr2_buffer_state_decode(bp->state),
		   pvr2_buffer_state_decode(pvr2_buffer_state_queued));
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	pvr2_buffer_remove(bp);
	list_add_tail(&bp->list_overhead,&sp->queued_list);
	bp->state = pvr2_buffer_state_queued;
	(sp->q_count)++;
	sp->q_bcount += bp->max_count;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/"
		   " bufferPool     %8s inc cap=%07d cnt=%02d",
		   pvr2_buffer_state_decode(bp->state),
		   sp->q_bcount,sp->q_count);
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
134
100.00%
1
100.00%
Total
134
100.00%
1
100.00%



static void pvr2_buffer_wipe(struct pvr2_buffer *bp)
{
	if (bp->state == pvr2_buffer_state_queued) {
		usb_kill_urb(bp->purb);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%



static int pvr2_buffer_init(struct pvr2_buffer *bp,
			    struct pvr2_stream *sp,
			    unsigned int id)
{
	memset(bp,0,sizeof(*bp));
	bp->signature = BUFFER_SIG;
	bp->id = id;
	pvr2_trace(PVR2_TRACE_BUF_POOL,
		   "/*---TRACE_FLOW---*/ bufferInit     %p stream=%p",bp,sp);
	bp->stream = sp;
	bp->state = pvr2_buffer_state_none;
	INIT_LIST_HEAD(&bp->list_overhead);
	bp->purb = usb_alloc_urb(0,GFP_KERNEL);
	if (! bp->purb) return -ENOMEM;
#ifdef SANITY_CHECK_BUFFERS
	pvr2_buffer_describe(bp,"create");
#endif
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
113
100.00%
1
100.00%
Total
113
100.00%
1
100.00%



static void pvr2_buffer_done(struct pvr2_buffer *bp)
{
#ifdef SANITY_CHECK_BUFFERS
	pvr2_buffer_describe(bp,"delete");
#endif
	pvr2_buffer_wipe(bp);
	pvr2_buffer_set_none(bp);
	bp->signature = 0;
	bp->stream = NULL;
	usb_free_urb(bp->purb);
	pvr2_trace(PVR2_TRACE_BUF_POOL,"/*---TRACE_FLOW---*/"
		   " bufferDone     %p",bp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
62
100.00%
2
100.00%
Total
62
100.00%
2
100.00%



static int pvr2_stream_buffer_count(struct pvr2_stream *sp,unsigned int cnt)
{
	int ret;
	unsigned int scnt;

	/* Allocate buffers pointer array in multiples of 32 entries */
	if (cnt == sp->buffer_total_count) return 0;

	pvr2_trace(PVR2_TRACE_BUF_POOL,
		   "/*---TRACE_FLOW---*/ poolResize    "
		   " stream=%p cur=%d adj=%+d",
		   sp,
		   sp->buffer_total_count,
		   cnt-sp->buffer_total_count);

	scnt = cnt & ~0x1f;
	if (cnt > scnt) scnt += 0x20;

	if (cnt > sp->buffer_total_count) {
		if (scnt > sp->buffer_slot_count) {
			struct pvr2_buffer **nb;
			nb = kmalloc(scnt * sizeof(*nb),GFP_KERNEL);
			if (!nb) return -ENOMEM;
			if (sp->buffer_slot_count) {
				memcpy(nb,sp->buffers,
				       sp->buffer_slot_count * sizeof(*nb));
				kfree(sp->buffers);
			}
			sp->buffers = nb;
			sp->buffer_slot_count = scnt;
		}
		while (sp->buffer_total_count < cnt) {
			struct pvr2_buffer *bp;
			bp = kmalloc(sizeof(*bp),GFP_KERNEL);
			if (!bp) return -ENOMEM;
			ret = pvr2_buffer_init(bp,sp,sp->buffer_total_count);
			if (ret) {
				kfree(bp);
				return -ENOMEM;
			}
			sp->buffers[sp->buffer_total_count] = bp;
			(sp->buffer_total_count)++;
			pvr2_buffer_set_idle(bp);
		}
	} else {
		while (sp->buffer_total_count > cnt) {
			struct pvr2_buffer *bp;
			bp = sp->buffers[sp->buffer_total_count - 1];
			/* Paranoia */
			sp->buffers[sp->buffer_total_count - 1] = NULL;
			(sp->buffer_total_count)--;
			pvr2_buffer_done(bp);
			kfree(bp);
		}
		if (scnt < sp->buffer_slot_count) {
			struct pvr2_buffer **nb = NULL;
			if (scnt) {
				nb = kmemdup(sp->buffers, scnt * sizeof(*nb),
					     GFP_KERNEL);
				if (!nb) return -ENOMEM;
			}
			kfree(sp->buffers);
			sp->buffers = nb;
			sp->buffer_slot_count = scnt;
		}
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
386
98.72%
2
66.67%
thomas meyer
thomas meyer
5
1.28%
1
33.33%
Total
391
100.00%
3
100.00%



static int pvr2_stream_achieve_buffer_count(struct pvr2_stream *sp)
{
	struct pvr2_buffer *bp;
	unsigned int cnt;

	if (sp->buffer_total_count == sp->buffer_target_count) return 0;

	pvr2_trace(PVR2_TRACE_BUF_POOL,
		   "/*---TRACE_FLOW---*/"
		   " poolCheck      stream=%p cur=%d tgt=%d",
		   sp,sp->buffer_total_count,sp->buffer_target_count);

	if (sp->buffer_total_count < sp->buffer_target_count) {
		return pvr2_stream_buffer_count(sp,sp->buffer_target_count);
	}

	cnt = 0;
	while ((sp->buffer_total_count - cnt) > sp->buffer_target_count) {
		bp = sp->buffers[sp->buffer_total_count - (cnt + 1)];
		if (bp->state != pvr2_buffer_state_idle) break;
		cnt++;
	}
	if (cnt) {
		pvr2_stream_buffer_count(sp,sp->buffer_total_count - cnt);
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
142
100.00%
1
100.00%
Total
142
100.00%
1
100.00%



static void pvr2_stream_internal_flush(struct pvr2_stream *sp)
{
	struct list_head *lp;
	struct pvr2_buffer *bp1;
	while ((lp = sp->queued_list.next) != &sp->queued_list) {
		bp1 = list_entry(lp,struct pvr2_buffer,list_overhead);
		pvr2_buffer_wipe(bp1);
		/* At this point, we should be guaranteed that no
                   completion callback may happen on this buffer.  But it's
                   possible that it might have completed after we noticed
                   it but before we wiped it.  So double check its status
                   here first. */
		if (bp1->state != pvr2_buffer_state_queued) continue;
		pvr2_buffer_set_idle(bp1);
	}
	if (sp->buffer_total_count != sp->buffer_target_count) {
		pvr2_stream_achieve_buffer_count(sp);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
89
100.00%
1
100.00%
Total
89
100.00%
1
100.00%



static void pvr2_stream_init(struct pvr2_stream *sp)
{
	spin_lock_init(&sp->list_lock);
	mutex_init(&sp->mutex);
	INIT_LIST_HEAD(&sp->queued_list);
	INIT_LIST_HEAD(&sp->ready_list);
	INIT_LIST_HEAD(&sp->idle_list);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



static void pvr2_stream_done(struct pvr2_stream *sp)
{
	mutex_lock(&sp->mutex); do {
		pvr2_stream_internal_flush(sp);
		pvr2_stream_buffer_count(sp,0);
	} while (0); mutex_unlock(&sp->mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
47
100.00%
1
100.00%
Total
47
100.00%
1
100.00%



static void buffer_complete(struct urb *urb)
{
	struct pvr2_buffer *bp = urb->context;
	struct pvr2_stream *sp;
	unsigned long irq_flags;
	BUFFER_CHECK(bp);
	sp = bp->stream;
	bp->used_count = 0;
	bp->status = 0;
	pvr2_trace(PVR2_TRACE_BUF_FLOW,
		   "/*---TRACE_FLOW---*/ bufferComplete %p stat=%d cnt=%d",
		   bp,urb->status,urb->actual_length);
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	if ((!(urb->status)) ||
	    (urb->status == -ENOENT) ||
	    (urb->status == -ECONNRESET) ||
	    (urb->status == -ESHUTDOWN)) {
		(sp->buffers_processed)++;
		sp->bytes_processed += urb->actual_length;
		bp->used_count = urb->actual_length;
		if (sp->fail_count) {
			pvr2_trace(PVR2_TRACE_TOLERANCE,
				   "stream %p transfer ok"
				   " - fail count reset",sp);
			sp->fail_count = 0;
		}
	} else if (sp->fail_count < sp->fail_tolerance) {
		// We can tolerate this error, because we're below the
		// threshold...
		(sp->fail_count)++;
		(sp->buffers_failed)++;
		pvr2_trace(PVR2_TRACE_TOLERANCE,
			   "stream %p ignoring error %d"
			   " - fail count increased to %u",
			   sp,urb->status,sp->fail_count);
	} else {
		(sp->buffers_failed)++;
		bp->status = urb->status;
	}
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
	pvr2_buffer_set_ready(bp);
	if (sp->callback_func) {
		sp->callback_func(sp->callback_data);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
263
100.00%
2
100.00%
Total
263
100.00%
2
100.00%



struct pvr2_stream *pvr2_stream_create(void)
{
	struct pvr2_stream *sp;
	sp = kzalloc(sizeof(*sp),GFP_KERNEL);
	if (!sp) return sp;
	pvr2_trace(PVR2_TRACE_INIT,"pvr2_stream_create: sp=%p",sp);
	pvr2_stream_init(sp);
	return sp;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
52
100.00%
2
100.00%
Total
52
100.00%
2
100.00%



void pvr2_stream_destroy(struct pvr2_stream *sp)
{
	if (!sp) return;
	pvr2_trace(PVR2_TRACE_INIT,"pvr2_stream_destroy: sp=%p",sp);
	pvr2_stream_done(sp);
	kfree(sp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
35
100.00%
1
100.00%
Total
35
100.00%
1
100.00%



void pvr2_stream_setup(struct pvr2_stream *sp,
		       struct usb_device *dev,
		       int endpoint,
		       unsigned int tolerance)
{
	mutex_lock(&sp->mutex); do {
		pvr2_stream_internal_flush(sp);
		sp->dev = dev;
		sp->endpoint = endpoint;
		sp->fail_tolerance = tolerance;
	} while(0); mutex_unlock(&sp->mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
69
100.00%
1
100.00%
Total
69
100.00%
1
100.00%



void pvr2_stream_set_callback(struct pvr2_stream *sp,
			      pvr2_stream_callback func,
			      void *data)
{
	unsigned long irq_flags;
	mutex_lock(&sp->mutex);
	do {
		spin_lock_irqsave(&sp->list_lock,irq_flags);
		sp->callback_data = data;
		sp->callback_func = func;
		spin_unlock_irqrestore(&sp->list_lock,irq_flags);
	} while(0);
	mutex_unlock(&sp->mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
77
100.00%
1
100.00%
Total
77
100.00%
1
100.00%



void pvr2_stream_get_stats(struct pvr2_stream *sp,
			   struct pvr2_stream_stats *stats,
			   int zero_counts)
{
	unsigned long irq_flags;
	spin_lock_irqsave(&sp->list_lock,irq_flags);
	if (stats) {
		stats->buffers_in_queue = sp->q_count;
		stats->buffers_in_idle = sp->i_count;
		stats->buffers_in_ready = sp->r_count;
		stats->buffers_processed = sp->buffers_processed;
		stats->buffers_failed = sp->buffers_failed;
		stats->bytes_processed = sp->bytes_processed;
	}
	if (zero_counts) {
		sp->buffers_processed = 0;
		sp->buffers_failed = 0;
		sp->bytes_processed = 0;
	}
	spin_unlock_irqrestore(&sp->list_lock,irq_flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
120
100.00%
1
100.00%
Total
120
100.00%
1
100.00%

/* Query / set the nominal buffer count */


int pvr2_stream_get_buffer_count(struct pvr2_stream *sp)
{
	return sp->buffer_target_count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



int pvr2_stream_set_buffer_count(struct pvr2_stream *sp,unsigned int cnt)
{
	int ret;
	if (sp->buffer_target_count == cnt) return 0;
	mutex_lock(&sp->mutex);
	do {
		sp->buffer_target_count = cnt;
		ret = pvr2_stream_achieve_buffer_count(sp);
	} while(0);
	mutex_unlock(&sp->mutex);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
68
100.00%
1
100.00%
Total
68
100.00%
1
100.00%



struct pvr2_buffer *pvr2_stream_get_idle_buffer(struct pvr2_stream *sp)
{
	struct list_head *lp = sp->idle_list.next;
	if (lp == &sp->idle_list) return NULL;
	return list_entry(lp,struct pvr2_buffer,list_overhead);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
46
100.00%
2
100.00%
Total
46
100.00%
2
100.00%



struct pvr2_buffer *pvr2_stream_get_ready_buffer(struct pvr2_stream *sp)
{
	struct list_head *lp = sp->ready_list.next;
	if (lp == &sp->ready_list) return NULL;
	return list_entry(lp,struct pvr2_buffer,list_overhead);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
46
100.00%
2
100.00%
Total
46
100.00%
2
100.00%



struct pvr2_buffer *pvr2_stream_get_buffer(struct pvr2_stream *sp,int id)
{
	if (id < 0) return NULL;
	if (id >= sp->buffer_total_count) return NULL;
	return sp->buffers[id];
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
43
100.00%
2
100.00%
Total
43
100.00%
2
100.00%



int pvr2_stream_get_ready_count(struct pvr2_stream *sp)
{
	return sp->r_count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



void pvr2_stream_kill(struct pvr2_stream *sp)
{
	struct pvr2_buffer *bp;
	mutex_lock(&sp->mutex);
	do {
		pvr2_stream_internal_flush(sp);
		while ((bp = pvr2_stream_get_ready_buffer(sp)) != NULL) {
			pvr2_buffer_set_idle(bp);
		}
		if (sp->buffer_total_count != sp->buffer_target_count) {
			pvr2_stream_achieve_buffer_count(sp);
		}
	} while(0);
	mutex_unlock(&sp->mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
80
98.77%
1
50.00%
al viro
al viro
1
1.23%
1
50.00%
Total
81
100.00%
2
100.00%



int pvr2_buffer_queue(struct pvr2_buffer *bp)
{

#undef SEED_BUFFER
#ifdef SEED_BUFFER
	unsigned int idx;
	unsigned int val;
#endif
	int ret = 0;
	struct pvr2_stream *sp;
	if (!bp) return -EINVAL;
	sp = bp->stream;
	mutex_lock(&sp->mutex);
	do {
		pvr2_buffer_wipe(bp);
		if (!sp->dev) {
			ret = -EIO;
			break;
		}
		pvr2_buffer_set_queued(bp);
#ifdef SEED_BUFFER
		for (idx = 0; idx < (bp->max_count) / 4; idx++) {
			val = bp->id << 24;
			val |= idx;
			((unsigned int *)(bp->ptr))[idx] = val;
		}
#endif
		bp->status = -EINPROGRESS;
		usb_fill_bulk_urb(bp->purb,      // struct urb *urb
				  sp->dev,       // struct usb_device *dev
				  // endpoint (below)
				  usb_rcvbulkpipe(sp->dev,sp->endpoint),
				  bp->ptr,       // void *transfer_buffer
				  bp->max_count, // int buffer_length
				  buffer_complete,
				  bp);
		usb_submit_urb(bp->purb,GFP_KERNEL);
	} while(0);
	mutex_unlock(&sp->mutex);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
214
100.00%
1
100.00%
Total
214
100.00%
1
100.00%



int pvr2_buffer_set_buffer(struct pvr2_buffer *bp,void *ptr,unsigned int cnt)
{
	int ret = 0;
	unsigned long irq_flags;
	struct pvr2_stream *sp;
	if (!bp) return -EINVAL;
	sp = bp->stream;
	mutex_lock(&sp->mutex);
	do {
		spin_lock_irqsave(&sp->list_lock,irq_flags);
		if (bp->state != pvr2_buffer_state_idle) {
			ret = -EPERM;
		} else {
			bp->ptr = ptr;
			bp->stream->i_bcount -= bp->max_count;
			bp->max_count = cnt;
			bp->stream->i_bcount += bp->max_count;
			pvr2_trace(PVR2_TRACE_BUF_FLOW,
				   "/*---TRACE_FLOW---*/ bufferPool    "
				   " %8s cap cap=%07d cnt=%02d",
				   pvr2_buffer_state_decode(
					   pvr2_buffer_state_idle),
				   bp->stream->i_bcount,bp->stream->i_count);
		}
		spin_unlock_irqrestore(&sp->list_lock,irq_flags);
	} while(0);
	mutex_unlock(&sp->mutex);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
169
100.00%
1
100.00%
Total
169
100.00%
1
100.00%



unsigned int pvr2_buffer_get_count(struct pvr2_buffer *bp)
{
	return bp->used_count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%



int pvr2_buffer_get_status(struct pvr2_buffer *bp)
{
	return bp->status;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%



int pvr2_buffer_get_id(struct pvr2_buffer *bp)
{
	return bp->id;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
15
100.00%
1
100.00%
Total
15
100.00%
1
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
mike isely
mike isely
3299
99.58%
6
66.67%
adrian bunk
adrian bunk
8
0.24%
1
11.11%
thomas meyer
thomas meyer
5
0.15%
1
11.11%
al viro
al viro
1
0.03%
1
11.11%
Total
3313
100.00%
9
100.00%
  
Directory: drivers/media/usb/pvrusb2

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.