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