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, 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 these 113 * is incorrect standard (mismatch between expected and configured). 114 * So perhaps, we could add a counter for errors. When the counter 115 * 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 packet 219 */ 220 static 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 now 254 * 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 received 263 * 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 we 275 * 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 and 283 * continue to get next one 284 */ 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 callback 297 */ 298 static void stk1160_isoc_irq(struct urb *urb) 299 { 300 int i, rc; 301 struct stk1160 *dev = urb->context; 302 303 switch (urb->status) { 304 case 0: 305 break; 306 case -ECONNRESET: /* kill */ 307 case -ENOENT: 308 case -ESHUTDOWN: 309 /* TODO: check uvc driver: he frees the queue here */ 310 return; 311 default: 312 stk1160_err("urb error! status %d\n", urb->status); 313 return; 314 } 315 316 stk1160_process_isoc(dev, urb); 317 318 /* Reset urb buffers */ 319 for (i = 0; i < urb->number_of_packets; i++) { 320 urb->iso_frame_desc[i].status = 0; 321 urb->iso_frame_desc[i].actual_length = 0; 322 } 323 324 rc = usb_submit_urb(urb, GFP_ATOMIC); 325 if (rc) 326 stk1160_err("urb re-submit failed (%d)\n", rc); 327 } 328 329 /* 330 * Cancel urbs 331 * This function can't be called in atomic context 332 */ 333 void stk1160_cancel_isoc(struct stk1160 *dev) 334 { 335 int i, num_bufs = dev->isoc_ctl.num_bufs; 336 337 /* 338 * This check is not necessary, but we add it 339 * to avoid a spurious debug message 340 */ 341 if (!num_bufs) 342 return; 343 344 stk1160_dbg("killing %d urbs...\n", num_bufs); 345 346 for (i = 0; i < num_bufs; i++) { 347 348 /* 349 * To kill urbs we can't be in atomic context. 350 * We don't care for NULL pointer since 351 * usb_kill_urb allows it. 352 */ 353 usb_kill_urb(dev->isoc_ctl.urb_ctl[i].urb); 354 } 355 356 stk1160_dbg("all urbs killed\n"); 357 } 358 359 static void stk_free_urb(struct stk1160 *dev, struct stk1160_urb *stk_urb) 360 { 361 usb_free_noncoherent(dev->udev, stk_urb->urb->transfer_buffer_length, 362 stk_urb->transfer_buffer, DMA_FROM_DEVICE, 363 stk_urb->sgt); 364 usb_free_urb(stk_urb->urb); 365 366 stk_urb->transfer_buffer = NULL; 367 stk_urb->sgt = NULL; 368 stk_urb->urb = NULL; 369 stk_urb->dev = NULL; 370 stk_urb->dma = 0; 371 } 372 373 /* 374 * Releases urb and transfer buffers 375 * Obviusly, associated urb must be killed before releasing it. 376 */ 377 void stk1160_free_isoc(struct stk1160 *dev) 378 { 379 int i, num_bufs = dev->isoc_ctl.num_bufs; 380 381 stk1160_dbg("freeing %d urb buffers...\n", num_bufs); 382 383 for (i = 0; i < num_bufs; i++) 384 stk_free_urb(dev, &dev->isoc_ctl.urb_ctl[i]); 385 386 dev->isoc_ctl.num_bufs = 0; 387 388 stk1160_dbg("all urb buffers freed\n"); 389 } 390 391 /* 392 * Helper for cancelling and freeing urbs 393 * This function can't be called in atomic context 394 */ 395 void stk1160_uninit_isoc(struct stk1160 *dev) 396 { 397 stk1160_cancel_isoc(dev); 398 stk1160_free_isoc(dev); 399 } 400 401 static int stk1160_fill_urb(struct stk1160 *dev, struct stk1160_urb *stk_urb, 402 int sb_size, int max_packets) 403 { 404 stk_urb->urb = usb_alloc_urb(max_packets, GFP_KERNEL); 405 if (!stk_urb->urb) 406 return -ENOMEM; 407 408 stk_urb->transfer_buffer = usb_alloc_noncoherent(dev->udev, sb_size, 409 GFP_KERNEL, &stk_urb->dma, 410 DMA_FROM_DEVICE, &stk_urb->sgt); 411 if (!stk_urb->transfer_buffer) 412 goto free_urb; 413 414 stk_urb->dev = dev; 415 return 0; 416 417 free_urb: 418 usb_free_urb(stk_urb->urb); 419 stk_urb->urb = NULL; 420 421 return 0; 422 } 423 /* 424 * Allocate URBs 425 */ 426 int stk1160_alloc_isoc(struct stk1160 *dev) 427 { 428 struct urb *urb; 429 int i, j, k, sb_size, max_packets, num_bufs; 430 int ret; 431 432 /* 433 * It may be necessary to release isoc here, 434 * since isoc are only released on disconnection. 435 * (see new_pkt_size flag) 436 */ 437 if (dev->isoc_ctl.num_bufs) 438 stk1160_uninit_isoc(dev); 439 440 stk1160_dbg("allocating urbs...\n"); 441 442 num_bufs = STK1160_NUM_BUFS; 443 max_packets = STK1160_NUM_PACKETS; 444 sb_size = max_packets * dev->max_pkt_size; 445 446 dev->isoc_ctl.buf = NULL; 447 dev->isoc_ctl.max_pkt_size = dev->max_pkt_size; 448 449 /* allocate urbs and transfer buffers */ 450 for (i = 0; i < num_bufs; i++) { 451 452 ret = stk1160_fill_urb(dev, &dev->isoc_ctl.urb_ctl[i], 453 sb_size, max_packets); 454 if (ret) 455 goto free_i_bufs; 456 457 urb = dev->isoc_ctl.urb_ctl[i].urb; 458 459 if (!urb) { 460 /* Not enough transfer buffers, so just give up */ 461 if (i < STK1160_MIN_BUFS) 462 goto free_i_bufs; 463 goto nomore_tx_bufs; 464 } 465 memset(dev->isoc_ctl.urb_ctl[i].transfer_buffer, 0, sb_size); 466 467 /* 468 * FIXME: Where can I get the endpoint? 469 */ 470 urb->dev = dev->udev; 471 urb->pipe = usb_rcvisocpipe(dev->udev, STK1160_EP_VIDEO); 472 urb->transfer_buffer = dev->isoc_ctl.urb_ctl[i].transfer_buffer; 473 urb->transfer_buffer_length = sb_size; 474 urb->complete = stk1160_isoc_irq; 475 urb->context = dev; 476 urb->interval = 1; 477 urb->start_frame = 0; 478 urb->number_of_packets = max_packets; 479 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 480 urb->transfer_dma = dev->isoc_ctl.urb_ctl[i].dma; 481 urb->sgt = dev->isoc_ctl.urb_ctl[i].sgt; 482 483 k = 0; 484 for (j = 0; j < max_packets; j++) { 485 urb->iso_frame_desc[j].offset = k; 486 urb->iso_frame_desc[j].length = 487 dev->isoc_ctl.max_pkt_size; 488 k += dev->isoc_ctl.max_pkt_size; 489 } 490 } 491 492 stk1160_dbg("%d urbs allocated\n", num_bufs); 493 494 /* At last we can say we have some buffers */ 495 dev->isoc_ctl.num_bufs = num_bufs; 496 497 return 0; 498 499 nomore_tx_bufs: 500 /* 501 * Failed to allocate desired buffer count. However, we may have 502 * enough to work fine, so we just free the extra urb, 503 * store the allocated count and keep going, fingers crossed! 504 */ 505 506 stk1160_warn("%d urbs allocated. Trying to continue...\n", i); 507 508 dev->isoc_ctl.num_bufs = i; 509 510 return 0; 511 512 free_i_bufs: 513 /* Save the allocated buffers so far, so we can properly free them */ 514 dev->isoc_ctl.num_bufs = i; 515 stk1160_free_isoc(dev); 516 return -ENOMEM; 517 } 518 519