xref: /linux/drivers/media/usb/stk1160/stk1160-video.c (revision a4eb44a6435d6d8f9e642407a4a06f65eb90ca04) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
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>
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:
31 		errmsg = "unlinked synchronously";
32 		break;
33 	case -ECONNRESET:
34 		errmsg = "unlinked asynchronously";
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 */
71 	WARN_ON(dev->isoc_ctl.buf);
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 
89 	buf->vb.sequence = dev->sequence++;
90 	buf->vb.field = V4L2_FIELD_INTERLACED;
91 	buf->vb.vb2_buf.timestamp = ktime_get_ns();
92 
93 	vb2_set_plane_payload(&buf->vb.vb2_buf, 0, buf->bytesused);
94 	vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
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 {
332 	int i, num_bufs = dev->isoc_ctl.num_bufs;
333 
334 	/*
335 	 * This check is not necessary, but we add it
336 	 * to avoid a spurious debug message
337 	 */
338 	if (!num_bufs)
339 		return;
340 
341 	stk1160_dbg("killing %d urbs...\n", num_bufs);
342 
343 	for (i = 0; i < num_bufs; i++) {
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;
363 	int i, num_bufs = dev->isoc_ctl.num_bufs;
364 
365 	stk1160_dbg("freeing %d urb buffers...\n", num_bufs);
366 
367 	for (i = 0; i < num_bufs; i++) {
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;
432 	dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
433 	if (!dev->isoc_ctl.urb) {
434 		stk1160_err("out of memory for urb array\n");
435 		return -ENOMEM;
436 	}
437 
438 	dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *),
439 						GFP_KERNEL);
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);
450 		if (!urb)
451 			goto free_i_bufs;
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]) {
461 			stk1160_err("cannot alloc %d bytes for tx[%d] buffer\n",
462 				sb_size, i);
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;
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 
498 	stk1160_dbg("%d urbs allocated\n", num_bufs);
499 
500 	/* At last we can say we have some buffers */
501 	dev->isoc_ctl.num_bufs = num_bufs;
502 
503 	return 0;
504 
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 
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;
525 }
526 
527