[linux-2.6-block.git] / drivers / media / usb / stk1160 / stk1160-video.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * STK1160 driver
 *
 * Copyright (C) 2012 Ezequiel Garcia
 * <elezegarcia--a.t--gmail.com>
 *
 * Based on Easycap driver by R.M. Thomas
 *	Copyright (C) 2010 R.M. Thomas
 *	<rmthomas--a.t--sciolus.org>
 */

#include <linux/module.h>
#include <linux/usb.h>
#include <linux/slab.h>
#include <linux/ratelimit.h>

#include "stk1160.h"

static unsigned int debug;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable debug messages");

static inline void print_err_status(struct stk1160 *dev,
				     int packet, int status)
{
	char *errmsg = "Unknown";

	switch (status) {
	case -ENOENT:
		errmsg = "unlinked synchronously";
		break;
	case -ECONNRESET:
		errmsg = "unlinked asynchronously";
		break;
	case -ENOSR:
		errmsg = "Buffer error (overrun)";
		break;
	case -EPIPE:
		errmsg = "Stalled (device not responding)";
		break;
	case -EOVERFLOW:
		errmsg = "Babble (bad cable?)";
		break;
	case -EPROTO:
		errmsg = "Bit-stuff error (bad cable?)";
		break;
	case -EILSEQ:
		errmsg = "CRC/Timeout (could be anything)";
		break;
	case -ETIME:
		errmsg = "Device does not respond";
		break;
	}

	if (packet < 0)
		printk_ratelimited(KERN_WARNING "URB status %d [%s].\n",
				status, errmsg);
	else
		printk_ratelimited(KERN_INFO "URB packet %d, status %d [%s].\n",
			       packet, status, errmsg);
}

static inline
struct stk1160_buffer *stk1160_next_buffer(struct stk1160 *dev)
{
	struct stk1160_buffer *buf = NULL;
	unsigned long flags = 0;

	/* Current buffer must be NULL when this functions gets called */
	WARN_ON(dev->isoc_ctl.buf);

	spin_lock_irqsave(&dev->buf_lock, flags);
	if (!list_empty(&dev->avail_bufs)) {
		buf = list_first_entry(&dev->avail_bufs,
				struct stk1160_buffer, list);
		list_del(&buf->list);
	}
	spin_unlock_irqrestore(&dev->buf_lock, flags);

	return buf;
}

static inline
void stk1160_buffer_done(struct stk1160 *dev)
{
	struct stk1160_buffer *buf = dev->isoc_ctl.buf;

	buf->vb.sequence = dev->sequence++;
	buf->vb.field = V4L2_FIELD_INTERLACED;
	buf->vb.vb2_buf.timestamp = ktime_get_ns();

	vb2_set_plane_payload(&buf->vb.vb2_buf, 0, buf->bytesused);
	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);

	dev->isoc_ctl.buf = NULL;
}

