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