drivers/media/usb/au0828/au0828-video.c

   1 /*
   2  * Auvitek AU0828 USB Bridge (Analog video support)
   3  *
   4  * Copyright (C) 2009 Devin Heitmueller <dheitmueller@linuxtv.org>
   5  * Copyright (C) 2005-2008 Auvitek International, Ltd.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * As published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA.
  21  */
  22
  23 /* Developer Notes:
  24  *
  25  * VBI support is not yet working
  26  * The hardware scaler supported is unimplemented
  27  * AC97 audio support is unimplemented (only i2s audio mode)
  28  *
  29  */
  30
  31 #include "au0828.h"
  32
  33 #include <linux/module.h>
  34 #include <linux/slab.h>
  35 #include <linux/init.h>
  36 #include <linux/device.h>
  37 #include <media/v4l2-common.h>
  38 #include <media/v4l2-ioctl.h>
  39 #include <media/v4l2-event.h>
  40 #include <media/tuner.h>
  41 #include "au0828-reg.h"
  42
  43 static DEFINE_MUTEX(au0828_sysfs_lock);
  44
  45 /* ------------------------------------------------------------------
  46         Videobuf operations
  47    ------------------------------------------------------------------*/
  48
  49 static unsigned int isoc_debug;
  50 module_param(isoc_debug, int, 0644);
  51 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
  52
  53 #define au0828_isocdbg(fmt, arg...) \
  54 do {\
  55         if (isoc_debug) { \
  56                 pr_info("au0828 %s :"fmt, \
  57                        __func__ , ##arg);          \
  58         } \
  59   } while (0)
  60
  61 static inline void i2c_gate_ctrl(struct au0828_dev *dev, int val)
  62 {
  63         if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
  64                 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, val);
  65 }
  66
  67 static inline void print_err_status(struct au0828_dev *dev,
  68                                     int packet, int status)
  69 {
  70         char *errmsg = "Unknown";
  71
  72         switch (status) {
  73         case -ENOENT:
  74                 errmsg = "unlinked synchronuously";
  75                 break;
  76         case -ECONNRESET:
  77                 errmsg = "unlinked asynchronuously";
  78                 break;
  79         case -ENOSR:
  80                 errmsg = "Buffer error (overrun)";
  81                 break;
  82         case -EPIPE:
  83                 errmsg = "Stalled (device not responding)";
  84                 break;
  85         case -EOVERFLOW:
  86                 errmsg = "Babble (bad cable?)";
  87                 break;
  88         case -EPROTO:
  89                 errmsg = "Bit-stuff error (bad cable?)";
  90                 break;
  91         case -EILSEQ:
  92                 errmsg = "CRC/Timeout (could be anything)";
  93                 break;
  94         case -ETIME:
  95                 errmsg = "Device does not respond";
  96                 break;
  97         }
  98         if (packet < 0) {
  99                 au0828_isocdbg("URB status %d [%s].\n", status, errmsg);
 100         } else {
 101                 au0828_isocdbg("URB packet %d, status %d [%s].\n",
 102                                packet, status, errmsg);
 103         }
 104 }
 105
 106 static int check_dev(struct au0828_dev *dev)
 107 {
 108         if (dev->dev_state & DEV_DISCONNECTED) {
 109                 pr_info("v4l2 ioctl: device not present\n");
 110                 return -ENODEV;
 111         }
 112
 113         if (dev->dev_state & DEV_MISCONFIGURED) {
 114                 pr_info("v4l2 ioctl: device is misconfigured; "
 115                        "close and open it again\n");
 116                 return -EIO;
 117         }
 118         return 0;
 119 }
 120
 121 /*
 122  * IRQ callback, called by URB callback
 123  */
 124 static void au0828_irq_callback(struct urb *urb)
 125 {
 126         struct au0828_dmaqueue  *dma_q = urb->context;
 127         struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
 128         unsigned long flags = 0;
 129         int i;
 130
 131         switch (urb->status) {
 132         case 0:             /* success */
 133         case -ETIMEDOUT:    /* NAK */
 134                 break;
 135         case -ECONNRESET:   /* kill */
 136         case -ENOENT:
 137         case -ESHUTDOWN:
 138                 au0828_isocdbg("au0828_irq_callback called: status kill\n");
 139                 return;
 140         default:            /* unknown error */
 141                 au0828_isocdbg("urb completition error %d.\n", urb->status);
 142                 break;
 143         }
 144
 145         /* Copy data from URB */
 146         spin_lock_irqsave(&dev->slock, flags);
 147         dev->isoc_ctl.isoc_copy(dev, urb);
 148         spin_unlock_irqrestore(&dev->slock, flags);
 149
 150         /* Reset urb buffers */
 151         for (i = 0; i < urb->number_of_packets; i++) {
 152                 urb->iso_frame_desc[i].status = 0;
 153                 urb->iso_frame_desc[i].actual_length = 0;
 154         }
 155         urb->status = 0;
 156
 157         urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 158         if (urb->status) {
 159                 au0828_isocdbg("urb resubmit failed (error=%i)\n",
 160                                urb->status);
 161         }
 162         dev->stream_state = STREAM_ON;
 163 }
 164
 165 /*
 166  * Stop and Deallocate URBs
 167  */
 168 static void au0828_uninit_isoc(struct au0828_dev *dev)
 169 {
 170         struct urb *urb;
 171         int i;
 172
 173         au0828_isocdbg("au0828: called au0828_uninit_isoc\n");
 174
 175         dev->isoc_ctl.nfields = -1;
 176         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 177                 urb = dev->isoc_ctl.urb[i];
 178                 if (urb) {
 179                         if (!irqs_disabled())
 180                                 usb_kill_urb(urb);
 181                         else
 182                                 usb_unlink_urb(urb);
 183
 184                         if (dev->isoc_ctl.transfer_buffer[i]) {
 185                                 usb_free_coherent(dev->usbdev,
 186                                         urb->transfer_buffer_length,
 187                                         dev->isoc_ctl.transfer_buffer[i],
 188                                         urb->transfer_dma);
 189                         }
 190                         usb_free_urb(urb);
 191                         dev->isoc_ctl.urb[i] = NULL;
 192                 }
 193                 dev->isoc_ctl.transfer_buffer[i] = NULL;
 194         }
 195
 196         kfree(dev->isoc_ctl.urb);
 197         kfree(dev->isoc_ctl.transfer_buffer);
 198
 199         dev->isoc_ctl.urb = NULL;
 200         dev->isoc_ctl.transfer_buffer = NULL;
 201         dev->isoc_ctl.num_bufs = 0;
 202
 203         dev->stream_state = STREAM_OFF;
 204 }
 205
 206 /*
 207  * Allocate URBs and start IRQ
 208  */
 209 static int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
 210                             int num_bufs, int max_pkt_size,
 211                             int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
 212 {
 213         struct au0828_dmaqueue *dma_q = &dev->vidq;
 214         int i;
 215         int sb_size, pipe;
 216         struct urb *urb;
 217         int j, k;
 218         int rc;
 219
 220         au0828_isocdbg("au0828: called au0828_prepare_isoc\n");
 221
 222         /* De-allocates all pending stuff */
 223         au0828_uninit_isoc(dev);
 224
 225         dev->isoc_ctl.isoc_copy = isoc_copy;
 226         dev->isoc_ctl.num_bufs = num_bufs;
 227
 228         dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
 229         if (!dev->isoc_ctl.urb) {
 230                 au0828_isocdbg("cannot alloc memory for usb buffers\n");
 231                 return -ENOMEM;
 232         }
 233
 234         dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
 235                                               GFP_KERNEL);
 236         if (!dev->isoc_ctl.transfer_buffer) {
 237                 au0828_isocdbg("cannot allocate memory for usb transfer\n");
 238                 kfree(dev->isoc_ctl.urb);
 239                 return -ENOMEM;
 240         }
 241
 242         dev->isoc_ctl.max_pkt_size = max_pkt_size;
 243         dev->isoc_ctl.buf = NULL;
 244
 245         sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
 246
 247         /* allocate urbs and transfer buffers */
 248         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 249                 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
 250                 if (!urb) {
 251                         au0828_isocdbg("cannot alloc isoc_ctl.urb %i\n", i);
 252                         au0828_uninit_isoc(dev);
 253                         return -ENOMEM;
 254                 }
 255                 dev->isoc_ctl.urb[i] = urb;
 256
 257                 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev,
 258                         sb_size, GFP_KERNEL, &urb->transfer_dma);
 259                 if (!dev->isoc_ctl.transfer_buffer[i]) {
 260                         printk("unable to allocate %i bytes for transfer"
 261                                         " buffer %i%s\n",
 262                                         sb_size, i,
 263                                         in_interrupt() ? " while in int" : "");
 264                         au0828_uninit_isoc(dev);
 265                         return -ENOMEM;
 266                 }
 267                 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
 268
 269                 pipe = usb_rcvisocpipe(dev->usbdev,
 270                                        dev->isoc_in_endpointaddr),
 271
 272                 usb_fill_int_urb(urb, dev->usbdev, pipe,
 273                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
 274                                  au0828_irq_callback, dma_q, 1);
 275
 276                 urb->number_of_packets = max_packets;
 277                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 278
 279                 k = 0;
 280                 for (j = 0; j < max_packets; j++) {
 281                         urb->iso_frame_desc[j].offset = k;
 282                         urb->iso_frame_desc[j].length =
 283                                                 dev->isoc_ctl.max_pkt_size;
 284                         k += dev->isoc_ctl.max_pkt_size;
 285                 }
 286         }
 287
 288         init_waitqueue_head(&dma_q->wq);
 289
 290         /* submit urbs and enables IRQ */
 291         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 292                 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
 293                 if (rc) {
 294                         au0828_isocdbg("submit of urb %i failed (error=%i)\n",
 295                                        i, rc);
 296                         au0828_uninit_isoc(dev);
 297                         return rc;
 298                 }
 299         }
 300
 301         return 0;
 302 }
 303
 304 /*
 305  * Announces that a buffer were filled and request the next
 306  */
 307 static inline void buffer_filled(struct au0828_dev *dev,
 308                                   struct au0828_dmaqueue *dma_q,
 309                                   struct au0828_buffer *buf)
 310 {
 311         /* Advice that buffer was filled */
 312         au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
 313
 314         buf->vb.state = VIDEOBUF_DONE;
 315         buf->vb.field_count++;
 316         v4l2_get_timestamp(&buf->vb.ts);
 317
 318         dev->isoc_ctl.buf = NULL;
 319
 320         list_del(&buf->vb.queue);
 321         wake_up(&buf->vb.done);
 322 }
 323
 324 static inline void vbi_buffer_filled(struct au0828_dev *dev,
 325                                      struct au0828_dmaqueue *dma_q,
 326                                      struct au0828_buffer *buf)
 327 {
 328         /* Advice that buffer was filled */
 329         au0828_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
 330
 331         buf->vb.state = VIDEOBUF_DONE;
 332         buf->vb.field_count++;
 333         v4l2_get_timestamp(&buf->vb.ts);
 334
 335         dev->isoc_ctl.vbi_buf = NULL;
 336
 337         list_del(&buf->vb.queue);
 338         wake_up(&buf->vb.done);
 339 }
 340
 341 /*
 342  * Identify the buffer header type and properly handles
 343  */
 344 static void au0828_copy_video(struct au0828_dev *dev,
 345                               struct au0828_dmaqueue  *dma_q,
 346                               struct au0828_buffer *buf,
 347                               unsigned char *p,
 348                               unsigned char *outp, unsigned long len)
 349 {
 350         void *fieldstart, *startwrite, *startread;
 351         int  linesdone, currlinedone, offset, lencopy, remain;
 352         int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
 353
 354         if (len == 0)
 355                 return;
 356
 357         if (dma_q->pos + len > buf->vb.size)
 358                 len = buf->vb.size - dma_q->pos;
 359
 360         startread = p;
 361         remain = len;
 362
 363         /* Interlaces frame */
 364         if (buf->top_field)
 365                 fieldstart = outp;
 366         else
 367                 fieldstart = outp + bytesperline;
 368
 369         linesdone = dma_q->pos / bytesperline;
 370         currlinedone = dma_q->pos % bytesperline;
 371         offset = linesdone * bytesperline * 2 + currlinedone;
 372         startwrite = fieldstart + offset;
 373         lencopy = bytesperline - currlinedone;
 374         lencopy = lencopy > remain ? remain : lencopy;
 375
 376         if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
 377                 au0828_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
 378                                ((char *)startwrite + lencopy) -
 379                                ((char *)outp + buf->vb.size));
 380                 remain = (char *)outp + buf->vb.size - (char *)startwrite;
 381                 lencopy = remain;
 382         }
 383         if (lencopy <= 0)
 384                 return;
 385         memcpy(startwrite, startread, lencopy);
 386
 387         remain -= lencopy;
 388
 389         while (remain > 0) {
 390                 startwrite += lencopy + bytesperline;
 391                 startread += lencopy;
 392                 if (bytesperline > remain)
 393                         lencopy = remain;
 394                 else
 395                         lencopy = bytesperline;
 396
 397                 if ((char *)startwrite + lencopy > (char *)outp +
 398                     buf->vb.size) {
 399                         au0828_isocdbg("Overflow %zi bytes past buf end (2)\n",
 400                                        ((char *)startwrite + lencopy) -
 401                                        ((char *)outp + buf->vb.size));
 402                         lencopy = remain = (char *)outp + buf->vb.size -
 403                                            (char *)startwrite;
 404                 }
 405                 if (lencopy <= 0)
 406                         break;
 407
 408                 memcpy(startwrite, startread, lencopy);
 409
 410                 remain -= lencopy;
 411         }
 412
 413         if (offset > 1440) {
 414                 /* We have enough data to check for greenscreen */
 415                 if (outp[0] < 0x60 && outp[1440] < 0x60)
 416                         dev->greenscreen_detected = 1;
 417         }
 418
 419         dma_q->pos += len;
 420 }
 421
 422 /*
 423  * video-buf generic routine to get the next available buffer
 424  */
 425 static inline void get_next_buf(struct au0828_dmaqueue *dma_q,
 426                                 struct au0828_buffer **buf)
 427 {
 428         struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
 429
 430         if (list_empty(&dma_q->active)) {
 431                 au0828_isocdbg("No active queue to serve\n");
 432                 dev->isoc_ctl.buf = NULL;
 433                 *buf = NULL;
 434                 return;
 435         }
 436
 437         /* Get the next buffer */
 438         *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
 439         dev->isoc_ctl.buf = *buf;
 440
 441         return;
 442 }
 443
 444 static void au0828_copy_vbi(struct au0828_dev *dev,
 445                               struct au0828_dmaqueue  *dma_q,
 446                               struct au0828_buffer *buf,
 447                               unsigned char *p,
 448                               unsigned char *outp, unsigned long len)
 449 {
 450         unsigned char *startwrite, *startread;
 451         int bytesperline;
 452         int i, j = 0;
 453
 454         if (dev == NULL) {
 455                 au0828_isocdbg("dev is null\n");
 456                 return;
 457         }
 458
 459         if (dma_q == NULL) {
 460                 au0828_isocdbg("dma_q is null\n");
 461                 return;
 462         }
 463         if (buf == NULL)
 464                 return;
 465         if (p == NULL) {
 466                 au0828_isocdbg("p is null\n");
 467                 return;
 468         }
 469         if (outp == NULL) {
 470                 au0828_isocdbg("outp is null\n");
 471                 return;
 472         }
 473
 474         bytesperline = dev->vbi_width;
 475
 476         if (dma_q->pos + len > buf->vb.size)
 477                 len = buf->vb.size - dma_q->pos;
 478
 479         startread = p;
 480         startwrite = outp + (dma_q->pos / 2);
 481
 482         /* Make sure the bottom field populates the second half of the frame */
 483         if (buf->top_field == 0)
 484                 startwrite += bytesperline * dev->vbi_height;
 485
 486         for (i = 0; i < len; i += 2)
 487                 startwrite[j++] = startread[i+1];
 488
 489         dma_q->pos += len;
 490 }
 491
 492
 493 /*
 494  * video-buf generic routine to get the next available VBI buffer
 495  */
 496 static inline void vbi_get_next_buf(struct au0828_dmaqueue *dma_q,
 497                                     struct au0828_buffer **buf)
 498 {
 499         struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vbiq);
 500         char *outp;
 501
 502         if (list_empty(&dma_q->active)) {
 503                 au0828_isocdbg("No active queue to serve\n");
 504                 dev->isoc_ctl.vbi_buf = NULL;
 505                 *buf = NULL;
 506                 return;
 507         }
 508
 509         /* Get the next buffer */
 510         *buf = list_entry(dma_q->active.next, struct au0828_buffer, vb.queue);
 511         /* Cleans up buffer - Useful for testing for frame/URB loss */
 512         outp = videobuf_to_vmalloc(&(*buf)->vb);
 513         memset(outp, 0x00, (*buf)->vb.size);
 514
 515         dev->isoc_ctl.vbi_buf = *buf;
 516
 517         return;
 518 }
 519
 520 /*
 521  * Controls the isoc copy of each urb packet
 522  */
 523 static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
 524 {
 525         struct au0828_buffer    *buf;
 526         struct au0828_buffer    *vbi_buf;
 527         struct au0828_dmaqueue  *dma_q = urb->context;
 528         struct au0828_dmaqueue  *vbi_dma_q = &dev->vbiq;
 529         unsigned char *outp = NULL;
 530         unsigned char *vbioutp = NULL;
 531         int i, len = 0, rc = 1;
 532         unsigned char *p;
 533         unsigned char fbyte;
 534         unsigned int vbi_field_size;
 535         unsigned int remain, lencopy;
 536
 537         if (!dev)
 538                 return 0;
 539
 540         if ((dev->dev_state & DEV_DISCONNECTED) ||
 541             (dev->dev_state & DEV_MISCONFIGURED))
 542                 return 0;
 543
 544         if (urb->status < 0) {
 545                 print_err_status(dev, -1, urb->status);
 546                 if (urb->status == -ENOENT)
 547                         return 0;
 548         }
 549
 550         buf = dev->isoc_ctl.buf;
 551         if (buf != NULL)
 552                 outp = videobuf_to_vmalloc(&buf->vb);
 553
 554         vbi_buf = dev->isoc_ctl.vbi_buf;
 555         if (vbi_buf != NULL)
 556                 vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
 557
 558         for (i = 0; i < urb->number_of_packets; i++) {
 559                 int status = urb->iso_frame_desc[i].status;
 560
 561                 if (status < 0) {
 562                         print_err_status(dev, i, status);
 563                         if (urb->iso_frame_desc[i].status != -EPROTO)
 564                                 continue;
 565                 }
 566
 567                 if (urb->iso_frame_desc[i].actual_length <= 0)
 568                         continue;
 569
 570                 if (urb->iso_frame_desc[i].actual_length >
 571                                                 dev->max_pkt_size) {
 572                         au0828_isocdbg("packet bigger than packet size");
 573                         continue;
 574                 }
 575
 576                 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
 577                 fbyte = p[0];
 578                 len = urb->iso_frame_desc[i].actual_length - 4;
 579                 p += 4;
 580
 581                 if (fbyte & 0x80) {
 582                         len -= 4;
 583                         p += 4;
 584                         au0828_isocdbg("Video frame %s\n",
 585                                        (fbyte & 0x40) ? "odd" : "even");
 586                         if (fbyte & 0x40) {
 587                                 /* VBI */
 588                                 if (vbi_buf != NULL)
 589                                         vbi_buffer_filled(dev,
 590                                                           vbi_dma_q,
 591                                                           vbi_buf);
 592                                 vbi_get_next_buf(vbi_dma_q, &vbi_buf);
 593                                 if (vbi_buf == NULL)
 594                                         vbioutp = NULL;
 595                                 else
 596                                         vbioutp = videobuf_to_vmalloc(
 597                                                 &vbi_buf->vb);
 598
 599                                 /* Video */
 600                                 if (buf != NULL)
 601                                         buffer_filled(dev, dma_q, buf);
 602                                 get_next_buf(dma_q, &buf);
 603                                 if (buf == NULL)
 604                                         outp = NULL;
 605                                 else
 606                                         outp = videobuf_to_vmalloc(&buf->vb);
 607
 608                                 /* As long as isoc traffic is arriving, keep
 609                                    resetting the timer */
 610                                 if (dev->vid_timeout_running)
 611                                         mod_timer(&dev->vid_timeout,
 612                                                   jiffies + (HZ / 10));
 613                                 if (dev->vbi_timeout_running)
 614                                         mod_timer(&dev->vbi_timeout,
 615                                                   jiffies + (HZ / 10));
 616                         }
 617
 618                         if (buf != NULL) {
 619                                 if (fbyte & 0x40)
 620                                         buf->top_field = 1;
 621                                 else
 622                                         buf->top_field = 0;
 623                         }
 624
 625                         if (vbi_buf != NULL) {
 626                                 if (fbyte & 0x40)
 627                                         vbi_buf->top_field = 1;
 628                                 else
 629                                         vbi_buf->top_field = 0;
 630                         }
 631
 632                         dev->vbi_read = 0;
 633                         vbi_dma_q->pos = 0;
 634                         dma_q->pos = 0;
 635                 }
 636
 637                 vbi_field_size = dev->vbi_width * dev->vbi_height * 2;
 638                 if (dev->vbi_read < vbi_field_size) {
 639                         remain  = vbi_field_size - dev->vbi_read;
 640                         if (len < remain)
 641                                 lencopy = len;
 642                         else
 643                                 lencopy = remain;
 644
 645                         if (vbi_buf != NULL)
 646                                 au0828_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
 647                                                 vbioutp, len);
 648
 649                         len -= lencopy;
 650                         p += lencopy;
 651                         dev->vbi_read += lencopy;
 652                 }
 653
 654                 if (dev->vbi_read >= vbi_field_size && buf != NULL)
 655                         au0828_copy_video(dev, dma_q, buf, p, outp, len);
 656         }
 657         return rc;
 658 }
 659
 660 static int
 661 buffer_setup(struct videobuf_queue *vq, unsigned int *count,
 662              unsigned int *size)
 663 {
 664         struct au0828_fh *fh = vq->priv_data;
 665         *size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
 666
 667         if (0 == *count)
 668                 *count = AU0828_DEF_BUF;
 669
 670         if (*count < AU0828_MIN_BUF)
 671                 *count = AU0828_MIN_BUF;
 672         return 0;
 673 }
 674
 675 /* This is called *without* dev->slock held; please keep it that way */
 676 static void free_buffer(struct videobuf_queue *vq, struct au0828_buffer *buf)
 677 {
 678         struct au0828_fh     *fh  = vq->priv_data;
 679         struct au0828_dev    *dev = fh->dev;
 680         unsigned long flags = 0;
 681         if (in_interrupt())
 682                 BUG();
 683
 684         /* We used to wait for the buffer to finish here, but this didn't work
 685            because, as we were keeping the state as VIDEOBUF_QUEUED,
 686            videobuf_queue_cancel marked it as finished for us.
 687            (Also, it could wedge forever if the hardware was misconfigured.)
 688
 689            This should be safe; by the time we get here, the buffer isn't
 690            queued anymore. If we ever start marking the buffers as
 691            VIDEOBUF_ACTIVE, it won't be, though.
 692         */
 693         spin_lock_irqsave(&dev->slock, flags);
 694         if (dev->isoc_ctl.buf == buf)
 695                 dev->isoc_ctl.buf = NULL;
 696         spin_unlock_irqrestore(&dev->slock, flags);
 697
 698         videobuf_vmalloc_free(&buf->vb);
 699         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 700 }
 701
 702 static int
 703 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 704                                                 enum v4l2_field field)
 705 {
 706         struct au0828_fh     *fh  = vq->priv_data;
 707         struct au0828_buffer *buf = container_of(vb, struct au0828_buffer, vb);
 708         struct au0828_dev    *dev = fh->dev;
 709         int                  rc = 0, urb_init = 0;
 710
 711         buf->vb.size = (fh->dev->width * fh->dev->height * 16 + 7) >> 3;
 712
 713         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 714                 return -EINVAL;
 715
 716         buf->vb.width  = dev->width;
 717         buf->vb.height = dev->height;
 718         buf->vb.field  = field;
 719
 720         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 721                 rc = videobuf_iolock(vq, &buf->vb, NULL);
 722                 if (rc < 0) {
 723                         pr_info("videobuf_iolock failed\n");
 724                         goto fail;
 725                 }
 726         }
 727
 728         if (!dev->isoc_ctl.num_bufs)
 729                 urb_init = 1;
 730
 731         if (urb_init) {
 732                 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
 733                                       AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
 734                                       au0828_isoc_copy);
 735                 if (rc < 0) {
 736                         pr_info("au0828_init_isoc failed\n");
 737                         goto fail;
 738                 }
 739         }
 740
 741         buf->vb.state = VIDEOBUF_PREPARED;
 742         return 0;
 743
 744 fail:
 745         free_buffer(vq, buf);
 746         return rc;
 747 }
 748
 749 static void
 750 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 751 {
 752         struct au0828_buffer    *buf     = container_of(vb,
 753                                                         struct au0828_buffer,
 754                                                         vb);
 755         struct au0828_fh        *fh      = vq->priv_data;
 756         struct au0828_dev       *dev     = fh->dev;
 757         struct au0828_dmaqueue  *vidq    = &dev->vidq;
 758
 759         buf->vb.state = VIDEOBUF_QUEUED;
 760         list_add_tail(&buf->vb.queue, &vidq->active);
 761 }
 762
 763 static void buffer_release(struct videobuf_queue *vq,
 764                                 struct videobuf_buffer *vb)
 765 {
 766         struct au0828_buffer   *buf  = container_of(vb,
 767                                                     struct au0828_buffer,
 768                                                     vb);
 769
 770         free_buffer(vq, buf);
 771 }
 772
 773 static struct videobuf_queue_ops au0828_video_qops = {
 774         .buf_setup      = buffer_setup,
 775         .buf_prepare    = buffer_prepare,
 776         .buf_queue      = buffer_queue,
 777         .buf_release    = buffer_release,
 778 };
 779
 780 /* ------------------------------------------------------------------
 781    V4L2 interface
 782    ------------------------------------------------------------------*/
 783
 784 static int au0828_i2s_init(struct au0828_dev *dev)
 785 {
 786         /* Enable i2s mode */
 787         au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
 788         return 0;
 789 }
 790
 791 /*
 792  * Auvitek au0828 analog stream enable
 793  */
 794 static int au0828_analog_stream_enable(struct au0828_dev *d)
 795 {
 796         struct usb_interface *iface;
 797         int ret, h, w;
 798
 799         dprintk(1, "au0828_analog_stream_enable called\n");
 800
 801         iface = usb_ifnum_to_if(d->usbdev, 0);
 802         if (iface && iface->cur_altsetting->desc.bAlternateSetting != 5) {
 803                 dprintk(1, "Changing intf#0 to alt 5\n");
 804                 /* set au0828 interface0 to AS5 here again */
 805                 ret = usb_set_interface(d->usbdev, 0, 5);
 806                 if (ret < 0) {
 807                         pr_info("Au0828 can't set alt setting to 5!\n");
 808                         return -EBUSY;
 809                 }
 810         }
 811
 812         h = d->height / 2 + 2;
 813         w = d->width * 2;
 814
 815         au0828_writereg(d, AU0828_SENSORCTRL_VBI_103, 0x00);
 816         au0828_writereg(d, 0x106, 0x00);
 817         /* set x position */
 818         au0828_writereg(d, 0x110, 0x00);
 819         au0828_writereg(d, 0x111, 0x00);
 820         au0828_writereg(d, 0x114, w & 0xff);
 821         au0828_writereg(d, 0x115, w >> 8);
 822         /* set y position */
 823         au0828_writereg(d, 0x112, 0x00);
 824         au0828_writereg(d, 0x113, 0x00);
 825         au0828_writereg(d, 0x116, h & 0xff);
 826         au0828_writereg(d, 0x117, h >> 8);
 827         au0828_writereg(d, AU0828_SENSORCTRL_100, 0xb3);
 828
 829         return 0;
 830 }
 831
 832 int au0828_analog_stream_disable(struct au0828_dev *d)
 833 {
 834         dprintk(1, "au0828_analog_stream_disable called\n");
 835         au0828_writereg(d, AU0828_SENSORCTRL_100, 0x0);
 836         return 0;
 837 }
 838
 839 static void au0828_analog_stream_reset(struct au0828_dev *dev)
 840 {
 841         dprintk(1, "au0828_analog_stream_reset called\n");
 842         au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
 843         mdelay(30);
 844         au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
 845 }
 846
 847 /*
 848  * Some operations needs to stop current streaming
 849  */
 850 static int au0828_stream_interrupt(struct au0828_dev *dev)
 851 {
 852         int ret = 0;
 853
 854         dev->stream_state = STREAM_INTERRUPT;
 855         if (dev->dev_state == DEV_DISCONNECTED)
 856                 return -ENODEV;
 857         else if (ret) {
 858                 dev->dev_state = DEV_MISCONFIGURED;
 859                 dprintk(1, "%s device is misconfigured!\n", __func__);
 860                 return ret;
 861         }
 862         return 0;
 863 }
 864
 865 /*
 866  * au0828_release_resources
 867  * unregister v4l2 devices
 868  */
 869 void au0828_analog_unregister(struct au0828_dev *dev)
 870 {
 871         dprintk(1, "au0828_release_resources called\n");
 872         mutex_lock(&au0828_sysfs_lock);
 873
 874         if (dev->vdev)
 875                 video_unregister_device(dev->vdev);
 876         if (dev->vbi_dev)
 877                 video_unregister_device(dev->vbi_dev);
 878
 879         mutex_unlock(&au0828_sysfs_lock);
 880 }
 881
 882
 883 /* Usage lock check functions */
 884 static int res_get(struct au0828_fh *fh, unsigned int bit)
 885 {
 886         struct au0828_dev    *dev = fh->dev;
 887
 888         if (fh->resources & bit)
 889                 /* have it already allocated */
 890                 return 1;
 891
 892         /* is it free? */
 893         if (dev->resources & bit) {
 894                 /* no, someone else uses it */
 895                 return 0;
 896         }
 897         /* it's free, grab it */
 898         fh->resources  |= bit;
 899         dev->resources |= bit;
 900         dprintk(1, "res: get %d\n", bit);
 901
 902         return 1;
 903 }
 904
 905 static int res_check(struct au0828_fh *fh, unsigned int bit)
 906 {
 907         return fh->resources & bit;
 908 }
 909
 910 static int res_locked(struct au0828_dev *dev, unsigned int bit)
 911 {
 912         return dev->resources & bit;
 913 }
 914
 915 static void res_free(struct au0828_fh *fh, unsigned int bits)
 916 {
 917         struct au0828_dev    *dev = fh->dev;
 918
 919         BUG_ON((fh->resources & bits) != bits);
 920
 921         fh->resources  &= ~bits;
 922         dev->resources &= ~bits;
 923         dprintk(1, "res: put %d\n", bits);
 924 }
 925
 926 static int get_ressource(struct au0828_fh *fh)
 927 {
 928         switch (fh->type) {
 929         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 930                 return AU0828_RESOURCE_VIDEO;
 931         case V4L2_BUF_TYPE_VBI_CAPTURE:
 932                 return AU0828_RESOURCE_VBI;
 933         default:
 934                 BUG();
 935                 return 0;
 936         }
 937 }
 938
 939 /* This function ensures that video frames continue to be delivered even if
 940    the ITU-656 input isn't receiving any data (thereby preventing applications
 941    such as tvtime from hanging) */
 942 static void au0828_vid_buffer_timeout(unsigned long data)
 943 {
 944         struct au0828_dev *dev = (struct au0828_dev *) data;
 945         struct au0828_dmaqueue *dma_q = &dev->vidq;
 946         struct au0828_buffer *buf;
 947         unsigned char *vid_data;
 948         unsigned long flags = 0;
 949
 950         spin_lock_irqsave(&dev->slock, flags);
 951
 952         buf = dev->isoc_ctl.buf;
 953         if (buf != NULL) {
 954                 vid_data = videobuf_to_vmalloc(&buf->vb);
 955                 memset(vid_data, 0x00, buf->vb.size); /* Blank green frame */
 956                 buffer_filled(dev, dma_q, buf);
 957         }
 958         get_next_buf(dma_q, &buf);
 959
 960         if (dev->vid_timeout_running == 1)
 961                 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
 962
 963         spin_unlock_irqrestore(&dev->slock, flags);
 964 }
 965
 966 static void au0828_vbi_buffer_timeout(unsigned long data)
 967 {
 968         struct au0828_dev *dev = (struct au0828_dev *) data;
 969         struct au0828_dmaqueue *dma_q = &dev->vbiq;
 970         struct au0828_buffer *buf;
 971         unsigned char *vbi_data;
 972         unsigned long flags = 0;
 973
 974         spin_lock_irqsave(&dev->slock, flags);
 975
 976         buf = dev->isoc_ctl.vbi_buf;
 977         if (buf != NULL) {
 978                 vbi_data = videobuf_to_vmalloc(&buf->vb);
 979                 memset(vbi_data, 0x00, buf->vb.size);
 980                 vbi_buffer_filled(dev, dma_q, buf);
 981         }
 982         vbi_get_next_buf(dma_q, &buf);
 983
 984         if (dev->vbi_timeout_running == 1)
 985                 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
 986         spin_unlock_irqrestore(&dev->slock, flags);
 987 }
 988
 989
 990 static int au0828_v4l2_open(struct file *filp)
 991 {
 992         int ret = 0;
 993         struct video_device *vdev = video_devdata(filp);
 994         struct au0828_dev *dev = video_drvdata(filp);
 995         struct au0828_fh *fh;
 996         int type;
 997
 998         switch (vdev->vfl_type) {
 999         case VFL_TYPE_GRABBER:
1000                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1001                 break;
1002         case VFL_TYPE_VBI:
1003                 type = V4L2_BUF_TYPE_VBI_CAPTURE;
1004                 break;
1005         default:
1006                 return -EINVAL;
1007         }
1008
1009         fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
1010         if (NULL == fh) {
1011                 dprintk(1, "Failed allocate au0828_fh struct!\n");
1012                 return -ENOMEM;
1013         }
1014
1015         fh->type = type;
1016         fh->dev = dev;
1017         v4l2_fh_init(&fh->fh, vdev);
1018         filp->private_data = fh;
1019
1020         if (mutex_lock_interruptible(&dev->lock)) {
1021                 kfree(fh);
1022                 return -ERESTARTSYS;
1023         }
1024         if (dev->users == 0) {
1025                 au0828_analog_stream_enable(dev);
1026                 au0828_analog_stream_reset(dev);
1027
1028                 /* If we were doing ac97 instead of i2s, it would go here...*/
1029                 au0828_i2s_init(dev);
1030
1031                 dev->stream_state = STREAM_OFF;
1032                 dev->dev_state |= DEV_INITIALIZED;
1033         }
1034
1035         dev->users++;
1036         mutex_unlock(&dev->lock);
1037
1038         videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
1039                                     NULL, &dev->slock,
1040                                     V4L2_BUF_TYPE_VIDEO_CAPTURE,
1041                                     V4L2_FIELD_INTERLACED,
1042                                     sizeof(struct au0828_buffer), fh,
1043                                     &dev->lock);
1044
1045         /* VBI Setup */
1046         videobuf_queue_vmalloc_init(&fh->vb_vbiq, &au0828_vbi_qops,
1047                                     NULL, &dev->slock,
1048                                     V4L2_BUF_TYPE_VBI_CAPTURE,
1049                                     V4L2_FIELD_SEQ_TB,
1050                                     sizeof(struct au0828_buffer), fh,
1051                                     &dev->lock);
1052         v4l2_fh_add(&fh->fh);
1053         return ret;
1054 }
1055
1056 static int au0828_v4l2_close(struct file *filp)
1057 {
1058         int ret;
1059         struct au0828_fh *fh = filp->private_data;
1060         struct au0828_dev *dev = fh->dev;
1061
1062         v4l2_fh_del(&fh->fh);
1063         v4l2_fh_exit(&fh->fh);
1064         mutex_lock(&dev->lock);
1065         if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1066                 /* Cancel timeout thread in case they didn't call streamoff */
1067                 dev->vid_timeout_running = 0;
1068                 del_timer_sync(&dev->vid_timeout);
1069
1070                 videobuf_stop(&fh->vb_vidq);
1071                 res_free(fh, AU0828_RESOURCE_VIDEO);
1072         }
1073
1074         if (res_check(fh, AU0828_RESOURCE_VBI)) {
1075                 /* Cancel timeout thread in case they didn't call streamoff */
1076                 dev->vbi_timeout_running = 0;
1077                 del_timer_sync(&dev->vbi_timeout);
1078
1079                 videobuf_stop(&fh->vb_vbiq);
1080                 res_free(fh, AU0828_RESOURCE_VBI);
1081         }
1082
1083         if (dev->users == 1 && video_is_registered(video_devdata(filp))) {
1084                 au0828_analog_stream_disable(dev);
1085
1086                 au0828_uninit_isoc(dev);
1087
1088                 /* Save some power by putting tuner to sleep */
1089                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1090                 dev->std_set_in_tuner_core = 0;
1091
1092                 /* When close the device, set the usb intf0 into alt0 to free
1093                    USB bandwidth */
1094                 ret = usb_set_interface(dev->usbdev, 0, 0);
1095                 if (ret < 0)
1096                         pr_info("Au0828 can't set alternate to 0!\n");
1097         }
1098         mutex_unlock(&dev->lock);
1099
1100         videobuf_mmap_free(&fh->vb_vidq);
1101         videobuf_mmap_free(&fh->vb_vbiq);
1102         kfree(fh);
1103         dev->users--;
1104         wake_up_interruptible_nr(&dev->open, 1);
1105         return 0;
1106 }
1107
1108 /* Must be called with dev->lock held */
1109 static void au0828_init_tuner(struct au0828_dev *dev)
1110 {
1111         struct v4l2_frequency f = {
1112                 .frequency = dev->ctrl_freq,
1113                 .type = V4L2_TUNER_ANALOG_TV,
1114         };
1115
1116         if (dev->std_set_in_tuner_core)
1117                 return;
1118         dev->std_set_in_tuner_core = 1;
1119         i2c_gate_ctrl(dev, 1);
1120         /* If we've never sent the standard in tuner core, do so now.
1121            We don't do this at device probe because we don't want to
1122            incur the cost of a firmware load */
1123         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->std);
1124         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
1125         i2c_gate_ctrl(dev, 0);
1126 }
1127
1128 static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
1129                                 size_t count, loff_t *pos)
1130 {
1131         struct au0828_fh *fh = filp->private_data;
1132         struct au0828_dev *dev = fh->dev;
1133         int rc;
1134
1135         rc = check_dev(dev);
1136         if (rc < 0)
1137                 return rc;
1138
1139         if (mutex_lock_interruptible(&dev->lock))
1140                 return -ERESTARTSYS;
1141         au0828_init_tuner(dev);
1142         mutex_unlock(&dev->lock);
1143
1144         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1145                 if (res_locked(dev, AU0828_RESOURCE_VIDEO))
1146                         return -EBUSY;
1147
1148                 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1149                                         filp->f_flags & O_NONBLOCK);
1150         }
1151
1152         if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1153                 if (!res_get(fh, AU0828_RESOURCE_VBI))
1154                         return -EBUSY;
1155
1156                 if (dev->vbi_timeout_running == 0) {
1157                         /* Handle case where caller tries to read without
1158                            calling streamon first */
1159                         dev->vbi_timeout_running = 1;
1160                         mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1161                 }
1162
1163                 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
1164                                             filp->f_flags & O_NONBLOCK);
1165         }
1166
1167         return 0;
1168 }
1169
1170 static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
1171 {
1172         struct au0828_fh *fh = filp->private_data;
1173         struct au0828_dev *dev = fh->dev;
1174         unsigned long req_events = poll_requested_events(wait);
1175         unsigned int res;
1176
1177         if (check_dev(dev) < 0)
1178                 return POLLERR;
1179
1180         res = v4l2_ctrl_poll(filp, wait);
1181         if (!(req_events & (POLLIN | POLLRDNORM)))
1182                 return res;
1183
1184         if (mutex_lock_interruptible(&dev->lock))
1185                 return -ERESTARTSYS;
1186         au0828_init_tuner(dev);
1187         mutex_unlock(&dev->lock);
1188
1189         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1190                 if (!res_get(fh, AU0828_RESOURCE_VIDEO))
1191                         return POLLERR;
1192                 return res | videobuf_poll_stream(filp, &fh->vb_vidq, wait);
1193         }
1194         if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1195                 if (!res_get(fh, AU0828_RESOURCE_VBI))
1196                         return POLLERR;
1197                 return res | videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
1198         }
1199         return POLLERR;
1200 }
1201
1202 static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1203 {
1204         struct au0828_fh *fh    = filp->private_data;
1205         struct au0828_dev *dev   = fh->dev;
1206         int              rc;
1207
1208         rc = check_dev(dev);
1209         if (rc < 0)
1210                 return rc;
1211
1212         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1213                 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1214         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1215                 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
1216
1217         return rc;
1218 }
1219
1220 static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1221                              struct v4l2_format *format)
1222 {
1223         int ret;
1224         int width = format->fmt.pix.width;
1225         int height = format->fmt.pix.height;
1226
1227         /* If they are demanding a format other than the one we support,
1228            bail out (tvtime asks for UYVY and then retries with YUYV) */
1229         if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
1230                 return -EINVAL;
1231
1232         /* format->fmt.pix.width only support 720 and height 480 */
1233         if (width != 720)
1234                 width = 720;
1235         if (height != 480)
1236                 height = 480;
1237
1238         format->fmt.pix.width = width;
1239         format->fmt.pix.height = height;
1240         format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1241         format->fmt.pix.bytesperline = width * 2;
1242         format->fmt.pix.sizeimage = width * height * 2;
1243         format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1244         format->fmt.pix.field = V4L2_FIELD_INTERLACED;
1245         format->fmt.pix.priv = 0;
1246
1247         if (cmd == VIDIOC_TRY_FMT)
1248                 return 0;
1249
1250         /* maybe set new image format, driver current only support 720*480 */
1251         dev->width = width;
1252         dev->height = height;
1253         dev->frame_size = width * height * 2;
1254         dev->field_size = width * height;
1255         dev->bytesperline = width * 2;
1256
1257         if (dev->stream_state == STREAM_ON) {
1258                 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1259                 ret = au0828_stream_interrupt(dev);
1260                 if (ret != 0) {
1261                         dprintk(1, "error interrupting video stream!\n");
1262                         return ret;
1263                 }
1264         }
1265
1266         au0828_analog_stream_enable(dev);
1267
1268         return 0;
1269 }
1270
1271
1272 static int vidioc_querycap(struct file *file, void  *priv,
1273                            struct v4l2_capability *cap)
1274 {
1275         struct video_device *vdev = video_devdata(file);
1276         struct au0828_fh *fh = priv;
1277         struct au0828_dev *dev = fh->dev;
1278
1279         strlcpy(cap->driver, "au0828", sizeof(cap->driver));
1280         strlcpy(cap->card, dev->board.name, sizeof(cap->card));
1281         usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
1282
1283         /* set the device capabilities */
1284         cap->device_caps = V4L2_CAP_AUDIO |
1285                 V4L2_CAP_READWRITE |
1286                 V4L2_CAP_STREAMING |
1287                 V4L2_CAP_TUNER;
1288         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1289                 cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE;
1290         else
1291                 cap->device_caps |= V4L2_CAP_VBI_CAPTURE;
1292         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1293                 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE;
1294         return 0;
1295 }
1296
1297 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1298                                         struct v4l2_fmtdesc *f)
1299 {
1300         if (f->index)
1301                 return -EINVAL;
1302
1303         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1304         strcpy(f->description, "Packed YUV2");
1305
1306         f->flags = 0;
1307         f->pixelformat = V4L2_PIX_FMT_UYVY;
1308
1309         return 0;
1310 }
1311
1312 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1313                                         struct v4l2_format *f)
1314 {
1315         struct au0828_fh *fh  = priv;
1316         struct au0828_dev *dev = fh->dev;
1317
1318         f->fmt.pix.width = dev->width;
1319         f->fmt.pix.height = dev->height;
1320         f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1321         f->fmt.pix.bytesperline = dev->bytesperline;
1322         f->fmt.pix.sizeimage = dev->frame_size;
1323         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1324         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1325         f->fmt.pix.priv = 0;
1326         return 0;
1327 }
1328
1329 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1330                                   struct v4l2_format *f)
1331 {
1332         struct au0828_fh *fh  = priv;
1333         struct au0828_dev *dev = fh->dev;
1334
1335         return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1336 }
1337
1338 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1339                                 struct v4l2_format *f)
1340 {
1341         struct au0828_fh *fh  = priv;
1342         struct au0828_dev *dev = fh->dev;
1343         int rc;
1344
1345         rc = check_dev(dev);
1346         if (rc < 0)
1347                 return rc;
1348
1349         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1350                 pr_info("%s queue busy\n", __func__);
1351                 rc = -EBUSY;
1352                 goto out;
1353         }
1354
1355         rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
1356 out:
1357         return rc;
1358 }
1359
1360 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1361 {
1362         struct au0828_fh *fh = priv;
1363         struct au0828_dev *dev = fh->dev;
1364
1365         dev->std = norm;
1366
1367         au0828_init_tuner(dev);
1368
1369         i2c_gate_ctrl(dev, 1);
1370
1371         /*
1372          * FIXME: when we support something other than 60Hz standards,
1373          * we are going to have to make the au0828 bridge adjust the size
1374          * of its capture buffer, which is currently hardcoded at 720x480
1375          */
1376
1377         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
1378
1379         i2c_gate_ctrl(dev, 0);
1380
1381         return 0;
1382 }
1383
1384 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1385 {
1386         struct au0828_fh *fh = priv;
1387         struct au0828_dev *dev = fh->dev;
1388
1389         *norm = dev->std;
1390         return 0;
1391 }
1392
1393 static int vidioc_enum_input(struct file *file, void *priv,
1394                                 struct v4l2_input *input)
1395 {
1396         struct au0828_fh *fh = priv;
1397         struct au0828_dev *dev = fh->dev;
1398         unsigned int tmp;
1399
1400         static const char *inames[] = {
1401                 [AU0828_VMUX_UNDEFINED] = "Undefined",
1402                 [AU0828_VMUX_COMPOSITE] = "Composite",
1403                 [AU0828_VMUX_SVIDEO] = "S-Video",
1404                 [AU0828_VMUX_CABLE] = "Cable TV",
1405                 [AU0828_VMUX_TELEVISION] = "Television",
1406                 [AU0828_VMUX_DVB] = "DVB",
1407                 [AU0828_VMUX_DEBUG] = "tv debug"
1408         };
1409
1410         tmp = input->index;
1411
1412         if (tmp >= AU0828_MAX_INPUT)
1413                 return -EINVAL;
1414         if (AUVI_INPUT(tmp).type == 0)
1415                 return -EINVAL;
1416
1417         input->index = tmp;
1418         strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
1419         if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1420             (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE)) {
1421                 input->type |= V4L2_INPUT_TYPE_TUNER;
1422                 input->audioset = 1;
1423         } else {
1424                 input->type |= V4L2_INPUT_TYPE_CAMERA;
1425                 input->audioset = 2;
1426         }
1427
1428         input->std = dev->vdev->tvnorms;
1429
1430         return 0;
1431 }
1432
1433 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1434 {
1435         struct au0828_fh *fh = priv;
1436         struct au0828_dev *dev = fh->dev;
1437         *i = dev->ctrl_input;
1438         return 0;
1439 }
1440
1441 static void au0828_s_input(struct au0828_dev *dev, int index)
1442 {
1443         int i;
1444
1445         switch (AUVI_INPUT(index).type) {
1446         case AU0828_VMUX_SVIDEO:
1447                 dev->input_type = AU0828_VMUX_SVIDEO;
1448                 dev->ctrl_ainput = 1;
1449                 break;
1450         case AU0828_VMUX_COMPOSITE:
1451                 dev->input_type = AU0828_VMUX_COMPOSITE;
1452                 dev->ctrl_ainput = 1;
1453                 break;
1454         case AU0828_VMUX_TELEVISION:
1455                 dev->input_type = AU0828_VMUX_TELEVISION;
1456                 dev->ctrl_ainput = 0;
1457                 break;
1458         default:
1459                 dprintk(1, "unknown input type set [%d]\n",
1460                         AUVI_INPUT(index).type);
1461                 break;
1462         }
1463
1464         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1465                         AUVI_INPUT(index).vmux, 0, 0);
1466
1467         for (i = 0; i < AU0828_MAX_INPUT; i++) {
1468                 int enable = 0;
1469                 if (AUVI_INPUT(i).audio_setup == NULL)
1470                         continue;
1471
1472                 if (i == index)
1473                         enable = 1;
1474                 else
1475                         enable = 0;
1476                 if (enable) {
1477                         (AUVI_INPUT(i).audio_setup)(dev, enable);
1478                 } else {
1479                         /* Make sure we leave it turned on if some
1480                            other input is routed to this callback */
1481                         if ((AUVI_INPUT(i).audio_setup) !=
1482                             ((AUVI_INPUT(index).audio_setup))) {
1483                                 (AUVI_INPUT(i).audio_setup)(dev, enable);
1484                         }
1485                 }
1486         }
1487
1488         v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1489                         AUVI_INPUT(index).amux, 0, 0);
1490 }
1491
1492 static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1493 {
1494         struct au0828_fh *fh = priv;
1495         struct au0828_dev *dev = fh->dev;
1496
1497         dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1498                 index);
1499         if (index >= AU0828_MAX_INPUT)
1500                 return -EINVAL;
1501         if (AUVI_INPUT(index).type == 0)
1502                 return -EINVAL;
1503         dev->ctrl_input = index;
1504         au0828_s_input(dev, index);
1505         return 0;
1506 }
1507
1508 static int vidioc_enumaudio(struct file *file, void *priv, struct v4l2_audio *a)
1509 {
1510         if (a->index > 1)
1511                 return -EINVAL;
1512
1513         if (a->index == 0)
1514                 strcpy(a->name, "Television");
1515         else
1516                 strcpy(a->name, "Line in");
1517
1518         a->capability = V4L2_AUDCAP_STEREO;
1519         return 0;
1520 }
1521
1522 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1523 {
1524         struct au0828_fh *fh = priv;
1525         struct au0828_dev *dev = fh->dev;
1526
1527         a->index = dev->ctrl_ainput;
1528         if (a->index == 0)
1529                 strcpy(a->name, "Television");
1530         else
1531                 strcpy(a->name, "Line in");
1532
1533         a->capability = V4L2_AUDCAP_STEREO;
1534         return 0;
1535 }
1536
1537 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1538 {
1539         struct au0828_fh *fh = priv;
1540         struct au0828_dev *dev = fh->dev;
1541
1542         if (a->index != dev->ctrl_ainput)
1543                 return -EINVAL;
1544         return 0;
1545 }
1546
1547 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1548 {
1549         struct au0828_fh *fh = priv;
1550         struct au0828_dev *dev = fh->dev;
1551
1552         if (t->index != 0)
1553                 return -EINVAL;
1554
1555         strcpy(t->name, "Auvitek tuner");
1556
1557         au0828_init_tuner(dev);
1558         i2c_gate_ctrl(dev, 1);
1559         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1560         i2c_gate_ctrl(dev, 0);
1561         return 0;
1562 }
1563
1564 static int vidioc_s_tuner(struct file *file, void *priv,
1565                                 const struct v4l2_tuner *t)
1566 {
1567         struct au0828_fh *fh = priv;
1568         struct au0828_dev *dev = fh->dev;
1569
1570         if (t->index != 0)
1571                 return -EINVAL;
1572
1573         au0828_init_tuner(dev);
1574         i2c_gate_ctrl(dev, 1);
1575         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1576         i2c_gate_ctrl(dev, 0);
1577
1578         dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1579                 t->afc);
1580
1581         return 0;
1582
1583 }
1584
1585 static int vidioc_g_frequency(struct file *file, void *priv,
1586                                 struct v4l2_frequency *freq)
1587 {
1588         struct au0828_fh *fh = priv;
1589         struct au0828_dev *dev = fh->dev;
1590
1591         if (freq->tuner != 0)
1592                 return -EINVAL;
1593         freq->frequency = dev->ctrl_freq;
1594         return 0;
1595 }
1596
1597 static int vidioc_s_frequency(struct file *file, void *priv,
1598                                 const struct v4l2_frequency *freq)
1599 {
1600         struct au0828_fh *fh = priv;
1601         struct au0828_dev *dev = fh->dev;
1602         struct v4l2_frequency new_freq = *freq;
1603
1604         if (freq->tuner != 0)
1605                 return -EINVAL;
1606
1607         au0828_init_tuner(dev);
1608         i2c_gate_ctrl(dev, 1);
1609
1610         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1611         /* Get the actual set (and possibly clamped) frequency */
1612         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1613         dev->ctrl_freq = new_freq.frequency;
1614
1615         i2c_gate_ctrl(dev, 0);
1616
1617         au0828_analog_stream_reset(dev);
1618
1619         return 0;
1620 }
1621
1622
1623 /* RAW VBI ioctls */
1624
1625 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1626                                 struct v4l2_format *format)
1627 {
1628         struct au0828_fh      *fh  = priv;
1629         struct au0828_dev     *dev = fh->dev;
1630
1631         format->fmt.vbi.samples_per_line = dev->vbi_width;
1632         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1633         format->fmt.vbi.offset = 0;
1634         format->fmt.vbi.flags = 0;
1635         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1636
1637         format->fmt.vbi.count[0] = dev->vbi_height;
1638         format->fmt.vbi.count[1] = dev->vbi_height;
1639         format->fmt.vbi.start[0] = 21;
1640         format->fmt.vbi.start[1] = 284;
1641         memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1642
1643         return 0;
1644 }
1645
1646 static int vidioc_cropcap(struct file *file, void *priv,
1647                           struct v4l2_cropcap *cc)
1648 {
1649         struct au0828_fh *fh = priv;
1650         struct au0828_dev *dev = fh->dev;
1651
1652         if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1653                 return -EINVAL;
1654
1655         cc->bounds.left = 0;
1656         cc->bounds.top = 0;
1657         cc->bounds.width = dev->width;
1658         cc->bounds.height = dev->height;
1659
1660         cc->defrect = cc->bounds;
1661
1662         cc->pixelaspect.numerator = 54;
1663         cc->pixelaspect.denominator = 59;
1664
1665         return 0;
1666 }
1667
1668 static int vidioc_streamon(struct file *file, void *priv,
1669                            enum v4l2_buf_type type)
1670 {
1671         struct au0828_fh      *fh  = priv;
1672         struct au0828_dev     *dev = fh->dev;
1673         int                   rc = -EINVAL;
1674
1675         rc = check_dev(dev);
1676         if (rc < 0)
1677                 return rc;
1678
1679         if (unlikely(type != fh->type))
1680                 return -EINVAL;
1681
1682         dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1683                 fh, type, fh->resources, dev->resources);
1684
1685         if (unlikely(!res_get(fh, get_ressource(fh))))
1686                 return -EBUSY;
1687
1688         au0828_init_tuner(dev);
1689         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1690                 au0828_analog_stream_enable(dev);
1691                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
1692         }
1693
1694         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1695                 rc = videobuf_streamon(&fh->vb_vidq);
1696                 dev->vid_timeout_running = 1;
1697                 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1698         } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1699                 rc = videobuf_streamon(&fh->vb_vbiq);
1700                 dev->vbi_timeout_running = 1;
1701                 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1702         }
1703
1704         return rc;
1705 }
1706
1707 static int vidioc_streamoff(struct file *file, void *priv,
1708                             enum v4l2_buf_type type)
1709 {
1710         struct au0828_fh      *fh  = priv;
1711         struct au0828_dev     *dev = fh->dev;
1712         int                   rc;
1713         int                   i;
1714
1715         rc = check_dev(dev);
1716         if (rc < 0)
1717                 return rc;
1718
1719         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1720             fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
1721                 return -EINVAL;
1722         if (type != fh->type)
1723                 return -EINVAL;
1724
1725         dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1726                 fh, type, fh->resources, dev->resources);
1727
1728         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1729                 dev->vid_timeout_running = 0;
1730                 del_timer_sync(&dev->vid_timeout);
1731
1732                 au0828_analog_stream_disable(dev);
1733                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1734                 rc = au0828_stream_interrupt(dev);
1735                 if (rc != 0)
1736                         return rc;
1737
1738                 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1739                         if (AUVI_INPUT(i).audio_setup == NULL)
1740                                 continue;
1741                         (AUVI_INPUT(i).audio_setup)(dev, 0);
1742                 }
1743
1744                 if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1745                         videobuf_streamoff(&fh->vb_vidq);
1746                         res_free(fh, AU0828_RESOURCE_VIDEO);
1747                 }
1748         } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1749                 dev->vbi_timeout_running = 0;
1750                 del_timer_sync(&dev->vbi_timeout);
1751
1752                 if (res_check(fh, AU0828_RESOURCE_VBI)) {
1753                         videobuf_streamoff(&fh->vb_vbiq);
1754                         res_free(fh, AU0828_RESOURCE_VBI);
1755                 }
1756         }
1757
1758         return 0;
1759 }
1760
1761 #ifdef CONFIG_VIDEO_ADV_DEBUG
1762 static int vidioc_g_register(struct file *file, void *priv,
1763                              struct v4l2_dbg_register *reg)
1764 {
1765         struct au0828_fh *fh = priv;
1766         struct au0828_dev *dev = fh->dev;
1767
1768         reg->val = au0828_read(dev, reg->reg);
1769         reg->size = 1;
1770         return 0;
1771 }
1772
1773 static int vidioc_s_register(struct file *file, void *priv,
1774                              const struct v4l2_dbg_register *reg)
1775 {
1776         struct au0828_fh *fh = priv;
1777         struct au0828_dev *dev = fh->dev;
1778
1779         return au0828_writereg(dev, reg->reg, reg->val);
1780 }
1781 #endif
1782
1783 static int vidioc_log_status(struct file *file, void *fh)
1784 {
1785         struct video_device *vdev = video_devdata(file);
1786
1787         v4l2_ctrl_log_status(file, fh);
1788         v4l2_device_call_all(vdev->v4l2_dev, 0, core, log_status);
1789         return 0;
1790 }
1791
1792 static int vidioc_reqbufs(struct file *file, void *priv,
1793                           struct v4l2_requestbuffers *rb)
1794 {
1795         struct au0828_fh *fh = priv;
1796         struct au0828_dev *dev = fh->dev;
1797         int rc;
1798
1799         rc = check_dev(dev);
1800         if (rc < 0)
1801                 return rc;
1802
1803         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1804                 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1805         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1806                 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1807
1808         return rc;
1809 }
1810
1811 static int vidioc_querybuf(struct file *file, void *priv,
1812                            struct v4l2_buffer *b)
1813 {
1814         struct au0828_fh *fh = priv;
1815         struct au0828_dev *dev = fh->dev;
1816         int rc;
1817
1818         rc = check_dev(dev);
1819         if (rc < 0)
1820                 return rc;
1821
1822         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1823                 rc = videobuf_querybuf(&fh->vb_vidq, b);
1824         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1825                 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1826
1827         return rc;
1828 }
1829
1830 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1831 {
1832         struct au0828_fh *fh = priv;
1833         struct au0828_dev *dev = fh->dev;
1834         int rc;
1835
1836         rc = check_dev(dev);
1837         if (rc < 0)
1838                 return rc;
1839
1840         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1841                 rc = videobuf_qbuf(&fh->vb_vidq, b);
1842         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1843                 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1844
1845         return rc;
1846 }
1847
1848 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1849 {
1850         struct au0828_fh *fh = priv;
1851         struct au0828_dev *dev = fh->dev;
1852         int rc;
1853
1854         rc = check_dev(dev);
1855         if (rc < 0)
1856                 return rc;
1857
1858         /* Workaround for a bug in the au0828 hardware design that sometimes
1859            results in the colorspace being inverted */
1860         if (dev->greenscreen_detected == 1) {
1861                 dprintk(1, "Detected green frame.  Resetting stream...\n");
1862                 au0828_analog_stream_reset(dev);
1863                 dev->greenscreen_detected = 0;
1864         }
1865
1866         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1867                 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1868         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1869                 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1870
1871         return rc;
1872 }
1873
1874 void au0828_v4l2_suspend(struct au0828_dev *dev)
1875 {
1876         struct urb *urb;
1877         int i;
1878
1879         pr_info("stopping V4L2\n");
1880
1881         if (dev->stream_state == STREAM_ON) {
1882                 pr_info("stopping V4L2 active URBs\n");
1883                 au0828_analog_stream_disable(dev);
1884                 /* stop urbs */
1885                 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1886                         urb = dev->isoc_ctl.urb[i];
1887                         if (urb) {
1888                                 if (!irqs_disabled())
1889                                         usb_kill_urb(urb);
1890                                 else
1891                                         usb_unlink_urb(urb);
1892                         }
1893                 }
1894         }
1895
1896         if (dev->vid_timeout_running)
1897                 del_timer_sync(&dev->vid_timeout);
1898         if (dev->vbi_timeout_running)
1899                 del_timer_sync(&dev->vbi_timeout);
1900 }
1901
1902 void au0828_v4l2_resume(struct au0828_dev *dev)
1903 {
1904         int i, rc;
1905
1906         pr_info("restarting V4L2\n");
1907
1908         if (dev->stream_state == STREAM_ON) {
1909                 au0828_stream_interrupt(dev);
1910                 au0828_init_tuner(dev);
1911         }
1912
1913         if (dev->vid_timeout_running)
1914                 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1915         if (dev->vbi_timeout_running)
1916                 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1917
1918         /* If we were doing ac97 instead of i2s, it would go here...*/
1919         au0828_i2s_init(dev);
1920
1921         au0828_analog_stream_enable(dev);
1922
1923         if (!(dev->stream_state == STREAM_ON)) {
1924                 au0828_analog_stream_reset(dev);
1925                 /* submit urbs */
1926                 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1927                         rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
1928                         if (rc) {
1929                                 au0828_isocdbg("submit of urb %i failed (error=%i)\n",
1930                                                i, rc);
1931                                 au0828_uninit_isoc(dev);
1932                         }
1933                 }
1934         }
1935 }
1936
1937 static struct v4l2_file_operations au0828_v4l_fops = {
1938         .owner      = THIS_MODULE,
1939         .open       = au0828_v4l2_open,
1940         .release    = au0828_v4l2_close,
1941         .read       = au0828_v4l2_read,
1942         .poll       = au0828_v4l2_poll,
1943         .mmap       = au0828_v4l2_mmap,
1944         .unlocked_ioctl = video_ioctl2,
1945 };
1946
1947 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1948         .vidioc_querycap            = vidioc_querycap,
1949         .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
1950         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
1951         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
1952         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
1953         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
1954         .vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
1955         .vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
1956         .vidioc_enumaudio           = vidioc_enumaudio,
1957         .vidioc_g_audio             = vidioc_g_audio,
1958         .vidioc_s_audio             = vidioc_s_audio,
1959         .vidioc_cropcap             = vidioc_cropcap,
1960         .vidioc_reqbufs             = vidioc_reqbufs,
1961         .vidioc_querybuf            = vidioc_querybuf,
1962         .vidioc_qbuf                = vidioc_qbuf,
1963         .vidioc_dqbuf               = vidioc_dqbuf,
1964         .vidioc_s_std               = vidioc_s_std,
1965         .vidioc_g_std               = vidioc_g_std,
1966         .vidioc_enum_input          = vidioc_enum_input,
1967         .vidioc_g_input             = vidioc_g_input,
1968         .vidioc_s_input             = vidioc_s_input,
1969         .vidioc_streamon            = vidioc_streamon,
1970         .vidioc_streamoff           = vidioc_streamoff,
1971         .vidioc_g_tuner             = vidioc_g_tuner,
1972         .vidioc_s_tuner             = vidioc_s_tuner,
1973         .vidioc_g_frequency         = vidioc_g_frequency,
1974         .vidioc_s_frequency         = vidioc_s_frequency,
1975 #ifdef CONFIG_VIDEO_ADV_DEBUG
1976         .vidioc_g_register          = vidioc_g_register,
1977         .vidioc_s_register          = vidioc_s_register,
1978 #endif
1979         .vidioc_log_status          = vidioc_log_status,
1980         .vidioc_subscribe_event     = v4l2_ctrl_subscribe_event,
1981         .vidioc_unsubscribe_event   = v4l2_event_unsubscribe,
1982 };
1983
1984 static const struct video_device au0828_video_template = {
1985         .fops                       = &au0828_v4l_fops,
1986         .release                    = video_device_release,
1987         .ioctl_ops                  = &video_ioctl_ops,
1988         .tvnorms                    = V4L2_STD_NTSC_M | V4L2_STD_PAL_M,
1989 };
1990
1991 /**************************************************************************/
1992
1993 int au0828_analog_register(struct au0828_dev *dev,
1994                            struct usb_interface *interface)
1995 {
1996         int retval = -ENOMEM;
1997         struct usb_host_interface *iface_desc;
1998         struct usb_endpoint_descriptor *endpoint;
1999         int i, ret;
2000
2001         dprintk(1, "au0828_analog_register called for intf#%d!\n",
2002                 interface->cur_altsetting->desc.bInterfaceNumber);
2003
2004         /* set au0828 usb interface0 to as5 */
2005         retval = usb_set_interface(dev->usbdev,
2006                         interface->cur_altsetting->desc.bInterfaceNumber, 5);
2007         if (retval != 0) {
2008                 pr_info("Failure setting usb interface0 to as5\n");
2009                 return retval;
2010         }
2011
2012         /* Figure out which endpoint has the isoc interface */
2013         iface_desc = interface->cur_altsetting;
2014         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
2015                 endpoint = &iface_desc->endpoint[i].desc;
2016                 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
2017                      == USB_DIR_IN) &&
2018                     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
2019                      == USB_ENDPOINT_XFER_ISOC)) {
2020
2021                         /* we find our isoc in endpoint */
2022                         u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
2023                         dev->max_pkt_size = (tmp & 0x07ff) *
2024                                 (((tmp & 0x1800) >> 11) + 1);
2025                         dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
2026                         dprintk(1,
2027                                 "Found isoc endpoint 0x%02x, max size = %d\n",
2028                                 dev->isoc_in_endpointaddr, dev->max_pkt_size);
2029                 }
2030         }
2031         if (!(dev->isoc_in_endpointaddr)) {
2032                 pr_info("Could not locate isoc endpoint\n");
2033                 kfree(dev);
2034                 return -ENODEV;
2035         }
2036
2037         init_waitqueue_head(&dev->open);
2038         spin_lock_init(&dev->slock);
2039
2040         /* init video dma queues */
2041         INIT_LIST_HEAD(&dev->vidq.active);
2042         INIT_LIST_HEAD(&dev->vidq.queued);
2043         INIT_LIST_HEAD(&dev->vbiq.active);
2044         INIT_LIST_HEAD(&dev->vbiq.queued);
2045
2046         dev->vid_timeout.function = au0828_vid_buffer_timeout;
2047         dev->vid_timeout.data = (unsigned long) dev;
2048         init_timer(&dev->vid_timeout);
2049
2050         dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
2051         dev->vbi_timeout.data = (unsigned long) dev;
2052         init_timer(&dev->vbi_timeout);
2053
2054         dev->width = NTSC_STD_W;
2055         dev->height = NTSC_STD_H;
2056         dev->field_size = dev->width * dev->height;
2057         dev->frame_size = dev->field_size << 1;
2058         dev->bytesperline = dev->width << 1;
2059         dev->vbi_width = 720;
2060         dev->vbi_height = 1;
2061         dev->ctrl_ainput = 0;
2062         dev->ctrl_freq = 960;
2063         dev->std = V4L2_STD_NTSC_M;
2064         au0828_s_input(dev, 0);
2065
2066         /* allocate and fill v4l2 video struct */
2067         dev->vdev = video_device_alloc();
2068         if (NULL == dev->vdev) {
2069                 dprintk(1, "Can't allocate video_device.\n");
2070                 return -ENOMEM;
2071         }
2072
2073         /* allocate the VBI struct */
2074         dev->vbi_dev = video_device_alloc();
2075         if (NULL == dev->vbi_dev) {
2076                 dprintk(1, "Can't allocate vbi_device.\n");
2077                 ret = -ENOMEM;
2078                 goto err_vdev;
2079         }
2080
2081         /* Fill the video capture device struct */
2082         *dev->vdev = au0828_video_template;
2083         dev->vdev->v4l2_dev = &dev->v4l2_dev;
2084         dev->vdev->lock = &dev->lock;
2085         strcpy(dev->vdev->name, "au0828a video");
2086
2087         /* Setup the VBI device */
2088         *dev->vbi_dev = au0828_video_template;
2089         dev->vbi_dev->v4l2_dev = &dev->v4l2_dev;
2090         dev->vbi_dev->lock = &dev->lock;
2091         strcpy(dev->vbi_dev->name, "au0828a vbi");
2092
2093         /* Register the v4l2 device */
2094         video_set_drvdata(dev->vdev, dev);
2095         retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
2096         if (retval != 0) {
2097                 dprintk(1, "unable to register video device (error = %d).\n",
2098                         retval);
2099                 ret = -ENODEV;
2100                 goto err_vbi_dev;
2101         }
2102
2103         /* Register the vbi device */
2104         video_set_drvdata(dev->vbi_dev, dev);
2105         retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
2106         if (retval != 0) {
2107                 dprintk(1, "unable to register vbi device (error = %d).\n",
2108                         retval);
2109                 ret = -ENODEV;
2110                 goto err_vbi_dev;
2111         }
2112
2113         dprintk(1, "%s completed!\n", __func__);
2114
2115         return 0;
2116
2117 err_vbi_dev:
2118         video_device_release(dev->vbi_dev);
2119 err_vdev:
2120         video_device_release(dev->vdev);
2121         return ret;
2122 }
2123