static inline
void stk1160_copy_video(struct stk1160 *dev, u8 *src, int len)
{
	int linesdone, lineoff, lencopy;
	int bytesperline = dev->width * 2;
	struct stk1160_buffer *buf = dev->isoc_ctl.buf;
	u8 *dst = buf->mem;
	int remain;

	/*
	 * TODO: These stk1160_dbg are very spammy!
	 * We should 1) check why we are getting them
	 * and 2) add ratelimit.
	 *
	 * UPDATE: One of the reasons (the only one?) for getting these
	 * is incorrect standard (mismatch between expected and configured).
	 * So perhaps, we could add a counter for errors. When the counter
	 * reaches some value, we simply stop streaming.
	 */

	len -= 4;
	src += 4;

	remain = len;

	linesdone = buf->pos / bytesperline;
	lineoff = buf->pos % bytesperline; /* offset in current line */

	if (!buf->odd)
		dst += bytesperline;

	/* Multiply linesdone by two, to take account of the other field */
	dst += linesdone * bytesperline * 2 + lineoff;

	/* Copy the remaining of current line */
	if (remain < (bytesperline - lineoff))
		lencopy = remain;
	else
		lencopy = bytesperline - lineoff;

	/*
	 * Check if we have enough space left in the buffer.
	 * In that case, we force loop exit after copy.
	 */
	if (lencopy > buf->bytesused - buf->length) {
		lencopy = buf->bytesused - buf->length;
		remain = lencopy;
	}

	/* Check if the copy is done */
	if (lencopy == 0 || remain == 0)
		return;

	/* Let the bug hunt begin! sanity checks! */
	if (lencopy < 0) {
		stk1160_dbg("copy skipped: negative lencopy\n");
		return;
	}

	if ((unsigned long)dst + lencopy >
		(unsigned long)buf->mem + buf->length) {
		printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");
		return;
	}

	memcpy(dst, src, lencopy);

	buf->bytesused += lencopy;
	buf->pos += lencopy;
	remain -= lencopy;

	/* Copy current field line by line, interlacing with the other field */
	while (remain > 0) {

		dst += lencopy + bytesperline;
		src += lencopy;

		/* Copy one line at a time */
		if (remain < bytesperline)
			lencopy = remain;
		else
			lencopy = bytesperline;

		/*
		 * Check if we have enough space left in the buffer.
		 * In that case, we force loop exit after copy.
		 */
		if (lencopy > buf->bytesused - buf->length) {
			lencopy = buf->bytesused - buf->length;
			remain = lencopy;
		}

		/* Check if the copy is done */
		if (lencopy == 0 || remain == 0)
			return;

		if (lencopy < 0) {
			printk_ratelimited(KERN_WARNING "stk1160: negative lencopy detected\n");
			return;
		}

		if ((unsigned long)dst + lencopy >
			(unsigned long)buf->mem + buf->length) {
			printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");
			return;
		}

		memcpy(dst, src, lencopy);
		remain -= lencopy;

		buf->bytesused += lencopy;
		buf->pos += lencopy;
	}
}

/*
 * Controls the isoc copy of each urb packet
 */
static void stk1160_process_isoc(struct stk1160 *dev, struct urb *urb)
{
	int i, len, status;
	u8 *p;

	if (!dev) {
		stk1160_warn("%s called with null device\n", __func__);
		return;
	}

	if (urb->status < 0) {
		/* Print status and drop current packet (or field?) */
		print_err_status(dev, -1, urb->status);
		return;
	}

	for (i = 0; i < urb->number_of_packets; i++) {
		status = urb->iso_frame_desc[i].status;
		if (status < 0) {
			print_err_status(dev, i, status);
			continue;
		}

		/* Get packet actual length and pointer to data */
		p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
		len = urb->iso_frame_desc[i].actual_length;

		/* Empty packet */
		if (len <= 4)
			continue;

		/*
		 * An 8-byte packet sequence means end of field.
		 * So if we don't have any packet, we start receiving one now
		 * and if we do have a packet, then we are done with it.
		 *
		 * These end of field packets are always 0xc0 or 0x80,
		 * but not always 8-byte long so we don't check packet length.
		 */
		if (p[0] == 0xc0) {

			/*
			 * If first byte is 0xc0 then we received
			 * second field, and frame has ended.
			 */
			if (dev->isoc_ctl.buf != NULL)
				stk1160_buffer_done(dev);

			dev->isoc_ctl.buf = stk1160_next_buffer(dev);
			if (dev->isoc_ctl.buf == NULL)
				return;
		}

		/*
		 * If we don't have a buffer here, then it means we
		 * haven't found the start mark sequence.
		 */
		if (dev->isoc_ctl.buf == NULL)
			continue;

		if (p[0] == 0xc0 || p[0] == 0x80) {

			/* We set next packet parity and
			 * continue to get next one
			 */
			dev->isoc_ctl.buf->odd = *p & 0x40;
			dev->isoc_ctl.buf->pos = 0;
			continue;
		}

		stk1160_copy_video(dev, p, len);
	}
}


/*
 * IRQ callback, called by URB callback
 */
static void stk1160_isoc_irq(struct urb *urb)
{
	int i, rc;
	struct stk1160 *dev = urb->context;

	switch (urb->status) {
	case 0:
		break;
	case -ECONNRESET:   /* kill */
	case -ENOENT:
	case -ESHUTDOWN:
		/* TODO: check uvc driver: he frees the queue here */
		return;
	default:
		stk1160_err("urb error! status %d\n", urb->status);
		return;
	}

	stk1160_process_isoc(dev, urb);

	/* Reset urb buffers */
	for (i = 0; i < urb->number_of_packets; i++) {
		urb->iso_frame_desc[i].status = 0;
		urb->iso_frame_desc[i].actual_length = 0;
	}

	rc = usb_submit_urb(urb, GFP_ATOMIC);
	if (rc)
		stk1160_err("urb re-submit failed (%d)\n", rc);
}

