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