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