/*
 * Cancel urbs
 * This function can't be called in atomic context
 */
void stk1160_cancel_isoc(struct stk1160 *dev)
{
	int i, num_bufs = dev->isoc_ctl.num_bufs;

	/*
	 * This check is not necessary, but we add it
	 * to avoid a spurious debug message
	 */
	if (!num_bufs)
		return;

	stk1160_dbg("killing %d urbs...\n", num_bufs);

	for (i = 0; i < num_bufs; i++) {

		/*
		 * To kill urbs we can't be in atomic context.
		 * We don't care for NULL pointer since
		 * usb_kill_urb allows it.
		 */
		usb_kill_urb(dev->isoc_ctl.urb[i]);
	}

	stk1160_dbg("all urbs killed\n");
}

/*
 * Releases urb and transfer buffers
 * Obviusly, associated urb must be killed before releasing it.
 */
void stk1160_free_isoc(struct stk1160 *dev)
{
	struct urb *urb;
	int i, num_bufs = dev->isoc_ctl.num_bufs;

	stk1160_dbg("freeing %d urb buffers...\n", num_bufs);

	for (i = 0; i < num_bufs; i++) {

		urb = dev->isoc_ctl.urb[i];
		if (urb) {

			if (dev->isoc_ctl.transfer_buffer[i]) {
#ifndef CONFIG_DMA_NONCOHERENT
				usb_free_coherent(dev->udev,
					urb->transfer_buffer_length,
					dev->isoc_ctl.transfer_buffer[i],
					urb->transfer_dma);
#else
				kfree(dev->isoc_ctl.transfer_buffer[i]);
#endif
			}
			usb_free_urb(urb);
			dev->isoc_ctl.urb[i] = NULL;
		}
		dev->isoc_ctl.transfer_buffer[i] = NULL;
	}

	kfree(dev->isoc_ctl.urb);
	kfree(dev->isoc_ctl.transfer_buffer);

	dev->isoc_ctl.urb = NULL;
	dev->isoc_ctl.transfer_buffer = NULL;
	dev->isoc_ctl.num_bufs = 0;

	stk1160_dbg("all urb buffers freed\n");
}

/*
 * Helper for cancelling and freeing urbs
 * This function can't be called in atomic context
 */
void stk1160_uninit_isoc(struct stk1160 *dev)
{
	stk1160_cancel_isoc(dev);
	stk1160_free_isoc(dev);
}

/*
 * Allocate URBs
 */
int stk1160_alloc_isoc(struct stk1160 *dev)
{
	struct urb *urb;
	int i, j, k, sb_size, max_packets, num_bufs;

	/*
	 * It may be necessary to release isoc here,
	 * since isoc are only released on disconnection.
	 * (see new_pkt_size flag)
	 */
	if (dev->isoc_ctl.num_bufs)
		stk1160_uninit_isoc(dev);

	stk1160_dbg("allocating urbs...\n");

	num_bufs = STK1160_NUM_BUFS;
	max_packets = STK1160_NUM_PACKETS;
	sb_size = max_packets * dev->max_pkt_size;

	dev->isoc_ctl.buf = NULL;
	dev->isoc_ctl.max_pkt_size = dev->max_pkt_size;
	dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
	if (!dev->isoc_ctl.urb) {
		stk1160_err("out of memory for urb array\n");
		return -ENOMEM;
	}

	dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *),
						GFP_KERNEL);
	if (!dev->isoc_ctl.transfer_buffer) {
		stk1160_err("out of memory for usb transfers\n");
		kfree(dev->isoc_ctl.urb);
		return -ENOMEM;
	}

	/* allocate urbs and transfer buffers */
	for (i = 0; i < num_bufs; i++) {

		urb = usb_alloc_urb(max_packets, GFP_KERNEL);
		if (!urb)
			goto free_i_bufs;
		dev->isoc_ctl.urb[i] = urb;

#ifndef CONFIG_DMA_NONCOHERENT
		dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
			sb_size, GFP_KERNEL, &urb->transfer_dma);
