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/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 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 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         do_gettimeofday(&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         do_gettimeofday(&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 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 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         mutex_lock(&dev->lock);
 868         if (dev->resources & bit) {
 869                 /* no, someone else uses it */
 870                 mutex_unlock(&dev->lock);
 871                 return 0;
 872         }
 873         /* it's free, grab it */
 874         fh->resources  |= bit;
 875         dev->resources |= bit;
 876         dprintk(1, "res: get %d\n", bit);
 877         mutex_unlock(&dev->lock);
 878         return 1;
 879 }
 880
 881 static int res_check(struct au0828_fh *fh, unsigned int bit)
 882 {
 883         return fh->resources & bit;
 884 }
 885
 886 static int res_locked(struct au0828_dev *dev, unsigned int bit)
 887 {
 888         return dev->resources & bit;
 889 }
 890
 891 static void res_free(struct au0828_fh *fh, unsigned int bits)
 892 {
 893         struct au0828_dev    *dev = fh->dev;
 894
 895         BUG_ON((fh->resources & bits) != bits);
 896
 897         mutex_lock(&dev->lock);
 898         fh->resources  &= ~bits;
 899         dev->resources &= ~bits;
 900         dprintk(1, "res: put %d\n", bits);
 901         mutex_unlock(&dev->lock);
 902 }
 903
 904 static int get_ressource(struct au0828_fh *fh)
 905 {
 906         switch (fh->type) {
 907         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 908                 return AU0828_RESOURCE_VIDEO;
 909         case V4L2_BUF_TYPE_VBI_CAPTURE:
 910                 return AU0828_RESOURCE_VBI;
 911         default:
 912                 BUG();
 913                 return 0;
 914         }
 915 }
 916
 917 /* This function ensures that video frames continue to be delivered even if
 918    the ITU-656 input isn't receiving any data (thereby preventing applications
 919    such as tvtime from hanging) */
 920 void au0828_vid_buffer_timeout(unsigned long data)
 921 {
 922         struct au0828_dev *dev = (struct au0828_dev *) data;
 923         struct au0828_dmaqueue *dma_q = &dev->vidq;
 924         struct au0828_buffer *buf;
 925         unsigned char *vid_data;
 926         unsigned long flags = 0;
 927
 928         spin_lock_irqsave(&dev->slock, flags);
 929
 930         buf = dev->isoc_ctl.buf;
 931         if (buf != NULL) {
 932                 vid_data = videobuf_to_vmalloc(&buf->vb);
 933                 memset(vid_data, 0x00, buf->vb.size); /* Blank green frame */
 934                 buffer_filled(dev, dma_q, buf);
 935         }
 936         get_next_buf(dma_q, &buf);
 937
 938         if (dev->vid_timeout_running == 1)
 939                 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
 940
 941         spin_unlock_irqrestore(&dev->slock, flags);
 942 }
 943
 944 void au0828_vbi_buffer_timeout(unsigned long data)
 945 {
 946         struct au0828_dev *dev = (struct au0828_dev *) data;
 947         struct au0828_dmaqueue *dma_q = &dev->vbiq;
 948         struct au0828_buffer *buf;
 949         unsigned char *vbi_data;
 950         unsigned long flags = 0;
 951
 952         spin_lock_irqsave(&dev->slock, flags);
 953
 954         buf = dev->isoc_ctl.vbi_buf;
 955         if (buf != NULL) {
 956                 vbi_data = videobuf_to_vmalloc(&buf->vb);
 957                 memset(vbi_data, 0x00, buf->vb.size);
 958                 vbi_buffer_filled(dev, dma_q, buf);
 959         }
 960         vbi_get_next_buf(dma_q, &buf);
 961
 962         if (dev->vbi_timeout_running == 1)
 963                 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
 964         spin_unlock_irqrestore(&dev->slock, flags);
 965 }
 966
 967
 968 static int au0828_v4l2_open(struct file *filp)
 969 {
 970         int ret = 0;
 971         struct video_device *vdev = video_devdata(filp);
 972         struct au0828_dev *dev = video_drvdata(filp);
 973         struct au0828_fh *fh;
 974         int type;
 975
 976         switch (vdev->vfl_type) {
 977         case VFL_TYPE_GRABBER:
 978                 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 979                 break;
 980         case VFL_TYPE_VBI:
 981                 type = V4L2_BUF_TYPE_VBI_CAPTURE;
 982                 break;
 983         default:
 984                 return -EINVAL;
 985         }
 986
 987         fh = kzalloc(sizeof(struct au0828_fh), GFP_KERNEL);
 988         if (NULL == fh) {
 989                 dprintk(1, "Failed allocate au0828_fh struct!\n");
 990                 return -ENOMEM;
 991         }
 992
 993         fh->type = type;
 994         fh->dev = dev;
 995         filp->private_data = fh;
 996
 997         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
 998                 /* set au0828 interface0 to AS5 here again */
 999                 ret = usb_set_interface(dev->usbdev, 0, 5);
1000                 if (ret < 0) {
1001                         printk(KERN_INFO "Au0828 can't set alternate to 5!\n");
1002                         return -EBUSY;
1003                 }
1004                 dev->width = NTSC_STD_W;
1005                 dev->height = NTSC_STD_H;
1006                 dev->frame_size = dev->width * dev->height * 2;
1007                 dev->field_size = dev->width * dev->height;
1008                 dev->bytesperline = dev->width * 2;
1009
1010                 au0828_analog_stream_enable(dev);
1011                 au0828_analog_stream_reset(dev);
1012
1013                 /* If we were doing ac97 instead of i2s, it would go here...*/
1014                 au0828_i2s_init(dev);
1015
1016                 dev->stream_state = STREAM_OFF;
1017                 dev->dev_state |= DEV_INITIALIZED;
1018         }
1019
1020         dev->users++;
1021
1022         videobuf_queue_vmalloc_init(&fh->vb_vidq, &au0828_video_qops,
1023                                     NULL, &dev->slock,
1024                                     V4L2_BUF_TYPE_VIDEO_CAPTURE,
1025                                     V4L2_FIELD_INTERLACED,
1026                                     sizeof(struct au0828_buffer), fh, NULL);
1027
1028         /* VBI Setup */
1029         dev->vbi_width = 720;
1030         dev->vbi_height = 1;
1031         videobuf_queue_vmalloc_init(&fh->vb_vbiq, &au0828_vbi_qops,
1032                                     NULL, &dev->slock,
1033                                     V4L2_BUF_TYPE_VBI_CAPTURE,
1034                                     V4L2_FIELD_SEQ_TB,
1035                                     sizeof(struct au0828_buffer), fh, NULL);
1036
1037         return ret;
1038 }
1039
1040 static int au0828_v4l2_close(struct file *filp)
1041 {
1042         int ret;
1043         struct au0828_fh *fh = filp->private_data;
1044         struct au0828_dev *dev = fh->dev;
1045
1046         if (res_check(fh, AU0828_RESOURCE_VIDEO)) {
1047                 /* Cancel timeout thread in case they didn't call streamoff */
1048                 dev->vid_timeout_running = 0;
1049                 del_timer_sync(&dev->vid_timeout);
1050
1051                 videobuf_stop(&fh->vb_vidq);
1052                 res_free(fh, AU0828_RESOURCE_VIDEO);
1053         }
1054
1055         if (res_check(fh, AU0828_RESOURCE_VBI)) {
1056                 /* Cancel timeout thread in case they didn't call streamoff */
1057                 dev->vbi_timeout_running = 0;
1058                 del_timer_sync(&dev->vbi_timeout);
1059
1060                 videobuf_stop(&fh->vb_vbiq);
1061                 res_free(fh, AU0828_RESOURCE_VBI);
1062         }
1063
1064         if (dev->users == 1) {
1065                 if (dev->dev_state & DEV_DISCONNECTED) {
1066                         au0828_analog_unregister(dev);
1067                         kfree(dev);
1068                         return 0;
1069                 }
1070
1071                 au0828_analog_stream_disable(dev);
1072
1073                 au0828_uninit_isoc(dev);
1074
1075                 /* Save some power by putting tuner to sleep */
1076                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1077
1078                 /* When close the device, set the usb intf0 into alt0 to free
1079                    USB bandwidth */
1080                 ret = usb_set_interface(dev->usbdev, 0, 0);
1081                 if (ret < 0)
1082                         printk(KERN_INFO "Au0828 can't set alternate to 0!\n");
1083         }
1084
1085         videobuf_mmap_free(&fh->vb_vidq);
1086         videobuf_mmap_free(&fh->vb_vbiq);
1087         kfree(fh);
1088         dev->users--;
1089         wake_up_interruptible_nr(&dev->open, 1);
1090         return 0;
1091 }
1092
1093 static ssize_t au0828_v4l2_read(struct file *filp, char __user *buf,
1094                                 size_t count, loff_t *pos)
1095 {
1096         struct au0828_fh *fh = filp->private_data;
1097         struct au0828_dev *dev = fh->dev;
1098         int rc;
1099
1100         rc = check_dev(dev);
1101         if (rc < 0)
1102                 return rc;
1103
1104         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1105                 if (res_locked(dev, AU0828_RESOURCE_VIDEO))
1106                         return -EBUSY;
1107
1108                 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1109                                         filp->f_flags & O_NONBLOCK);
1110         }
1111
1112         if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1113                 if (!res_get(fh, AU0828_RESOURCE_VBI))
1114                         return -EBUSY;
1115
1116                 if (dev->vbi_timeout_running == 0) {
1117                         /* Handle case where caller tries to read without
1118                            calling streamon first */
1119                         dev->vbi_timeout_running = 1;
1120                         mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1121                 }
1122
1123                 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
1124                                             filp->f_flags & O_NONBLOCK);
1125         }
1126
1127         return 0;
1128 }
1129
1130 static unsigned int au0828_v4l2_poll(struct file *filp, poll_table *wait)
1131 {
1132         struct au0828_fh *fh = filp->private_data;
1133         struct au0828_dev *dev = fh->dev;
1134         int rc;
1135
1136         rc = check_dev(dev);
1137         if (rc < 0)
1138                 return rc;
1139
1140         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1141                 if (!res_get(fh, AU0828_RESOURCE_VIDEO))
1142                         return POLLERR;
1143                 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
1144         } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1145                 if (!res_get(fh, AU0828_RESOURCE_VBI))
1146                         return POLLERR;
1147                 return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
1148         } else {
1149                 return POLLERR;
1150         }
1151 }
1152
1153 static int au0828_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1154 {
1155         struct au0828_fh *fh    = filp->private_data;
1156         struct au0828_dev *dev   = fh->dev;
1157         int              rc;
1158
1159         rc = check_dev(dev);
1160         if (rc < 0)
1161                 return rc;
1162
1163         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1164                 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1165         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1166                 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
1167
1168         return rc;
1169 }
1170
1171 static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1172                              struct v4l2_format *format)
1173 {
1174         int ret;
1175         int width = format->fmt.pix.width;
1176         int height = format->fmt.pix.height;
1177
1178         if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1179                 return -EINVAL;
1180
1181         /* If they are demanding a format other than the one we support,
1182            bail out (tvtime asks for UYVY and then retries with YUYV) */
1183         if (format->fmt.pix.pixelformat != V4L2_PIX_FMT_UYVY)
1184                 return -EINVAL;
1185
1186         /* format->fmt.pix.width only support 720 and height 480 */
1187         if (width != 720)
1188                 width = 720;
1189         if (height != 480)
1190                 height = 480;
1191
1192         format->fmt.pix.width = width;
1193         format->fmt.pix.height = height;
1194         format->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1195         format->fmt.pix.bytesperline = width * 2;
1196         format->fmt.pix.sizeimage = width * height * 2;
1197         format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1198         format->fmt.pix.field = V4L2_FIELD_INTERLACED;
1199
1200         if (cmd == VIDIOC_TRY_FMT)
1201                 return 0;
1202
1203         /* maybe set new image format, driver current only support 720*480 */
1204         dev->width = width;
1205         dev->height = height;
1206         dev->frame_size = width * height * 2;
1207         dev->field_size = width * height;
1208         dev->bytesperline = width * 2;
1209
1210         if (dev->stream_state == STREAM_ON) {
1211                 dprintk(1, "VIDIOC_SET_FMT: interrupting stream!\n");
1212                 ret = au0828_stream_interrupt(dev);
1213                 if (ret != 0) {
1214                         dprintk(1, "error interrupting video stream!\n");
1215                         return ret;
1216                 }
1217         }
1218
1219         /* set au0828 interface0 to AS5 here again */
1220         ret = usb_set_interface(dev->usbdev, 0, 5);
1221         if (ret < 0) {
1222                 printk(KERN_INFO "Au0828 can't set alt setting to 5!\n");
1223                 return -EBUSY;
1224         }
1225
1226         au0828_analog_stream_enable(dev);
1227
1228         return 0;
1229 }
1230
1231
1232 static int vidioc_queryctrl(struct file *file, void *priv,
1233                             struct v4l2_queryctrl *qc)
1234 {
1235         struct au0828_fh *fh = priv;
1236         struct au0828_dev *dev = fh->dev;
1237         v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
1238         if (qc->type)
1239                 return 0;
1240         else
1241                 return -EINVAL;
1242 }
1243
1244 static int vidioc_querycap(struct file *file, void  *priv,
1245                            struct v4l2_capability *cap)
1246 {
1247         struct au0828_fh *fh  = priv;
1248         struct au0828_dev *dev = fh->dev;
1249
1250         strlcpy(cap->driver, "au0828", sizeof(cap->driver));
1251         strlcpy(cap->card, dev->board.name, sizeof(cap->card));
1252         strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
1253
1254         /*set the device capabilities */
1255         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1256                 V4L2_CAP_VBI_CAPTURE |
1257                 V4L2_CAP_AUDIO |
1258                 V4L2_CAP_READWRITE |
1259                 V4L2_CAP_STREAMING |
1260                 V4L2_CAP_TUNER;
1261         return 0;
1262 }
1263
1264 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1265                                         struct v4l2_fmtdesc *f)
1266 {
1267         if (f->index)
1268                 return -EINVAL;
1269
1270         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1271         strcpy(f->description, "Packed YUV2");
1272
1273         f->flags = 0;
1274         f->pixelformat = V4L2_PIX_FMT_UYVY;
1275
1276         return 0;
1277 }
1278
1279 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1280                                         struct v4l2_format *f)
1281 {
1282         struct au0828_fh *fh  = priv;
1283         struct au0828_dev *dev = fh->dev;
1284
1285         f->fmt.pix.width = dev->width;
1286         f->fmt.pix.height = dev->height;
1287         f->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
1288         f->fmt.pix.bytesperline = dev->bytesperline;
1289         f->fmt.pix.sizeimage = dev->frame_size;
1290         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* NTSC/PAL */
1291         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
1292         return 0;
1293 }
1294
1295 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1296                                   struct v4l2_format *f)
1297 {
1298         struct au0828_fh *fh  = priv;
1299         struct au0828_dev *dev = fh->dev;
1300
1301         return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1302 }
1303
1304 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1305                                 struct v4l2_format *f)
1306 {
1307         struct au0828_fh *fh  = priv;
1308         struct au0828_dev *dev = fh->dev;
1309         int rc;
1310
1311         rc = check_dev(dev);
1312         if (rc < 0)
1313                 return rc;
1314
1315         mutex_lock(&dev->lock);
1316
1317         if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1318                 printk(KERN_INFO "%s queue busy\n", __func__);
1319                 rc = -EBUSY;
1320                 goto out;
1321         }
1322
1323         rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
1324 out:
1325         mutex_unlock(&dev->lock);
1326         return rc;
1327 }
1328
1329 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
1330 {
1331         struct au0828_fh *fh = priv;
1332         struct au0828_dev *dev = fh->dev;
1333
1334         /* FIXME: when we support something other than NTSC, we are going to
1335            have to make the au0828 bridge adjust the size of its capture
1336            buffer, which is currently hardcoded at 720x480 */
1337
1338         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, *norm);
1339         return 0;
1340 }
1341
1342 static int vidioc_enum_input(struct file *file, void *priv,
1343                                 struct v4l2_input *input)
1344 {
1345         struct au0828_fh *fh = priv;
1346         struct au0828_dev *dev = fh->dev;
1347         unsigned int tmp;
1348
1349         static const char *inames[] = {
1350                 [AU0828_VMUX_UNDEFINED] = "Undefined",
1351                 [AU0828_VMUX_COMPOSITE] = "Composite",
1352                 [AU0828_VMUX_SVIDEO] = "S-Video",
1353                 [AU0828_VMUX_CABLE] = "Cable TV",
1354                 [AU0828_VMUX_TELEVISION] = "Television",
1355                 [AU0828_VMUX_DVB] = "DVB",
1356                 [AU0828_VMUX_DEBUG] = "tv debug"
1357         };
1358
1359         tmp = input->index;
1360
1361         if (tmp >= AU0828_MAX_INPUT)
1362                 return -EINVAL;
1363         if (AUVI_INPUT(tmp).type == 0)
1364                 return -EINVAL;
1365
1366         input->index = tmp;
1367         strcpy(input->name, inames[AUVI_INPUT(tmp).type]);
1368         if ((AUVI_INPUT(tmp).type == AU0828_VMUX_TELEVISION) ||
1369             (AUVI_INPUT(tmp).type == AU0828_VMUX_CABLE))
1370                 input->type |= V4L2_INPUT_TYPE_TUNER;
1371         else
1372                 input->type |= V4L2_INPUT_TYPE_CAMERA;
1373
1374         input->std = dev->vdev->tvnorms;
1375
1376         return 0;
1377 }
1378
1379 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1380 {
1381         struct au0828_fh *fh = priv;
1382         struct au0828_dev *dev = fh->dev;
1383         *i = dev->ctrl_input;
1384         return 0;
1385 }
1386
1387 static int vidioc_s_input(struct file *file, void *priv, unsigned int index)
1388 {
1389         struct au0828_fh *fh = priv;
1390         struct au0828_dev *dev = fh->dev;
1391         int i;
1392
1393         dprintk(1, "VIDIOC_S_INPUT in function %s, input=%d\n", __func__,
1394                 index);
1395         if (index >= AU0828_MAX_INPUT)
1396                 return -EINVAL;
1397         if (AUVI_INPUT(index).type == 0)
1398                 return -EINVAL;
1399         dev->ctrl_input = index;
1400
1401         switch (AUVI_INPUT(index).type) {
1402         case AU0828_VMUX_SVIDEO:
1403                 dev->input_type = AU0828_VMUX_SVIDEO;
1404                 break;
1405         case AU0828_VMUX_COMPOSITE:
1406                 dev->input_type = AU0828_VMUX_COMPOSITE;
1407                 break;
1408         case AU0828_VMUX_TELEVISION:
1409                 dev->input_type = AU0828_VMUX_TELEVISION;
1410                 break;
1411         default:
1412                 dprintk(1, "VIDIOC_S_INPUT unknown input type set [%d]\n",
1413                         AUVI_INPUT(index).type);
1414                 break;
1415         }
1416
1417         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1418                         AUVI_INPUT(index).vmux, 0, 0);
1419
1420         for (i = 0; i < AU0828_MAX_INPUT; i++) {
1421                 int enable = 0;
1422                 if (AUVI_INPUT(i).audio_setup == NULL)
1423                         continue;
1424
1425                 if (i == index)
1426                         enable = 1;
1427                 else
1428                         enable = 0;
1429                 if (enable) {
1430                         (AUVI_INPUT(i).audio_setup)(dev, enable);
1431                 } else {
1432                         /* Make sure we leave it turned on if some
1433                            other input is routed to this callback */
1434                         if ((AUVI_INPUT(i).audio_setup) !=
1435                             ((AUVI_INPUT(index).audio_setup))) {
1436                                 (AUVI_INPUT(i).audio_setup)(dev, enable);
1437                         }
1438                 }
1439         }
1440
1441         v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1442                         AUVI_INPUT(index).amux, 0, 0);
1443         return 0;
1444 }
1445
1446 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1447 {
1448         struct au0828_fh *fh = priv;
1449         struct au0828_dev *dev = fh->dev;
1450         unsigned int index = a->index;
1451
1452         if (a->index > 1)
1453                 return -EINVAL;
1454
1455         index = dev->ctrl_ainput;
1456         if (index == 0)
1457                 strcpy(a->name, "Television");
1458         else
1459                 strcpy(a->name, "Line in");
1460
1461         a->capability = V4L2_AUDCAP_STEREO;
1462         a->index = index;
1463         return 0;
1464 }
1465
1466 static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1467 {
1468         struct au0828_fh *fh = priv;
1469         struct au0828_dev *dev = fh->dev;
1470         if (a->index != dev->ctrl_ainput)
1471                 return -EINVAL;
1472         return 0;
1473 }
1474
1475 static int vidioc_g_ctrl(struct file *file, void *priv,
1476                          struct v4l2_control *ctrl)
1477 {
1478         struct au0828_fh *fh = priv;
1479         struct au0828_dev *dev = fh->dev;
1480
1481         v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
1482         return 0;
1483
1484 }
1485
1486 static int vidioc_s_ctrl(struct file *file, void *priv,
1487                                 struct v4l2_control *ctrl)
1488 {
1489         struct au0828_fh *fh = priv;
1490         struct au0828_dev *dev = fh->dev;
1491         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_ctrl, ctrl);
1492         return 0;
1493 }
1494
1495 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1496 {
1497         struct au0828_fh *fh = priv;
1498         struct au0828_dev *dev = fh->dev;
1499
1500         if (t->index != 0)
1501                 return -EINVAL;
1502
1503         strcpy(t->name, "Auvitek tuner");
1504         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1505         return 0;
1506 }
1507
1508 static int vidioc_s_tuner(struct file *file, void *priv,
1509                                 struct v4l2_tuner *t)
1510 {
1511         struct au0828_fh *fh = priv;
1512         struct au0828_dev *dev = fh->dev;
1513
1514         if (t->index != 0)
1515                 return -EINVAL;
1516
1517         t->type = V4L2_TUNER_ANALOG_TV;
1518         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1519         dprintk(1, "VIDIOC_S_TUNER: signal = %x, afc = %x\n", t->signal,
1520                 t->afc);
1521         return 0;
1522
1523 }
1524
1525 static int vidioc_g_frequency(struct file *file, void *priv,
1526                                 struct v4l2_frequency *freq)
1527 {
1528         struct au0828_fh *fh = priv;
1529         struct au0828_dev *dev = fh->dev;
1530
1531         freq->type = V4L2_TUNER_ANALOG_TV;
1532         freq->frequency = dev->ctrl_freq;
1533         return 0;
1534 }
1535
1536 static int vidioc_s_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         if (freq->tuner != 0)
1543                 return -EINVAL;
1544         if (freq->type != V4L2_TUNER_ANALOG_TV)
1545                 return -EINVAL;
1546
1547         dev->ctrl_freq = freq->frequency;
1548
1549         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1550
1551         au0828_analog_stream_reset(dev);
1552
1553         return 0;
1554 }
1555
1556
1557 /* RAW VBI ioctls */
1558
1559 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1560                                 struct v4l2_format *format)
1561 {
1562         struct au0828_fh      *fh  = priv;
1563         struct au0828_dev     *dev = fh->dev;
1564
1565         format->fmt.vbi.samples_per_line = dev->vbi_width;
1566         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1567         format->fmt.vbi.offset = 0;
1568         format->fmt.vbi.flags = 0;
1569         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1570
1571         format->fmt.vbi.count[0] = dev->vbi_height;
1572         format->fmt.vbi.count[1] = dev->vbi_height;
1573         format->fmt.vbi.start[0] = 21;
1574         format->fmt.vbi.start[1] = 284;
1575
1576         return 0;
1577 }
1578
1579 static int vidioc_g_chip_ident(struct file *file, void *priv,
1580                struct v4l2_dbg_chip_ident *chip)
1581 {
1582         struct au0828_fh *fh = priv;
1583         struct au0828_dev *dev = fh->dev;
1584         chip->ident = V4L2_IDENT_NONE;
1585         chip->revision = 0;
1586
1587         if (v4l2_chip_match_host(&chip->match)) {
1588                 chip->ident = V4L2_IDENT_AU0828;
1589                 return 0;
1590         }
1591
1592         v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
1593         if (chip->ident == V4L2_IDENT_NONE)
1594                 return -EINVAL;
1595
1596         return 0;
1597 }
1598
1599 static int vidioc_cropcap(struct file *file, void *priv,
1600                           struct v4l2_cropcap *cc)
1601 {
1602         struct au0828_fh *fh = priv;
1603         struct au0828_dev *dev = fh->dev;
1604
1605         if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1606                 return -EINVAL;
1607
1608         cc->bounds.left = 0;
1609         cc->bounds.top = 0;
1610         cc->bounds.width = dev->width;
1611         cc->bounds.height = dev->height;
1612
1613         cc->defrect = cc->bounds;
1614
1615         cc->pixelaspect.numerator = 54;
1616         cc->pixelaspect.denominator = 59;
1617
1618         return 0;
1619 }
1620
1621 static int vidioc_streamon(struct file *file, void *priv,
1622                            enum v4l2_buf_type type)
1623 {
1624         struct au0828_fh      *fh  = priv;
1625         struct au0828_dev     *dev = fh->dev;
1626         int                   rc = -EINVAL;
1627
1628         rc = check_dev(dev);
1629         if (rc < 0)
1630                 return rc;
1631
1632         if (unlikely(type != fh->type))
1633                 return -EINVAL;
1634
1635         dprintk(1, "vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1636                 fh, type, fh->resources, dev->resources);
1637
1638         if (unlikely(!res_get(fh, get_ressource(fh))))
1639                 return -EBUSY;
1640
1641         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1642                 au0828_analog_stream_enable(dev);
1643                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
1644         }
1645
1646         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1647                 rc = videobuf_streamon(&fh->vb_vidq);
1648                 dev->vid_timeout_running = 1;
1649                 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1650         } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1651                 rc = videobuf_streamon(&fh->vb_vbiq);
1652                 dev->vbi_timeout_running = 1;
1653                 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1654         }
1655
1656         return rc;
1657 }
1658
1659 static int vidioc_streamoff(struct file *file, void *priv,
1660                             enum v4l2_buf_type type)
1661 {
1662         struct au0828_fh      *fh  = priv;
1663         struct au0828_dev     *dev = fh->dev;
1664         int                   rc;
1665         int                   i;
1666
1667         rc = check_dev(dev);
1668         if (rc < 0)
1669                 return rc;
1670
1671         if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1672             fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
1673                 return -EINVAL;
1674         if (type != fh->type)
1675                 return -EINVAL;
1676
1677         dprintk(1, "vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1678                 fh, type, fh->resources, dev->resources);
1679
1680         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1681                 dev->vid_timeout_running = 0;
1682                 del_timer_sync(&dev->vid_timeout);
1683
1684                 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1685                 rc = au0828_stream_interrupt(dev);
1686                 if (rc != 0)
1687                         return rc;
1688
1689                 for (i = 0; i < AU0828_MAX_INPUT; i++) {
1690                         if (AUVI_INPUT(i).audio_setup == NULL)
1691                                 continue;
1692                         (AUVI_INPUT(i).audio_setup)(dev, 0);
1693                 }
1694
1695                 videobuf_streamoff(&fh->vb_vidq);
1696                 res_free(fh, AU0828_RESOURCE_VIDEO);
1697         } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1698                 dev->vbi_timeout_running = 0;
1699                 del_timer_sync(&dev->vbi_timeout);
1700
1701                 videobuf_streamoff(&fh->vb_vbiq);
1702                 res_free(fh, AU0828_RESOURCE_VBI);
1703         }
1704
1705         return 0;
1706 }
1707
1708 #ifdef CONFIG_VIDEO_ADV_DEBUG
1709 static int vidioc_g_register(struct file *file, void *priv,
1710                              struct v4l2_dbg_register *reg)
1711 {
1712         struct au0828_fh *fh = priv;
1713         struct au0828_dev *dev = fh->dev;
1714
1715         switch (reg->match.type) {
1716         case V4L2_CHIP_MATCH_I2C_DRIVER:
1717                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1718                 return 0;
1719         default:
1720                 return -EINVAL;
1721         }
1722 }
1723
1724 static int vidioc_s_register(struct file *file, void *priv,
1725                              struct v4l2_dbg_register *reg)
1726 {
1727         struct au0828_fh *fh = priv;
1728         struct au0828_dev *dev = fh->dev;
1729
1730         switch (reg->match.type) {
1731         case V4L2_CHIP_MATCH_I2C_DRIVER:
1732                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1733                 return 0;
1734         default:
1735                 return -EINVAL;
1736         }
1737         return 0;
1738 }
1739 #endif
1740
1741 static int vidioc_reqbufs(struct file *file, void *priv,
1742                           struct v4l2_requestbuffers *rb)
1743 {
1744         struct au0828_fh *fh = priv;
1745         struct au0828_dev *dev = fh->dev;
1746         int rc;
1747
1748         rc = check_dev(dev);
1749         if (rc < 0)
1750                 return rc;
1751
1752         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1753                 rc = videobuf_reqbufs(&fh->vb_vidq, rb);
1754         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1755                 rc = videobuf_reqbufs(&fh->vb_vbiq, rb);
1756
1757         return rc;
1758 }
1759
1760 static int vidioc_querybuf(struct file *file, void *priv,
1761                            struct v4l2_buffer *b)
1762 {
1763         struct au0828_fh *fh = priv;
1764         struct au0828_dev *dev = fh->dev;
1765         int rc;
1766
1767         rc = check_dev(dev);
1768         if (rc < 0)
1769                 return rc;
1770
1771         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1772                 rc = videobuf_querybuf(&fh->vb_vidq, b);
1773         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1774                 rc = videobuf_querybuf(&fh->vb_vbiq, b);
1775
1776         return rc;
1777 }
1778
1779 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1780 {
1781         struct au0828_fh *fh = priv;
1782         struct au0828_dev *dev = fh->dev;
1783         int rc;
1784
1785         rc = check_dev(dev);
1786         if (rc < 0)
1787                 return rc;
1788
1789         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1790                 rc = videobuf_qbuf(&fh->vb_vidq, b);
1791         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1792                 rc = videobuf_qbuf(&fh->vb_vbiq, b);
1793
1794         return rc;
1795 }
1796
1797 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1798 {
1799         struct au0828_fh *fh = priv;
1800         struct au0828_dev *dev = fh->dev;
1801         int rc;
1802
1803         rc = check_dev(dev);
1804         if (rc < 0)
1805                 return rc;
1806
1807         /* Workaround for a bug in the au0828 hardware design that sometimes
1808            results in the colorspace being inverted */
1809         if (dev->greenscreen_detected == 1) {
1810                 dprintk(1, "Detected green frame.  Resetting stream...\n");
1811                 au0828_analog_stream_reset(dev);
1812                 dev->greenscreen_detected = 0;
1813         }
1814
1815         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1816                 rc = videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1817         else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1818                 rc = videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & O_NONBLOCK);
1819
1820         return rc;
1821 }
1822
1823 static struct v4l2_file_operations au0828_v4l_fops = {
1824         .owner      = THIS_MODULE,
1825         .open       = au0828_v4l2_open,
1826         .release    = au0828_v4l2_close,
1827         .read       = au0828_v4l2_read,
1828         .poll       = au0828_v4l2_poll,
1829         .mmap       = au0828_v4l2_mmap,
1830         .ioctl      = video_ioctl2,
1831 };
1832
1833 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1834         .vidioc_querycap            = vidioc_querycap,
1835         .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
1836         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
1837         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
1838         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
1839         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
1840         .vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
1841         .vidioc_g_audio             = vidioc_g_audio,
1842         .vidioc_s_audio             = vidioc_s_audio,
1843         .vidioc_cropcap             = vidioc_cropcap,
1844         .vidioc_reqbufs             = vidioc_reqbufs,
1845         .vidioc_querybuf            = vidioc_querybuf,
1846         .vidioc_qbuf                = vidioc_qbuf,
1847         .vidioc_dqbuf               = vidioc_dqbuf,
1848         .vidioc_s_std               = vidioc_s_std,
1849         .vidioc_enum_input          = vidioc_enum_input,
1850         .vidioc_g_input             = vidioc_g_input,
1851         .vidioc_s_input             = vidioc_s_input,
1852         .vidioc_queryctrl           = vidioc_queryctrl,
1853         .vidioc_g_ctrl              = vidioc_g_ctrl,
1854         .vidioc_s_ctrl              = vidioc_s_ctrl,
1855         .vidioc_streamon            = vidioc_streamon,
1856         .vidioc_streamoff           = vidioc_streamoff,
1857         .vidioc_g_tuner             = vidioc_g_tuner,
1858         .vidioc_s_tuner             = vidioc_s_tuner,
1859         .vidioc_g_frequency         = vidioc_g_frequency,
1860         .vidioc_s_frequency         = vidioc_s_frequency,
1861 #ifdef CONFIG_VIDEO_ADV_DEBUG
1862         .vidioc_g_register          = vidioc_g_register,
1863         .vidioc_s_register          = vidioc_s_register,
1864 #endif
1865         .vidioc_g_chip_ident        = vidioc_g_chip_ident,
1866 };
1867
1868 static const struct video_device au0828_video_template = {
1869         .fops                       = &au0828_v4l_fops,
1870         .release                    = video_device_release,
1871         .ioctl_ops                  = &video_ioctl_ops,
1872         .tvnorms                    = V4L2_STD_NTSC_M,
1873         .current_norm               = V4L2_STD_NTSC_M,
1874 };
1875
1876 /**************************************************************************/
1877
1878 int au0828_analog_register(struct au0828_dev *dev,
1879                            struct usb_interface *interface)
1880 {
1881         int retval = -ENOMEM;
1882         struct usb_host_interface *iface_desc;
1883         struct usb_endpoint_descriptor *endpoint;
1884         int i, ret;
1885
1886         dprintk(1, "au0828_analog_register called!\n");
1887
1888         /* set au0828 usb interface0 to as5 */
1889         retval = usb_set_interface(dev->usbdev,
1890                         interface->cur_altsetting->desc.bInterfaceNumber, 5);
1891         if (retval != 0) {
1892                 printk(KERN_INFO "Failure setting usb interface0 to as5\n");
1893                 return retval;
1894         }
1895
1896         /* Figure out which endpoint has the isoc interface */
1897         iface_desc = interface->cur_altsetting;
1898         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
1899                 endpoint = &iface_desc->endpoint[i].desc;
1900                 if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1901                      == USB_DIR_IN) &&
1902                     ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
1903                      == USB_ENDPOINT_XFER_ISOC)) {
1904
1905                         /* we find our isoc in endpoint */
1906                         u16 tmp = le16_to_cpu(endpoint->wMaxPacketSize);
1907                         dev->max_pkt_size = (tmp & 0x07ff) *
1908                                 (((tmp & 0x1800) >> 11) + 1);
1909                         dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1910                 }
1911         }
1912         if (!(dev->isoc_in_endpointaddr)) {
1913                 printk(KERN_INFO "Could not locate isoc endpoint\n");
1914                 kfree(dev);
1915                 return -ENODEV;
1916         }
1917
1918         init_waitqueue_head(&dev->open);
1919         spin_lock_init(&dev->slock);
1920         mutex_init(&dev->lock);
1921
1922         /* init video dma queues */
1923         INIT_LIST_HEAD(&dev->vidq.active);
1924         INIT_LIST_HEAD(&dev->vidq.queued);
1925         INIT_LIST_HEAD(&dev->vbiq.active);
1926         INIT_LIST_HEAD(&dev->vbiq.queued);
1927
1928         dev->vid_timeout.function = au0828_vid_buffer_timeout;
1929         dev->vid_timeout.data = (unsigned long) dev;
1930         init_timer(&dev->vid_timeout);
1931
1932         dev->vbi_timeout.function = au0828_vbi_buffer_timeout;
1933         dev->vbi_timeout.data = (unsigned long) dev;
1934         init_timer(&dev->vbi_timeout);
1935
1936         dev->width = NTSC_STD_W;
1937         dev->height = NTSC_STD_H;
1938         dev->field_size = dev->width * dev->height;
1939         dev->frame_size = dev->field_size << 1;
1940         dev->bytesperline = dev->width << 1;
1941         dev->ctrl_ainput = 0;
1942
1943         /* allocate and fill v4l2 video struct */
1944         dev->vdev = video_device_alloc();
1945         if (NULL == dev->vdev) {
1946                 dprintk(1, "Can't allocate video_device.\n");
1947                 return -ENOMEM;
1948         }
1949
1950         /* allocate the VBI struct */
1951         dev->vbi_dev = video_device_alloc();
1952         if (NULL == dev->vbi_dev) {
1953                 dprintk(1, "Can't allocate vbi_device.\n");
1954                 ret = -ENOMEM;
1955                 goto err_vdev;
1956         }
1957
1958         /* Fill the video capture device struct */
1959         *dev->vdev = au0828_video_template;
1960         dev->vdev->parent = &dev->usbdev->dev;
1961         strcpy(dev->vdev->name, "au0828a video");
1962
1963         /* Setup the VBI device */
1964         *dev->vbi_dev = au0828_video_template;
1965         dev->vbi_dev->parent = &dev->usbdev->dev;
1966         strcpy(dev->vbi_dev->name, "au0828a vbi");
1967
1968         /* Register the v4l2 device */
1969         video_set_drvdata(dev->vdev, dev);
1970         retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
1971         if (retval != 0) {
1972                 dprintk(1, "unable to register video device (error = %d).\n",
1973                         retval);
1974                 ret = -ENODEV;
1975                 goto err_vbi_dev;
1976         }
1977
1978         /* Register the vbi device */
1979         video_set_drvdata(dev->vbi_dev, dev);
1980         retval = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, -1);
1981         if (retval != 0) {
1982                 dprintk(1, "unable to register vbi device (error = %d).\n",
1983                         retval);
1984                 ret = -ENODEV;
1985                 goto err_vbi_dev;
1986         }
1987
1988         dprintk(1, "%s completed!\n", __func__);
1989
1990         return 0;
1991
1992 err_vbi_dev:
1993         video_device_release(dev->vbi_dev);
1994 err_vdev:
1995         video_device_release(dev->vdev);
1996         return ret;
1997 }
1998