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