#else
		dev->isoc_ctl.transfer_buffer[i] = kmalloc(sb_size, GFP_KERNEL);
#endif
		if (!dev->isoc_ctl.transfer_buffer[i]) {
			stk1160_err("cannot alloc %d bytes for tx[%d] buffer\n",
				sb_size, i);

			/* Not enough transfer buffers, so just give up */
			if (i < STK1160_MIN_BUFS)
				goto free_i_bufs;
			goto nomore_tx_bufs;
		}
		memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);

		/*
		 * FIXME: Where can I get the endpoint?
		 */
		urb->dev = dev->udev;
		urb->pipe = usb_rcvisocpipe(dev->udev, STK1160_EP_VIDEO);
		urb->transfer_buffer = dev->isoc_ctl.transfer_buffer[i];
		urb->transfer_buffer_length = sb_size;
		urb->complete = stk1160_isoc_irq;
		urb->context = dev;
		urb->interval = 1;
		urb->start_frame = 0;
		urb->number_of_packets = max_packets;
#ifndef CONFIG_DMA_NONCOHERENT
		urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
#else
		urb->transfer_flags = URB_ISO_ASAP;
#endif

		k = 0;
		for (j = 0; j < max_packets; j++) {
			urb->iso_frame_desc[j].offset = k;
			urb->iso_frame_desc[j].length =
					dev->isoc_ctl.max_pkt_size;
			k += dev->isoc_ctl.max_pkt_size;
		}
	}

	stk1160_dbg("%d urbs allocated\n", num_bufs);

	/* At last we can say we have some buffers */
	dev->isoc_ctl.num_bufs = num_bufs;

	return 0;

nomore_tx_bufs:
	/*
	 * Failed to allocate desired buffer count. However, we may have
	 * enough to work fine, so we just free the extra urb,
	 * store the allocated count and keep going, fingers crossed!
	 */
	usb_free_urb(dev->isoc_ctl.urb[i]);
	dev->isoc_ctl.urb[i] = NULL;

	stk1160_warn("%d urbs allocated. Trying to continue...\n", i - 1);

	dev->isoc_ctl.num_bufs = i - 1;

	return 0;

free_i_bufs:
	/* Save the allocated buffers so far, so we can properly free them */
	dev->isoc_ctl.num_bufs = i+1;
	stk1160_free_isoc(dev);
	return -ENOMEM;
}
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
9cb2173e EG	2	/*
	3	* STK1160 driver
	4	*
	5	* Copyright (C) 2012 Ezequiel Garcia
	6	* <elezegarcia--a.t--gmail.com>
	7	*
	8	* Based on Easycap driver by R.M. Thomas
	9	* Copyright (C) 2010 R.M. Thomas
	10	* <rmthomas--a.t--sciolus.org>
9cb2173e EG	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/usb.h>
	15	#include <linux/slab.h>
	16	#include <linux/ratelimit.h>
	17
	18	#include "stk1160.h"
	19
	20	static unsigned int debug;
	21	module_param(debug, int, 0644);
	22	MODULE_PARM_DESC(debug, "enable debug messages");
	23
	24	static inline void print_err_status(struct stk1160 *dev,
	25	int packet, int status)
	26	{
	27	char *errmsg = "Unknown";
	28
	29	switch (status) {
	30	case -ENOENT:
b436e26e	31	errmsg = "unlinked synchronously";
9cb2173e EG	32	break;
9cb2173e EG	33	case -ECONNRESET:
b436e26e	34	errmsg = "unlinked asynchronously";
9cb2173e EG	35	break;
	36	case -ENOSR:
	37	errmsg = "Buffer error (overrun)";
	38	break;
	39	case -EPIPE:
	40	errmsg = "Stalled (device not responding)";
	41	break;
	42	case -EOVERFLOW:
	43	errmsg = "Babble (bad cable?)";
	44	break;
	45	case -EPROTO:
	46	errmsg = "Bit-stuff error (bad cable?)";
	47	break;
	48	case -EILSEQ:
	49	errmsg = "CRC/Timeout (could be anything)";
	50	break;
	51	case -ETIME:
	52	errmsg = "Device does not respond";
	53	break;
	54	}
	55
	56	if (packet < 0)
	57	printk_ratelimited(KERN_WARNING "URB status %d [%s].\n",
	58	status, errmsg);
	59	else
	60	printk_ratelimited(KERN_INFO "URB packet %d, status %d [%s].\n",
	61	packet, status, errmsg);
	62	}
	63
	64	static inline
	65	struct stk1160_buffer stk1160_next_buffer(struct stk1160 dev)
	66	{
	67	struct stk1160_buffer *buf = NULL;
	68	unsigned long flags = 0;
	69
	70	/* Current buffer must be NULL when this functions gets called */
