540 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * STK1160 driver4 *5 * Copyright (C) 2012 Ezequiel Garcia6 * <elezegarcia--a.t--gmail.com>7 *8 * Based on Easycap driver by R.M. Thomas9 * Copyright (C) 2010 R.M. Thomas10 * <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 20static unsigned int debug;21module_param(debug, int, 0644);22MODULE_PARM_DESC(debug, "enable debug messages");23 24static 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 else60 printk_ratelimited(KERN_INFO "URB packet %d, status %d [%s].\n",61 packet, status, errmsg);62}63 64static inline65struct 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 84static inline85void 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 99static inline100void stk1160_copy_video(struct stk1160 *dev, u8 *src, int len)101{102 int linesdone, lineoff, lencopy, offset;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 check why we are getting them.111 *112 * UPDATE: One of the reasons (the only one?) for getting these113 * is incorrect standard (mismatch between expected and configured).114 * So perhaps, we could add a counter for errors. When the counter115 * reaches some value, we simply stop streaming.116 */117 118 len -= 4;119 src += 4;120 121 remain = len;122 123 linesdone = buf->pos / bytesperline;124 lineoff = buf->pos % bytesperline; /* offset in current line */125 126 if (!buf->odd)127 dst += bytesperline;128 129 /* Multiply linesdone by two, to take account of the other field */130 dst += linesdone * bytesperline * 2 + lineoff;131 132 /* Copy the remaining of current line */133 lencopy = min(remain, bytesperline - lineoff);134 135 /*136 * Check if we have enough space left in the buffer.137 * In that case, we force loop exit after copy.138 */139 offset = dst - (u8 *)buf->mem;140 if (offset > buf->length) {141 dev_warn_ratelimited(dev->dev, "out of bounds offset\n");142 return;143 }144 if (lencopy > buf->length - offset) {145 lencopy = buf->length - offset;146 remain = lencopy;147 }148 149 /* Check if the copy is done */150 if (lencopy == 0 || remain == 0)151 return;152 153 /* Let the bug hunt begin! sanity checks! */154 if (lencopy < 0) {155 printk_ratelimited(KERN_DEBUG "copy skipped: negative lencopy\n");156 return;157 }158 159 if ((unsigned long)dst + lencopy >160 (unsigned long)buf->mem + buf->length) {161 printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");162 return;163 }164 165 memcpy(dst, src, lencopy);166 167 buf->bytesused += lencopy;168 buf->pos += lencopy;169 remain -= lencopy;170 171 /* Copy current field line by line, interlacing with the other field */172 while (remain > 0) {173 174 dst += lencopy + bytesperline;175 src += lencopy;176 177 /* Copy one line at a time */178 lencopy = min(remain, bytesperline);179 180 /*181 * Check if we have enough space left in the buffer.182 * In that case, we force loop exit after copy.183 */184 offset = dst - (u8 *)buf->mem;185 if (offset > buf->length) {186 dev_warn_ratelimited(dev->dev, "offset out of bounds\n");187 return;188 }189 if (lencopy > buf->length - offset) {190 lencopy = buf->length - offset;191 remain = lencopy;192 }193 194 /* Check if the copy is done */195 if (lencopy == 0 || remain == 0)196 return;197 198 if (lencopy < 0) {199 printk_ratelimited(KERN_WARNING "stk1160: negative lencopy detected\n");200 return;201 }202 203 if ((unsigned long)dst + lencopy >204 (unsigned long)buf->mem + buf->length) {205 printk_ratelimited(KERN_WARNING "stk1160: buffer overflow detected\n");206 return;207 }208 209 memcpy(dst, src, lencopy);210 remain -= lencopy;211 212 buf->bytesused += lencopy;213 buf->pos += lencopy;214 }215}216 217/*218 * Controls the isoc copy of each urb packet219 */220static void stk1160_process_isoc(struct stk1160 *dev, struct urb *urb)221{222 int i, len, status;223 u8 *p;224 225 if (!dev) {226 stk1160_warn("%s called with null device\n", __func__);227 return;228 }229 230 if (urb->status < 0) {231 /* Print status and drop current packet (or field?) */232 print_err_status(dev, -1, urb->status);233 return;234 }235 236 for (i = 0; i < urb->number_of_packets; i++) {237 status = urb->iso_frame_desc[i].status;238 if (status < 0) {239 print_err_status(dev, i, status);240 continue;241 }242 243 /* Get packet actual length and pointer to data */244 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;245 len = urb->iso_frame_desc[i].actual_length;246 247 /* Empty packet */248 if (len <= 4)249 continue;250 251 /*252 * An 8-byte packet sequence means end of field.253 * So if we don't have any packet, we start receiving one now254 * and if we do have a packet, then we are done with it.255 *256 * These end of field packets are always 0xc0 or 0x80,257 * but not always 8-byte long so we don't check packet length.258 */259 if (p[0] == 0xc0) {260 261 /*262 * If first byte is 0xc0 then we received263 * second field, and frame has ended.264 */265 if (dev->isoc_ctl.buf != NULL)266 stk1160_buffer_done(dev);267 268 dev->isoc_ctl.buf = stk1160_next_buffer(dev);269 if (dev->isoc_ctl.buf == NULL)270 return;271 }272 273 /*274 * If we don't have a buffer here, then it means we275 * haven't found the start mark sequence.276 */277 if (dev->isoc_ctl.buf == NULL)278 continue;279 280 if (p[0] == 0xc0 || p[0] == 0x80) {281 282 /* We set next packet parity and283 * continue to get next one284 */285 dev->isoc_ctl.buf->odd = *p & 0x40;286 dev->isoc_ctl.buf->pos = 0;287 continue;288 }289 290 stk1160_copy_video(dev, p, len);291 }292}293 294 295/*296 * IRQ callback, called by URB callback297 */298static void stk1160_isoc_irq(struct urb *urb)299{300 int i, rc;301 struct stk1160_urb *stk_urb = urb->context;302 struct stk1160 *dev = stk_urb->dev;303 struct device *dma_dev = stk1160_get_dmadev(dev);304 305 switch (urb->status) {306 case 0:307 break;308 case -ECONNRESET: /* kill */309 case -ENOENT:310 case -ESHUTDOWN:311 /* TODO: check uvc driver: he frees the queue here */312 return;313 default:314 stk1160_err("urb error! status %d\n", urb->status);315 return;316 }317 318 invalidate_kernel_vmap_range(stk_urb->transfer_buffer,319 urb->transfer_buffer_length);320 dma_sync_sgtable_for_cpu(dma_dev, stk_urb->sgt, DMA_FROM_DEVICE);321 322 stk1160_process_isoc(dev, urb);323 324 /* Reset urb buffers */325 for (i = 0; i < urb->number_of_packets; i++) {326 urb->iso_frame_desc[i].status = 0;327 urb->iso_frame_desc[i].actual_length = 0;328 }329 330 dma_sync_sgtable_for_device(dma_dev, stk_urb->sgt, DMA_FROM_DEVICE);331 rc = usb_submit_urb(urb, GFP_ATOMIC);332 if (rc)333 stk1160_err("urb re-submit failed (%d)\n", rc);334}335 336/*337 * Cancel urbs338 * This function can't be called in atomic context339 */340void stk1160_cancel_isoc(struct stk1160 *dev)341{342 int i, num_bufs = dev->isoc_ctl.num_bufs;343 344 /*345 * This check is not necessary, but we add it346 * to avoid a spurious debug message347 */348 if (!num_bufs)349 return;350 351 stk1160_dbg("killing %d urbs...\n", num_bufs);352 353 for (i = 0; i < num_bufs; i++) {354 355 /*356 * To kill urbs we can't be in atomic context.357 * We don't care for NULL pointer since358 * usb_kill_urb allows it.359 */360 usb_kill_urb(dev->isoc_ctl.urb_ctl[i].urb);361 }362 363 stk1160_dbg("all urbs killed\n");364}365 366static void stk_free_urb(struct stk1160 *dev, struct stk1160_urb *stk_urb)367{368 struct device *dma_dev = stk1160_get_dmadev(dev);369 370 dma_vunmap_noncontiguous(dma_dev, stk_urb->transfer_buffer);371 dma_free_noncontiguous(dma_dev, stk_urb->urb->transfer_buffer_length,372 stk_urb->sgt, DMA_FROM_DEVICE);373 usb_free_urb(stk_urb->urb);374 375 stk_urb->transfer_buffer = NULL;376 stk_urb->sgt = NULL;377 stk_urb->urb = NULL;378 stk_urb->dev = NULL;379 stk_urb->dma = 0;380}381 382/*383 * Releases urb and transfer buffers384 * Obviusly, associated urb must be killed before releasing it.385 */386void stk1160_free_isoc(struct stk1160 *dev)387{388 int i, num_bufs = dev->isoc_ctl.num_bufs;389 390 stk1160_dbg("freeing %d urb buffers...\n", num_bufs);391 392 for (i = 0; i < num_bufs; i++)393 stk_free_urb(dev, &dev->isoc_ctl.urb_ctl[i]);394 395 dev->isoc_ctl.num_bufs = 0;396 397 stk1160_dbg("all urb buffers freed\n");398}399 400/*401 * Helper for cancelling and freeing urbs402 * This function can't be called in atomic context403 */404void stk1160_uninit_isoc(struct stk1160 *dev)405{406 stk1160_cancel_isoc(dev);407 stk1160_free_isoc(dev);408}409 410static int stk1160_fill_urb(struct stk1160 *dev, struct stk1160_urb *stk_urb,411 int sb_size, int max_packets)412{413 struct device *dma_dev = stk1160_get_dmadev(dev);414 415 stk_urb->urb = usb_alloc_urb(max_packets, GFP_KERNEL);416 if (!stk_urb->urb)417 return -ENOMEM;418 stk_urb->sgt = dma_alloc_noncontiguous(dma_dev, sb_size,419 DMA_FROM_DEVICE, GFP_KERNEL, 0);420 421 /*422 * If the buffer allocation failed, we exit but return 0 since423 * we allow the driver working with less buffers424 */425 if (!stk_urb->sgt)426 goto free_urb;427 428 stk_urb->transfer_buffer = dma_vmap_noncontiguous(dma_dev, sb_size,429 stk_urb->sgt);430 if (!stk_urb->transfer_buffer)431 goto free_sgt;432 433 stk_urb->dma = stk_urb->sgt->sgl->dma_address;434 stk_urb->dev = dev;435 return 0;436free_sgt:437 dma_free_noncontiguous(dma_dev, sb_size, stk_urb->sgt, DMA_FROM_DEVICE);438 stk_urb->sgt = NULL;439free_urb:440 usb_free_urb(stk_urb->urb);441 stk_urb->urb = NULL;442 443 return 0;444}445/*446 * Allocate URBs447 */448int stk1160_alloc_isoc(struct stk1160 *dev)449{450 struct urb *urb;451 int i, j, k, sb_size, max_packets, num_bufs;452 int ret;453 454 /*455 * It may be necessary to release isoc here,456 * since isoc are only released on disconnection.457 * (see new_pkt_size flag)458 */459 if (dev->isoc_ctl.num_bufs)460 stk1160_uninit_isoc(dev);461 462 stk1160_dbg("allocating urbs...\n");463 464 num_bufs = STK1160_NUM_BUFS;465 max_packets = STK1160_NUM_PACKETS;466 sb_size = max_packets * dev->max_pkt_size;467 468 dev->isoc_ctl.buf = NULL;469 dev->isoc_ctl.max_pkt_size = dev->max_pkt_size;470 471 /* allocate urbs and transfer buffers */472 for (i = 0; i < num_bufs; i++) {473 474 ret = stk1160_fill_urb(dev, &dev->isoc_ctl.urb_ctl[i],475 sb_size, max_packets);476 if (ret)477 goto free_i_bufs;478 479 urb = dev->isoc_ctl.urb_ctl[i].urb;480 481 if (!urb) {482 /* Not enough transfer buffers, so just give up */483 if (i < STK1160_MIN_BUFS)484 goto free_i_bufs;485 goto nomore_tx_bufs;486 }487 memset(dev->isoc_ctl.urb_ctl[i].transfer_buffer, 0, sb_size);488 489 /*490 * FIXME: Where can I get the endpoint?491 */492 urb->dev = dev->udev;493 urb->pipe = usb_rcvisocpipe(dev->udev, STK1160_EP_VIDEO);494 urb->transfer_buffer = dev->isoc_ctl.urb_ctl[i].transfer_buffer;495 urb->transfer_buffer_length = sb_size;496 urb->complete = stk1160_isoc_irq;497 urb->context = &dev->isoc_ctl.urb_ctl[i];498 urb->interval = 1;499 urb->start_frame = 0;500 urb->number_of_packets = max_packets;501 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;502 urb->transfer_dma = dev->isoc_ctl.urb_ctl[i].dma;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 520nomore_tx_bufs:521 /*522 * Failed to allocate desired buffer count. However, we may have523 * enough to work fine, so we just free the extra urb,524 * store the allocated count and keep going, fingers crossed!525 */526 527 stk1160_warn("%d urbs allocated. Trying to continue...\n", i);528 529 dev->isoc_ctl.num_bufs = i;530 531 return 0;532 533free_i_bufs:534 /* Save the allocated buffers so far, so we can properly free them */535 dev->isoc_ctl.num_bufs = i;536 stk1160_free_isoc(dev);537 return -ENOMEM;538}539 540