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 "em28xx-v4l.h"
  42 #include <media/v4l2-common.h>
  43 #include <media/v4l2-ioctl.h>
  44 #include <media/v4l2-event.h>
  45 #include <media/v4l2-clk.h>
  46 #include <media/msp3400.h>
  47 #include <media/tuner.h>
  48
  49 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
  50                       "Markus Rechberger <mrechberger@gmail.com>, " \
  51                       "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
  52                       "Sascha Sommer <saschasommer@freenet.de>"
  53
  54 static unsigned int isoc_debug;
  55 module_param(isoc_debug, int, 0644);
  56 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
  57
  58 static unsigned int disable_vbi;
  59 module_param(disable_vbi, int, 0644);
  60 MODULE_PARM_DESC(disable_vbi, "disable vbi support");
  61
  62 static int alt;
  63 module_param(alt, int, 0644);
  64 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
  65
  66 #define em28xx_videodbg(fmt, arg...) do {\
  67         if (video_debug) \
  68                 printk(KERN_INFO "%s %s :"fmt, \
  69                          dev->name, __func__ , ##arg); } while (0)
  70
  71 #define em28xx_isocdbg(fmt, arg...) \
  72 do {\
  73         if (isoc_debug) { \
  74                 printk(KERN_INFO "%s %s :"fmt, \
  75                          dev->name, __func__ , ##arg); \
  76         } \
  77   } while (0)
  78
  79 MODULE_AUTHOR(DRIVER_AUTHOR);
  80 MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface");
  81 MODULE_LICENSE("GPL");
  82 MODULE_VERSION(EM28XX_VERSION);
  83
  84
  85 #define EM25XX_FRMDATAHDR_BYTE1                 0x02
  86 #define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE     0x20
  87 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_END       0x02
  88 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID        0x01
  89 #define EM25XX_FRMDATAHDR_BYTE2_MASK    (EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \
  90                                          EM25XX_FRMDATAHDR_BYTE2_FRAME_END |   \
  91                                          EM25XX_FRMDATAHDR_BYTE2_FRAME_ID)
  92
  93
  94 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  95 static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  96 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
  97
  98 module_param_array(video_nr, int, NULL, 0444);
  99 module_param_array(vbi_nr, int, NULL, 0444);
 100 module_param_array(radio_nr, int, NULL, 0444);
 101 MODULE_PARM_DESC(video_nr, "video device numbers");
 102 MODULE_PARM_DESC(vbi_nr,   "vbi device numbers");
 103 MODULE_PARM_DESC(radio_nr, "radio device numbers");
 104
 105 static unsigned int video_debug;
 106 module_param(video_debug, int, 0644);
 107 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
 108
 109 /* supported video standards */
 110 static struct em28xx_fmt format[] = {
 111         {
 112                 .name     = "16 bpp YUY2, 4:2:2, packed",
 113                 .fourcc   = V4L2_PIX_FMT_YUYV,
 114                 .depth    = 16,
 115                 .reg      = EM28XX_OUTFMT_YUV422_Y0UY1V,
 116         }, {
 117                 .name     = "16 bpp RGB 565, LE",
 118                 .fourcc   = V4L2_PIX_FMT_RGB565,
 119                 .depth    = 16,
 120                 .reg      = EM28XX_OUTFMT_RGB_16_656,
 121         }, {
 122                 .name     = "8 bpp Bayer BGBG..GRGR",
 123                 .fourcc   = V4L2_PIX_FMT_SBGGR8,
 124                 .depth    = 8,
 125                 .reg      = EM28XX_OUTFMT_RGB_8_BGBG,
 126         }, {
 127                 .name     = "8 bpp Bayer GRGR..BGBG",
 128                 .fourcc   = V4L2_PIX_FMT_SGRBG8,
 129                 .depth    = 8,
 130                 .reg      = EM28XX_OUTFMT_RGB_8_GRGR,
 131         }, {
 132                 .name     = "8 bpp Bayer GBGB..RGRG",
 133                 .fourcc   = V4L2_PIX_FMT_SGBRG8,
 134                 .depth    = 8,
 135                 .reg      = EM28XX_OUTFMT_RGB_8_GBGB,
 136         }, {
 137                 .name     = "12 bpp YUV411",
 138                 .fourcc   = V4L2_PIX_FMT_YUV411P,
 139                 .depth    = 12,
 140                 .reg      = EM28XX_OUTFMT_YUV411,
 141         },
 142 };
 143
 144 static int em28xx_vbi_supported(struct em28xx *dev)
 145 {
 146         /* Modprobe option to manually disable */
 147         if (disable_vbi == 1)
 148                 return 0;
 149
 150         if (dev->board.is_webcam)
 151                 return 0;
 152
 153         /* FIXME: check subdevices for VBI support */
 154
 155         if (dev->chip_id == CHIP_ID_EM2860 ||
 156             dev->chip_id == CHIP_ID_EM2883)
 157                 return 1;
 158
 159         /* Version of em28xx that does not support VBI */
 160         return 0;
 161 }
 162
 163 /*
 164  * em28xx_wake_i2c()
 165  * configure i2c attached devices
 166  */
 167 static void em28xx_wake_i2c(struct em28xx *dev)
 168 {
 169         v4l2_device_call_all(&dev->v4l2_dev, 0, core,  reset, 0);
 170         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
 171                         INPUT(dev->ctl_input)->vmux, 0, 0);
 172         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
 173 }
 174
 175 static int em28xx_colorlevels_set_default(struct em28xx *dev)
 176 {
 177         em28xx_write_reg(dev, EM28XX_R20_YGAIN, CONTRAST_DEFAULT);
 178         em28xx_write_reg(dev, EM28XX_R21_YOFFSET, BRIGHTNESS_DEFAULT);
 179         em28xx_write_reg(dev, EM28XX_R22_UVGAIN, SATURATION_DEFAULT);
 180         em28xx_write_reg(dev, EM28XX_R23_UOFFSET, BLUE_BALANCE_DEFAULT);
 181         em28xx_write_reg(dev, EM28XX_R24_VOFFSET, RED_BALANCE_DEFAULT);
 182         em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, SHARPNESS_DEFAULT);
 183
 184         em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
 185         em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
 186         em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
 187         em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
 188         em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
 189         em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
 190         return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
 191 }
 192
 193 static int em28xx_set_outfmt(struct em28xx *dev)
 194 {
 195         int ret;
 196         u8 fmt, vinctrl;
 197
 198         fmt = dev->format->reg;
 199         if (!dev->is_em25xx)
 200                 fmt |= 0x20;
 201         /*
 202          * NOTE: it's not clear if this is really needed !
 203          * The datasheets say bit 5 is a reserved bit and devices seem to work
 204          * fine without it. But the Windows driver sets it for em2710/50+em28xx
 205          * devices and we've always been setting it, too.
 206          *
 207          * em2765 (em25xx, em276x/7x/8x) devices do NOT work with this bit set,
 208          * it's likely used for an additional (compressed ?) format there.
 209          */
 210         ret = em28xx_write_reg(dev, EM28XX_R27_OUTFMT, fmt);
 211         if (ret < 0)
 212                 return ret;
 213
 214         ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, dev->vinmode);
 215         if (ret < 0)
 216                 return ret;
 217
 218         vinctrl = dev->vinctl;
 219         if (em28xx_vbi_supported(dev) == 1) {
 220                 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
 221                 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
 222                 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
 223                 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
 224                 if (dev->norm & V4L2_STD_525_60) {
 225                         /* NTSC */
 226                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
 227                 } else if (dev->norm & V4L2_STD_625_50) {
 228                         /* PAL */
 229                         em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
 230                 }
 231         }
 232
 233         return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
 234 }
 235
 236 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
 237                                   u8 ymin, u8 ymax)
 238 {
 239         em28xx_videodbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
 240                         xmin, ymin, xmax, ymax);
 241
 242         em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
 243         em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
 244         em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
 245         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 246 }
 247
 248 static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
 249                                    u16 width, u16 height)
 250 {
 251         u8 cwidth = width >> 2;
 252         u8 cheight = height >> 2;
 253         u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
 254         /* NOTE: size limit: 2047x1023 = 2MPix */
 255
 256         em28xx_videodbg("capture area set to (%d,%d): %dx%d\n",
 257                        hstart, vstart,
 258                        ((overflow & 2) << 9 | cwidth << 2),
 259                        ((overflow & 1) << 10 | cheight << 2));
 260
 261         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
 262         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
 263         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
 264         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
 265         em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 266
 267         /* FIXME: function/meaning of these registers ? */
 268         /* FIXME: align width+height to multiples of 4 ?! */
 269         if (dev->is_em25xx) {
 270                 em28xx_write_reg(dev, 0x34, width >> 4);
 271                 em28xx_write_reg(dev, 0x35, height >> 4);
 272         }
 273 }
 274
 275 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 276 {
 277         u8 mode;
 278         /* the em2800 scaler only supports scaling down to 50% */
 279
 280         if (dev->board.is_em2800) {
 281                 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
 282         } else {
 283                 u8 buf[2];
 284
 285                 buf[0] = h;
 286                 buf[1] = h >> 8;
 287                 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
 288
 289                 buf[0] = v;
 290                 buf[1] = v >> 8;
 291                 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
 292                 /* it seems that both H and V scalers must be active
 293                    to work correctly */
 294                 mode = (h || v) ? 0x30 : 0x00;
 295         }
 296         return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
 297 }
 298
 299 /* FIXME: this only function read values from dev */
 300 static int em28xx_resolution_set(struct em28xx *dev)
 301 {
 302         int width, height;
 303         width = norm_maxw(dev);
 304         height = norm_maxh(dev);
 305
 306         /* Properly setup VBI */
 307         dev->vbi_width = 720;
 308         if (dev->norm & V4L2_STD_525_60)
 309                 dev->vbi_height = 12;
 310         else
 311                 dev->vbi_height = 18;
 312
 313         em28xx_set_outfmt(dev);
 314
 315         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
 316
 317         /* If we don't set the start position to 2 in VBI mode, we end up
 318            with line 20/21 being YUYV encoded instead of being in 8-bit
 319            greyscale.  The core of the issue is that line 21 (and line 23 for
 320            PAL WSS) are inside of active video region, and as a result they
 321            get the pixelformatting associated with that area.  So by cropping
 322            it out, we end up with the same format as the rest of the VBI
 323            region */
 324         if (em28xx_vbi_supported(dev) == 1)
 325                 em28xx_capture_area_set(dev, 0, 2, width, height);
 326         else
 327                 em28xx_capture_area_set(dev, 0, 0, width, height);
 328
 329         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 330 }
 331
 332 /* Set USB alternate setting for analog video */
 333 static int em28xx_set_alternate(struct em28xx *dev)
 334 {
 335         int errCode;
 336         int i;
 337         unsigned int min_pkt_size = dev->width * 2 + 4;
 338
 339         /* NOTE: for isoc transfers, only alt settings > 0 are allowed
 340                  bulk transfers seem to work only with alt=0 ! */
 341         dev->alt = 0;
 342         if ((alt > 0) && (alt < dev->num_alt)) {
 343                 em28xx_videodbg("alternate forced to %d\n", dev->alt);
 344                 dev->alt = alt;
 345                 goto set_alt;
 346         }
 347         if (dev->analog_xfer_bulk)
 348                 goto set_alt;
 349
 350         /* When image size is bigger than a certain value,
 351            the frame size should be increased, otherwise, only
 352            green screen will be received.
 353          */
 354         if (dev->width * 2 * dev->height > 720 * 240 * 2)
 355                 min_pkt_size *= 2;
 356
 357         for (i = 0; i < dev->num_alt; i++) {
 358                 /* stop when the selected alt setting offers enough bandwidth */
 359                 if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
 360                         dev->alt = i;
 361                         break;
 362                 /* otherwise make sure that we end up with the maximum bandwidth
 363                    because the min_pkt_size equation might be wrong...
 364                 */
 365                 } else if (dev->alt_max_pkt_size_isoc[i] >
 366                            dev->alt_max_pkt_size_isoc[dev->alt])
 367                         dev->alt = i;
 368         }
 369
 370 set_alt:
 371         /* NOTE: for bulk transfers, we need to call usb_set_interface()
 372          * even if the previous settings were the same. Otherwise streaming
 373          * fails with all urbs having status = -EOVERFLOW ! */
 374         if (dev->analog_xfer_bulk) {
 375                 dev->max_pkt_size = 512; /* USB 2.0 spec */
 376                 dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
 377         } else { /* isoc */
 378                 em28xx_videodbg("minimum isoc packet size: %u (alt=%d)\n",
 379                                min_pkt_size, dev->alt);
 380                 dev->max_pkt_size =
 381                                   dev->alt_max_pkt_size_isoc[dev->alt];
 382                 dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
 383         }
 384         em28xx_videodbg("setting alternate %d with wMaxPacketSize=%u\n",
 385                        dev->alt, dev->max_pkt_size);
 386         errCode = usb_set_interface(dev->udev, 0, dev->alt);
 387         if (errCode < 0) {
 388                 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
 389                               dev->alt, errCode);
 390                 return errCode;
 391         }
 392         return 0;
 393 }
 394
 395 /* ------------------------------------------------------------------
 396         DMA and thread functions
 397    ------------------------------------------------------------------*/
 398
 399 /*
 400  * Finish the current buffer
 401  */
 402 static inline void finish_buffer(struct em28xx *dev,
 403                                  struct em28xx_buffer *buf)
 404 {
 405         em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
 406
 407         buf->vb.v4l2_buf.sequence = dev->field_count++;
 408         buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
 409         v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 410
 411         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 412 }
 413
 414 /*
 415  * Copy picture data from USB buffer to videobuf buffer
 416  */
 417 static void em28xx_copy_video(struct em28xx *dev,
 418                               struct em28xx_buffer *buf,
 419                               unsigned char *usb_buf,
 420                               unsigned long len)
 421 {
 422         void *fieldstart, *startwrite, *startread;
 423         int  linesdone, currlinedone, offset, lencopy, remain;
 424         int bytesperline = dev->width << 1;
 425
 426         if (buf->pos + len > buf->length)
 427                 len = buf->length - buf->pos;
 428
 429         startread = usb_buf;
 430         remain = len;
 431
 432         if (dev->progressive || buf->top_field)
 433                 fieldstart = buf->vb_buf;
 434         else /* interlaced mode, even nr. of lines */
 435                 fieldstart = buf->vb_buf + bytesperline;
 436
 437         linesdone = buf->pos / bytesperline;
 438         currlinedone = buf->pos % bytesperline;
 439
 440         if (dev->progressive)
 441                 offset = linesdone * bytesperline + currlinedone;
 442         else
 443                 offset = linesdone * bytesperline * 2 + currlinedone;
 444
 445         startwrite = fieldstart + offset;
 446         lencopy = bytesperline - currlinedone;
 447         lencopy = lencopy > remain ? remain : lencopy;
 448
 449         if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
 450                 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
 451                               ((char *)startwrite + lencopy) -
 452                               ((char *)buf->vb_buf + buf->length));
 453                 remain = (char *)buf->vb_buf + buf->length -
 454                          (char *)startwrite;
 455                 lencopy = remain;
 456         }
 457         if (lencopy <= 0)
 458                 return;
 459         memcpy(startwrite, startread, lencopy);
 460
 461         remain -= lencopy;
 462
 463         while (remain > 0) {
 464                 if (dev->progressive)
 465                         startwrite += lencopy;
 466                 else
 467                         startwrite += lencopy + bytesperline;
 468                 startread += lencopy;
 469                 if (bytesperline > remain)
 470                         lencopy = remain;
 471                 else
 472                         lencopy = bytesperline;
 473
 474                 if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
 475                     buf->length) {
 476                         em28xx_isocdbg("Overflow of %zi bytes past buffer end"
 477                                        "(2)\n",
 478                                        ((char *)startwrite + lencopy) -
 479                                        ((char *)buf->vb_buf + buf->length));
 480                         lencopy = remain = (char *)buf->vb_buf + buf->length -
 481                                 (char *)startwrite;
 482                 }
 483                 if (lencopy <= 0)
 484                         break;
 485
 486                 memcpy(startwrite, startread, lencopy);
 487
 488                 remain -= lencopy;
 489         }
 490
 491         buf->pos += len;
 492 }
 493
 494 /*
 495  * Copy VBI data from USB buffer to videobuf buffer
 496  */
 497 static void em28xx_copy_vbi(struct em28xx *dev,
 498                             struct em28xx_buffer *buf,
 499                             unsigned char *usb_buf,
 500                             unsigned long len)
 501 {
 502         unsigned int offset;
 503
 504         if (buf->pos + len > buf->length)
 505                 len = buf->length - buf->pos;
 506
 507         offset = buf->pos;
 508         /* Make sure the bottom field populates the second half of the frame */
 509         if (buf->top_field == 0)
 510                 offset += dev->vbi_width * dev->vbi_height;
 511
 512         memcpy(buf->vb_buf + offset, usb_buf, len);
 513         buf->pos += len;
 514 }
 515
 516 static inline void print_err_status(struct em28xx *dev,
 517                                      int packet, int status)
 518 {
 519         char *errmsg = "Unknown";
 520
 521         switch (status) {
 522         case -ENOENT:
 523                 errmsg = "unlinked synchronuously";
 524                 break;
 525         case -ECONNRESET:
 526                 errmsg = "unlinked asynchronuously";
 527                 break;
 528         case -ENOSR:
 529                 errmsg = "Buffer error (overrun)";
 530                 break;
 531         case -EPIPE:
 532                 errmsg = "Stalled (device not responding)";
 533                 break;
 534         case -EOVERFLOW:
 535                 errmsg = "Babble (bad cable?)";
 536                 break;
 537         case -EPROTO:
 538                 errmsg = "Bit-stuff error (bad cable?)";
 539                 break;
 540         case -EILSEQ:
 541                 errmsg = "CRC/Timeout (could be anything)";
 542                 break;
 543         case -ETIME:
 544                 errmsg = "Device does not respond";
 545                 break;
 546         }
 547         if (packet < 0) {
 548                 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
 549         } else {
 550                 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
 551                                packet, status, errmsg);
 552         }
 553 }
 554
 555 /*
 556  * get the next available buffer from dma queue
 557  */
 558 static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
 559                                                  struct em28xx_dmaqueue *dma_q)
 560 {
 561         struct em28xx_buffer *buf;
 562
 563         if (list_empty(&dma_q->active)) {
 564                 em28xx_isocdbg("No active queue to serve\n");
 565                 return NULL;
 566         }
 567
 568         /* Get the next buffer */
 569         buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
 570         /* Cleans up buffer - Useful for testing for frame/URB loss */
 571         list_del(&buf->list);
 572         buf->pos = 0;
 573         buf->vb_buf = buf->mem;
 574
 575         return buf;
 576 }
 577
 578 /*
 579  * Finish the current buffer if completed and prepare for the next field
 580  */
 581 static struct em28xx_buffer *
 582 finish_field_prepare_next(struct em28xx *dev,
 583                           struct em28xx_buffer *buf,
 584                           struct em28xx_dmaqueue *dma_q)
 585 {
 586         if (dev->progressive || dev->top_field) { /* Brand new frame */
 587                 if (buf != NULL)
 588                         finish_buffer(dev, buf);
 589                 buf = get_next_buf(dev, dma_q);
 590         }
 591         if (buf != NULL) {
 592                 buf->top_field = dev->top_field;
 593                 buf->pos = 0;
 594         }
 595
 596         return buf;
 597 }
 598
 599 /*
 600  * Process data packet according to the em2710/em2750/em28xx frame data format
 601  */
 602 static inline void process_frame_data_em28xx(struct em28xx *dev,
 603                                              unsigned char *data_pkt,
 604                                              unsigned int  data_len)
 605 {
 606         struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
 607         struct em28xx_buffer    *vbi_buf = dev->usb_ctl.vbi_buf;
 608         struct em28xx_dmaqueue  *dma_q = &dev->vidq;
 609         struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
 610
 611         /* capture type 0 = vbi start
 612            capture type 1 = vbi in progress
 613            capture type 2 = video start
 614            capture type 3 = video in progress */
 615         if (data_len >= 4) {
 616                 /* NOTE: Headers are always 4 bytes and
 617                  * never split across packets */
 618                 if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
 619                     data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
 620                         /* Continuation */
 621                         data_pkt += 4;
 622                         data_len -= 4;
 623                 } else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
 624                         /* Field start (VBI mode) */
 625                         dev->capture_type = 0;
 626                         dev->vbi_read = 0;
 627                         em28xx_isocdbg("VBI START HEADER !!!\n");
 628                         dev->top_field = !(data_pkt[2] & 1);
 629                         data_pkt += 4;
 630                         data_len -= 4;
 631                 } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
 632                         /* Field start (VBI disabled) */
 633                         dev->capture_type = 2;
 634                         em28xx_isocdbg("VIDEO START HEADER !!!\n");
 635                         dev->top_field = !(data_pkt[2] & 1);
 636                         data_pkt += 4;
 637                         data_len -= 4;
 638                 }
 639         }
 640         /* NOTE: With bulk transfers, intermediate data packets
 641          * have no continuation header */
 642
 643         if (dev->capture_type == 0) {
 644                 vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
 645                 dev->usb_ctl.vbi_buf = vbi_buf;
 646                 dev->capture_type = 1;
 647         }
 648
 649         if (dev->capture_type == 1) {
 650                 int vbi_size = dev->vbi_width * dev->vbi_height;
 651                 int vbi_data_len = ((dev->vbi_read + data_len) > vbi_size) ?
 652                                    (vbi_size - dev->vbi_read) : data_len;
 653
 654                 /* Copy VBI data */
 655                 if (vbi_buf != NULL)
 656                         em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
 657                 dev->vbi_read += vbi_data_len;
 658
 659                 if (vbi_data_len < data_len) {
 660                         /* Continue with copying video data */
 661                         dev->capture_type = 2;
 662                         data_pkt += vbi_data_len;
 663                         data_len -= vbi_data_len;
 664                 }
 665         }
 666
 667         if (dev->capture_type == 2) {
 668                 buf = finish_field_prepare_next(dev, buf, dma_q);
 669                 dev->usb_ctl.vid_buf = buf;
 670                 dev->capture_type = 3;
 671         }
 672
 673         if (dev->capture_type == 3 && buf != NULL && data_len > 0)
 674                 em28xx_copy_video(dev, buf, data_pkt, data_len);
 675 }
 676
 677 /*
 678  * Process data packet according to the em25xx/em276x/7x/8x frame data format
 679  */
 680 static inline void process_frame_data_em25xx(struct em28xx *dev,
 681                                              unsigned char *data_pkt,
 682                                              unsigned int  data_len)
 683 {
 684         struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
 685         struct em28xx_dmaqueue  *dmaq = &dev->vidq;
 686         bool frame_end = 0;
 687
 688         /* Check for header */
 689         /* NOTE: at least with bulk transfers, only the first packet
 690          * has a header and has always set the FRAME_END bit         */
 691         if (data_len >= 2) {    /* em25xx header is only 2 bytes long */
 692                 if ((data_pkt[0] == EM25XX_FRMDATAHDR_BYTE1) &&
 693                     ((data_pkt[1] & ~EM25XX_FRMDATAHDR_BYTE2_MASK) == 0x00)) {
 694                         dev->top_field = !(data_pkt[1] &
 695                                            EM25XX_FRMDATAHDR_BYTE2_FRAME_ID);
 696                         frame_end = data_pkt[1] &
 697                                     EM25XX_FRMDATAHDR_BYTE2_FRAME_END;
 698                         data_pkt += 2;
 699                         data_len -= 2;
 700                 }
 701
 702                 /* Finish field and prepare next (BULK only) */
 703                 if (dev->analog_xfer_bulk && frame_end) {
 704                         buf = finish_field_prepare_next(dev, buf, dmaq);
 705                         dev->usb_ctl.vid_buf = buf;
 706                 }
 707                 /* NOTE: in ISOC mode when a new frame starts and buf==NULL,
 708                  * we COULD already prepare a buffer here to avoid skipping the
 709                  * first frame.
 710                  */
 711         }
 712
 713         /* Copy data */
 714         if (buf != NULL && data_len > 0)
 715                 em28xx_copy_video(dev, buf, data_pkt, data_len);
 716
 717         /* Finish frame (ISOC only) => avoids lag of 1 frame */
 718         if (!dev->analog_xfer_bulk && frame_end) {
 719                 buf = finish_field_prepare_next(dev, buf, dmaq);
 720                 dev->usb_ctl.vid_buf = buf;
 721         }
 722
 723         /* NOTE: Tested with USB bulk transfers only !
 724          * The wording in the datasheet suggests that isoc might work different.
 725          * The current code assumes that with isoc transfers each packet has a
 726          * header like with the other em28xx devices.
 727          */
 728         /* NOTE: Support for interlaced mode is pure theory. It has not been
 729          * tested and it is unknown if these devices actually support it. */
 730         /* NOTE: No VBI support yet (these chips likely do not support VBI). */
 731 }
 732
 733 /* Processes and copies the URB data content (video and VBI data) */
 734 static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
 735 {
 736         int xfer_bulk, num_packets, i;
 737         unsigned char *usb_data_pkt;
 738         unsigned int usb_data_len;
 739
 740         if (!dev)
 741                 return 0;
 742
 743         if (dev->disconnected)
 744                 return 0;
 745
 746         if (urb->status < 0)
 747                 print_err_status(dev, -1, urb->status);
 748
 749         xfer_bulk = usb_pipebulk(urb->pipe);
 750
 751         if (xfer_bulk) /* bulk */
 752                 num_packets = 1;
 753         else /* isoc */
 754                 num_packets = urb->number_of_packets;
 755
 756         for (i = 0; i < num_packets; i++) {
 757                 if (xfer_bulk) { /* bulk */
 758                         usb_data_len = urb->actual_length;
 759
 760                         usb_data_pkt = urb->transfer_buffer;
 761                 } else { /* isoc */
 762                         if (urb->iso_frame_desc[i].status < 0) {
 763                                 print_err_status(dev, i,
 764                                                  urb->iso_frame_desc[i].status);
 765                                 if (urb->iso_frame_desc[i].status != -EPROTO)
 766                                         continue;
 767                         }
 768
 769                         usb_data_len = urb->iso_frame_desc[i].actual_length;
 770                         if (usb_data_len > dev->max_pkt_size) {
 771                                 em28xx_isocdbg("packet bigger than packet size");
 772                                 continue;
 773                         }
 774
 775                         usb_data_pkt = urb->transfer_buffer +
 776                                        urb->iso_frame_desc[i].offset;
 777                 }
 778
 779                 if (usb_data_len == 0) {
 780                         /* NOTE: happens very often with isoc transfers */
 781                         /* em28xx_usbdbg("packet %d is empty",i); - spammy */
 782                         continue;
 783                 }
 784
 785                 if (dev->is_em25xx)
 786                         process_frame_data_em25xx(dev,
 787                                                   usb_data_pkt, usb_data_len);
 788                 else
 789                         process_frame_data_em28xx(dev,
 790                                                   usb_data_pkt, usb_data_len);
 791
 792         }
 793         return 1;
 794 }
 795
 796
 797 static int get_ressource(enum v4l2_buf_type f_type)
 798 {
 799         switch (f_type) {
 800         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 801                 return EM28XX_RESOURCE_VIDEO;
 802         case V4L2_BUF_TYPE_VBI_CAPTURE:
 803                 return EM28XX_RESOURCE_VBI;
 804         default:
 805                 BUG();
 806                 return 0;
 807         }
 808 }
 809
 810 /* Usage lock check functions */
 811 static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
 812 {
 813         int res_type = get_ressource(f_type);
 814
 815         /* is it free? */
 816         if (dev->resources & res_type) {
 817                 /* no, someone else uses it */
 818                 return -EBUSY;
 819         }
 820
 821         /* it's free, grab it */
 822         dev->resources |= res_type;
 823         em28xx_videodbg("res: get %d\n", res_type);
 824         return 0;
 825 }
 826
 827 static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
 828 {
 829         int res_type = get_ressource(f_type);
 830
 831         dev->resources &= ~res_type;
 832         em28xx_videodbg("res: put %d\n", res_type);
 833 }
 834
 835 /* ------------------------------------------------------------------
 836         Videobuf2 operations
 837    ------------------------------------------------------------------*/
 838
 839 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 840                        unsigned int *nbuffers, unsigned int *nplanes,
 841                        unsigned int sizes[], void *alloc_ctxs[])
 842 {
 843         struct em28xx *dev = vb2_get_drv_priv(vq);
 844         unsigned long size;
 845
 846         if (fmt)
 847                 size = fmt->fmt.pix.sizeimage;
 848         else
 849                 size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 850
 851         if (size == 0)
 852                 return -EINVAL;
 853
 854         if (0 == *nbuffers)
 855                 *nbuffers = 32;
 856
 857         *nplanes = 1;
 858         sizes[0] = size;
 859
 860         return 0;
 861 }
 862
 863 static int
 864 buffer_prepare(struct vb2_buffer *vb)
 865 {
 866         struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
 867         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
 868         unsigned long size;
 869
 870         em28xx_videodbg("%s, field=%d\n", __func__, vb->v4l2_buf.field);
 871
 872         size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 873
 874         if (vb2_plane_size(vb, 0) < size) {
 875                 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
 876                                 __func__, vb2_plane_size(vb, 0), size);
 877                 return -EINVAL;
 878         }
 879         vb2_set_plane_payload(&buf->vb, 0, size);
 880
 881         return 0;
 882 }
 883
 884 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
 885 {
 886         struct em28xx *dev = vb2_get_drv_priv(vq);
 887         struct v4l2_frequency f;
 888         int rc = 0;
 889
 890         em28xx_videodbg("%s\n", __func__);
 891
 892         /* Make sure streaming is not already in progress for this type
 893            of filehandle (e.g. video, vbi) */
 894         rc = res_get(dev, vq->type);
 895         if (rc)
 896                 return rc;
 897
 898         if (dev->streaming_users == 0) {
 899                 /* First active streaming user, so allocate all the URBs */
 900
 901                 /* Allocate the USB bandwidth */
 902                 em28xx_set_alternate(dev);
 903
 904                 /* Needed, since GPIO might have disabled power of
 905                    some i2c device
 906                 */
 907                 em28xx_wake_i2c(dev);
 908
 909                 dev->capture_type = -1;
 910                 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
 911                                           dev->analog_xfer_bulk,
 912                                           EM28XX_NUM_BUFS,
 913                                           dev->max_pkt_size,
 914                                           dev->packet_multiplier,
 915                                           em28xx_urb_data_copy);
 916                 if (rc < 0)
 917                         return rc;
 918
 919                 /*
 920                  * djh: it's not clear whether this code is still needed.  I'm
 921                  * leaving it in here for now entirely out of concern for
 922                  * backward compatibility (the old code did it)
 923                  */
 924
 925                 /* Ask tuner to go to analog or radio mode */
 926                 memset(&f, 0, sizeof(f));
 927                 f.frequency = dev->ctl_freq;
 928                 if (vq->owner && vq->owner->vdev->vfl_type == VFL_TYPE_RADIO)
 929                         f.type = V4L2_TUNER_RADIO;
 930                 else
 931                         f.type = V4L2_TUNER_ANALOG_TV;
 932                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
 933         }
 934
 935         dev->streaming_users++;
 936
 937         return rc;
 938 }
 939
 940 static int em28xx_stop_streaming(struct vb2_queue *vq)
 941 {
 942         struct em28xx *dev = vb2_get_drv_priv(vq);
 943         struct em28xx_dmaqueue *vidq = &dev->vidq;
 944         unsigned long flags = 0;
 945
 946         em28xx_videodbg("%s\n", __func__);
 947
 948         res_free(dev, vq->type);
 949
 950         if (dev->streaming_users-- == 1) {
 951                 /* Last active user, so shutdown all the URBS */
 952                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
 953         }
 954
 955         spin_lock_irqsave(&dev->slock, flags);
 956         while (!list_empty(&vidq->active)) {
 957                 struct em28xx_buffer *buf;
 958                 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
 959                 list_del(&buf->list);
 960                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 961         }
 962         dev->usb_ctl.vid_buf = NULL;
 963         spin_unlock_irqrestore(&dev->slock, flags);
 964
 965         return 0;
 966 }
 967
 968 int em28xx_stop_vbi_streaming(struct vb2_queue *vq)
 969 {
 970         struct em28xx *dev = vb2_get_drv_priv(vq);
 971         struct em28xx_dmaqueue *vbiq = &dev->vbiq;
 972         unsigned long flags = 0;
 973
 974         em28xx_videodbg("%s\n", __func__);
 975
 976         res_free(dev, vq->type);
 977
 978         if (dev->streaming_users-- == 1) {
 979                 /* Last active user, so shutdown all the URBS */
 980                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
 981         }
 982
 983         spin_lock_irqsave(&dev->slock, flags);
 984         while (!list_empty(&vbiq->active)) {
 985                 struct em28xx_buffer *buf;
 986                 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
 987                 list_del(&buf->list);
 988                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 989         }
 990         dev->usb_ctl.vbi_buf = NULL;
 991         spin_unlock_irqrestore(&dev->slock, flags);
 992
 993         return 0;
 994 }
 995
 996 static void
 997 buffer_queue(struct vb2_buffer *vb)
 998 {
 999         struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1000         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
1001         struct em28xx_dmaqueue *vidq = &dev->vidq;
1002         unsigned long flags = 0;
1003
1004         em28xx_videodbg("%s\n", __func__);
1005         buf->mem = vb2_plane_vaddr(vb, 0);
1006         buf->length = vb2_plane_size(vb, 0);
1007
1008         spin_lock_irqsave(&dev->slock, flags);
1009         list_add_tail(&buf->list, &vidq->active);
1010         spin_unlock_irqrestore(&dev->slock, flags);
1011 }
1012
1013 static struct vb2_ops em28xx_video_qops = {
1014         .queue_setup    = queue_setup,
1015         .buf_prepare    = buffer_prepare,
1016         .buf_queue      = buffer_queue,
1017         .start_streaming = em28xx_start_analog_streaming,
1018         .stop_streaming = em28xx_stop_streaming,
1019         .wait_prepare   = vb2_ops_wait_prepare,
1020         .wait_finish    = vb2_ops_wait_finish,
1021 };
1022
1023 static int em28xx_vb2_setup(struct em28xx *dev)
1024 {
1025         int rc;
1026         struct vb2_queue *q;
1027
1028         /* Setup Videobuf2 for Video capture */
1029         q = &dev->vb_vidq;
1030         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1031         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1032         q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1033         q->drv_priv = dev;
1034         q->buf_struct_size = sizeof(struct em28xx_buffer);
1035         q->ops = &em28xx_video_qops;
1036         q->mem_ops = &vb2_vmalloc_memops;
1037
1038         rc = vb2_queue_init(q);
1039         if (rc < 0)
1040                 return rc;
1041
1042         /* Setup Videobuf2 for VBI capture */
1043         q = &dev->vb_vbiq;
1044         q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1045         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
1046         q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1047         q->drv_priv = dev;
1048         q->buf_struct_size = sizeof(struct em28xx_buffer);
1049         q->ops = &em28xx_vbi_qops;
1050         q->mem_ops = &vb2_vmalloc_memops;
1051
1052         rc = vb2_queue_init(q);
1053         if (rc < 0)
1054                 return rc;
1055
1056         return 0;
1057 }
1058
1059 /*********************  v4l2 interface  **************************************/
1060
1061 static void video_mux(struct em28xx *dev, int index)
1062 {
1063         dev->ctl_input = index;
1064         dev->ctl_ainput = INPUT(index)->amux;
1065         dev->ctl_aoutput = INPUT(index)->aout;
1066
1067         if (!dev->ctl_aoutput)
1068                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1069
1070         v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1071                         INPUT(index)->vmux, 0, 0);
1072
1073         if (dev->board.has_msp34xx) {
1074                 if (dev->i2s_speed) {
1075                         v4l2_device_call_all(&dev->v4l2_dev, 0, audio,
1076                                 s_i2s_clock_freq, dev->i2s_speed);
1077                 }
1078                 /* Note: this is msp3400 specific */
1079                 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1080                          dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
1081         }
1082
1083         if (dev->board.adecoder != EM28XX_NOADECODER) {
1084                 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1085                         dev->ctl_ainput, dev->ctl_aoutput, 0);
1086         }
1087
1088         em28xx_audio_analog_set(dev);
1089 }
1090
1091 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
1092 {
1093         struct em28xx *dev = priv;
1094
1095         /*
1096          * In the case of non-AC97 volume controls, we still need
1097          * to do some setups at em28xx, in order to mute/unmute
1098          * and to adjust audio volume. However, the value ranges
1099          * should be checked by the corresponding V4L subdriver.
1100          */
1101         switch (ctrl->id) {
1102         case V4L2_CID_AUDIO_MUTE:
1103                 dev->mute = ctrl->val;
1104                 em28xx_audio_analog_set(dev);
1105                 break;
1106         case V4L2_CID_AUDIO_VOLUME:
1107                 dev->volume = ctrl->val;
1108                 em28xx_audio_analog_set(dev);
1109                 break;
1110         }
1111 }
1112
1113 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
1114 {
1115         struct em28xx *dev = container_of(ctrl->handler, struct em28xx, ctrl_handler);
1116         int ret = -EINVAL;
1117
1118         switch (ctrl->id) {
1119         case V4L2_CID_AUDIO_MUTE:
1120                 dev->mute = ctrl->val;
1121                 ret = em28xx_audio_analog_set(dev);
1122                 break;
1123         case V4L2_CID_AUDIO_VOLUME:
1124                 dev->volume = ctrl->val;
1125                 ret = em28xx_audio_analog_set(dev);
1126                 break;
1127         case V4L2_CID_CONTRAST:
1128                 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1129                 break;
1130         case V4L2_CID_BRIGHTNESS:
1131                 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1132                 break;
1133         case V4L2_CID_SATURATION:
1134                 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1135                 break;
1136         case V4L2_CID_BLUE_BALANCE:
1137                 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1138                 break;
1139         case V4L2_CID_RED_BALANCE:
1140                 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1141                 break;
1142         case V4L2_CID_SHARPNESS:
1143                 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
1144                 break;
1145         }
1146
1147         return (ret < 0) ? ret : 0;
1148 }
1149
1150 const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
1151         .s_ctrl = em28xx_s_ctrl,
1152 };
1153
1154 static void size_to_scale(struct em28xx *dev,
1155                         unsigned int width, unsigned int height,
1156                         unsigned int *hscale, unsigned int *vscale)
1157 {
1158         unsigned int          maxw = norm_maxw(dev);
1159         unsigned int          maxh = norm_maxh(dev);
1160
1161         *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1162         if (*hscale > EM28XX_HVSCALE_MAX)
1163                 *hscale = EM28XX_HVSCALE_MAX;
1164
1165         *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1166         if (*vscale > EM28XX_HVSCALE_MAX)
1167                 *vscale = EM28XX_HVSCALE_MAX;
1168 }
1169
1170 static void scale_to_size(struct em28xx *dev,
1171                           unsigned int hscale, unsigned int vscale,
1172                           unsigned int *width, unsigned int *height)
1173 {
1174         unsigned int          maxw = norm_maxw(dev);
1175         unsigned int          maxh = norm_maxh(dev);
1176
1177         *width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1178         *height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1179 }
1180
1181 /* ------------------------------------------------------------------
1182         IOCTL vidioc handling
1183    ------------------------------------------------------------------*/
1184
1185 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1186                                         struct v4l2_format *f)
1187 {
1188         struct em28xx_fh      *fh  = priv;
1189         struct em28xx         *dev = fh->dev;
1190
1191         f->fmt.pix.width = dev->width;
1192         f->fmt.pix.height = dev->height;
1193         f->fmt.pix.pixelformat = dev->format->fourcc;
1194         f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
1195         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline  * dev->height;
1196         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1197
1198         /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1199         if (dev->progressive)
1200                 f->fmt.pix.field = V4L2_FIELD_NONE;
1201         else
1202                 f->fmt.pix.field = dev->interlaced ?
1203                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1204         return 0;
1205 }
1206
1207 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1208 {
1209         unsigned int i;
1210
1211         for (i = 0; i < ARRAY_SIZE(format); i++)
1212                 if (format[i].fourcc == fourcc)
1213                         return &format[i];
1214
1215         return NULL;
1216 }
1217
1218 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1219                         struct v4l2_format *f)
1220 {
1221         struct em28xx_fh      *fh    = priv;
1222         struct em28xx         *dev   = fh->dev;
1223         unsigned int          width  = f->fmt.pix.width;
1224         unsigned int          height = f->fmt.pix.height;
1225         unsigned int          maxw   = norm_maxw(dev);
1226         unsigned int          maxh   = norm_maxh(dev);
1227         unsigned int          hscale, vscale;
1228         struct em28xx_fmt     *fmt;
1229
1230         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1231         if (!fmt) {
1232                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1233                                 f->fmt.pix.pixelformat);
1234                 return -EINVAL;
1235         }
1236
1237         if (dev->board.is_em2800) {
1238                 /* the em2800 can only scale down to 50% */
1239                 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1240                 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1241                 /*
1242                  * MaxPacketSize for em2800 is too small to capture at full
1243                  * resolution use half of maxw as the scaler can only scale
1244                  * to 50%
1245                  */
1246                 if (width == maxw && height == maxh)
1247                         width /= 2;
1248         } else {
1249                 /* width must even because of the YUYV format
1250                    height must be even because of interlacing */
1251                 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1252                                       1, 0);
1253         }
1254
1255         size_to_scale(dev, width, height, &hscale, &vscale);
1256         scale_to_size(dev, hscale, vscale, &width, &height);
1257
1258         f->fmt.pix.width = width;
1259         f->fmt.pix.height = height;
1260         f->fmt.pix.pixelformat = fmt->fourcc;
1261         f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
1262         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1263         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1264         if (dev->progressive)
1265                 f->fmt.pix.field = V4L2_FIELD_NONE;
1266         else
1267                 f->fmt.pix.field = dev->interlaced ?
1268                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1269         f->fmt.pix.priv = 0;
1270
1271         return 0;
1272 }
1273
1274 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1275                                    unsigned width, unsigned height)
1276 {
1277         struct em28xx_fmt     *fmt;
1278
1279         fmt = format_by_fourcc(fourcc);
1280         if (!fmt)
1281                 return -EINVAL;
1282
1283         dev->format = fmt;
1284         dev->width  = width;
1285         dev->height = height;
1286
1287         /* set new image size */
1288         size_to_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
1289
1290         em28xx_resolution_set(dev);
1291
1292         return 0;
1293 }
1294
1295 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1296                         struct v4l2_format *f)
1297 {
1298         struct em28xx *dev = video_drvdata(file);
1299
1300         if (dev->streaming_users > 0)
1301                 return -EBUSY;
1302
1303         vidioc_try_fmt_vid_cap(file, priv, f);
1304
1305         return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1306                                 f->fmt.pix.width, f->fmt.pix.height);
1307 }
1308
1309 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1310 {
1311         struct em28xx_fh   *fh  = priv;
1312         struct em28xx      *dev = fh->dev;
1313
1314         *norm = dev->norm;
1315
1316         return 0;
1317 }
1318
1319 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1320 {
1321         struct em28xx_fh   *fh  = priv;
1322         struct em28xx      *dev = fh->dev;
1323
1324         v4l2_device_call_all(&dev->v4l2_dev, 0, video, querystd, norm);
1325
1326         return 0;
1327 }
1328
1329 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1330 {
1331         struct em28xx_fh   *fh  = priv;
1332         struct em28xx      *dev = fh->dev;
1333         struct v4l2_format f;
1334
1335         if (norm == dev->norm)
1336                 return 0;
1337
1338         if (dev->streaming_users > 0)
1339                 return -EBUSY;
1340
1341         dev->norm = norm;
1342
1343         /* Adjusts width/height, if needed */
1344         f.fmt.pix.width = 720;
1345         f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
1346         vidioc_try_fmt_vid_cap(file, priv, &f);
1347
1348         /* set new image size */
1349         dev->width = f.fmt.pix.width;
1350         dev->height = f.fmt.pix.height;
1351         size_to_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
1352
1353         em28xx_resolution_set(dev);
1354         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
1355
1356         return 0;
1357 }
1358
1359 static int vidioc_g_parm(struct file *file, void *priv,
1360                          struct v4l2_streamparm *p)
1361 {
1362         struct em28xx_fh   *fh  = priv;
1363         struct em28xx      *dev = fh->dev;
1364         int rc = 0;
1365
1366         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1367         if (dev->board.is_webcam)
1368                 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0,
1369                                                 video, g_parm, p);
1370         else
1371                 v4l2_video_std_frame_period(dev->norm,
1372                                                  &p->parm.capture.timeperframe);
1373
1374         return rc;
1375 }
1376
1377 static int vidioc_s_parm(struct file *file, void *priv,
1378                          struct v4l2_streamparm *p)
1379 {
1380         struct em28xx_fh   *fh  = priv;
1381         struct em28xx      *dev = fh->dev;
1382
1383         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1384         return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p);
1385 }
1386
1387 static const char *iname[] = {
1388         [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1389         [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1390         [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1391         [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1392         [EM28XX_VMUX_SVIDEO]     = "S-Video",
1393         [EM28XX_VMUX_TELEVISION] = "Television",
1394         [EM28XX_VMUX_CABLE]      = "Cable TV",
1395         [EM28XX_VMUX_DVB]        = "DVB",
1396         [EM28XX_VMUX_DEBUG]      = "for debug only",
1397 };
1398
1399 static int vidioc_enum_input(struct file *file, void *priv,
1400                                 struct v4l2_input *i)
1401 {
1402         struct em28xx_fh   *fh  = priv;
1403         struct em28xx      *dev = fh->dev;
1404         unsigned int       n;
1405
1406         n = i->index;
1407         if (n >= MAX_EM28XX_INPUT)
1408                 return -EINVAL;
1409         if (0 == INPUT(n)->type)
1410                 return -EINVAL;
1411
1412         i->index = n;
1413         i->type = V4L2_INPUT_TYPE_CAMERA;
1414
1415         strcpy(i->name, iname[INPUT(n)->type]);
1416
1417         if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1418                 (EM28XX_VMUX_CABLE == INPUT(n)->type))
1419                 i->type = V4L2_INPUT_TYPE_TUNER;
1420
1421         i->std = dev->vdev->tvnorms;
1422         /* webcams do not have the STD API */
1423         if (dev->board.is_webcam)
1424                 i->capabilities = 0;
1425
1426         return 0;
1427 }
1428
1429 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1430 {
1431         struct em28xx_fh   *fh  = priv;
1432         struct em28xx      *dev = fh->dev;
1433
1434         *i = dev->ctl_input;
1435
1436         return 0;
1437 }
1438
1439 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1440 {
1441         struct em28xx_fh   *fh  = priv;
1442         struct em28xx      *dev = fh->dev;
1443
1444         if (i >= MAX_EM28XX_INPUT)
1445                 return -EINVAL;
1446         if (0 == INPUT(i)->type)
1447                 return -EINVAL;
1448
1449         video_mux(dev, i);
1450         return 0;
1451 }
1452
1453 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1454 {
1455         struct em28xx_fh   *fh    = priv;
1456         struct em28xx      *dev   = fh->dev;
1457
1458         switch (a->index) {
1459         case EM28XX_AMUX_VIDEO:
1460                 strcpy(a->name, "Television");
1461                 break;
1462         case EM28XX_AMUX_LINE_IN:
1463                 strcpy(a->name, "Line In");
1464                 break;
1465         case EM28XX_AMUX_VIDEO2:
1466                 strcpy(a->name, "Television alt");
1467                 break;
1468         case EM28XX_AMUX_PHONE:
1469                 strcpy(a->name, "Phone");
1470                 break;
1471         case EM28XX_AMUX_MIC:
1472                 strcpy(a->name, "Mic");
1473                 break;
1474         case EM28XX_AMUX_CD:
1475                 strcpy(a->name, "CD");
1476                 break;
1477         case EM28XX_AMUX_AUX:
1478                 strcpy(a->name, "Aux");
1479                 break;
1480         case EM28XX_AMUX_PCM_OUT:
1481                 strcpy(a->name, "PCM");
1482                 break;
1483         default:
1484                 return -EINVAL;
1485         }
1486
1487         a->index = dev->ctl_ainput;
1488         a->capability = V4L2_AUDCAP_STEREO;
1489
1490         return 0;
1491 }
1492
1493 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1494 {
1495         struct em28xx_fh   *fh  = priv;
1496         struct em28xx      *dev = fh->dev;
1497
1498         if (a->index >= MAX_EM28XX_INPUT)
1499                 return -EINVAL;
1500         if (0 == INPUT(a->index)->type)
1501                 return -EINVAL;
1502
1503         dev->ctl_ainput = INPUT(a->index)->amux;
1504         dev->ctl_aoutput = INPUT(a->index)->aout;
1505
1506         if (!dev->ctl_aoutput)
1507                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1508
1509         return 0;
1510 }
1511
1512 static int vidioc_g_tuner(struct file *file, void *priv,
1513                                 struct v4l2_tuner *t)
1514 {
1515         struct em28xx_fh      *fh  = priv;
1516         struct em28xx         *dev = fh->dev;
1517
1518         if (0 != t->index)
1519                 return -EINVAL;
1520
1521         strcpy(t->name, "Tuner");
1522
1523         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1524         return 0;
1525 }
1526
1527 static int vidioc_s_tuner(struct file *file, void *priv,
1528                                 const struct v4l2_tuner *t)
1529 {
1530         struct em28xx_fh      *fh  = priv;
1531         struct em28xx         *dev = fh->dev;
1532
1533         if (0 != t->index)
1534                 return -EINVAL;
1535
1536         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1537         return 0;
1538 }
1539
1540 static int vidioc_g_frequency(struct file *file, void *priv,
1541                                 struct v4l2_frequency *f)
1542 {
1543         struct em28xx_fh      *fh  = priv;
1544         struct em28xx         *dev = fh->dev;
1545
1546         if (0 != f->tuner)
1547                 return -EINVAL;
1548
1549         f->frequency = dev->ctl_freq;
1550         return 0;
1551 }
1552
1553 static int vidioc_s_frequency(struct file *file, void *priv,
1554                                 const struct v4l2_frequency *f)
1555 {
1556         struct v4l2_frequency new_freq = *f;
1557         struct em28xx_fh      *fh  = priv;
1558         struct em28xx         *dev = fh->dev;
1559
1560         if (0 != f->tuner)
1561                 return -EINVAL;
1562
1563         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
1564         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1565         dev->ctl_freq = new_freq.frequency;
1566
1567         return 0;
1568 }
1569
1570 #ifdef CONFIG_VIDEO_ADV_DEBUG
1571 static int vidioc_g_chip_info(struct file *file, void *priv,
1572                struct v4l2_dbg_chip_info *chip)
1573 {
1574         struct em28xx_fh      *fh  = priv;
1575         struct em28xx         *dev = fh->dev;
1576
1577         if (chip->match.addr > 1)
1578                 return -EINVAL;
1579         if (chip->match.addr == 1)
1580                 strlcpy(chip->name, "ac97", sizeof(chip->name));
1581         else
1582                 strlcpy(chip->name, dev->v4l2_dev.name, sizeof(chip->name));
1583         return 0;
1584 }
1585
1586 static int em28xx_reg_len(int reg)
1587 {
1588         switch (reg) {
1589         case EM28XX_R40_AC97LSB:
1590         case EM28XX_R30_HSCALELOW:
1591         case EM28XX_R32_VSCALELOW:
1592                 return 2;
1593         default:
1594                 return 1;
1595         }
1596 }
1597
1598 static int vidioc_g_register(struct file *file, void *priv,
1599                              struct v4l2_dbg_register *reg)
1600 {
1601         struct em28xx_fh      *fh  = priv;
1602         struct em28xx         *dev = fh->dev;
1603         int ret;
1604
1605         if (reg->match.addr > 1)
1606                 return -EINVAL;
1607         if (reg->match.addr) {
1608                 ret = em28xx_read_ac97(dev, reg->reg);
1609                 if (ret < 0)
1610                         return ret;
1611
1612                 reg->val = ret;
1613                 reg->size = 1;
1614                 return 0;
1615         }
1616
1617         /* Match host */
1618         reg->size = em28xx_reg_len(reg->reg);
1619         if (reg->size == 1) {
1620                 ret = em28xx_read_reg(dev, reg->reg);
1621
1622                 if (ret < 0)
1623                         return ret;
1624
1625                 reg->val = ret;
1626         } else {
1627                 __le16 val = 0;
1628                 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1629                                                    reg->reg, (char *)&val, 2);
1630                 if (ret < 0)
1631                         return ret;
1632
1633                 reg->val = le16_to_cpu(val);
1634         }
1635
1636         return 0;
1637 }
1638
1639 static int vidioc_s_register(struct file *file, void *priv,
1640                              const struct v4l2_dbg_register *reg)
1641 {
1642         struct em28xx_fh      *fh  = priv;
1643         struct em28xx         *dev = fh->dev;
1644         __le16 buf;
1645
1646         if (reg->match.addr > 1)
1647                 return -EINVAL;
1648         if (reg->match.addr)
1649                 return em28xx_write_ac97(dev, reg->reg, reg->val);
1650
1651         /* Match host */
1652         buf = cpu_to_le16(reg->val);
1653
1654         return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1655                                em28xx_reg_len(reg->reg));
1656 }
1657 #endif
1658
1659
1660 static int vidioc_querycap(struct file *file, void  *priv,
1661                                         struct v4l2_capability *cap)
1662 {
1663         struct video_device *vdev = video_devdata(file);
1664         struct em28xx_fh      *fh  = priv;
1665         struct em28xx         *dev = fh->dev;
1666
1667         strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1668         strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1669         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1670
1671         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1672                 cap->device_caps = V4L2_CAP_READWRITE |
1673                         V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1674         else if (vdev->vfl_type == VFL_TYPE_RADIO)
1675                 cap->device_caps = V4L2_CAP_RADIO;
1676         else
1677                 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1678
1679         if (dev->audio_mode.has_audio)
1680                 cap->device_caps |= V4L2_CAP_AUDIO;
1681
1682         if (dev->tuner_type != TUNER_ABSENT)
1683                 cap->device_caps |= V4L2_CAP_TUNER;
1684
1685         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1686                 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1687         if (dev->vbi_dev)
1688                 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1689         if (dev->radio_dev)
1690                 cap->capabilities |= V4L2_CAP_RADIO;
1691         return 0;
1692 }
1693
1694 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1695                                         struct v4l2_fmtdesc *f)
1696 {
1697         if (unlikely(f->index >= ARRAY_SIZE(format)))
1698                 return -EINVAL;
1699
1700         strlcpy(f->description, format[f->index].name, sizeof(f->description));
1701         f->pixelformat = format[f->index].fourcc;
1702
1703         return 0;
1704 }
1705
1706 static int vidioc_enum_framesizes(struct file *file, void *priv,
1707                                   struct v4l2_frmsizeenum *fsize)
1708 {
1709         struct em28xx_fh      *fh  = priv;
1710         struct em28xx         *dev = fh->dev;
1711         struct em28xx_fmt     *fmt;
1712         unsigned int          maxw = norm_maxw(dev);
1713         unsigned int          maxh = norm_maxh(dev);
1714
1715         fmt = format_by_fourcc(fsize->pixel_format);
1716         if (!fmt) {
1717                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1718                                 fsize->pixel_format);
1719                 return -EINVAL;
1720         }
1721
1722         if (dev->board.is_em2800) {
1723                 if (fsize->index > 1)
1724                         return -EINVAL;
1725                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1726                 fsize->discrete.width = maxw / (1 + fsize->index);
1727                 fsize->discrete.height = maxh / (1 + fsize->index);
1728                 return 0;
1729         }
1730
1731         if (fsize->index != 0)
1732                 return -EINVAL;
1733
1734         /* Report a continuous range */
1735         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1736         scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1737                       &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1738         if (fsize->stepwise.min_width < 48)
1739                 fsize->stepwise.min_width = 48;
1740         if (fsize->stepwise.min_height < 38)
1741                 fsize->stepwise.min_height = 38;
1742         fsize->stepwise.max_width = maxw;
1743         fsize->stepwise.max_height = maxh;
1744         fsize->stepwise.step_width = 1;
1745         fsize->stepwise.step_height = 1;
1746         return 0;
1747 }
1748
1749 /* RAW VBI ioctls */
1750
1751 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1752                                 struct v4l2_format *format)
1753 {
1754         struct em28xx_fh      *fh  = priv;
1755         struct em28xx         *dev = fh->dev;
1756
1757         format->fmt.vbi.samples_per_line = dev->vbi_width;
1758         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1759         format->fmt.vbi.offset = 0;
1760         format->fmt.vbi.flags = 0;
1761         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1762         format->fmt.vbi.count[0] = dev->vbi_height;
1763         format->fmt.vbi.count[1] = dev->vbi_height;
1764         memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1765
1766         /* Varies by video standard (NTSC, PAL, etc.) */
1767         if (dev->norm & V4L2_STD_525_60) {
1768                 /* NTSC */
1769                 format->fmt.vbi.start[0] = 10;
1770                 format->fmt.vbi.start[1] = 273;
1771         } else if (dev->norm & V4L2_STD_625_50) {
1772                 /* PAL */
1773                 format->fmt.vbi.start[0] = 6;
1774                 format->fmt.vbi.start[1] = 318;
1775         }
1776
1777         return 0;
1778 }
1779
1780 /* ----------------------------------------------------------- */
1781 /* RADIO ESPECIFIC IOCTLS                                      */
1782 /* ----------------------------------------------------------- */
1783
1784 static int radio_g_tuner(struct file *file, void *priv,
1785                          struct v4l2_tuner *t)
1786 {
1787         struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1788
1789         if (unlikely(t->index > 0))
1790                 return -EINVAL;
1791
1792         strcpy(t->name, "Radio");
1793
1794         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1795
1796         return 0;
1797 }
1798
1799 static int radio_s_tuner(struct file *file, void *priv,
1800                          const struct v4l2_tuner *t)
1801 {
1802         struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1803
1804         if (0 != t->index)
1805                 return -EINVAL;
1806
1807         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1808
1809         return 0;
1810 }
1811
1812 /*
1813  * em28xx_v4l2_open()
1814  * inits the device and starts isoc transfer
1815  */
1816 static int em28xx_v4l2_open(struct file *filp)
1817 {
1818         struct video_device *vdev = video_devdata(filp);
1819         struct em28xx *dev = video_drvdata(filp);
1820         enum v4l2_buf_type fh_type = 0;
1821         struct em28xx_fh *fh;
1822
1823         switch (vdev->vfl_type) {
1824         case VFL_TYPE_GRABBER:
1825                 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1826                 break;
1827         case VFL_TYPE_VBI:
1828                 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1829                 break;
1830         case VFL_TYPE_RADIO:
1831                 break;
1832         default:
1833                 return -EINVAL;
1834         }
1835
1836         em28xx_videodbg("open dev=%s type=%s users=%d\n",
1837                         video_device_node_name(vdev), v4l2_type_names[fh_type],
1838                         dev->users);
1839
1840
1841         if (mutex_lock_interruptible(&dev->lock))
1842                 return -ERESTARTSYS;
1843         fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
1844         if (!fh) {
1845                 em28xx_errdev("em28xx-video.c: Out of memory?!\n");
1846                 mutex_unlock(&dev->lock);
1847                 return -ENOMEM;
1848         }
1849         v4l2_fh_init(&fh->fh, vdev);
1850         fh->dev = dev;
1851         fh->type = fh_type;
1852         filp->private_data = fh;
1853
1854         if (dev->users == 0) {
1855                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
1856
1857                 if (vdev->vfl_type != VFL_TYPE_RADIO)
1858                         em28xx_resolution_set(dev);
1859
1860                 /*
1861                  * Needed, since GPIO might have disabled power
1862                  * of some i2c devices
1863                  */
1864                 em28xx_wake_i2c(dev);
1865         }
1866
1867         if (vdev->vfl_type == VFL_TYPE_RADIO) {
1868                 em28xx_videodbg("video_open: setting radio device\n");
1869                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
1870         }
1871
1872         dev->users++;
1873
1874         mutex_unlock(&dev->lock);
1875         v4l2_fh_add(&fh->fh);
1876
1877         return 0;
1878 }
1879
1880 /*
1881  * em28xx_v4l2_fini()
1882  * unregisters the v4l2,i2c and usb devices
1883  * called when the device gets disconected or at module unload
1884 */
1885 static int em28xx_v4l2_fini(struct em28xx *dev)
1886 {
1887         if (dev->is_audio_only) {
1888                 /* Shouldn't initialize IR for this interface */
1889                 return 0;
1890         }
1891
1892         if (!dev->has_video) {
1893                 /* This device does not support the v4l2 extension */
1894                 return 0;
1895         }
1896
1897         v4l2_device_disconnect(&dev->v4l2_dev);
1898
1899         em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1900
1901         if (dev->radio_dev) {
1902                 em28xx_info("V4L2 device %s deregistered\n",
1903                             video_device_node_name(dev->radio_dev));
1904                 video_unregister_device(dev->radio_dev);
1905         }
1906         if (dev->vbi_dev) {
1907                 em28xx_info("V4L2 device %s deregistered\n",
1908                             video_device_node_name(dev->vbi_dev));
1909                 video_unregister_device(dev->vbi_dev);
1910         }
1911         if (dev->vdev) {
1912                 em28xx_info("V4L2 device %s deregistered\n",
1913                             video_device_node_name(dev->vdev));
1914                 video_unregister_device(dev->vdev);
1915         }
1916
1917         if (dev->clk) {
1918                 v4l2_clk_unregister_fixed(dev->clk);
1919                 dev->clk = NULL;
1920         }
1921
1922         v4l2_ctrl_handler_free(&dev->ctrl_handler);
1923         v4l2_device_unregister(&dev->v4l2_dev);
1924
1925         if (dev->users)
1926                 em28xx_warn("Device is open ! Memory deallocation is deferred on last close.\n");
1927
1928         return 0;
1929 }
1930
1931 /*
1932  * em28xx_v4l2_close()
1933  * stops streaming and deallocates all resources allocated by the v4l2
1934  * calls and ioctls
1935  */
1936 static int em28xx_v4l2_close(struct file *filp)
1937 {
1938         struct em28xx_fh *fh  = filp->private_data;
1939         struct em28xx    *dev = fh->dev;
1940         int              errCode;
1941
1942         em28xx_videodbg("users=%d\n", dev->users);
1943
1944         vb2_fop_release(filp);
1945         mutex_lock(&dev->lock);
1946
1947         if (dev->users == 1) {
1948                 /* free the remaining resources if device is disconnected */
1949                 if (dev->disconnected) {
1950                         kfree(dev->alt_max_pkt_size_isoc);
1951                         goto exit;
1952                 }
1953
1954                 /* Save some power by putting tuner to sleep */
1955                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
1956
1957                 /* do this before setting alternate! */
1958                 em28xx_set_mode(dev, EM28XX_SUSPEND);
1959
1960                 /* set alternate 0 */
1961                 dev->alt = 0;
1962                 em28xx_videodbg("setting alternate 0\n");
1963                 errCode = usb_set_interface(dev->udev, 0, 0);
1964                 if (errCode < 0) {
1965                         em28xx_errdev("cannot change alternate number to "
1966                                         "0 (error=%i)\n", errCode);
1967                 }
1968         }
1969
1970 exit:
1971         dev->users--;
1972         mutex_unlock(&dev->lock);
1973         return 0;
1974 }
1975
1976 /*
1977  * em28xx_videodevice_release()
1978  * called when the last user of the video device exits and frees the memeory
1979  */
1980 static void em28xx_videodevice_release(struct video_device *vdev)
1981 {
1982         struct em28xx *dev = video_get_drvdata(vdev);
1983
1984         video_device_release(vdev);
1985         if (vdev == dev->vdev)
1986                 dev->vdev = NULL;
1987         else if (vdev == dev->vbi_dev)
1988                 dev->vbi_dev = NULL;
1989         else if (vdev == dev->radio_dev)
1990                 dev->radio_dev = NULL;
1991 }
1992
1993 static const struct v4l2_file_operations em28xx_v4l_fops = {
1994         .owner         = THIS_MODULE,
1995         .open          = em28xx_v4l2_open,
1996         .release       = em28xx_v4l2_close,
1997         .read          = vb2_fop_read,
1998         .poll          = vb2_fop_poll,
1999         .mmap          = vb2_fop_mmap,
2000         .unlocked_ioctl = video_ioctl2,
2001 };
2002
2003 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2004         .vidioc_querycap            = vidioc_querycap,
2005         .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
2006         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
2007         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
2008         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
2009         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2010         .vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
2011         .vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2012         .vidioc_enum_framesizes     = vidioc_enum_framesizes,
2013         .vidioc_g_audio             = vidioc_g_audio,
2014         .vidioc_s_audio             = vidioc_s_audio,
2015
2016         .vidioc_reqbufs             = vb2_ioctl_reqbufs,
2017         .vidioc_create_bufs         = vb2_ioctl_create_bufs,
2018         .vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
2019         .vidioc_querybuf            = vb2_ioctl_querybuf,
2020         .vidioc_qbuf                = vb2_ioctl_qbuf,
2021         .vidioc_dqbuf               = vb2_ioctl_dqbuf,
2022
2023         .vidioc_g_std               = vidioc_g_std,
2024         .vidioc_querystd            = vidioc_querystd,
2025         .vidioc_s_std               = vidioc_s_std,
2026         .vidioc_g_parm              = vidioc_g_parm,
2027         .vidioc_s_parm              = vidioc_s_parm,
2028         .vidioc_enum_input          = vidioc_enum_input,
2029         .vidioc_g_input             = vidioc_g_input,
2030         .vidioc_s_input             = vidioc_s_input,
2031         .vidioc_streamon            = vb2_ioctl_streamon,
2032         .vidioc_streamoff           = vb2_ioctl_streamoff,
2033         .vidioc_g_tuner             = vidioc_g_tuner,
2034         .vidioc_s_tuner             = vidioc_s_tuner,
2035         .vidioc_g_frequency         = vidioc_g_frequency,
2036         .vidioc_s_frequency         = vidioc_s_frequency,
2037         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2038         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2039 #ifdef CONFIG_VIDEO_ADV_DEBUG
2040         .vidioc_g_chip_info         = vidioc_g_chip_info,
2041         .vidioc_g_register          = vidioc_g_register,
2042         .vidioc_s_register          = vidioc_s_register,
2043 #endif
2044 };
2045
2046 static const struct video_device em28xx_video_template = {
2047         .fops           = &em28xx_v4l_fops,
2048         .ioctl_ops      = &video_ioctl_ops,
2049         .release        = em28xx_videodevice_release,
2050         .tvnorms        = V4L2_STD_ALL,
2051 };
2052
2053 static const struct v4l2_file_operations radio_fops = {
2054         .owner         = THIS_MODULE,
2055         .open          = em28xx_v4l2_open,
2056         .release       = em28xx_v4l2_close,
2057         .unlocked_ioctl = video_ioctl2,
2058 };
2059
2060 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2061         .vidioc_querycap      = vidioc_querycap,
2062         .vidioc_g_tuner       = radio_g_tuner,
2063         .vidioc_s_tuner       = radio_s_tuner,
2064         .vidioc_g_frequency   = vidioc_g_frequency,
2065         .vidioc_s_frequency   = vidioc_s_frequency,
2066         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2067         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2068 #ifdef CONFIG_VIDEO_ADV_DEBUG
2069         .vidioc_g_chip_info   = vidioc_g_chip_info,
2070         .vidioc_g_register    = vidioc_g_register,
2071         .vidioc_s_register    = vidioc_s_register,
2072 #endif
2073 };
2074
2075 static struct video_device em28xx_radio_template = {
2076         .fops           = &radio_fops,
2077         .ioctl_ops      = &radio_ioctl_ops,
2078         .release        = em28xx_videodevice_release,
2079 };
2080
2081 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2082 static unsigned short saa711x_addrs[] = {
2083         0x4a >> 1, 0x48 >> 1,   /* SAA7111, SAA7111A and SAA7113 */
2084         0x42 >> 1, 0x40 >> 1,   /* SAA7114, SAA7115 and SAA7118 */
2085         I2C_CLIENT_END };
2086
2087 static unsigned short tvp5150_addrs[] = {
2088         0xb8 >> 1,
2089         0xba >> 1,
2090         I2C_CLIENT_END
2091 };
2092
2093 static unsigned short msp3400_addrs[] = {
2094         0x80 >> 1,
2095         0x88 >> 1,
2096         I2C_CLIENT_END
2097 };
2098
2099 /******************************** usb interface ******************************/
2100
2101 static struct video_device *em28xx_vdev_init(struct em28xx *dev,
2102                                         const struct video_device *template,
2103                                         const char *type_name)
2104 {
2105         struct video_device *vfd;
2106
2107         vfd = video_device_alloc();
2108         if (NULL == vfd)
2109                 return NULL;
2110
2111         *vfd            = *template;
2112         vfd->v4l2_dev   = &dev->v4l2_dev;
2113         vfd->debug      = video_debug;
2114         vfd->lock       = &dev->lock;
2115         set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
2116         if (dev->board.is_webcam)
2117                 vfd->tvnorms = 0;
2118
2119         snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2120                  dev->name, type_name);
2121
2122         video_set_drvdata(vfd, dev);
2123         return vfd;
2124 }
2125
2126 static void em28xx_tuner_setup(struct em28xx *dev)
2127 {
2128         struct tuner_setup           tun_setup;
2129         struct v4l2_frequency        f;
2130
2131         if (dev->tuner_type == TUNER_ABSENT)
2132                 return;
2133
2134         memset(&tun_setup, 0, sizeof(tun_setup));
2135
2136         tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2137         tun_setup.tuner_callback = em28xx_tuner_callback;
2138
2139         if (dev->board.radio.type) {
2140                 tun_setup.type = dev->board.radio.type;
2141                 tun_setup.addr = dev->board.radio_addr;
2142
2143                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);
2144         }
2145
2146         if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2147                 tun_setup.type   = dev->tuner_type;
2148                 tun_setup.addr   = dev->tuner_addr;
2149
2150                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);
2151         }
2152
2153         if (dev->tda9887_conf) {
2154                 struct v4l2_priv_tun_config tda9887_cfg;
2155
2156                 tda9887_cfg.tuner = TUNER_TDA9887;
2157                 tda9887_cfg.priv = &dev->tda9887_conf;
2158
2159                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config, &tda9887_cfg);
2160         }
2161
2162         if (dev->tuner_type == TUNER_XC2028) {
2163                 struct v4l2_priv_tun_config  xc2028_cfg;
2164                 struct xc2028_ctrl           ctl;
2165
2166                 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2167                 memset(&ctl, 0, sizeof(ctl));
2168
2169                 em28xx_setup_xc3028(dev, &ctl);
2170
2171                 xc2028_cfg.tuner = TUNER_XC2028;
2172                 xc2028_cfg.priv  = &ctl;
2173
2174                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2175         }
2176
2177         /* configure tuner */
2178         f.tuner = 0;
2179         f.type = V4L2_TUNER_ANALOG_TV;
2180         f.frequency = 9076;     /* just a magic number */
2181         dev->ctl_freq = f.frequency;
2182         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
2183 }
2184
2185 static int em28xx_v4l2_init(struct em28xx *dev)
2186 {
2187         u8 val;
2188         int ret;
2189         unsigned int maxw;
2190         struct v4l2_ctrl_handler *hdl = &dev->ctrl_handler;
2191
2192         if (dev->is_audio_only) {
2193                 /* Shouldn't initialize IR for this interface */
2194                 return 0;
2195         }
2196
2197         if (!dev->has_video) {
2198                 /* This device does not support the v4l2 extension */
2199                 return 0;
2200         }
2201
2202         em28xx_info("Registering V4L2 extension\n");
2203
2204         mutex_lock(&dev->lock);
2205
2206         ret = v4l2_device_register(&dev->udev->dev, &dev->v4l2_dev);
2207         if (ret < 0) {
2208                 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2209                 goto err;
2210         }
2211
2212         v4l2_ctrl_handler_init(hdl, 8);
2213         dev->v4l2_dev.ctrl_handler = hdl;
2214
2215         /*
2216          * Default format, used for tvp5150 or saa711x output formats
2217          */
2218         dev->vinmode = 0x10;
2219         dev->vinctl  = EM28XX_VINCTRL_INTERLACED |
2220                        EM28XX_VINCTRL_CCIR656_ENABLE;
2221
2222         /* request some modules */
2223
2224         if (dev->board.has_msp34xx)
2225                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2226                         "msp3400", 0, msp3400_addrs);
2227
2228         if (dev->board.decoder == EM28XX_SAA711X)
2229                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2230                         "saa7115_auto", 0, saa711x_addrs);
2231
2232         if (dev->board.decoder == EM28XX_TVP5150)
2233                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2234                         "tvp5150", 0, tvp5150_addrs);
2235
2236         if (dev->board.adecoder == EM28XX_TVAUDIO)
2237                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2238                         "tvaudio", dev->board.tvaudio_addr, NULL);
2239
2240         /* Initialize tuner and camera */
2241
2242         if (dev->board.tuner_type != TUNER_ABSENT) {
2243                 int has_demod = (dev->tda9887_conf & TDA9887_PRESENT);
2244
2245                 if (dev->board.radio.type)
2246                         v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2247                                 "tuner", dev->board.radio_addr, NULL);
2248
2249                 if (has_demod)
2250                         v4l2_i2c_new_subdev(&dev->v4l2_dev,
2251                                 &dev->i2c_adap[dev->def_i2c_bus], "tuner",
2252                                 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2253                 if (dev->tuner_addr == 0) {
2254                         enum v4l2_i2c_tuner_type type =
2255                                 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2256                         struct v4l2_subdev *sd;
2257
2258                         sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
2259                                 &dev->i2c_adap[dev->def_i2c_bus], "tuner",
2260                                 0, v4l2_i2c_tuner_addrs(type));
2261
2262                         if (sd)
2263                                 dev->tuner_addr = v4l2_i2c_subdev_addr(sd);
2264                 } else {
2265                         v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap[dev->def_i2c_bus],
2266                                 "tuner", dev->tuner_addr, NULL);
2267                 }
2268         }
2269
2270         em28xx_tuner_setup(dev);
2271         em28xx_init_camera(dev);
2272
2273         /* Configure audio */
2274         ret = em28xx_audio_setup(dev);
2275         if (ret < 0) {
2276                 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
2277                         __func__, ret);
2278                 goto unregister_dev;
2279         }
2280         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2281                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2282                         V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2283                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2284                         V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
2285         } else {
2286                 /* install the em28xx notify callback */
2287                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
2288                                 em28xx_ctrl_notify, dev);
2289                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
2290                                 em28xx_ctrl_notify, dev);
2291         }
2292
2293         /* wake i2c devices */
2294         em28xx_wake_i2c(dev);
2295
2296         /* init video dma queues */
2297         INIT_LIST_HEAD(&dev->vidq.active);
2298         INIT_LIST_HEAD(&dev->vbiq.active);
2299
2300         if (dev->board.has_msp34xx) {
2301                 /* Send a reset to other chips via gpio */
2302                 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2303                 if (ret < 0) {
2304                         em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2305                                       __func__, ret);
2306                         goto unregister_dev;
2307                 }
2308                 msleep(3);
2309
2310                 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2311                 if (ret < 0) {
2312                         em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2313                                       __func__, ret);
2314                         goto unregister_dev;
2315                 }
2316                 msleep(3);
2317         }
2318
2319         /* set default norm */
2320         dev->norm = V4L2_STD_PAL;
2321         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
2322         dev->interlaced = EM28XX_INTERLACED_DEFAULT;
2323
2324         /* Analog specific initialization */
2325         dev->format = &format[0];
2326
2327         maxw = norm_maxw(dev);
2328         /* MaxPacketSize for em2800 is too small to capture at full resolution
2329          * use half of maxw as the scaler can only scale to 50% */
2330         if (dev->board.is_em2800)
2331                 maxw /= 2;
2332
2333         em28xx_set_video_format(dev, format[0].fourcc,
2334                                 maxw, norm_maxh(dev));
2335
2336         video_mux(dev, 0);
2337
2338         /* Audio defaults */
2339         dev->mute = 1;
2340         dev->volume = 0x1f;
2341
2342 /*      em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
2343         val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2344         em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2345                          (EM28XX_XCLK_AUDIO_UNMUTE | val));
2346
2347         em28xx_set_outfmt(dev);
2348         em28xx_compression_disable(dev);
2349
2350         /* Add image controls */
2351         /* NOTE: at this point, the subdevices are already registered, so bridge
2352          * controls are only added/enabled when no subdevice provides them */
2353         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_CONTRAST))
2354                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2355                                   V4L2_CID_CONTRAST,
2356                                   0, 0x1f, 1, CONTRAST_DEFAULT);
2357         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_BRIGHTNESS))
2358                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2359                                   V4L2_CID_BRIGHTNESS,
2360                                   -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
2361         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_SATURATION))
2362                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2363                                   V4L2_CID_SATURATION,
2364                                   0, 0x1f, 1, SATURATION_DEFAULT);
2365         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_BLUE_BALANCE))
2366                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2367                                   V4L2_CID_BLUE_BALANCE,
2368                                   -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
2369         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_RED_BALANCE))
2370                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2371                                   V4L2_CID_RED_BALANCE,
2372                                   -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
2373         if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_SHARPNESS))
2374                 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops,
2375                                   V4L2_CID_SHARPNESS,
2376                                   0, 0x0f, 1, SHARPNESS_DEFAULT);
2377
2378         /* Reset image controls */
2379         em28xx_colorlevels_set_default(dev);
2380         v4l2_ctrl_handler_setup(&dev->ctrl_handler);
2381         ret = dev->ctrl_handler.error;
2382         if (ret)
2383                 goto unregister_dev;
2384
2385         /* allocate and fill video video_device struct */
2386         dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
2387         if (!dev->vdev) {
2388                 em28xx_errdev("cannot allocate video_device.\n");
2389                 ret = -ENODEV;
2390                 goto unregister_dev;
2391         }
2392         dev->vdev->queue = &dev->vb_vidq;
2393         dev->vdev->queue->lock = &dev->vb_queue_lock;
2394
2395         /* disable inapplicable ioctls */
2396         if (dev->board.is_webcam) {
2397                 v4l2_disable_ioctl(dev->vdev, VIDIOC_QUERYSTD);
2398                 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_STD);
2399                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_STD);
2400         } else {
2401                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM);
2402         }
2403         if (dev->tuner_type == TUNER_ABSENT) {
2404                 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_TUNER);
2405                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_TUNER);
2406                 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_FREQUENCY);
2407                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_FREQUENCY);
2408         }
2409         if (!dev->audio_mode.has_audio) {
2410                 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_AUDIO);
2411                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_AUDIO);
2412         }
2413
2414         /* register v4l2 video video_device */
2415         ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
2416                                        video_nr[dev->devno]);
2417         if (ret) {
2418                 em28xx_errdev("unable to register video device (error=%i).\n",
2419                               ret);
2420                 goto unregister_dev;
2421         }
2422
2423         /* Allocate and fill vbi video_device struct */
2424         if (em28xx_vbi_supported(dev) == 1) {
2425                 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
2426                                                 "vbi");
2427
2428                 dev->vbi_dev->queue = &dev->vb_vbiq;
2429                 dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
2430
2431                 /* disable inapplicable ioctls */
2432                 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM);
2433                 if (dev->tuner_type == TUNER_ABSENT) {
2434                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_TUNER);
2435                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_TUNER);
2436                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_FREQUENCY);
2437                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_FREQUENCY);
2438                 }
2439                 if (!dev->audio_mode.has_audio) {
2440                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_AUDIO);
2441                         v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_AUDIO);
2442                 }
2443
2444                 /* register v4l2 vbi video_device */
2445                 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
2446                                             vbi_nr[dev->devno]);
2447                 if (ret < 0) {
2448                         em28xx_errdev("unable to register vbi device\n");
2449                         goto unregister_dev;
2450                 }
2451         }
2452
2453         if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2454                 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
2455                                                   "radio");
2456                 if (!dev->radio_dev) {
2457                         em28xx_errdev("cannot allocate video_device.\n");
2458                         ret = -ENODEV;
2459                         goto unregister_dev;
2460                 }
2461                 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
2462                                             radio_nr[dev->devno]);
2463                 if (ret < 0) {
2464                         em28xx_errdev("can't register radio device\n");
2465                         goto unregister_dev;
2466                 }
2467                 em28xx_info("Registered radio device as %s\n",
2468                             video_device_node_name(dev->radio_dev));
2469         }
2470
2471         em28xx_info("V4L2 video device registered as %s\n",
2472                     video_device_node_name(dev->vdev));
2473
2474         if (dev->vbi_dev)
2475                 em28xx_info("V4L2 VBI device registered as %s\n",
2476                             video_device_node_name(dev->vbi_dev));
2477
2478         /* Save some power by putting tuner to sleep */
2479         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
2480
2481         /* initialize videobuf2 stuff */
2482         em28xx_vb2_setup(dev);
2483
2484         em28xx_info("V4L2 extension successfully initialized\n");
2485
2486         mutex_unlock(&dev->lock);
2487         return 0;
2488
2489 unregister_dev:
2490         v4l2_ctrl_handler_free(&dev->ctrl_handler);
2491         v4l2_device_unregister(&dev->v4l2_dev);
2492 err:
2493         mutex_unlock(&dev->lock);
2494         return ret;
2495 }
2496
2497 static struct em28xx_ops v4l2_ops = {
2498         .id   = EM28XX_V4L2,
2499         .name = "Em28xx v4l2 Extension",
2500         .init = em28xx_v4l2_init,
2501         .fini = em28xx_v4l2_fini,
2502 };
2503
2504 static int __init em28xx_video_register(void)
2505 {
2506         return em28xx_register_extension(&v4l2_ops);
2507 }
2508
2509 static void __exit em28xx_video_unregister(void)
2510 {
2511         em28xx_unregister_extension(&v4l2_ops);
2512 }
2513
2514 module_init(em28xx_video_register);
2515 module_exit(em28xx_video_unregister);