e003ae39	71	WARN_ON(dev->isoc_ctl.buf);
9cb2173e EG	72
	73	spin_lock_irqsave(&dev->buf_lock, flags);
	74	if (!list_empty(&dev->avail_bufs)) {
	75	buf = list_first_entry(&dev->avail_bufs,
	76	struct stk1160_buffer, list);
	77	list_del(&buf->list);
	78	}
	79	spin_unlock_irqrestore(&dev->buf_lock, flags);
	80
	81	return buf;
	82	}
	83
	84	static inline
	85	void stk1160_buffer_done(struct stk1160 *dev)
	86	{
	87	struct stk1160_buffer *buf = dev->isoc_ctl.buf;
	88
2d700715 JS	89	buf->vb.sequence = dev->sequence++;
2d700715 JS	90	buf->vb.field = V4L2_FIELD_INTERLACED;
d6dd645e	91	buf->vb.vb2_buf.timestamp = ktime_get_ns();
9cb2173e	92
2d700715 JS	93	vb2_set_plane_payload(&buf->vb.vb2_buf, 0, buf->bytesused);
2d700715 JS	94	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
9cb2173e EG	95
	96	dev->isoc_ctl.buf = NULL;
	97	}
	98
	99	static inline
	100	void stk1160_copy_video(struct stk1160 dev, u8 src, int len)
	101	{
	102	int linesdone, lineoff, lencopy;
	103	int bytesperline = dev->width * 2;
	104	struct stk1160_buffer *buf = dev->isoc_ctl.buf;
	105	u8 *dst = buf->mem;
	106	int remain;
	107
	108	/*
	109	* TODO: These stk1160_dbg are very spammy!
	110	* We should 1) check why we are getting them
	111	* and 2) add ratelimit.
	112	*
	113	* UPDATE: One of the reasons (the only one?) for getting these
	114	* is incorrect standard (mismatch between expected and configured).
	115	* So perhaps, we could add a counter for errors. When the counter
	116	* reaches some value, we simply stop streaming.
	117	*/
	118
	119	len -= 4;
	120	src += 4;
	121
	122	remain = len;
	123
	124	linesdone = buf->pos / bytesperline;
	125	lineoff = buf->pos % bytesperline; /* offset in current line */
	126
	127	if (!buf->odd)
	128	dst += bytesperline;
	129
	130	/* Multiply linesdone by two, to take account of the other field */
	131	dst += linesdone * bytesperline * 2 + lineoff;
	132
	133	/* Copy the remaining of current line */
	134	if (remain < (bytesperline - lineoff))
	135	lencopy = remain;
	136	else
	137	lencopy = bytesperline - lineoff;
	138
	139	/*
	140	* Check if we have enough space left in the buffer.
	141	* In that case, we force loop exit after copy.
	142	*/
	143	if (lencopy > buf->bytesused - buf->length) {
	144	lencopy = buf->bytesused - buf->length;
	145	remain = lencopy;
	146	}
	147
	148	/* Check if the copy is done */
	149	if (lencopy == 0 \|\| remain == 0)
	150	return;
	151
	152	/* Let the bug hunt begin! sanity checks! */
	153	if (lencopy < 0) {
	154	stk1160_dbg("copy skipped: negative lencopy\n");
	155	return;
	156	}
	157
	158	if ((unsigned long)dst + lencopy >
159	(unsigned long)buf->mem + buf->length) {
160	printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");
161	return;
162	}
163
164	memcpy(dst, src, lencopy);
165
166	buf->bytesused += lencopy;
167	buf->pos += lencopy;
168	remain -= lencopy;
169
170	/* Copy current field line by line, interlacing with the other field */
171	while (remain > 0) {
172
173	dst += lencopy + bytesperline;
174	src += lencopy;
175
176	/* Copy one line at a time */
177	if (remain < bytesperline)
178	lencopy = remain;
179	else
180	lencopy = bytesperline;
181
182	/*
183	* Check if we have enough space left in the buffer.
184	* In that case, we force loop exit after copy.
185	*/
186	if (lencopy > buf->bytesused - buf->length) {
187	lencopy = buf->bytesused - buf->length;
188	remain = lencopy;
189	}
190
191	/* Check if the copy is done */
192	if (lencopy == 0 \|\| remain == 0)
193	return;
194
195	if (lencopy < 0) {
196	printk_ratelimited(KERN_WARNING "stk1160: negative lencopy detected\n");
197	return;
198	}
199
200	if ((unsigned long)dst + lencopy >
201	(unsigned long)buf->mem + buf->length) {
202	printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");
203	return;
204	}
205
206	memcpy(dst, src, lencopy);
207	remain -= lencopy;
208
209	buf->bytesused += lencopy;
210	buf->pos += lencopy;
211	}
212	}
213
214	/*
215	* Controls the isoc copy of each urb packet
216	*/
217	static void stk1160_process_isoc(struct stk1160 dev, struct urb urb)
218	{
219	int i, len, status;
220	u8 *p;
221
222	if (!dev) {
223	stk1160_warn("%s called with null device\n", __func__);
224	return;
225	}
226
227	if (urb->status < 0) {
228	/* Print status and drop current packet (or field?) */
229	print_err_status(dev, -1, urb->status);
230	return;
231	}
232
233	for (i = 0; i < urb->number_of_packets; i++) {
234	status = urb->iso_frame_desc[i].status;
235	if (status < 0) {
236	print_err_status(dev, i, status);
237	continue;
238	}
239
240	/* Get packet actual length and pointer to data */
241	p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
242	len = urb->iso_frame_desc[i].actual_length;
243
244	/* Empty packet */
245	if (len <= 4)
246	continue;
247
248	/*
249	* An 8-byte packet sequence means end of field.
250	* So if we don't have any packet, we start receiving one now
251	* and if we do have a packet, then we are done with it.
252	*
253	* These end of field packets are always 0xc0 or 0x80,
254	* but not always 8-byte long so we don't check packet length.
255	*/
256	if (p[0] == 0xc0) {
257
258	/*
259	* If first byte is 0xc0 then we received
260	* second field, and frame has ended.
261	*/
262	if (dev->isoc_ctl.buf != NULL)
263	stk1160_buffer_done(dev);
264
265	dev->isoc_ctl.buf = stk1160_next_buffer(dev);
266	if (dev->isoc_ctl.buf == NULL)
267	return;
268	}
269
270	/*
271	* If we don't have a buffer here, then it means we
272	* haven't found the start mark sequence.
273	*/
274	if (dev->isoc_ctl.buf == NULL)
275	continue;
276
277	if (p[0] == 0xc0 \|\| p[0] == 0x80) {
278
279	/* We set next packet parity and
280	* continue to get next one
281	*/
282	dev->isoc_ctl.buf->odd = *p & 0x40;
283	dev->isoc_ctl.buf->pos = 0;
284	continue;
285	}
286
287	stk1160_copy_video(dev, p, len);
288	}
289	}
290
291
292	/*
293	* IRQ callback, called by URB callback
294	*/
295	static void stk1160_isoc_irq(struct urb *urb)
296	{
297	int i, rc;
298	struct stk1160 *dev = urb->context;
299
300	switch (urb->status) {
301	case 0:
302	break;
303	case -ECONNRESET: /* kill */
304	case -ENOENT:
305	case -ESHUTDOWN:
306	/* TODO: check uvc driver: he frees the queue here */
307	return;
308	default:
309	stk1160_err("urb error! status %d\n", urb->status);
310	return;
311	}
312
313	stk1160_process_isoc(dev, urb);
314
315	/* Reset urb buffers */
316	for (i = 0; i < urb->number_of_packets; i++) {
317	urb->iso_frame_desc[i].status = 0;
318	urb->iso_frame_desc[i].actual_length = 0;
319	}
320
321	rc = usb_submit_urb(urb, GFP_ATOMIC);
322	if (rc)
323	stk1160_err("urb re-submit failed (%d)\n", rc);
324	}
325
326	/*
327	* Cancel urbs
328	* This function can't be called in atomic context
329	*/
330	void stk1160_cancel_isoc(struct stk1160 *dev)
331	{
18ad8965	332	int i, num_bufs = dev->isoc_ctl.num_bufs;
9cb2173e EG	333
	334	/*
	335	* This check is not necessary, but we add it
	336	* to avoid a spurious debug message
	337	*/
18ad8965	338	if (!num_bufs)
9cb2173e EG	339	return;
9cb2173e EG	340
18ad8965	341	stk1160_dbg("killing %d urbs...\n", num_bufs);
9cb2173e	342
18ad8965	343	for (i = 0; i < num_bufs; i++) {
9cb2173e EG	344
	345	/*
	346	* To kill urbs we can't be in atomic context.
	347	* We don't care for NULL pointer since
	348	* usb_kill_urb allows it.
	349	*/
	350	usb_kill_urb(dev->isoc_ctl.urb[i]);
	351	}
	352
	353	stk1160_dbg("all urbs killed\n");
	354	}
	355
	356	/*
	357	* Releases urb and transfer buffers
	358	* Obviusly, associated urb must be killed before releasing it.
	359	*/
	360	void stk1160_free_isoc(struct stk1160 *dev)
	361	{
	362	struct urb *urb;
18ad8965	363	int i, num_bufs = dev->isoc_ctl.num_bufs;
9cb2173e	364
18ad8965	365	stk1160_dbg("freeing %d urb buffers...\n", num_bufs);
9cb2173e	366
18ad8965	367	for (i = 0; i < num_bufs; i++) {
9cb2173e EG	368
	369	urb = dev->isoc_ctl.urb[i];
	370	if (urb) {
	371
	372	if (dev->isoc_ctl.transfer_buffer[i]) {
	373	#ifndef CONFIG_DMA_NONCOHERENT
	374	usb_free_coherent(dev->udev,
	375	urb->transfer_buffer_length,
	376	dev->isoc_ctl.transfer_buffer[i],
	377	urb->transfer_dma);
	378	#else
	379	kfree(dev->isoc_ctl.transfer_buffer[i]);
	380	#endif
	381	}
	382	usb_free_urb(urb);
	383	dev->isoc_ctl.urb[i] = NULL;
	384	}
	385	dev->isoc_ctl.transfer_buffer[i] = NULL;
	386	}
	387
	388	kfree(dev->isoc_ctl.urb);
	389	kfree(dev->isoc_ctl.transfer_buffer);
	390
	391	dev->isoc_ctl.urb = NULL;
	392	dev->isoc_ctl.transfer_buffer = NULL;
	393	dev->isoc_ctl.num_bufs = 0;
	394
	395	stk1160_dbg("all urb buffers freed\n");
	396	}
	397
	398	/*
	399	* Helper for cancelling and freeing urbs
	400	* This function can't be called in atomic context
	401	*/
	402	void stk1160_uninit_isoc(struct stk1160 *dev)
	403	{
	404	stk1160_cancel_isoc(dev);
	405	stk1160_free_isoc(dev);
	406	}
	407
	408	/*
	409	* Allocate URBs
	410	*/
	411	int stk1160_alloc_isoc(struct stk1160 *dev)
	412	{
	413	struct urb *urb;
	414	int i, j, k, sb_size, max_packets, num_bufs;
	415
	416	/*
	417	* It may be necessary to release isoc here,
	418	* since isoc are only released on disconnection.
	419	* (see new_pkt_size flag)
	420	*/
	421	if (dev->isoc_ctl.num_bufs)
	422	stk1160_uninit_isoc(dev);
	423
	424	stk1160_dbg("allocating urbs...\n");
	425
	426	num_bufs = STK1160_NUM_BUFS;
	427	max_packets = STK1160_NUM_PACKETS;
	428	sb_size = max_packets * dev->max_pkt_size;
	429
	430	dev->isoc_ctl.buf = NULL;
	431	dev->isoc_ctl.max_pkt_size = dev->max_pkt_size;
6396bb22	432	dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
9cb2173e EG	433	if (!dev->isoc_ctl.urb) {
	434	stk1160_err("out of memory for urb array\n");
	435	return -ENOMEM;
	436	}
	437
6396bb22 KC	438	dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *),
6396bb22 KC	439	GFP_KERNEL);
9cb2173e EG	440	if (!dev->isoc_ctl.transfer_buffer) {
	441	stk1160_err("out of memory for usb transfers\n");
	442	kfree(dev->isoc_ctl.urb);
	443	return -ENOMEM;
	444	}
	445
	446	/* allocate urbs and transfer buffers */
	447	for (i = 0; i < num_bufs; i++) {
	448
	449	urb = usb_alloc_urb(max_packets, GFP_KERNEL);
9d849287	450	if (!urb)
06574184	451	goto free_i_bufs;
9cb2173e EG	452	dev->isoc_ctl.urb[i] = urb;
	453
	454	#ifndef CONFIG_DMA_NONCOHERENT
	455	dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
	456	sb_size, GFP_KERNEL, &urb->transfer_dma);
	457	#else
	458	dev->isoc_ctl.transfer_buffer[i] = kmalloc(sb_size, GFP_KERNEL);
	459	#endif
	460	if (!dev->isoc_ctl.transfer_buffer[i]) {
06574184 EG	461	stk1160_err("cannot alloc %d bytes for tx[%d] buffer\n",
06574184 EG	462	sb_size, i);
2902fb7e EG	463
	464	/* Not enough transfer buffers, so just give up */
	465	if (i < STK1160_MIN_BUFS)
	466	goto free_i_bufs;
	467	goto nomore_tx_bufs;
9cb2173e EG	468	}
	469	memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
	470
	471	/*
	472	* FIXME: Where can I get the endpoint?
	473	*/
	474	urb->dev = dev->udev;
	475	urb->pipe = usb_rcvisocpipe(dev->udev, STK1160_EP_VIDEO);
	476	urb->transfer_buffer = dev->isoc_ctl.transfer_buffer[i];
	477	urb->transfer_buffer_length = sb_size;
	478	urb->complete = stk1160_isoc_irq;
	479	urb->context = dev;
	480	urb->interval = 1;
	481	urb->start_frame = 0;
	482	urb->number_of_packets = max_packets;
	483	#ifndef CONFIG_DMA_NONCOHERENT
	484	urb->transfer_flags = URB_ISO_ASAP \| URB_NO_TRANSFER_DMA_MAP;
	485	#else
	486	urb->transfer_flags = URB_ISO_ASAP;
	487	#endif
	488
	489	k = 0;
	490	for (j = 0; j < max_packets; j++) {
	491	urb->iso_frame_desc[j].offset = k;
	492	urb->iso_frame_desc[j].length =
	493	dev->isoc_ctl.max_pkt_size;
	494	k += dev->isoc_ctl.max_pkt_size;
	495	}
	496	}
	497
2902fb7e	498	stk1160_dbg("%d urbs allocated\n", num_bufs);
9cb2173e EG	499
	500	/* At last we can say we have some buffers */
	501	dev->isoc_ctl.num_bufs = num_bufs;
	502
	503	return 0;
06574184	504
2902fb7e EG	505	nomore_tx_bufs:
	506	/*
	507	* Failed to allocate desired buffer count. However, we may have
	508	* enough to work fine, so we just free the extra urb,
	509	* store the allocated count and keep going, fingers crossed!
	510	*/
	511	usb_free_urb(dev->isoc_ctl.urb[i]);
	512	dev->isoc_ctl.urb[i] = NULL;
	513
	514	stk1160_warn("%d urbs allocated. Trying to continue...\n", i - 1);
	515
	516	dev->isoc_ctl.num_bufs = i - 1;
	517
	518	return 0;
	519
06574184 EG	520	free_i_bufs:
	521	/* Save the allocated buffers so far, so we can properly free them */
	522	dev->isoc_ctl.num_bufs = i+1;
	523	stk1160_free_isoc(dev);
	524	return -ENOMEM;
9cb2173e EG	525	}
9cb2173e EG	526