kernel/drivers/media/usb/stk1160/stk1160-video.c

   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