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