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

   1 /*
   2    em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
   3                     video capture devices
   4
   5    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
   6                       Markus Rechberger <mrechberger@gmail.com>
   7                       Mauro Carvalho Chehab <mchehab@infradead.org>
   8                       Sascha Sommer <saschasommer@freenet.de>
   9    Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
  10
  11         Some parts based on SN9C10x PC Camera Controllers GPL driver made
  12                 by Luca Risolia <luca.risolia@studio.unibo.it>
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 2 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27  */
  28
  29 #include <linux/init.h>
  30 #include <linux/list.h>
  31 #include <linux/module.h>
  32 #include <linux/kernel.h>
  33 #include <linux/bitmap.h>
  34 #include <linux/usb.h>
  35 #include <linux/i2c.h>
  36 #include <linux/mm.h>
  37 #include <linux/mutex.h>
  38 #include <linux/slab.h>
  39
  40 #include "em28xx.h"
  41 #include <media/v4l2-common.h>
  42 #include <media/v4l2-ioctl.h>
  43 #include <media/v4l2-event.h>
  44 #include <media/v4l2-chip-ident.h>
  45 #include <media/msp3400.h>
  46 #include <media/tuner.h>
  47
  48 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
  49                       "Markus Rechberger <mrechberger@gmail.com>, " \
  50                       "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
  51                       "Sascha Sommer <saschasommer@freenet.de>"
  52
  53 #define DRIVER_DESC         "Empia em28xx based USB video device driver"
  54
  55 #define EM28XX_VERSION "0.1.3"
  56
  57 #define em28xx_videodbg(fmt, arg...) do {\
  58         if (video_debug) \
  59                 printk(KERN_INFO "%s %s :"fmt, \
  60                          dev->name, __func__ , ##arg); } while (0)
  61
  62 static unsigned int isoc_debug;
  63 module_param(isoc_debug, int, 0644);
  64 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
  65
  66 #define em28xx_isocdbg(fmt, arg...) \
  67 do {\
  68         if (isoc_debug) { \
  69                 printk(KERN_INFO "%s %s :"fmt, \
  70                          dev->name, __func__ , ##arg); \
  71         } \
  72   } while (0)
  73
  74 MODULE_AUTHOR(DRIVER_AUTHOR);
  75 MODULE_DESCRIPTION(DRIVER_DESC);
  76 MODULE_LICENSE("GPL");
  77 MODULE_VERSION(EM28XX_VERSION);
  78
  79 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  80 static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  81 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  82
  83 module_param_array(video_nr, int, NULL, 0444);
  84 module_param_array(vbi_nr, int, NULL, 0444);
  85 module_param_array(radio_nr, int, NULL, 0444);
  86 MODULE_PARM_DESC(video_nr, "video device numbers");
  87 MODULE_PARM_DESC(vbi_nr,   "vbi device numbers");
  88 MODULE_PARM_DESC(radio_nr, "radio device numbers");
  89
  90 static unsigned int video_debug;
  91 module_param(video_debug, int, 0644);
  92 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
  93
  94 /* supported video standards */
  95 static struct em28xx_fmt format[] = {
  96         {
  97                 .name     = "16 bpp YUY2, 4:2:2, packed",
  98                 .fourcc   = V4L2_PIX_FMT_YUYV,
  99                 .depth    = 16,
 100                 .reg      = EM28XX_OUTFMT_YUV422_Y0UY1V,
 101         }, {
 102                 .name     = "16 bpp RGB 565, LE",
 103                 .fourcc   = V4L2_PIX_FMT_RGB565,
 104                 .depth    = 16,
 105                 .reg      = EM28XX_OUTFMT_RGB_16_656,
 106         }, {
 107                 .name     = "8 bpp Bayer BGBG..GRGR",
 108                 .fourcc   = V4L2_PIX_FMT_SBGGR8,
 109                 .depth    = 8,
 110                 .reg      = EM28XX_OUTFMT_RGB_8_BGBG,
 111         }, {
 112                 .name     = "8 bpp Bayer GRGR..BGBG",
 113                 .fourcc   = V4L2_PIX_FMT_SGRBG8,
 114                 .depth    = 8,
 115                 .reg      = EM28XX_OUTFMT_RGB_8_GRGR,
 116         }, {
 117                 .name     = "8 bpp Bayer GBGB..RGRG",
 118                 .fourcc   = V4L2_PIX_FMT_SGBRG8,
 119                 .depth    = 8,
 120                 .reg      = EM28XX_OUTFMT_RGB_8_GBGB,
 121         }, {
 122                 .name     = "12 bpp YUV411",
 123                 .fourcc   = V4L2_PIX_FMT_YUV411P,
 124                 .depth    = 12,
 125                 .reg      = EM28XX_OUTFMT_YUV411,
 126         },
 127 };
 128
 129 /* ------------------------------------------------------------------
 130         DMA and thread functions
 131    ------------------------------------------------------------------*/
 132
 133 /*
 134  * Finish the current buffer
 135  */
 136 static inline void finish_buffer(struct em28xx *dev,
 137                                  struct em28xx_buffer *buf)
 138 {
 139         em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
 140
 141         buf->vb.v4l2_buf.sequence = dev->field_count++;
 142         buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
 143         v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 144
 145         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 146 }
 147
 148 /*
 149  * Copy picture data from USB buffer to videobuf buffer
 150  */
 151 static void em28xx_copy_video(struct em28xx *dev,
 152                               struct em28xx_buffer *buf,
 153                               unsigned char *usb_buf,
 154                               unsigned long len)
 155 {
 156         void *fieldstart, *startwrite, *startread;
 157         int  linesdone, currlinedone, offset, lencopy, remain;
 158         int bytesperline = dev->width << 1;
 159
 160         if (buf->pos + len > buf->length)
 161                 len = buf->length - buf->pos;
 162
 163         startread = usb_buf;
 164         remain = len;
 165
 166         if (dev->progressive || buf->top_field)
 167                 fieldstart = buf->vb_buf;
 168         else /* interlaced mode, even nr. of lines */
 169                 fieldstart = buf->vb_buf + bytesperline;
 170
 171         linesdone = buf->pos / bytesperline;
 172         currlinedone = buf->pos % bytesperline;
 173
 174         if (dev->progressive)
 175                 offset = linesdone * bytesperline + currlinedone;
 176         else
 177                 offset = linesdone * bytesperline * 2 + currlinedone;
 178
 179         startwrite = fieldstart + offset;
 180         lencopy = bytesperline - currlinedone;
 181         lencopy = lencopy > remain ? remain : lencopy;
 182
 183         if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
 184                 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
 185                               ((char *)startwrite + lencopy) -
 186                               ((char *)buf->vb_buf + buf->length));
 187                 remain = (char *)buf->vb_buf + buf->length -
 188                          (char *)startwrite;
 189                 lencopy = remain;
 190         }
 191         if (lencopy <= 0)
 192                 return;
 193         memcpy(startwrite, startread, lencopy);
 194
 195         remain -= lencopy;
 196
 197         while (remain > 0) {
 198                 if (dev->progressive)
 199                         startwrite += lencopy;
 200                 else
 201                         startwrite += lencopy + bytesperline;
 202                 startread += lencopy;
 203                 if (bytesperline > remain)
 204                         lencopy = remain;
 205                 else
 206                         lencopy = bytesperline;
 207
 208                 if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
 209                     buf->length) {
 210                         em28xx_isocdbg("Overflow of %zi bytes past buffer end"
 211                                        "(2)\n",
 212                                        ((char *)startwrite + lencopy) -
 213                                        ((char *)buf->vb_buf + buf->length));
 214                         lencopy = remain = (char *)buf->vb_buf + buf->length -
 215                                 (char *)startwrite;
 216                 }
 217                 if (lencopy <= 0)
 218                         break;
 219
 220                 memcpy(startwrite, startread, lencopy);
 221
 222                 remain -= lencopy;
 223         }
 224
 225         buf->pos += len;
 226 }
 227
 228 /*
 229  * Copy VBI data from USB buffer to videobuf buffer
 230  */
 231 static void em28xx_copy_vbi(struct em28xx *dev,
 232                             struct em28xx_buffer *buf,
 233                             unsigned char *usb_buf,
 234                             unsigned long len)
 235 {
 236         unsigned int offset;
 237
 238         if (buf->pos + len > buf->length)
 239                 len = buf->length - buf->pos;
 240
 241         offset = buf->pos;
 242         /* Make sure the bottom field populates the second half of the frame */
 243         if (buf->top_field == 0)
 244                 offset += dev->vbi_width * dev->vbi_height;
 245
 246         memcpy(buf->vb_buf + offset, usb_buf, len);
 247         buf->pos += len;
 248 }
 249
 250 static inline void print_err_status(struct em28xx *dev,
 251                                      int packet, int status)
 252 {
 253         char *errmsg = "Unknown";
 254
 255         switch (status) {
 256         case -ENOENT:
 257                 errmsg = "unlinked synchronuously";
 258                 break;
 259         case -ECONNRESET:
 260                 errmsg = "unlinked asynchronuously";
 261                 break;
 262         case -ENOSR:
 263                 errmsg = "Buffer error (overrun)";
 264                 break;
 265         case -EPIPE:
 266                 errmsg = "Stalled (device not responding)";
 267                 break;
 268         case -EOVERFLOW:
 269                 errmsg = "Babble (bad cable?)";
 270                 break;
 271         case -EPROTO:
 272                 errmsg = "Bit-stuff error (bad cable?)";
 273                 break;
 274         case -EILSEQ:
 275                 errmsg = "CRC/Timeout (could be anything)";
 276                 break;
 277         case -ETIME:
 278                 errmsg = "Device does not respond";
 279                 break;
 280         }
 281         if (packet < 0) {
 282                 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
 283         } else {
 284                 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
 285                                packet, status, errmsg);
 286         }
 287 }
 288
 289 /*
 290  * get the next available buffer from dma queue
 291  */
 292 static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
 293                                                  struct em28xx_dmaqueue *dma_q)
 294 {
 295         struct em28xx_buffer *buf;
 296
 297         if (list_empty(&dma_q->active)) {
 298                 em28xx_isocdbg("No active queue to serve\n");
 299                 return NULL;
 300         }
 301
 302         /* Get the next buffer */
 303         buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
 304         /* Cleans up buffer - Useful for testing for frame/URB loss */
 305         list_del(&buf->list);
 306         buf->pos = 0;
 307         buf->vb_buf = buf->mem;
 308
 309         return buf;
 310 }
 311
 312 /*
 313  * Finish the current buffer if completed and prepare for the next field
 314  */
 315 static struct em28xx_buffer *
 316 finish_field_prepare_next(struct em28xx *dev,
 317                           struct em28xx_buffer *buf,
 318                           struct em28xx_dmaqueue *dma_q)
 319 {
 320         if (dev->progressive || dev->top_field) { /* Brand new frame */
 321                 if (buf != NULL)
 322                         finish_buffer(dev, buf);
 323                 buf = get_next_buf(dev, dma_q);
 324         }
 325         if (buf != NULL) {
 326                 buf->top_field = dev->top_field;
 327                 buf->pos = 0;
 328         }
 329
 330         return buf;
 331 }
 332
 333 /*
 334  * Process data packet according to the em2710/em2750/em28xx frame data format
 335  */
 336 static inline void process_frame_data_em28xx(struct em28xx *dev,
 337                                              unsigned char *data_pkt,
 338                                              unsigned int  data_len)
 339 {
 340         struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
 341         struct em28xx_buffer    *vbi_buf = dev->usb_ctl.vbi_buf;
 342         struct em28xx_dmaqueue  *dma_q = &dev->vidq;
 343         struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
 344
 345         /* capture type 0 = vbi start
 346            capture type 1 = vbi in progress
 347            capture type 2 = video start
 348            capture type 3 = video in progress */
 349         if (data_len >= 4) {
 350                 /* NOTE: Headers are always 4 bytes and
 351                  * never split across packets */
 352                 if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
 353                     data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
 354                         /* Continuation */
 355                         data_pkt += 4;
 356                         data_len -= 4;
 357                 } else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
 358                         /* Field start (VBI mode) */
 359                         dev->capture_type = 0;
 360                         dev->vbi_read = 0;
 361                         em28xx_isocdbg("VBI START HEADER !!!\n");
 362                         dev->top_field = !(data_pkt[2] & 1);
 363                         data_pkt += 4;
 364                         data_len -= 4;
 365                 } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
 366                         /* Field start (VBI disabled) */
 367                         dev->capture_type = 2;
 368                         em28xx_isocdbg("VIDEO START HEADER !!!\n");
 369                         dev->top_field = !(data_pkt[2] & 1);
 370                         data_pkt += 4;
 371                         data_len -= 4;
 372                 }
 373         }
 374         /* NOTE: With bulk transfers, intermediate data packets
 375          * have no continuation header */
 376
 377         if (dev->capture_type == 0) {
 378                 vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
 379                 dev->usb_ctl.vbi_buf = vbi_buf;
 380                 dev->capture_type = 1;
 381         }
 382
 383         if (dev->capture_type == 1) {
 384                 int vbi_size = dev->vbi_width * dev->vbi_height;
 385                 int vbi_data_len = ((dev->vbi_read + data_len) > vbi_size) ?
 386                                    (vbi_size - dev->vbi_read) : data_len;
 387
 388                 /* Copy VBI data */
 389                 if (vbi_buf != NULL)
 390                         em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
 391                 dev->vbi_read += vbi_data_len;
 392
 393                 if (vbi_data_len < data_len) {
 394                         /* Continue with copying video data */
 395                         dev->capture_type = 2;
 396                         data_pkt += vbi_data_len;
 397                         data_len -= vbi_data_len;
 398                 }
 399         }
 400
 401         if (dev->capture_type == 2) {
 402                 buf = finish_field_prepare_next(dev, buf, dma_q);
 403                 dev->usb_ctl.vid_buf = buf;
 404                 dev->capture_type = 3;
 405         }
 406
 407         if (dev->capture_type == 3 && buf != NULL && data_len > 0)
 408                 em28xx_copy_video(dev, buf, data_pkt, data_len);
 409 }
 410
 411 /* Processes and copies the URB data content (video and VBI data) */
 412 static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
 413 {
 414         int xfer_bulk, num_packets, i;
 415         unsigned char *usb_data_pkt;
 416         unsigned int usb_data_len;
 417
 418         if (!dev)
 419                 return 0;
 420
 421         if (dev->disconnected)
 422                 return 0;
 423
 424         if (urb->status < 0)
 425                 print_err_status(dev, -1, urb->status);
 426
 427         xfer_bulk = usb_pipebulk(urb->pipe);
 428
 429         if (xfer_bulk) /* bulk */
 430                 num_packets = 1;
 431         else /* isoc */
 432                 num_packets = urb->number_of_packets;
 433
 434         for (i = 0; i < num_packets; i++) {
 435                 if (xfer_bulk) { /* bulk */
 436                         usb_data_len = urb->actual_length;
 437
 438                         usb_data_pkt = urb->transfer_buffer;
 439                 } else { /* isoc */
 440                         if (urb->iso_frame_desc[i].status < 0) {
 441                                 print_err_status(dev, i,
 442                                                  urb->iso_frame_desc[i].status);
 443                                 if (urb->iso_frame_desc[i].status != -EPROTO)
 444                                         continue;
 445                         }
 446
 447                         usb_data_len = urb->iso_frame_desc[i].actual_length;
 448                         if (usb_data_len > dev->max_pkt_size) {
 449                                 em28xx_isocdbg("packet bigger than packet size");
 450                                 continue;
 451                         }
 452
 453                         usb_data_pkt = urb->transfer_buffer +
 454                                        urb->iso_frame_desc[i].offset;
 455                 }
 456
 457                 if (usb_data_len == 0) {
 458                         /* NOTE: happens very often with isoc transfers */
 459                         /* em28xx_usbdbg("packet %d is empty",i); - spammy */
 460                         continue;
 461                 }
 462
 463                 process_frame_data_em28xx(dev, usb_data_pkt, usb_data_len);
 464         }
 465         return 1;
 466 }
 467
 468
 469 static int get_ressource(enum v4l2_buf_type f_type)
 470 {
 471         switch (f_type) {
 472         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 473                 return EM28XX_RESOURCE_VIDEO;
 474         case V4L2_BUF_TYPE_VBI_CAPTURE:
 475                 return EM28XX_RESOURCE_VBI;
 476         default:
 477                 BUG();
 478                 return 0;
 479         }
 480 }
 481
 482 /* Usage lock check functions */
 483 static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
 484 {
 485         int res_type = get_ressource(f_type);
 486
 487         /* is it free? */
 488         if (dev->resources & res_type) {
 489                 /* no, someone else uses it */
 490                 return -EBUSY;
 491         }
 492
 493         /* it's free, grab it */
 494         dev->resources |= res_type;
 495         em28xx_videodbg("res: get %d\n", res_type);
 496         return 0;
 497 }
 498
 499 static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
 500 {
 501         int res_type = get_ressource(f_type);
 502
 503         dev->resources &= ~res_type;
 504         em28xx_videodbg("res: put %d\n", res_type);
 505 }
 506
 507 /* ------------------------------------------------------------------
 508         Videobuf2 operations
 509    ------------------------------------------------------------------*/
 510
 511 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 512                        unsigned int *nbuffers, unsigned int *nplanes,
 513                        unsigned int sizes[], void *alloc_ctxs[])
 514 {
 515         struct em28xx *dev = vb2_get_drv_priv(vq);
 516         unsigned long size;
 517
 518         if (fmt)
 519                 size = fmt->fmt.pix.sizeimage;
 520         else
 521                 size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 522
 523         if (size == 0)
 524                 return -EINVAL;
 525
 526         if (0 == *nbuffers)
 527                 *nbuffers = 32;
 528
 529         *nplanes = 1;
 530         sizes[0] = size;
 531
 532         return 0;
 533 }
 534
 535 static int
 536 buffer_prepare(struct vb2_buffer *vb)
 537 {
 538         struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
 539         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
 540         unsigned long size;
 541
 542         em28xx_videodbg("%s, field=%d\n", __func__, vb->v4l2_buf.field);
 543
 544         size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 545
 546         if (vb2_plane_size(vb, 0) < size) {
 547                 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
 548                                 __func__, vb2_plane_size(vb, 0), size);
 549                 return -EINVAL;
 550         }
 551         vb2_set_plane_payload(&buf->vb, 0, size);
 552
 553         return 0;
 554 }
 555
 556 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
 557 {
 558         struct em28xx *dev = vb2_get_drv_priv(vq);
 559         struct v4l2_frequency f;
 560         int rc = 0;
 561
 562         em28xx_videodbg("%s\n", __func__);
 563
 564         /* Make sure streaming is not already in progress for this type
 565            of filehandle (e.g. video, vbi) */
 566         rc = res_get(dev, vq->type);
 567         if (rc)
 568                 return rc;
 569
 570         if (dev->streaming_users++ == 0) {
 571                 /* First active streaming user, so allocate all the URBs */
 572
 573                 /* Allocate the USB bandwidth */
 574                 em28xx_set_alternate(dev);
 575
 576                 /* Needed, since GPIO might have disabled power of
 577                    some i2c device
 578                 */
 579                 em28xx_wake_i2c(dev);
 580
 581                 dev->capture_type = -1;
 582                 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
 583                                           dev->analog_xfer_bulk,
 584                                           EM28XX_NUM_BUFS,
 585                                           dev->max_pkt_size,
 586                                           dev->packet_multiplier,
 587                                           em28xx_urb_data_copy);
 588                 if (rc < 0)
 589                         goto fail;
 590
 591                 /*
 592                  * djh: it's not clear whether this code is still needed.  I'm
 593                  * leaving it in here for now entirely out of concern for
 594                  * backward compatibility (the old code did it)
 595                  */
 596
 597                 /* Ask tuner to go to analog or radio mode */
 598                 memset(&f, 0, sizeof(f));
 599                 f.frequency = dev->ctl_freq;
 600                 if (vq->owner && vq->owner->vdev->vfl_type == VFL_TYPE_RADIO)
 601                         f.type = V4L2_TUNER_RADIO;
 602                 else
 603                         f.type = V4L2_TUNER_ANALOG_TV;
 604                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
 605         }
 606
 607 fail:
 608         return rc;
 609 }
 610
 611 static int em28xx_stop_streaming(struct vb2_queue *vq)
 612 {
 613         struct em28xx *dev = vb2_get_drv_priv(vq);
 614         struct em28xx_dmaqueue *vidq = &dev->vidq;
 615         unsigned long flags = 0;
 616
 617         em28xx_videodbg("%s\n", __func__);
 618
 619         res_free(dev, vq->type);
 620
 621         if (dev->streaming_users-- == 1) {
 622                 /* Last active user, so shutdown all the URBS */
 623                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
 624         }
 625
 626         spin_lock_irqsave(&dev->slock, flags);
 627         while (!list_empty(&vidq->active)) {
 628                 struct em28xx_buffer *buf;
 629                 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
 630                 list_del(&buf->list);
 631                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 632         }
 633         dev->usb_ctl.vid_buf = NULL;
 634         spin_unlock_irqrestore(&dev->slock, flags);
 635
 636         return 0;
 637 }
 638
 639 int em28xx_stop_vbi_streaming(struct vb2_queue *vq)
 640 {
 641         struct em28xx *dev = vb2_get_drv_priv(vq);
 642         struct em28xx_dmaqueue *vbiq = &dev->vbiq;
 643         unsigned long flags = 0;
 644
 645         em28xx_videodbg("%s\n", __func__);
 646
 647         res_free(dev, vq->type);
 648
 649         if (dev->streaming_users-- == 1) {
 650                 /* Last active user, so shutdown all the URBS */
 651                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
 652         }
 653
 654         spin_lock_irqsave(&dev->slock, flags);
 655         while (!list_empty(&vbiq->active)) {
 656                 struct em28xx_buffer *buf;
 657                 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
 658                 list_del(&buf->list);
 659                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 660         }
 661         dev->usb_ctl.vbi_buf = NULL;
 662         spin_unlock_irqrestore(&dev->slock, flags);
 663
 664         return 0;
 665 }
 666
 667 static void
 668 buffer_queue(struct vb2_buffer *vb)
 669 {
 670         struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
 671         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
 672         struct em28xx_dmaqueue *vidq = &dev->vidq;
 673         unsigned long flags = 0;
 674
 675         em28xx_videodbg("%s\n", __func__);
 676         buf->mem = vb2_plane_vaddr(vb, 0);
 677         buf->length = vb2_plane_size(vb, 0);
 678
 679         spin_lock_irqsave(&dev->slock, flags);
 680         list_add_tail(&buf->list, &vidq->active);
 681         spin_unlock_irqrestore(&dev->slock, flags);
 682 }
 683
 684 static struct vb2_ops em28xx_video_qops = {
 685         .queue_setup    = queue_setup,
 686         .buf_prepare    = buffer_prepare,
 687         .buf_queue      = buffer_queue,
 688         .start_streaming = em28xx_start_analog_streaming,
 689         .stop_streaming = em28xx_stop_streaming,
 690         .wait_prepare   = vb2_ops_wait_prepare,
 691         .wait_finish    = vb2_ops_wait_finish,
 692 };
 693
 694 int em28xx_vb2_setup(struct em28xx *dev)
 695 {
 696         int rc;
 697         struct vb2_queue *q;
 698
 699         /* Setup Videobuf2 for Video capture */
 700         q = &dev->vb_vidq;
 701         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 702         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
 703         q->drv_priv = dev;
 704         q->buf_struct_size = sizeof(struct em28xx_buffer);
 705         q->ops = &em28xx_video_qops;
 706         q->mem_ops = &vb2_vmalloc_memops;
 707
 708         rc = vb2_queue_init(q);
 709         if (rc < 0)
 710                 return rc;
 711
 712         /* Setup Videobuf2 for VBI capture */
 713         q = &dev->vb_vbiq;
 714         q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
 715         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
 716         q->drv_priv = dev;
 717         q->buf_struct_size = sizeof(struct em28xx_buffer);
 718         q->ops = &em28xx_vbi_qops;
 719         q->mem_ops = &vb2_vmalloc_memops;
 720
 721         rc = vb2_queue_init(q);
 722         if (rc < 0)
 723                 return rc;
 724
 725         return 0;
 726 }
 727
 728 /*********************  v4l2 interface  **************************************/
 729
 730 static void video_mux(struct em28xx *dev, int index)
 731 {
 732         dev->ctl_input = index;
 733         dev->ctl_ainput = INPUT(index)->amux;
 734         dev->ctl_aoutput = INPUT(index)->aout;
 735
 736         if (!dev->ctl_aoutput)
 737                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
 738
 739         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
 740                         INPUT(index)->vmux, 0, 0);
 741
 742         if (dev->board.has_msp34xx) {
 743                 if (dev->i2s_speed) {
 744                         v4l2_device_call_all(&dev->v4l2_dev, 0, audio,
 745                                 s_i2s_clock_freq, dev->i2s_speed);
 746                 }
 747                 /* Note: this is msp3400 specific */
 748                 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
 749                          dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
 750         }
 751
 752         if (dev->board.adecoder != EM28XX_NOADECODER) {
 753                 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
 754                         dev->ctl_ainput, dev->ctl_aoutput, 0);
 755         }
 756
 757         em28xx_audio_analog_set(dev);
 758 }
 759
 760 void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
 761 {
 762         struct em28xx *dev = priv;
 763
 764         /*
 765          * In the case of non-AC97 volume controls, we still need
 766          * to do some setups at em28xx, in order to mute/unmute
 767          * and to adjust audio volume. However, the value ranges
 768          * should be checked by the corresponding V4L subdriver.
 769          */
 770         switch (ctrl->id) {
 771         case V4L2_CID_AUDIO_MUTE:
 772                 dev->mute = ctrl->val;
 773                 em28xx_audio_analog_set(dev);
 774                 break;
 775         case V4L2_CID_AUDIO_VOLUME:
 776                 dev->volume = ctrl->val;
 777                 em28xx_audio_analog_set(dev);
 778                 break;
 779         }
 780 }
 781
 782 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
 783 {
 784         struct em28xx *dev = container_of(ctrl->handler, struct em28xx, ctrl_handler);
 785
 786         switch (ctrl->id) {
 787         case V4L2_CID_AUDIO_MUTE:
 788                 dev->mute = ctrl->val;
 789                 break;
 790         case V4L2_CID_AUDIO_VOLUME:
 791                 dev->volume = ctrl->val;
 792                 break;
 793         }
 794
 795         return em28xx_audio_analog_set(dev);
 796 }
 797
 798 const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
 799         .s_ctrl = em28xx_s_ctrl,
 800 };
 801
 802 static int check_dev(struct em28xx *dev)
 803 {
 804         if (dev->disconnected) {
 805                 em28xx_errdev("v4l2 ioctl: device not present\n");
 806                 return -ENODEV;
 807         }
 808         return 0;
 809 }
 810
 811 static void get_scale(struct em28xx *dev,
 812                         unsigned int width, unsigned int height,
 813                         unsigned int *hscale, unsigned int *vscale)
 814 {
 815         unsigned int          maxw = norm_maxw(dev);
 816         unsigned int          maxh = norm_maxh(dev);
 817
 818         *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
 819         if (*hscale >= 0x4000)
 820                 *hscale = 0x3fff;
 821
 822         *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
 823         if (*vscale >= 0x4000)
 824                 *vscale = 0x3fff;
 825 }
 826
 827 /* ------------------------------------------------------------------
 828         IOCTL vidioc handling
 829    ------------------------------------------------------------------*/
 830
 831 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 832                                         struct v4l2_format *f)
 833 {
 834         struct em28xx_fh      *fh  = priv;
 835         struct em28xx         *dev = fh->dev;
 836
 837         f->fmt.pix.width = dev->width;
 838         f->fmt.pix.height = dev->height;
 839         f->fmt.pix.pixelformat = dev->format->fourcc;
 840         f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
 841         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline  * dev->height;
 842         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 843
 844         /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
 845         if (dev->progressive)
 846                 f->fmt.pix.field = V4L2_FIELD_NONE;
 847         else
 848                 f->fmt.pix.field = dev->interlaced ?
 849                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
 850         return 0;
 851 }
 852
 853 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
 854 {
 855         unsigned int i;
 856
 857         for (i = 0; i < ARRAY_SIZE(format); i++)
 858                 if (format[i].fourcc == fourcc)
 859                         return &format[i];
 860
 861         return NULL;
 862 }
 863
 864 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 865                         struct v4l2_format *f)
 866 {
 867         struct em28xx_fh      *fh    = priv;
 868         struct em28xx         *dev   = fh->dev;
 869         unsigned int          width  = f->fmt.pix.width;
 870         unsigned int          height = f->fmt.pix.height;
 871         unsigned int          maxw   = norm_maxw(dev);
 872         unsigned int          maxh   = norm_maxh(dev);
 873         unsigned int          hscale, vscale;
 874         struct em28xx_fmt     *fmt;
 875
 876         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 877         if (!fmt) {
 878                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
 879                                 f->fmt.pix.pixelformat);
 880                 return -EINVAL;
 881         }
 882
 883         if (dev->board.is_em2800) {
 884                 /* the em2800 can only scale down to 50% */
 885                 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
 886                 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
 887                 /*
 888                  * MaxPacketSize for em2800 is too small to capture at full
 889                  * resolution use half of maxw as the scaler can only scale
 890                  * to 50%
 891                  */
 892                 if (width == maxw && height == maxh)
 893                         width /= 2;
 894         } else {
 895                 /* width must even because of the YUYV format
 896                    height must be even because of interlacing */
 897                 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
 898                                       1, 0);
 899         }
 900
 901         get_scale(dev, width, height, &hscale, &vscale);
 902
 903         width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
 904         height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
 905
 906         f->fmt.pix.width = width;
 907         f->fmt.pix.height = height;
 908         f->fmt.pix.pixelformat = fmt->fourcc;
 909         f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
 910         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
 911         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 912         if (dev->progressive)
 913                 f->fmt.pix.field = V4L2_FIELD_NONE;
 914         else
 915                 f->fmt.pix.field = dev->interlaced ?
 916                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
 917
 918         return 0;
 919 }
 920
 921 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
 922                                    unsigned width, unsigned height)
 923 {
 924         struct em28xx_fmt     *fmt;
 925
 926         fmt = format_by_fourcc(fourcc);
 927         if (!fmt)
 928                 return -EINVAL;
 929
 930         dev->format = fmt;
 931         dev->width  = width;
 932         dev->height = height;
 933
 934         /* set new image size */
 935         get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
 936
 937         em28xx_resolution_set(dev);
 938
 939         return 0;
 940 }
 941
 942 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 943                         struct v4l2_format *f)
 944 {
 945         struct em28xx *dev = video_drvdata(file);
 946
 947         if (dev->streaming_users > 0)
 948                 return -EBUSY;
 949
 950         vidioc_try_fmt_vid_cap(file, priv, f);
 951
 952         return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
 953                                 f->fmt.pix.width, f->fmt.pix.height);
 954 }
 955
 956 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 957 {
 958         struct em28xx_fh   *fh  = priv;
 959         struct em28xx      *dev = fh->dev;
 960         int                rc;
 961
 962         if (dev->board.is_webcam)
 963                 return -ENOTTY;
 964         rc = check_dev(dev);
 965         if (rc < 0)
 966                 return rc;
 967
 968         *norm = dev->norm;
 969
 970         return 0;
 971 }
 972
 973 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
 974 {
 975         struct em28xx_fh   *fh  = priv;
 976         struct em28xx      *dev = fh->dev;
 977         int                rc;
 978
 979         if (dev->board.is_webcam)
 980                 return -ENOTTY;
 981         rc = check_dev(dev);
 982         if (rc < 0)
 983                 return rc;
 984
 985         v4l2_device_call_all(&dev->v4l2_dev, 0, video, querystd, norm);
 986
 987         return 0;
 988 }
 989
 990 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
 991 {
 992         struct em28xx_fh   *fh  = priv;
 993         struct em28xx      *dev = fh->dev;
 994         struct v4l2_format f;
 995         int                rc;
 996
 997         if (dev->board.is_webcam)
 998                 return -ENOTTY;
 999         if (*norm == dev->norm)
1000                 return 0;
1001         rc = check_dev(dev);
1002         if (rc < 0)
1003                 return rc;
1004
1005         if (dev->streaming_users > 0)
1006                 return -EBUSY;
1007
1008         dev->norm = *norm;
1009
1010         /* Adjusts width/height, if needed */
1011         f.fmt.pix.width = 720;
1012         f.fmt.pix.height = (*norm & V4L2_STD_525_60) ? 480 : 576;
1013         vidioc_try_fmt_vid_cap(file, priv, &f);
1014
1015         /* set new image size */
1016         dev->width = f.fmt.pix.width;
1017         dev->height = f.fmt.pix.height;
1018         get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
1019
1020         em28xx_resolution_set(dev);
1021         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
1022
1023         return 0;
1024 }
1025
1026 static int vidioc_g_parm(struct file *file, void *priv,
1027                          struct v4l2_streamparm *p)
1028 {
1029         struct em28xx_fh   *fh  = priv;
1030         struct em28xx      *dev = fh->dev;
1031         int rc = 0;
1032
1033         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1034                 return -EINVAL;
1035
1036         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1037         if (dev->board.is_webcam)
1038                 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0,
1039                                                 video, g_parm, p);
1040         else
1041                 v4l2_video_std_frame_period(dev->norm,
1042                                                  &p->parm.capture.timeperframe);
1043
1044         return rc;
1045 }
1046
1047 static int vidioc_s_parm(struct file *file, void *priv,
1048                          struct v4l2_streamparm *p)
1049 {
1050         struct em28xx_fh   *fh  = priv;
1051         struct em28xx      *dev = fh->dev;
1052
1053         if (!dev->board.is_webcam)
1054                 return -ENOTTY;
1055
1056         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1057                 return -EINVAL;
1058
1059         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1060         return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p);
1061 }
1062
1063 static const char *iname[] = {
1064         [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1065         [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1066         [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1067         [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1068         [EM28XX_VMUX_SVIDEO]     = "S-Video",
1069         [EM28XX_VMUX_TELEVISION] = "Television",
1070         [EM28XX_VMUX_CABLE]      = "Cable TV",
1071         [EM28XX_VMUX_DVB]        = "DVB",
1072         [EM28XX_VMUX_DEBUG]      = "for debug only",
1073 };
1074
1075 static int vidioc_enum_input(struct file *file, void *priv,
1076                                 struct v4l2_input *i)
1077 {
1078         struct em28xx_fh   *fh  = priv;
1079         struct em28xx      *dev = fh->dev;
1080         unsigned int       n;
1081
1082         n = i->index;
1083         if (n >= MAX_EM28XX_INPUT)
1084                 return -EINVAL;
1085         if (0 == INPUT(n)->type)
1086                 return -EINVAL;
1087
1088         i->index = n;
1089         i->type = V4L2_INPUT_TYPE_CAMERA;
1090
1091         strcpy(i->name, iname[INPUT(n)->type]);
1092
1093         if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1094                 (EM28XX_VMUX_CABLE == INPUT(n)->type))
1095                 i->type = V4L2_INPUT_TYPE_TUNER;
1096
1097         i->std = dev->vdev->tvnorms;
1098         /* webcams do not have the STD API */
1099         if (dev->board.is_webcam)
1100                 i->capabilities = 0;
1101
1102         return 0;
1103 }
1104
1105 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1106 {
1107         struct em28xx_fh   *fh  = priv;
1108         struct em28xx      *dev = fh->dev;
1109
1110         *i = dev->ctl_input;
1111
1112         return 0;
1113 }
1114
1115 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1116 {
1117         struct em28xx_fh   *fh  = priv;
1118         struct em28xx      *dev = fh->dev;
1119         int                rc;
1120
1121         rc = check_dev(dev);
1122         if (rc < 0)
1123                 return rc;
1124
1125         if (i >= MAX_EM28XX_INPUT)
1126                 return -EINVAL;
1127         if (0 == INPUT(i)->type)
1128                 return -EINVAL;
1129
1130         video_mux(dev, i);
1131         return 0;
1132 }
1133
1134 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1135 {
1136         struct em28xx_fh   *fh    = priv;
1137         struct em28xx      *dev   = fh->dev;
1138
1139         if (!dev->audio_mode.has_audio)
1140                 return -EINVAL;
1141
1142         switch (a->index) {
1143         case EM28XX_AMUX_VIDEO:
1144                 strcpy(a->name, "Television");
1145                 break;
1146         case EM28XX_AMUX_LINE_IN:
1147                 strcpy(a->name, "Line In");
1148                 break;
1149         case EM28XX_AMUX_VIDEO2:
1150                 strcpy(a->name, "Television alt");
1151                 break;
1152         case EM28XX_AMUX_PHONE:
1153                 strcpy(a->name, "Phone");
1154                 break;
1155         case EM28XX_AMUX_MIC:
1156                 strcpy(a->name, "Mic");
1157                 break;
1158         case EM28XX_AMUX_CD:
1159                 strcpy(a->name, "CD");
1160                 break;
1161         case EM28XX_AMUX_AUX:
1162                 strcpy(a->name, "Aux");
1163                 break;
1164         case EM28XX_AMUX_PCM_OUT:
1165                 strcpy(a->name, "PCM");
1166                 break;
1167         default:
1168                 return -EINVAL;
1169         }
1170
1171         a->index = dev->ctl_ainput;
1172         a->capability = V4L2_AUDCAP_STEREO;
1173
1174         return 0;
1175 }
1176
1177 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1178 {
1179         struct em28xx_fh   *fh  = priv;
1180         struct em28xx      *dev = fh->dev;
1181
1182
1183         if (!dev->audio_mode.has_audio)
1184                 return -EINVAL;
1185
1186         if (a->index >= MAX_EM28XX_INPUT)
1187                 return -EINVAL;
1188         if (0 == INPUT(a->index)->type)
1189                 return -EINVAL;
1190
1191         dev->ctl_ainput = INPUT(a->index)->amux;
1192         dev->ctl_aoutput = INPUT(a->index)->aout;
1193
1194         if (!dev->ctl_aoutput)
1195                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1196
1197         return 0;
1198 }
1199
1200 static int vidioc_g_tuner(struct file *file, void *priv,
1201                                 struct v4l2_tuner *t)
1202 {
1203         struct em28xx_fh      *fh  = priv;
1204         struct em28xx         *dev = fh->dev;
1205         int                   rc;
1206
1207         rc = check_dev(dev);
1208         if (rc < 0)
1209                 return rc;
1210
1211         if (0 != t->index)
1212                 return -EINVAL;
1213
1214         strcpy(t->name, "Tuner");
1215
1216         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1217         return 0;
1218 }
1219
1220 static int vidioc_s_tuner(struct file *file, void *priv,
1221                                 struct v4l2_tuner *t)
1222 {
1223         struct em28xx_fh      *fh  = priv;
1224         struct em28xx         *dev = fh->dev;
1225         int                   rc;
1226
1227         rc = check_dev(dev);
1228         if (rc < 0)
1229                 return rc;
1230
1231         if (0 != t->index)
1232                 return -EINVAL;
1233
1234         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1235         return 0;
1236 }
1237
1238 static int vidioc_g_frequency(struct file *file, void *priv,
1239                                 struct v4l2_frequency *f)
1240 {
1241         struct em28xx_fh      *fh  = priv;
1242         struct em28xx         *dev = fh->dev;
1243
1244         if (0 != f->tuner)
1245                 return -EINVAL;
1246
1247         f->frequency = dev->ctl_freq;
1248         return 0;
1249 }
1250
1251 static int vidioc_s_frequency(struct file *file, void *priv,
1252                                 struct v4l2_frequency *f)
1253 {
1254         struct em28xx_fh      *fh  = priv;
1255         struct em28xx         *dev = fh->dev;
1256         int                   rc;
1257
1258         rc = check_dev(dev);
1259         if (rc < 0)
1260                 return rc;
1261
1262         if (0 != f->tuner)
1263                 return -EINVAL;
1264
1265         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
1266         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, f);
1267         dev->ctl_freq = f->frequency;
1268
1269         return 0;
1270 }
1271
1272 #ifdef CONFIG_VIDEO_ADV_DEBUG
1273 static int em28xx_reg_len(int reg)
1274 {
1275         switch (reg) {
1276         case EM28XX_R40_AC97LSB:
1277         case EM28XX_R30_HSCALELOW:
1278         case EM28XX_R32_VSCALELOW:
1279                 return 2;
1280         default:
1281                 return 1;
1282         }
1283 }
1284
1285 static int vidioc_g_chip_ident(struct file *file, void *priv,
1286                struct v4l2_dbg_chip_ident *chip)
1287 {
1288         struct em28xx_fh      *fh  = priv;
1289         struct em28xx         *dev = fh->dev;
1290
1291         chip->ident = V4L2_IDENT_NONE;
1292         chip->revision = 0;
1293         if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
1294                 if (v4l2_chip_match_host(&chip->match))
1295                         chip->ident = V4L2_IDENT_NONE;
1296                 return 0;
1297         }
1298         if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
1299             chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
1300                 return -EINVAL;
1301
1302         v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
1303
1304         return 0;
1305 }
1306
1307
1308 static int vidioc_g_register(struct file *file, void *priv,
1309                              struct v4l2_dbg_register *reg)
1310 {
1311         struct em28xx_fh      *fh  = priv;
1312         struct em28xx         *dev = fh->dev;
1313         int ret;
1314
1315         switch (reg->match.type) {
1316         case V4L2_CHIP_MATCH_AC97:
1317                 ret = em28xx_read_ac97(dev, reg->reg);
1318                 if (ret < 0)
1319                         return ret;
1320
1321                 reg->val = ret;
1322                 reg->size = 1;
1323                 return 0;
1324         case V4L2_CHIP_MATCH_I2C_DRIVER:
1325                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1326                 return 0;
1327         case V4L2_CHIP_MATCH_I2C_ADDR:
1328                 /* TODO: is this correct? */
1329                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1330                 return 0;
1331         default:
1332                 if (!v4l2_chip_match_host(&reg->match))
1333                         return -EINVAL;
1334         }
1335
1336         /* Match host */
1337         reg->size = em28xx_reg_len(reg->reg);
1338         if (reg->size == 1) {
1339                 ret = em28xx_read_reg(dev, reg->reg);
1340
1341                 if (ret < 0)
1342                         return ret;
1343
1344                 reg->val = ret;
1345         } else {
1346                 __le16 val = 0;
1347                 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1348                                                    reg->reg, (char *)&val, 2);
1349                 if (ret < 0)
1350                         return ret;
1351
1352                 reg->val = le16_to_cpu(val);
1353         }
1354
1355         return 0;
1356 }
1357
1358 static int vidioc_s_register(struct file *file, void *priv,
1359                              struct v4l2_dbg_register *reg)
1360 {
1361         struct em28xx_fh      *fh  = priv;
1362         struct em28xx         *dev = fh->dev;
1363         __le16 buf;
1364
1365         switch (reg->match.type) {
1366         case V4L2_CHIP_MATCH_AC97:
1367                 return em28xx_write_ac97(dev, reg->reg, reg->val);
1368         case V4L2_CHIP_MATCH_I2C_DRIVER:
1369                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1370                 return 0;
1371         case V4L2_CHIP_MATCH_I2C_ADDR:
1372                 /* TODO: is this correct? */
1373                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1374                 return 0;
1375         default:
1376                 if (!v4l2_chip_match_host(&reg->match))
1377                         return -EINVAL;
1378         }
1379
1380         /* Match host */
1381         buf = cpu_to_le16(reg->val);
1382
1383         return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1384                                em28xx_reg_len(reg->reg));
1385 }
1386 #endif
1387
1388
1389 static int vidioc_cropcap(struct file *file, void *priv,
1390                                         struct v4l2_cropcap *cc)
1391 {
1392         struct em28xx_fh      *fh  = priv;
1393         struct em28xx         *dev = fh->dev;
1394
1395         if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1396                 return -EINVAL;
1397
1398         cc->bounds.left = 0;
1399         cc->bounds.top = 0;
1400         cc->bounds.width = dev->width;
1401         cc->bounds.height = dev->height;
1402         cc->defrect = cc->bounds;
1403         cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */
1404         cc->pixelaspect.denominator = 59;
1405
1406         return 0;
1407 }
1408
1409 static int vidioc_querycap(struct file *file, void  *priv,
1410                                         struct v4l2_capability *cap)
1411 {
1412         struct video_device *vdev = video_devdata(file);
1413         struct em28xx_fh      *fh  = priv;
1414         struct em28xx         *dev = fh->dev;
1415
1416         strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1417         strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1418         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1419
1420         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1421                 cap->device_caps = V4L2_CAP_READWRITE |
1422                         V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1423         else if (vdev->vfl_type == VFL_TYPE_RADIO)
1424                 cap->device_caps = V4L2_CAP_RADIO;
1425         else
1426                 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1427
1428         if (dev->audio_mode.has_audio)
1429                 cap->device_caps |= V4L2_CAP_AUDIO;
1430
1431         if (dev->tuner_type != TUNER_ABSENT)
1432                 cap->device_caps |= V4L2_CAP_TUNER;
1433
1434         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1435                 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1436         if (dev->vbi_dev)
1437                 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1438         if (dev->radio_dev)
1439                 cap->capabilities |= V4L2_CAP_RADIO;
1440         return 0;
1441 }
1442
1443 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1444                                         struct v4l2_fmtdesc *f)
1445 {
1446         if (unlikely(f->index >= ARRAY_SIZE(format)))
1447                 return -EINVAL;
1448
1449         strlcpy(f->description, format[f->index].name, sizeof(f->description));
1450         f->pixelformat = format[f->index].fourcc;
1451
1452         return 0;
1453 }
1454
1455 static int vidioc_enum_framesizes(struct file *file, void *priv,
1456                                   struct v4l2_frmsizeenum *fsize)
1457 {
1458         struct em28xx_fh      *fh  = priv;
1459         struct em28xx         *dev = fh->dev;
1460         struct em28xx_fmt     *fmt;
1461         unsigned int          maxw = norm_maxw(dev);
1462         unsigned int          maxh = norm_maxh(dev);
1463
1464         fmt = format_by_fourcc(fsize->pixel_format);
1465         if (!fmt) {
1466                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1467                                 fsize->pixel_format);
1468                 return -EINVAL;
1469         }
1470
1471         if (dev->board.is_em2800) {
1472                 if (fsize->index > 1)
1473                         return -EINVAL;
1474                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1475                 fsize->discrete.width = maxw / (1 + fsize->index);
1476                 fsize->discrete.height = maxh / (1 + fsize->index);
1477                 return 0;
1478         }
1479
1480         if (fsize->index != 0)
1481                 return -EINVAL;
1482
1483         /* Report a continuous range */
1484         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1485         fsize->stepwise.min_width = 48;
1486         fsize->stepwise.min_height = 32;
1487         fsize->stepwise.max_width = maxw;
1488         fsize->stepwise.max_height = maxh;
1489         fsize->stepwise.step_width = 1;
1490         fsize->stepwise.step_height = 1;
1491         return 0;
1492 }
1493
1494 /* RAW VBI ioctls */
1495
1496 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1497                                 struct v4l2_format *format)
1498 {
1499         struct em28xx_fh      *fh  = priv;
1500         struct em28xx         *dev = fh->dev;
1501
1502         format->fmt.vbi.samples_per_line = dev->vbi_width;
1503         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1504         format->fmt.vbi.offset = 0;
1505         format->fmt.vbi.flags = 0;
1506         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1507         format->fmt.vbi.count[0] = dev->vbi_height;
1508         format->fmt.vbi.count[1] = dev->vbi_height;
1509         memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1510
1511         /* Varies by video standard (NTSC, PAL, etc.) */
1512         if (dev->norm & V4L2_STD_525_60) {
1513                 /* NTSC */
1514                 format->fmt.vbi.start[0] = 10;
1515                 format->fmt.vbi.start[1] = 273;
1516         } else if (dev->norm & V4L2_STD_625_50) {
1517                 /* PAL */
1518                 format->fmt.vbi.start[0] = 6;
1519                 format->fmt.vbi.start[1] = 318;
1520         }
1521
1522         return 0;
1523 }
1524
1525 static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
1526                                 struct v4l2_format *format)
1527 {
1528         struct em28xx_fh      *fh  = priv;
1529         struct em28xx         *dev = fh->dev;
1530
1531         format->fmt.vbi.samples_per_line = dev->vbi_width;
1532         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1533         format->fmt.vbi.offset = 0;
1534         format->fmt.vbi.flags = 0;
1535         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1536         format->fmt.vbi.count[0] = dev->vbi_height;
1537         format->fmt.vbi.count[1] = dev->vbi_height;
1538         memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1539
1540         /* Varies by video standard (NTSC, PAL, etc.) */
1541         if (dev->norm & V4L2_STD_525_60) {
1542                 /* NTSC */
1543                 format->fmt.vbi.start[0] = 10;
1544                 format->fmt.vbi.start[1] = 273;
1545         } else if (dev->norm & V4L2_STD_625_50) {
1546                 /* PAL */
1547                 format->fmt.vbi.start[0] = 6;
1548                 format->fmt.vbi.start[1] = 318;
1549         }
1550
1551         return 0;
1552 }
1553
1554 /* ----------------------------------------------------------- */
1555 /* RADIO ESPECIFIC IOCTLS                                      */
1556 /* ----------------------------------------------------------- */
1557
1558 static int radio_g_tuner(struct file *file, void *priv,
1559                          struct v4l2_tuner *t)
1560 {
1561         struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1562
1563         if (unlikely(t->index > 0))
1564                 return -EINVAL;
1565
1566         strcpy(t->name, "Radio");
1567         t->type = V4L2_TUNER_RADIO;
1568
1569         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1570
1571         return 0;
1572 }
1573
1574 static int radio_s_tuner(struct file *file, void *priv,
1575                          struct v4l2_tuner *t)
1576 {
1577         struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1578
1579         if (0 != t->index)
1580                 return -EINVAL;
1581
1582         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1583
1584         return 0;
1585 }
1586
1587 /*
1588  * em28xx_v4l2_open()
1589  * inits the device and starts isoc transfer
1590  */
1591 static int em28xx_v4l2_open(struct file *filp)
1592 {
1593         struct video_device *vdev = video_devdata(filp);
1594         struct em28xx *dev = video_drvdata(filp);
1595         enum v4l2_buf_type fh_type = 0;
1596         struct em28xx_fh *fh;
1597
1598         switch (vdev->vfl_type) {
1599         case VFL_TYPE_GRABBER:
1600                 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1601                 break;
1602         case VFL_TYPE_VBI:
1603                 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1604                 break;
1605         }
1606
1607         em28xx_videodbg("open dev=%s type=%s users=%d\n",
1608                         video_device_node_name(vdev), v4l2_type_names[fh_type],
1609                         dev->users);
1610
1611
1612         if (mutex_lock_interruptible(&dev->lock))
1613                 return -ERESTARTSYS;
1614         fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
1615         if (!fh) {
1616                 em28xx_errdev("em28xx-video.c: Out of memory?!\n");
1617                 mutex_unlock(&dev->lock);
1618                 return -ENOMEM;
1619         }
1620         v4l2_fh_init(&fh->fh, vdev);
1621         fh->dev = dev;
1622         fh->type = fh_type;
1623         filp->private_data = fh;
1624
1625         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
1626                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
1627                 em28xx_resolution_set(dev);
1628
1629                 /* Needed, since GPIO might have disabled power of
1630                    some i2c device
1631                  */
1632                 em28xx_wake_i2c(dev);
1633
1634         }
1635
1636         if (vdev->vfl_type == VFL_TYPE_RADIO) {
1637                 em28xx_videodbg("video_open: setting radio device\n");
1638                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
1639         }
1640
1641         dev->users++;
1642
1643         mutex_unlock(&dev->lock);
1644         v4l2_fh_add(&fh->fh);
1645
1646         return 0;
1647 }
1648
1649 /*
1650  * em28xx_realease_resources()
1651  * unregisters the v4l2,i2c and usb devices
1652  * called when the device gets disconected or at module unload
1653 */
1654 void em28xx_release_analog_resources(struct em28xx *dev)
1655 {
1656
1657         /*FIXME: I2C IR should be disconnected */
1658
1659         if (dev->radio_dev) {
1660                 if (video_is_registered(dev->radio_dev))
1661                         video_unregister_device(dev->radio_dev);
1662                 else
1663                         video_device_release(dev->radio_dev);
1664                 dev->radio_dev = NULL;
1665         }
1666         if (dev->vbi_dev) {
1667                 em28xx_info("V4L2 device %s deregistered\n",
1668                             video_device_node_name(dev->vbi_dev));
1669                 if (video_is_registered(dev->vbi_dev))
1670                         video_unregister_device(dev->vbi_dev);
1671                 else
1672                         video_device_release(dev->vbi_dev);
1673                 dev->vbi_dev = NULL;
1674         }
1675         if (dev->vdev) {
1676                 em28xx_info("V4L2 device %s deregistered\n",
1677                             video_device_node_name(dev->vdev));
1678                 if (video_is_registered(dev->vdev))
1679                         video_unregister_device(dev->vdev);
1680                 else
1681                         video_device_release(dev->vdev);
1682                 dev->vdev = NULL;
1683         }
1684 }
1685
1686 /*
1687  * em28xx_v4l2_close()
1688  * stops streaming and deallocates all resources allocated by the v4l2
1689  * calls and ioctls
1690  */
1691 static int em28xx_v4l2_close(struct file *filp)
1692 {
1693         struct em28xx_fh *fh  = filp->private_data;
1694         struct em28xx    *dev = fh->dev;
1695         int              errCode;
1696
1697         em28xx_videodbg("users=%d\n", dev->users);
1698
1699         mutex_lock(&dev->lock);
1700         vb2_fop_release(filp);
1701
1702         if (dev->users == 1) {
1703                 /* the device is already disconnect,
1704                    free the remaining resources */
1705                 if (dev->disconnected) {
1706                         em28xx_release_resources(dev);
1707                         kfree(dev->alt_max_pkt_size_isoc);
1708                         mutex_unlock(&dev->lock);
1709                         kfree(dev);
1710                         return 0;
1711                 }
1712
1713                 /* Save some power by putting tuner to sleep */
1714                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1715
1716                 /* do this before setting alternate! */
1717                 em28xx_set_mode(dev, EM28XX_SUSPEND);
1718
1719                 /* set alternate 0 */
1720                 dev->alt = 0;
1721                 em28xx_videodbg("setting alternate 0\n");
1722                 errCode = usb_set_interface(dev->udev, 0, 0);
1723                 if (errCode < 0) {
1724                         em28xx_errdev("cannot change alternate number to "
1725                                         "0 (error=%i)\n", errCode);
1726                 }
1727         }
1728
1729         dev->users--;
1730         mutex_unlock(&dev->lock);
1731         return 0;
1732 }
1733
1734 static const struct v4l2_file_operations em28xx_v4l_fops = {
1735         .owner         = THIS_MODULE,
1736         .open          = em28xx_v4l2_open,
1737         .release       = em28xx_v4l2_close,
1738         .read          = vb2_fop_read,
1739         .poll          = vb2_fop_poll,
1740         .mmap          = vb2_fop_mmap,
1741         .unlocked_ioctl = video_ioctl2,
1742 };
1743
1744 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1745         .vidioc_querycap            = vidioc_querycap,
1746         .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
1747         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
1748         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
1749         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
1750         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
1751         .vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
1752         .vidioc_s_fmt_vbi_cap       = vidioc_s_fmt_vbi_cap,
1753         .vidioc_enum_framesizes     = vidioc_enum_framesizes,
1754         .vidioc_g_audio             = vidioc_g_audio,
1755         .vidioc_s_audio             = vidioc_s_audio,
1756         .vidioc_cropcap             = vidioc_cropcap,
1757
1758         .vidioc_reqbufs             = vb2_ioctl_reqbufs,
1759         .vidioc_create_bufs         = vb2_ioctl_create_bufs,
1760         .vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
1761         .vidioc_querybuf            = vb2_ioctl_querybuf,
1762         .vidioc_qbuf                = vb2_ioctl_qbuf,
1763         .vidioc_dqbuf               = vb2_ioctl_dqbuf,
1764
1765         .vidioc_g_std               = vidioc_g_std,
1766         .vidioc_querystd            = vidioc_querystd,
1767         .vidioc_s_std               = vidioc_s_std,
1768         .vidioc_g_parm              = vidioc_g_parm,
1769         .vidioc_s_parm              = vidioc_s_parm,
1770         .vidioc_enum_input          = vidioc_enum_input,
1771         .vidioc_g_input             = vidioc_g_input,
1772         .vidioc_s_input             = vidioc_s_input,
1773         .vidioc_streamon            = vb2_ioctl_streamon,
1774         .vidioc_streamoff           = vb2_ioctl_streamoff,
1775         .vidioc_g_tuner             = vidioc_g_tuner,
1776         .vidioc_s_tuner             = vidioc_s_tuner,
1777         .vidioc_g_frequency         = vidioc_g_frequency,
1778         .vidioc_s_frequency         = vidioc_s_frequency,
1779         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1780         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1781 #ifdef CONFIG_VIDEO_ADV_DEBUG
1782         .vidioc_g_register          = vidioc_g_register,
1783         .vidioc_s_register          = vidioc_s_register,
1784         .vidioc_g_chip_ident        = vidioc_g_chip_ident,
1785 #endif
1786 };
1787
1788 static const struct video_device em28xx_video_template = {
1789         .fops                       = &em28xx_v4l_fops,
1790         .release                    = video_device_release_empty,
1791         .ioctl_ops                  = &video_ioctl_ops,
1792
1793         .tvnorms                    = V4L2_STD_ALL,
1794 };
1795
1796 static const struct v4l2_file_operations radio_fops = {
1797         .owner         = THIS_MODULE,
1798         .open          = em28xx_v4l2_open,
1799         .release       = em28xx_v4l2_close,
1800         .unlocked_ioctl = video_ioctl2,
1801 };
1802
1803 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
1804         .vidioc_querycap      = vidioc_querycap,
1805         .vidioc_g_tuner       = radio_g_tuner,
1806         .vidioc_s_tuner       = radio_s_tuner,
1807         .vidioc_g_frequency   = vidioc_g_frequency,
1808         .vidioc_s_frequency   = vidioc_s_frequency,
1809         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1810         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1811 #ifdef CONFIG_VIDEO_ADV_DEBUG
1812         .vidioc_g_register    = vidioc_g_register,
1813         .vidioc_s_register    = vidioc_s_register,
1814 #endif
1815 };
1816
1817 static struct video_device em28xx_radio_template = {
1818         .name                 = "em28xx-radio",
1819         .fops                 = &radio_fops,
1820         .ioctl_ops            = &radio_ioctl_ops,
1821 };
1822
1823 /******************************** usb interface ******************************/
1824
1825
1826
1827 static struct video_device *em28xx_vdev_init(struct em28xx *dev,
1828                                         const struct video_device *template,
1829                                         const char *type_name)
1830 {
1831         struct video_device *vfd;
1832
1833         vfd = video_device_alloc();
1834         if (NULL == vfd)
1835                 return NULL;
1836
1837         *vfd            = *template;
1838         vfd->v4l2_dev   = &dev->v4l2_dev;
1839         vfd->debug      = video_debug;
1840         vfd->lock       = &dev->lock;
1841         set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
1842         if (dev->board.is_webcam)
1843                 vfd->tvnorms = 0;
1844
1845         snprintf(vfd->name, sizeof(vfd->name), "%s %s",
1846                  dev->name, type_name);
1847
1848         video_set_drvdata(vfd, dev);
1849         return vfd;
1850 }
1851
1852 int em28xx_register_analog_devices(struct em28xx *dev)
1853 {
1854         u8 val;
1855         int ret;
1856         unsigned int maxw;
1857
1858         printk(KERN_INFO "%s: v4l2 driver version %s\n",
1859                 dev->name, EM28XX_VERSION);
1860
1861         /* set default norm */
1862         dev->norm = V4L2_STD_PAL;
1863         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
1864         dev->interlaced = EM28XX_INTERLACED_DEFAULT;
1865
1866         /* Analog specific initialization */
1867         dev->format = &format[0];
1868
1869         maxw = norm_maxw(dev);
1870         /* MaxPacketSize for em2800 is too small to capture at full resolution
1871          * use half of maxw as the scaler can only scale to 50% */
1872         if (dev->board.is_em2800)
1873                 maxw /= 2;
1874
1875         em28xx_set_video_format(dev, format[0].fourcc,
1876                                 maxw, norm_maxh(dev));
1877
1878         video_mux(dev, 0);
1879
1880         /* Audio defaults */
1881         dev->mute = 1;
1882         dev->volume = 0x1f;
1883
1884 /*      em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
1885         val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
1886         em28xx_write_reg(dev, EM28XX_R0F_XCLK,
1887                          (EM28XX_XCLK_AUDIO_UNMUTE | val));
1888
1889         em28xx_set_outfmt(dev);
1890         em28xx_colorlevels_set_default(dev);
1891         em28xx_compression_disable(dev);
1892
1893         /* allocate and fill video video_device struct */
1894         dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
1895         if (!dev->vdev) {
1896                 em28xx_errdev("cannot allocate video_device.\n");
1897                 return -ENODEV;
1898         }
1899         dev->vdev->queue = &dev->vb_vidq;
1900         dev->vdev->queue->lock = &dev->vb_queue_lock;
1901
1902         /* register v4l2 video video_device */
1903         ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
1904                                        video_nr[dev->devno]);
1905         if (ret) {
1906                 em28xx_errdev("unable to register video device (error=%i).\n",
1907                               ret);
1908                 return ret;
1909         }
1910
1911         /* Allocate and fill vbi video_device struct */
1912         if (em28xx_vbi_supported(dev) == 1) {
1913                 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
1914                                                 "vbi");
1915
1916                 dev->vbi_dev->queue = &dev->vb_vbiq;
1917                 dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
1918
1919                 /* register v4l2 vbi video_device */
1920                 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
1921                                             vbi_nr[dev->devno]);
1922                 if (ret < 0) {
1923                         em28xx_errdev("unable to register vbi device\n");
1924                         return ret;
1925                 }
1926         }
1927
1928         if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
1929                 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
1930                                                   "radio");
1931                 if (!dev->radio_dev) {
1932                         em28xx_errdev("cannot allocate video_device.\n");
1933                         return -ENODEV;
1934                 }
1935                 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
1936                                             radio_nr[dev->devno]);
1937                 if (ret < 0) {
1938                         em28xx_errdev("can't register radio device\n");
1939                         return ret;
1940                 }
1941                 em28xx_info("Registered radio device as %s\n",
1942                             video_device_node_name(dev->radio_dev));
1943         }
1944
1945         em28xx_info("V4L2 video device registered as %s\n",
1946                     video_device_node_name(dev->vdev));
1947
1948         if (dev->vbi_dev)
1949                 em28xx_info("V4L2 VBI device registered as %s\n",
1950                             video_device_node_name(dev->vbi_dev));
1951
1952         return 0;
1953 }