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/drv-intf/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         buf->vb.vb2_buf.timestamp = ktime_get_ns();
 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,
 875                        unsigned int *nbuffers, unsigned int *nplanes,
 876                        unsigned int sizes[], void *alloc_ctxs[])
 877 {
 878         struct em28xx *dev = vb2_get_drv_priv(vq);
 879         struct em28xx_v4l2 *v4l2 = dev->v4l2;
 880         unsigned long size =
 881                     (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
 882
 883         if (*nplanes)
 884                 return sizes[0] < size ? -EINVAL : 0;
 885         *nplanes = 1;
 886         sizes[0] = size;
 887         return 0;
 888 }
 889
 890 static int
 891 buffer_prepare(struct vb2_buffer *vb)
 892 {
 893         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 894         struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
 895         struct em28xx_v4l2   *v4l2 = dev->v4l2;
 896         unsigned long size;
 897
 898         em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field);
 899
 900         size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3;
 901
 902         if (vb2_plane_size(vb, 0) < size) {
 903                 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
 904                                 __func__, vb2_plane_size(vb, 0), size);
 905                 return -EINVAL;
 906         }
 907         vb2_set_plane_payload(vb, 0, size);
 908
 909         return 0;
 910 }
 911
 912 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
 913 {
 914         struct em28xx *dev = vb2_get_drv_priv(vq);
 915         struct em28xx_v4l2 *v4l2 = dev->v4l2;
 916         struct v4l2_frequency f;
 917         struct v4l2_fh *owner;
 918         int rc = 0;
 919
 920         em28xx_videodbg("%s\n", __func__);
 921
 922         /* Make sure streaming is not already in progress for this type
 923            of filehandle (e.g. video, vbi) */
 924         rc = res_get(dev, vq->type);
 925         if (rc)
 926                 return rc;
 927
 928         if (v4l2->streaming_users == 0) {
 929                 /* First active streaming user, so allocate all the URBs */
 930
 931                 /* Allocate the USB bandwidth */
 932                 em28xx_set_alternate(dev);
 933
 934                 /* Needed, since GPIO might have disabled power of
 935                    some i2c device
 936                 */
 937                 em28xx_wake_i2c(dev);
 938
 939                 v4l2->capture_type = -1;
 940                 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
 941                                           dev->analog_xfer_bulk,
 942                                           EM28XX_NUM_BUFS,
 943                                           dev->max_pkt_size,
 944                                           dev->packet_multiplier,
 945                                           em28xx_urb_data_copy);
 946                 if (rc < 0)
 947                         return rc;
 948
 949                 /*
 950                  * djh: it's not clear whether this code is still needed.  I'm
 951                  * leaving it in here for now entirely out of concern for
 952                  * backward compatibility (the old code did it)
 953                  */
 954
 955                 /* Ask tuner to go to analog or radio mode */
 956                 memset(&f, 0, sizeof(f));
 957                 f.frequency = v4l2->frequency;
 958                 owner = (struct v4l2_fh *)vq->owner;
 959                 if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO)
 960                         f.type = V4L2_TUNER_RADIO;
 961                 else
 962                         f.type = V4L2_TUNER_ANALOG_TV;
 963                 v4l2_device_call_all(&v4l2->v4l2_dev,
 964                                      0, tuner, s_frequency, &f);
 965         }
 966
 967         v4l2->streaming_users++;
 968
 969         return rc;
 970 }
 971
 972 static void em28xx_stop_streaming(struct vb2_queue *vq)
 973 {
 974         struct em28xx *dev = vb2_get_drv_priv(vq);
 975         struct em28xx_v4l2 *v4l2 = dev->v4l2;
 976         struct em28xx_dmaqueue *vidq = &dev->vidq;
 977         unsigned long flags = 0;
 978
 979         em28xx_videodbg("%s\n", __func__);
 980
 981         res_free(dev, vq->type);
 982
 983         if (v4l2->streaming_users-- == 1) {
 984                 /* Last active user, so shutdown all the URBS */
 985                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
 986         }
 987
 988         spin_lock_irqsave(&dev->slock, flags);
 989         if (dev->usb_ctl.vid_buf != NULL) {
 990                 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf,
 991                                 VB2_BUF_STATE_ERROR);
 992                 dev->usb_ctl.vid_buf = NULL;
 993         }
 994         while (!list_empty(&vidq->active)) {
 995                 struct em28xx_buffer *buf;
 996
 997                 buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
 998                 list_del(&buf->list);
 999                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1000         }
1001         spin_unlock_irqrestore(&dev->slock, flags);
1002 }
1003
1004 void em28xx_stop_vbi_streaming(struct vb2_queue *vq)
1005 {
1006         struct em28xx *dev = vb2_get_drv_priv(vq);
1007         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1008         struct em28xx_dmaqueue *vbiq = &dev->vbiq;
1009         unsigned long flags = 0;
1010
1011         em28xx_videodbg("%s\n", __func__);
1012
1013         res_free(dev, vq->type);
1014
1015         if (v4l2->streaming_users-- == 1) {
1016                 /* Last active user, so shutdown all the URBS */
1017                 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1018         }
1019
1020         spin_lock_irqsave(&dev->slock, flags);
1021         if (dev->usb_ctl.vbi_buf != NULL) {
1022                 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf,
1023                                 VB2_BUF_STATE_ERROR);
1024                 dev->usb_ctl.vbi_buf = NULL;
1025         }
1026         while (!list_empty(&vbiq->active)) {
1027                 struct em28xx_buffer *buf;
1028
1029                 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
1030                 list_del(&buf->list);
1031                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1032         }
1033         spin_unlock_irqrestore(&dev->slock, flags);
1034 }
1035
1036 static void
1037 buffer_queue(struct vb2_buffer *vb)
1038 {
1039         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1040         struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
1041         struct em28xx_buffer *buf =
1042                 container_of(vbuf, struct em28xx_buffer, vb);
1043         struct em28xx_dmaqueue *vidq = &dev->vidq;
1044         unsigned long flags = 0;
1045
1046         em28xx_videodbg("%s\n", __func__);
1047         buf->mem = vb2_plane_vaddr(vb, 0);
1048         buf->length = vb2_plane_size(vb, 0);
1049
1050         spin_lock_irqsave(&dev->slock, flags);
1051         list_add_tail(&buf->list, &vidq->active);
1052         spin_unlock_irqrestore(&dev->slock, flags);
1053 }
1054
1055 static struct vb2_ops em28xx_video_qops = {
1056         .queue_setup    = queue_setup,
1057         .buf_prepare    = buffer_prepare,
1058         .buf_queue      = buffer_queue,
1059         .start_streaming = em28xx_start_analog_streaming,
1060         .stop_streaming = em28xx_stop_streaming,
1061         .wait_prepare   = vb2_ops_wait_prepare,
1062         .wait_finish    = vb2_ops_wait_finish,
1063 };
1064
1065 static int em28xx_vb2_setup(struct em28xx *dev)
1066 {
1067         int rc;
1068         struct vb2_queue *q;
1069         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1070
1071         /* Setup Videobuf2 for Video capture */
1072         q = &v4l2->vb_vidq;
1073         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1074         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
1075         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1076         q->drv_priv = dev;
1077         q->buf_struct_size = sizeof(struct em28xx_buffer);
1078         q->ops = &em28xx_video_qops;
1079         q->mem_ops = &vb2_vmalloc_memops;
1080
1081         rc = vb2_queue_init(q);
1082         if (rc < 0)
1083                 return rc;
1084
1085         /* Setup Videobuf2 for VBI capture */
1086         q = &v4l2->vb_vbiq;
1087         q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1088         q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
1089         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1090         q->drv_priv = dev;
1091         q->buf_struct_size = sizeof(struct em28xx_buffer);
1092         q->ops = &em28xx_vbi_qops;
1093         q->mem_ops = &vb2_vmalloc_memops;
1094
1095         rc = vb2_queue_init(q);
1096         if (rc < 0)
1097                 return rc;
1098
1099         return 0;
1100 }
1101
1102 /*********************  v4l2 interface  **************************************/
1103
1104 static void video_mux(struct em28xx *dev, int index)
1105 {
1106         struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev;
1107
1108         dev->ctl_input = index;
1109         dev->ctl_ainput = INPUT(index)->amux;
1110         dev->ctl_aoutput = INPUT(index)->aout;
1111
1112         if (!dev->ctl_aoutput)
1113                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1114
1115         v4l2_device_call_all(v4l2_dev, 0, video, s_routing,
1116                              INPUT(index)->vmux, 0, 0);
1117
1118         if (dev->board.has_msp34xx) {
1119                 if (dev->i2s_speed) {
1120                         v4l2_device_call_all(v4l2_dev, 0, audio,
1121                                              s_i2s_clock_freq, dev->i2s_speed);
1122                 }
1123                 /* Note: this is msp3400 specific */
1124                 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1125                                      dev->ctl_ainput,
1126                                      MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
1127         }
1128
1129         if (dev->board.adecoder != EM28XX_NOADECODER) {
1130                 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing,
1131                                      dev->ctl_ainput, dev->ctl_aoutput, 0);
1132         }
1133
1134         em28xx_audio_analog_set(dev);
1135 }
1136
1137 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
1138 {
1139         struct em28xx *dev = priv;
1140
1141         /*
1142          * In the case of non-AC97 volume controls, we still need
1143          * to do some setups at em28xx, in order to mute/unmute
1144          * and to adjust audio volume. However, the value ranges
1145          * should be checked by the corresponding V4L subdriver.
1146          */
1147         switch (ctrl->id) {
1148         case V4L2_CID_AUDIO_MUTE:
1149                 dev->mute = ctrl->val;
1150                 em28xx_audio_analog_set(dev);
1151                 break;
1152         case V4L2_CID_AUDIO_VOLUME:
1153                 dev->volume = ctrl->val;
1154                 em28xx_audio_analog_set(dev);
1155                 break;
1156         }
1157 }
1158
1159 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
1160 {
1161         struct em28xx_v4l2 *v4l2 =
1162                   container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler);
1163         struct em28xx *dev = v4l2->dev;
1164         int ret = -EINVAL;
1165
1166         switch (ctrl->id) {
1167         case V4L2_CID_AUDIO_MUTE:
1168                 dev->mute = ctrl->val;
1169                 ret = em28xx_audio_analog_set(dev);
1170                 break;
1171         case V4L2_CID_AUDIO_VOLUME:
1172                 dev->volume = ctrl->val;
1173                 ret = em28xx_audio_analog_set(dev);
1174                 break;
1175         case V4L2_CID_CONTRAST:
1176                 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val);
1177                 break;
1178         case V4L2_CID_BRIGHTNESS:
1179                 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val);
1180                 break;
1181         case V4L2_CID_SATURATION:
1182                 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val);
1183                 break;
1184         case V4L2_CID_BLUE_BALANCE:
1185                 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val);
1186                 break;
1187         case V4L2_CID_RED_BALANCE:
1188                 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val);
1189                 break;
1190         case V4L2_CID_SHARPNESS:
1191                 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val);
1192                 break;
1193         }
1194
1195         return (ret < 0) ? ret : 0;
1196 }
1197
1198 static const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
1199         .s_ctrl = em28xx_s_ctrl,
1200 };
1201
1202 static void size_to_scale(struct em28xx *dev,
1203                           unsigned int width, unsigned int height,
1204                         unsigned int *hscale, unsigned int *vscale)
1205 {
1206         unsigned int          maxw = norm_maxw(dev);
1207         unsigned int          maxh = norm_maxh(dev);
1208
1209         *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1210         if (*hscale > EM28XX_HVSCALE_MAX)
1211                 *hscale = EM28XX_HVSCALE_MAX;
1212
1213         *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1214         if (*vscale > EM28XX_HVSCALE_MAX)
1215                 *vscale = EM28XX_HVSCALE_MAX;
1216 }
1217
1218 static void scale_to_size(struct em28xx *dev,
1219                           unsigned int hscale, unsigned int vscale,
1220                           unsigned int *width, unsigned int *height)
1221 {
1222         unsigned int          maxw = norm_maxw(dev);
1223         unsigned int          maxh = norm_maxh(dev);
1224
1225         *width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1226         *height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1227 }
1228
1229 /* ------------------------------------------------------------------
1230         IOCTL vidioc handling
1231    ------------------------------------------------------------------*/
1232
1233 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1234                                 struct v4l2_format *f)
1235 {
1236         struct em28xx         *dev = video_drvdata(file);
1237         struct em28xx_v4l2    *v4l2 = dev->v4l2;
1238
1239         f->fmt.pix.width = v4l2->width;
1240         f->fmt.pix.height = v4l2->height;
1241         f->fmt.pix.pixelformat = v4l2->format->fourcc;
1242         f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3;
1243         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height;
1244         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1245
1246         /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1247         if (v4l2->progressive)
1248                 f->fmt.pix.field = V4L2_FIELD_NONE;
1249         else
1250                 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1251                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1252         return 0;
1253 }
1254
1255 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1256 {
1257         unsigned int i;
1258
1259         for (i = 0; i < ARRAY_SIZE(format); i++)
1260                 if (format[i].fourcc == fourcc)
1261                         return &format[i];
1262
1263         return NULL;
1264 }
1265
1266 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1267                                   struct v4l2_format *f)
1268 {
1269         struct em28xx         *dev   = video_drvdata(file);
1270         struct em28xx_v4l2    *v4l2  = dev->v4l2;
1271         unsigned int          width  = f->fmt.pix.width;
1272         unsigned int          height = f->fmt.pix.height;
1273         unsigned int          maxw   = norm_maxw(dev);
1274         unsigned int          maxh   = norm_maxh(dev);
1275         unsigned int          hscale, vscale;
1276         struct em28xx_fmt     *fmt;
1277
1278         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1279         if (!fmt) {
1280                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1281                                 f->fmt.pix.pixelformat);
1282                 return -EINVAL;
1283         }
1284
1285         if (dev->board.is_em2800) {
1286                 /* the em2800 can only scale down to 50% */
1287                 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1288                 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1289                 /*
1290                  * MaxPacketSize for em2800 is too small to capture at full
1291                  * resolution use half of maxw as the scaler can only scale
1292                  * to 50%
1293                  */
1294                 if (width == maxw && height == maxh)
1295                         width /= 2;
1296         } else {
1297                 /* width must even because of the YUYV format
1298                    height must be even because of interlacing */
1299                 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1300                                       1, 0);
1301         }
1302
1303         size_to_scale(dev, width, height, &hscale, &vscale);
1304         scale_to_size(dev, hscale, vscale, &width, &height);
1305
1306         f->fmt.pix.width = width;
1307         f->fmt.pix.height = height;
1308         f->fmt.pix.pixelformat = fmt->fourcc;
1309         f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
1310         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1311         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1312         if (v4l2->progressive)
1313                 f->fmt.pix.field = V4L2_FIELD_NONE;
1314         else
1315                 f->fmt.pix.field = v4l2->interlaced_fieldmode ?
1316                            V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1317         f->fmt.pix.priv = 0;
1318
1319         return 0;
1320 }
1321
1322 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1323                                    unsigned width, unsigned height)
1324 {
1325         struct em28xx_fmt     *fmt;
1326         struct em28xx_v4l2    *v4l2 = dev->v4l2;
1327
1328         fmt = format_by_fourcc(fourcc);
1329         if (!fmt)
1330                 return -EINVAL;
1331
1332         v4l2->format = fmt;
1333         v4l2->width  = width;
1334         v4l2->height = height;
1335
1336         /* set new image size */
1337         size_to_scale(dev, v4l2->width, v4l2->height,
1338                       &v4l2->hscale, &v4l2->vscale);
1339
1340         em28xx_resolution_set(dev);
1341
1342         return 0;
1343 }
1344
1345 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1346                                 struct v4l2_format *f)
1347 {
1348         struct em28xx *dev = video_drvdata(file);
1349         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1350
1351         if (vb2_is_busy(&v4l2->vb_vidq))
1352                 return -EBUSY;
1353
1354         vidioc_try_fmt_vid_cap(file, priv, f);
1355
1356         return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1357                                 f->fmt.pix.width, f->fmt.pix.height);
1358 }
1359
1360 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1361 {
1362         struct em28xx *dev = video_drvdata(file);
1363
1364         *norm = dev->v4l2->norm;
1365
1366         return 0;
1367 }
1368
1369 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
1370 {
1371         struct em28xx *dev = video_drvdata(file);
1372
1373         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm);
1374
1375         return 0;
1376 }
1377
1378 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1379 {
1380         struct em28xx      *dev  = video_drvdata(file);
1381         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1382         struct v4l2_format f;
1383
1384         if (norm == v4l2->norm)
1385                 return 0;
1386
1387         if (v4l2->streaming_users > 0)
1388                 return -EBUSY;
1389
1390         v4l2->norm = norm;
1391
1392         /* Adjusts width/height, if needed */
1393         f.fmt.pix.width = 720;
1394         f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576;
1395         vidioc_try_fmt_vid_cap(file, priv, &f);
1396
1397         /* set new image size */
1398         v4l2->width = f.fmt.pix.width;
1399         v4l2->height = f.fmt.pix.height;
1400         size_to_scale(dev, v4l2->width, v4l2->height,
1401                       &v4l2->hscale, &v4l2->vscale);
1402
1403         em28xx_resolution_set(dev);
1404         v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
1405
1406         return 0;
1407 }
1408
1409 static int vidioc_g_parm(struct file *file, void *priv,
1410                          struct v4l2_streamparm *p)
1411 {
1412         struct em28xx      *dev  = video_drvdata(file);
1413         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1414         int rc = 0;
1415
1416         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1417         if (dev->board.is_webcam)
1418                 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0,
1419                                                 video, g_parm, p);
1420         else
1421                 v4l2_video_std_frame_period(v4l2->norm,
1422                                             &p->parm.capture.timeperframe);
1423
1424         return rc;
1425 }
1426
1427 static int vidioc_s_parm(struct file *file, void *priv,
1428                          struct v4l2_streamparm *p)
1429 {
1430         struct em28xx *dev = video_drvdata(file);
1431
1432         p->parm.capture.readbuffers = EM28XX_MIN_BUF;
1433         return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev,
1434                                           0, video, s_parm, p);
1435 }
1436
1437 static const char *iname[] = {
1438         [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1439         [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1440         [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1441         [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1442         [EM28XX_VMUX_SVIDEO]     = "S-Video",
1443         [EM28XX_VMUX_TELEVISION] = "Television",
1444         [EM28XX_VMUX_CABLE]      = "Cable TV",
1445         [EM28XX_VMUX_DVB]        = "DVB",
1446         [EM28XX_VMUX_DEBUG]      = "for debug only",
1447 };
1448
1449 static int vidioc_enum_input(struct file *file, void *priv,
1450                              struct v4l2_input *i)
1451 {
1452         struct em28xx *dev = video_drvdata(file);
1453         unsigned int       n;
1454
1455         n = i->index;
1456         if (n >= MAX_EM28XX_INPUT)
1457                 return -EINVAL;
1458         if (0 == INPUT(n)->type)
1459                 return -EINVAL;
1460
1461         i->index = n;
1462         i->type = V4L2_INPUT_TYPE_CAMERA;
1463
1464         strcpy(i->name, iname[INPUT(n)->type]);
1465
1466         if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1467             (EM28XX_VMUX_CABLE == INPUT(n)->type))
1468                 i->type = V4L2_INPUT_TYPE_TUNER;
1469
1470         i->std = dev->v4l2->vdev.tvnorms;
1471         /* webcams do not have the STD API */
1472         if (dev->board.is_webcam)
1473                 i->capabilities = 0;
1474
1475         return 0;
1476 }
1477
1478 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1479 {
1480         struct em28xx *dev = video_drvdata(file);
1481
1482         *i = dev->ctl_input;
1483
1484         return 0;
1485 }
1486
1487 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1488 {
1489         struct em28xx *dev = video_drvdata(file);
1490
1491         if (i >= MAX_EM28XX_INPUT)
1492                 return -EINVAL;
1493         if (0 == INPUT(i)->type)
1494                 return -EINVAL;
1495
1496         video_mux(dev, i);
1497         return 0;
1498 }
1499
1500 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1501 {
1502         struct em28xx *dev = video_drvdata(file);
1503
1504         switch (a->index) {
1505         case EM28XX_AMUX_VIDEO:
1506                 strcpy(a->name, "Television");
1507                 break;
1508         case EM28XX_AMUX_LINE_IN:
1509                 strcpy(a->name, "Line In");
1510                 break;
1511         case EM28XX_AMUX_VIDEO2:
1512                 strcpy(a->name, "Television alt");
1513                 break;
1514         case EM28XX_AMUX_PHONE:
1515                 strcpy(a->name, "Phone");
1516                 break;
1517         case EM28XX_AMUX_MIC:
1518                 strcpy(a->name, "Mic");
1519                 break;
1520         case EM28XX_AMUX_CD:
1521                 strcpy(a->name, "CD");
1522                 break;
1523         case EM28XX_AMUX_AUX:
1524                 strcpy(a->name, "Aux");
1525                 break;
1526         case EM28XX_AMUX_PCM_OUT:
1527                 strcpy(a->name, "PCM");
1528                 break;
1529         default:
1530                 return -EINVAL;
1531         }
1532
1533         a->index = dev->ctl_ainput;
1534         a->capability = V4L2_AUDCAP_STEREO;
1535
1536         return 0;
1537 }
1538
1539 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
1540 {
1541         struct em28xx *dev = video_drvdata(file);
1542
1543         if (a->index >= MAX_EM28XX_INPUT)
1544                 return -EINVAL;
1545         if (0 == INPUT(a->index)->type)
1546                 return -EINVAL;
1547
1548         dev->ctl_ainput = INPUT(a->index)->amux;
1549         dev->ctl_aoutput = INPUT(a->index)->aout;
1550
1551         if (!dev->ctl_aoutput)
1552                 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1553
1554         return 0;
1555 }
1556
1557 static int vidioc_g_tuner(struct file *file, void *priv,
1558                           struct v4l2_tuner *t)
1559 {
1560         struct em28xx *dev = video_drvdata(file);
1561
1562         if (0 != t->index)
1563                 return -EINVAL;
1564
1565         strcpy(t->name, "Tuner");
1566
1567         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1568         return 0;
1569 }
1570
1571 static int vidioc_s_tuner(struct file *file, void *priv,
1572                           const struct v4l2_tuner *t)
1573 {
1574         struct em28xx *dev = video_drvdata(file);
1575
1576         if (0 != t->index)
1577                 return -EINVAL;
1578
1579         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1580         return 0;
1581 }
1582
1583 static int vidioc_g_frequency(struct file *file, void *priv,
1584                               struct v4l2_frequency *f)
1585 {
1586         struct em28xx         *dev = video_drvdata(file);
1587         struct em28xx_v4l2    *v4l2 = dev->v4l2;
1588
1589         if (0 != f->tuner)
1590                 return -EINVAL;
1591
1592         f->frequency = v4l2->frequency;
1593         return 0;
1594 }
1595
1596 static int vidioc_s_frequency(struct file *file, void *priv,
1597                               const struct v4l2_frequency *f)
1598 {
1599         struct v4l2_frequency  new_freq = *f;
1600         struct em28xx             *dev  = video_drvdata(file);
1601         struct em28xx_v4l2        *v4l2 = dev->v4l2;
1602
1603         if (0 != f->tuner)
1604                 return -EINVAL;
1605
1606         v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f);
1607         v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1608         v4l2->frequency = new_freq.frequency;
1609
1610         return 0;
1611 }
1612
1613 #ifdef CONFIG_VIDEO_ADV_DEBUG
1614 static int vidioc_g_chip_info(struct file *file, void *priv,
1615                               struct v4l2_dbg_chip_info *chip)
1616 {
1617         struct em28xx *dev = video_drvdata(file);
1618
1619         if (chip->match.addr > 1)
1620                 return -EINVAL;
1621         if (chip->match.addr == 1)
1622                 strlcpy(chip->name, "ac97", sizeof(chip->name));
1623         else
1624                 strlcpy(chip->name,
1625                         dev->v4l2->v4l2_dev.name, sizeof(chip->name));
1626         return 0;
1627 }
1628
1629 static int em28xx_reg_len(int reg)
1630 {
1631         switch (reg) {
1632         case EM28XX_R40_AC97LSB:
1633         case EM28XX_R30_HSCALELOW:
1634         case EM28XX_R32_VSCALELOW:
1635                 return 2;
1636         default:
1637                 return 1;
1638         }
1639 }
1640
1641 static int vidioc_g_register(struct file *file, void *priv,
1642                              struct v4l2_dbg_register *reg)
1643 {
1644         struct em28xx *dev = video_drvdata(file);
1645         int ret;
1646
1647         if (reg->match.addr > 1)
1648                 return -EINVAL;
1649         if (reg->match.addr) {
1650                 ret = em28xx_read_ac97(dev, reg->reg);
1651                 if (ret < 0)
1652                         return ret;
1653
1654                 reg->val = ret;
1655                 reg->size = 1;
1656                 return 0;
1657         }
1658
1659         /* Match host */
1660         reg->size = em28xx_reg_len(reg->reg);
1661         if (reg->size == 1) {
1662                 ret = em28xx_read_reg(dev, reg->reg);
1663
1664                 if (ret < 0)
1665                         return ret;
1666
1667                 reg->val = ret;
1668         } else {
1669                 __le16 val = 0;
1670
1671                 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1672                                                    reg->reg, (char *)&val, 2);
1673                 if (ret < 0)
1674                         return ret;
1675
1676                 reg->val = le16_to_cpu(val);
1677         }
1678
1679         return 0;
1680 }
1681
1682 static int vidioc_s_register(struct file *file, void *priv,
1683                              const struct v4l2_dbg_register *reg)
1684 {
1685         struct em28xx *dev = video_drvdata(file);
1686         __le16 buf;
1687
1688         if (reg->match.addr > 1)
1689                 return -EINVAL;
1690         if (reg->match.addr)
1691                 return em28xx_write_ac97(dev, reg->reg, reg->val);
1692
1693         /* Match host */
1694         buf = cpu_to_le16(reg->val);
1695
1696         return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1697                                em28xx_reg_len(reg->reg));
1698 }
1699 #endif
1700
1701 static int vidioc_querycap(struct file *file, void  *priv,
1702                            struct v4l2_capability *cap)
1703 {
1704         struct video_device   *vdev = video_devdata(file);
1705         struct em28xx         *dev  = video_drvdata(file);
1706         struct em28xx_v4l2    *v4l2 = dev->v4l2;
1707
1708         strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1709         strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1710         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1711
1712         if (vdev->vfl_type == VFL_TYPE_GRABBER)
1713                 cap->device_caps = V4L2_CAP_READWRITE |
1714                         V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1715         else if (vdev->vfl_type == VFL_TYPE_RADIO)
1716                 cap->device_caps = V4L2_CAP_RADIO;
1717         else
1718                 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
1719
1720         if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE)
1721                 cap->device_caps |= V4L2_CAP_AUDIO;
1722
1723         if (dev->tuner_type != TUNER_ABSENT)
1724                 cap->device_caps |= V4L2_CAP_TUNER;
1725
1726         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
1727                 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1728         if (video_is_registered(&v4l2->vbi_dev))
1729                 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1730         if (video_is_registered(&v4l2->radio_dev))
1731                 cap->capabilities |= V4L2_CAP_RADIO;
1732         return 0;
1733 }
1734
1735 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1736                                    struct v4l2_fmtdesc *f)
1737 {
1738         if (unlikely(f->index >= ARRAY_SIZE(format)))
1739                 return -EINVAL;
1740
1741         strlcpy(f->description, format[f->index].name, sizeof(f->description));
1742         f->pixelformat = format[f->index].fourcc;
1743
1744         return 0;
1745 }
1746
1747 static int vidioc_enum_framesizes(struct file *file, void *priv,
1748                                   struct v4l2_frmsizeenum *fsize)
1749 {
1750         struct em28xx         *dev = video_drvdata(file);
1751         struct em28xx_fmt     *fmt;
1752         unsigned int          maxw = norm_maxw(dev);
1753         unsigned int          maxh = norm_maxh(dev);
1754
1755         fmt = format_by_fourcc(fsize->pixel_format);
1756         if (!fmt) {
1757                 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1758                                 fsize->pixel_format);
1759                 return -EINVAL;
1760         }
1761
1762         if (dev->board.is_em2800) {
1763                 if (fsize->index > 1)
1764                         return -EINVAL;
1765                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1766                 fsize->discrete.width = maxw / (1 + fsize->index);
1767                 fsize->discrete.height = maxh / (1 + fsize->index);
1768                 return 0;
1769         }
1770
1771         if (fsize->index != 0)
1772                 return -EINVAL;
1773
1774         /* Report a continuous range */
1775         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1776         scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX,
1777                       &fsize->stepwise.min_width, &fsize->stepwise.min_height);
1778         if (fsize->stepwise.min_width < 48)
1779                 fsize->stepwise.min_width = 48;
1780         if (fsize->stepwise.min_height < 38)
1781                 fsize->stepwise.min_height = 38;
1782         fsize->stepwise.max_width = maxw;
1783         fsize->stepwise.max_height = maxh;
1784         fsize->stepwise.step_width = 1;
1785         fsize->stepwise.step_height = 1;
1786         return 0;
1787 }
1788
1789 /* RAW VBI ioctls */
1790
1791 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1792                                 struct v4l2_format *format)
1793 {
1794         struct em28xx         *dev  = video_drvdata(file);
1795         struct em28xx_v4l2    *v4l2 = dev->v4l2;
1796
1797         format->fmt.vbi.samples_per_line = v4l2->vbi_width;
1798         format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1799         format->fmt.vbi.offset = 0;
1800         format->fmt.vbi.flags = 0;
1801         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1802         format->fmt.vbi.count[0] = v4l2->vbi_height;
1803         format->fmt.vbi.count[1] = v4l2->vbi_height;
1804         memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
1805
1806         /* Varies by video standard (NTSC, PAL, etc.) */
1807         if (v4l2->norm & V4L2_STD_525_60) {
1808                 /* NTSC */
1809                 format->fmt.vbi.start[0] = 10;
1810                 format->fmt.vbi.start[1] = 273;
1811         } else if (v4l2->norm & V4L2_STD_625_50) {
1812                 /* PAL */
1813                 format->fmt.vbi.start[0] = 6;
1814                 format->fmt.vbi.start[1] = 318;
1815         }
1816
1817         return 0;
1818 }
1819
1820 /* ----------------------------------------------------------- */
1821 /* RADIO ESPECIFIC IOCTLS                                      */
1822 /* ----------------------------------------------------------- */
1823
1824 static int radio_g_tuner(struct file *file, void *priv,
1825                          struct v4l2_tuner *t)
1826 {
1827         struct em28xx *dev = video_drvdata(file);
1828
1829         if (unlikely(t->index > 0))
1830                 return -EINVAL;
1831
1832         strcpy(t->name, "Radio");
1833
1834         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t);
1835
1836         return 0;
1837 }
1838
1839 static int radio_s_tuner(struct file *file, void *priv,
1840                          const struct v4l2_tuner *t)
1841 {
1842         struct em28xx *dev = video_drvdata(file);
1843
1844         if (0 != t->index)
1845                 return -EINVAL;
1846
1847         v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t);
1848
1849         return 0;
1850 }
1851
1852 /*
1853  * em28xx_free_v4l2() - Free struct em28xx_v4l2
1854  *
1855  * @ref: struct kref for struct em28xx_v4l2
1856  *
1857  * Called when all users of struct em28xx_v4l2 are gone
1858  */
1859 static void em28xx_free_v4l2(struct kref *ref)
1860 {
1861         struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref);
1862
1863         v4l2->dev->v4l2 = NULL;
1864         kfree(v4l2);
1865 }
1866
1867 /*
1868  * em28xx_v4l2_open()
1869  * inits the device and starts isoc transfer
1870  */
1871 static int em28xx_v4l2_open(struct file *filp)
1872 {
1873         struct video_device *vdev = video_devdata(filp);
1874         struct em28xx *dev = video_drvdata(filp);
1875         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1876         enum v4l2_buf_type fh_type = 0;
1877         int ret;
1878
1879         switch (vdev->vfl_type) {
1880         case VFL_TYPE_GRABBER:
1881                 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1882                 break;
1883         case VFL_TYPE_VBI:
1884                 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1885                 break;
1886         case VFL_TYPE_RADIO:
1887                 break;
1888         default:
1889                 return -EINVAL;
1890         }
1891
1892         em28xx_videodbg("open dev=%s type=%s users=%d\n",
1893                         video_device_node_name(vdev), v4l2_type_names[fh_type],
1894                         v4l2->users);
1895
1896         if (mutex_lock_interruptible(&dev->lock))
1897                 return -ERESTARTSYS;
1898
1899         ret = v4l2_fh_open(filp);
1900         if (ret) {
1901                 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n",
1902                               __func__, ret);
1903                 mutex_unlock(&dev->lock);
1904                 return ret;
1905         }
1906
1907         if (v4l2->users == 0) {
1908                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
1909
1910                 if (vdev->vfl_type != VFL_TYPE_RADIO)
1911                         em28xx_resolution_set(dev);
1912
1913                 /*
1914                  * Needed, since GPIO might have disabled power
1915                  * of some i2c devices
1916                  */
1917                 em28xx_wake_i2c(dev);
1918         }
1919
1920         if (vdev->vfl_type == VFL_TYPE_RADIO) {
1921                 em28xx_videodbg("video_open: setting radio device\n");
1922                 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio);
1923         }
1924
1925         kref_get(&dev->ref);
1926         kref_get(&v4l2->ref);
1927         v4l2->users++;
1928
1929         mutex_unlock(&dev->lock);
1930
1931         return 0;
1932 }
1933
1934 /*
1935  * em28xx_v4l2_fini()
1936  * unregisters the v4l2,i2c and usb devices
1937  * called when the device gets disconected or at module unload
1938 */
1939 static int em28xx_v4l2_fini(struct em28xx *dev)
1940 {
1941         struct em28xx_v4l2 *v4l2 = dev->v4l2;
1942
1943         if (dev->is_audio_only) {
1944                 /* Shouldn't initialize IR for this interface */
1945                 return 0;
1946         }
1947
1948         if (!dev->has_video) {
1949                 /* This device does not support the v4l2 extension */
1950                 return 0;
1951         }
1952
1953         if (v4l2 == NULL)
1954                 return 0;
1955
1956         em28xx_info("Closing video extension\n");
1957
1958         mutex_lock(&dev->lock);
1959
1960         v4l2_device_disconnect(&v4l2->v4l2_dev);
1961
1962         em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
1963
1964         if (video_is_registered(&v4l2->radio_dev)) {
1965                 em28xx_info("V4L2 device %s deregistered\n",
1966                             video_device_node_name(&v4l2->radio_dev));
1967                 video_unregister_device(&v4l2->radio_dev);
1968         }
1969         if (video_is_registered(&v4l2->vbi_dev)) {
1970                 em28xx_info("V4L2 device %s deregistered\n",
1971                             video_device_node_name(&v4l2->vbi_dev));
1972                 video_unregister_device(&v4l2->vbi_dev);
1973         }
1974         if (video_is_registered(&v4l2->vdev)) {
1975                 em28xx_info("V4L2 device %s deregistered\n",
1976                             video_device_node_name(&v4l2->vdev));
1977                 video_unregister_device(&v4l2->vdev);
1978         }
1979
1980         v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
1981         v4l2_device_unregister(&v4l2->v4l2_dev);
1982
1983         if (v4l2->clk) {
1984                 v4l2_clk_unregister_fixed(v4l2->clk);
1985                 v4l2->clk = NULL;
1986         }
1987
1988         kref_put(&v4l2->ref, em28xx_free_v4l2);
1989
1990         mutex_unlock(&dev->lock);
1991
1992         kref_put(&dev->ref, em28xx_free_device);
1993
1994         return 0;
1995 }
1996
1997 static int em28xx_v4l2_suspend(struct em28xx *dev)
1998 {
1999         if (dev->is_audio_only)
2000                 return 0;
2001
2002         if (!dev->has_video)
2003                 return 0;
2004
2005         em28xx_info("Suspending video extension\n");
2006         em28xx_stop_urbs(dev);
2007         return 0;
2008 }
2009
2010 static int em28xx_v4l2_resume(struct em28xx *dev)
2011 {
2012         if (dev->is_audio_only)
2013                 return 0;
2014
2015         if (!dev->has_video)
2016                 return 0;
2017
2018         em28xx_info("Resuming video extension\n");
2019         /* what do we do here */
2020         return 0;
2021 }
2022
2023 /*
2024  * em28xx_v4l2_close()
2025  * stops streaming and deallocates all resources allocated by the v4l2
2026  * calls and ioctls
2027  */
2028 static int em28xx_v4l2_close(struct file *filp)
2029 {
2030         struct em28xx         *dev  = video_drvdata(filp);
2031         struct em28xx_v4l2    *v4l2 = dev->v4l2;
2032         int              errCode;
2033
2034         em28xx_videodbg("users=%d\n", v4l2->users);
2035
2036         vb2_fop_release(filp);
2037         mutex_lock(&dev->lock);
2038
2039         if (v4l2->users == 1) {
2040                 /* No sense to try to write to the device */
2041                 if (dev->disconnected)
2042                         goto exit;
2043
2044                 /* Save some power by putting tuner to sleep */
2045                 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2046
2047                 /* do this before setting alternate! */
2048                 em28xx_set_mode(dev, EM28XX_SUSPEND);
2049
2050                 /* set alternate 0 */
2051                 dev->alt = 0;
2052                 em28xx_videodbg("setting alternate 0\n");
2053                 errCode = usb_set_interface(dev->udev, 0, 0);
2054                 if (errCode < 0) {
2055                         em28xx_errdev("cannot change alternate number to "
2056                                         "0 (error=%i)\n", errCode);
2057                 }
2058         }
2059
2060 exit:
2061         v4l2->users--;
2062         kref_put(&v4l2->ref, em28xx_free_v4l2);
2063         mutex_unlock(&dev->lock);
2064         kref_put(&dev->ref, em28xx_free_device);
2065
2066         return 0;
2067 }
2068
2069 static const struct v4l2_file_operations em28xx_v4l_fops = {
2070         .owner         = THIS_MODULE,
2071         .open          = em28xx_v4l2_open,
2072         .release       = em28xx_v4l2_close,
2073         .read          = vb2_fop_read,
2074         .poll          = vb2_fop_poll,
2075         .mmap          = vb2_fop_mmap,
2076         .unlocked_ioctl = video_ioctl2,
2077 };
2078
2079 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2080         .vidioc_querycap            = vidioc_querycap,
2081         .vidioc_enum_fmt_vid_cap    = vidioc_enum_fmt_vid_cap,
2082         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
2083         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
2084         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
2085         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2086         .vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
2087         .vidioc_s_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
2088         .vidioc_enum_framesizes     = vidioc_enum_framesizes,
2089         .vidioc_g_audio             = vidioc_g_audio,
2090         .vidioc_s_audio             = vidioc_s_audio,
2091
2092         .vidioc_reqbufs             = vb2_ioctl_reqbufs,
2093         .vidioc_create_bufs         = vb2_ioctl_create_bufs,
2094         .vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
2095         .vidioc_querybuf            = vb2_ioctl_querybuf,
2096         .vidioc_qbuf                = vb2_ioctl_qbuf,
2097         .vidioc_dqbuf               = vb2_ioctl_dqbuf,
2098
2099         .vidioc_g_std               = vidioc_g_std,
2100         .vidioc_querystd            = vidioc_querystd,
2101         .vidioc_s_std               = vidioc_s_std,
2102         .vidioc_g_parm              = vidioc_g_parm,
2103         .vidioc_s_parm              = vidioc_s_parm,
2104         .vidioc_enum_input          = vidioc_enum_input,
2105         .vidioc_g_input             = vidioc_g_input,
2106         .vidioc_s_input             = vidioc_s_input,
2107         .vidioc_streamon            = vb2_ioctl_streamon,
2108         .vidioc_streamoff           = vb2_ioctl_streamoff,
2109         .vidioc_g_tuner             = vidioc_g_tuner,
2110         .vidioc_s_tuner             = vidioc_s_tuner,
2111         .vidioc_g_frequency         = vidioc_g_frequency,
2112         .vidioc_s_frequency         = vidioc_s_frequency,
2113         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2114         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2115 #ifdef CONFIG_VIDEO_ADV_DEBUG
2116         .vidioc_g_chip_info         = vidioc_g_chip_info,
2117         .vidioc_g_register          = vidioc_g_register,
2118         .vidioc_s_register          = vidioc_s_register,
2119 #endif
2120 };
2121
2122 static const struct video_device em28xx_video_template = {
2123         .fops           = &em28xx_v4l_fops,
2124         .ioctl_ops      = &video_ioctl_ops,
2125         .release        = video_device_release_empty,
2126         .tvnorms        = V4L2_STD_ALL,
2127 };
2128
2129 static const struct v4l2_file_operations radio_fops = {
2130         .owner         = THIS_MODULE,
2131         .open          = em28xx_v4l2_open,
2132         .release       = em28xx_v4l2_close,
2133         .unlocked_ioctl = video_ioctl2,
2134 };
2135
2136 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2137         .vidioc_querycap      = vidioc_querycap,
2138         .vidioc_g_tuner       = radio_g_tuner,
2139         .vidioc_s_tuner       = radio_s_tuner,
2140         .vidioc_g_frequency   = vidioc_g_frequency,
2141         .vidioc_s_frequency   = vidioc_s_frequency,
2142         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2143         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2144 #ifdef CONFIG_VIDEO_ADV_DEBUG
2145         .vidioc_g_chip_info   = vidioc_g_chip_info,
2146         .vidioc_g_register    = vidioc_g_register,
2147         .vidioc_s_register    = vidioc_s_register,
2148 #endif
2149 };
2150
2151 static struct video_device em28xx_radio_template = {
2152         .fops           = &radio_fops,
2153         .ioctl_ops      = &radio_ioctl_ops,
2154         .release        = video_device_release_empty,
2155 };
2156
2157 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
2158 static unsigned short saa711x_addrs[] = {
2159         0x4a >> 1, 0x48 >> 1,   /* SAA7111, SAA7111A and SAA7113 */
2160         0x42 >> 1, 0x40 >> 1,   /* SAA7114, SAA7115 and SAA7118 */
2161         I2C_CLIENT_END };
2162
2163 static unsigned short tvp5150_addrs[] = {
2164         0xb8 >> 1,
2165         0xba >> 1,
2166         I2C_CLIENT_END
2167 };
2168
2169 static unsigned short msp3400_addrs[] = {
2170         0x80 >> 1,
2171         0x88 >> 1,
2172         I2C_CLIENT_END
2173 };
2174
2175 /******************************** usb interface ******************************/
2176
2177 static void em28xx_vdev_init(struct em28xx *dev,
2178                              struct video_device *vfd,
2179                              const struct video_device *template,
2180                              const char *type_name)
2181 {
2182         *vfd            = *template;
2183         vfd->v4l2_dev   = &dev->v4l2->v4l2_dev;
2184         vfd->lock       = &dev->lock;
2185         if (dev->board.is_webcam)
2186                 vfd->tvnorms = 0;
2187
2188         snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2189                  dev->name, type_name);
2190
2191         video_set_drvdata(vfd, dev);
2192 }
2193
2194 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr)
2195 {
2196         struct em28xx_v4l2      *v4l2 = dev->v4l2;
2197         struct v4l2_device      *v4l2_dev = &v4l2->v4l2_dev;
2198         struct tuner_setup      tun_setup;
2199         struct v4l2_frequency   f;
2200
2201         memset(&tun_setup, 0, sizeof(tun_setup));
2202
2203         tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2204         tun_setup.tuner_callback = em28xx_tuner_callback;
2205
2206         if (dev->board.radio.type) {
2207                 tun_setup.type = dev->board.radio.type;
2208                 tun_setup.addr = dev->board.radio_addr;
2209
2210                 v4l2_device_call_all(v4l2_dev,
2211                                      0, tuner, s_type_addr, &tun_setup);
2212         }
2213
2214         if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2215                 tun_setup.type   = dev->tuner_type;
2216                 tun_setup.addr   = tuner_addr;
2217
2218                 v4l2_device_call_all(v4l2_dev,
2219                                      0, tuner, s_type_addr, &tun_setup);
2220         }
2221
2222         if (dev->board.tda9887_conf) {
2223                 struct v4l2_priv_tun_config tda9887_cfg;
2224
2225                 tda9887_cfg.tuner = TUNER_TDA9887;
2226                 tda9887_cfg.priv = &dev->board.tda9887_conf;
2227
2228                 v4l2_device_call_all(v4l2_dev,
2229                                      0, tuner, s_config, &tda9887_cfg);
2230         }
2231
2232         if (dev->tuner_type == TUNER_XC2028) {
2233                 struct v4l2_priv_tun_config  xc2028_cfg;
2234                 struct xc2028_ctrl           ctl;
2235
2236                 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2237                 memset(&ctl, 0, sizeof(ctl));
2238
2239                 em28xx_setup_xc3028(dev, &ctl);
2240
2241                 xc2028_cfg.tuner = TUNER_XC2028;
2242                 xc2028_cfg.priv  = &ctl;
2243
2244                 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2245         }
2246
2247         /* configure tuner */
2248         f.tuner = 0;
2249         f.type = V4L2_TUNER_ANALOG_TV;
2250         f.frequency = 9076;     /* just a magic number */
2251         v4l2->frequency = f.frequency;
2252         v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f);
2253 }
2254
2255 static int em28xx_v4l2_init(struct em28xx *dev)
2256 {
2257         u8 val;
2258         int ret;
2259         unsigned int maxw;
2260         struct v4l2_ctrl_handler *hdl;
2261         struct em28xx_v4l2 *v4l2;
2262
2263         if (dev->is_audio_only) {
2264                 /* Shouldn't initialize IR for this interface */
2265                 return 0;
2266         }
2267
2268         if (!dev->has_video) {
2269                 /* This device does not support the v4l2 extension */
2270                 return 0;
2271         }
2272
2273         em28xx_info("Registering V4L2 extension\n");
2274
2275         mutex_lock(&dev->lock);
2276
2277         v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL);
2278         if (v4l2 == NULL) {
2279                 em28xx_info("em28xx_v4l: memory allocation failed\n");
2280                 mutex_unlock(&dev->lock);
2281                 return -ENOMEM;
2282         }
2283         kref_init(&v4l2->ref);
2284         v4l2->dev = dev;
2285         dev->v4l2 = v4l2;
2286
2287         ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev);
2288         if (ret < 0) {
2289                 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2290                 goto err;
2291         }
2292
2293         hdl = &v4l2->ctrl_handler;
2294         v4l2_ctrl_handler_init(hdl, 8);
2295         v4l2->v4l2_dev.ctrl_handler = hdl;
2296
2297         if (dev->board.is_webcam)
2298                 v4l2->progressive = true;
2299
2300         /*
2301          * Default format, used for tvp5150 or saa711x output formats
2302          */
2303         v4l2->vinmode = 0x10;
2304         v4l2->vinctl  = EM28XX_VINCTRL_INTERLACED |
2305                         EM28XX_VINCTRL_CCIR656_ENABLE;
2306
2307         /* request some modules */
2308
2309         if (dev->board.has_msp34xx)
2310                 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2311                                     &dev->i2c_adap[dev->def_i2c_bus],
2312                                     "msp3400", 0, msp3400_addrs);
2313
2314         if (dev->board.decoder == EM28XX_SAA711X)
2315                 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2316                                     &dev->i2c_adap[dev->def_i2c_bus],
2317                                     "saa7115_auto", 0, saa711x_addrs);
2318
2319         if (dev->board.decoder == EM28XX_TVP5150)
2320                 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2321                                     &dev->i2c_adap[dev->def_i2c_bus],
2322                                     "tvp5150", 0, tvp5150_addrs);
2323
2324         if (dev->board.adecoder == EM28XX_TVAUDIO)
2325                 v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2326                                     &dev->i2c_adap[dev->def_i2c_bus],
2327                                     "tvaudio", dev->board.tvaudio_addr, NULL);
2328
2329         /* Initialize tuner and camera */
2330
2331         if (dev->board.tuner_type != TUNER_ABSENT) {
2332                 unsigned short tuner_addr = dev->board.tuner_addr;
2333                 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT);
2334
2335                 if (dev->board.radio.type)
2336                         v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2337                                             &dev->i2c_adap[dev->def_i2c_bus],
2338                                             "tuner", dev->board.radio_addr,
2339                                             NULL);
2340
2341                 if (has_demod)
2342                         v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2343                                             &dev->i2c_adap[dev->def_i2c_bus],
2344                                             "tuner", 0,
2345                                             v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2346                 if (tuner_addr == 0) {
2347                         enum v4l2_i2c_tuner_type type =
2348                                 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2349                         struct v4l2_subdev *sd;
2350
2351                         sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2352                                                  &dev->i2c_adap[dev->def_i2c_bus],
2353                                                  "tuner", 0,
2354                                                  v4l2_i2c_tuner_addrs(type));
2355
2356                         if (sd)
2357                                 tuner_addr = v4l2_i2c_subdev_addr(sd);
2358                 } else {
2359                         v4l2_i2c_new_subdev(&v4l2->v4l2_dev,
2360                                             &dev->i2c_adap[dev->def_i2c_bus],
2361                                             "tuner", tuner_addr, NULL);
2362                 }
2363
2364                 em28xx_tuner_setup(dev, tuner_addr);
2365         }
2366
2367         if (dev->em28xx_sensor != EM28XX_NOSENSOR)
2368                 em28xx_init_camera(dev);
2369
2370         /* Configure audio */
2371         ret = em28xx_audio_setup(dev);
2372         if (ret < 0) {
2373                 em28xx_errdev("%s: Error while setting audio - error [%d]!\n",
2374                               __func__, ret);
2375                 goto unregister_dev;
2376         }
2377         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
2378                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2379                                   V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2380                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2381                                   V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
2382         } else {
2383                 /* install the em28xx notify callback */
2384                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
2385                                  em28xx_ctrl_notify, dev);
2386                 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
2387                                  em28xx_ctrl_notify, dev);
2388         }
2389
2390         /* wake i2c devices */
2391         em28xx_wake_i2c(dev);
2392
2393         /* init video dma queues */
2394         INIT_LIST_HEAD(&dev->vidq.active);
2395         INIT_LIST_HEAD(&dev->vbiq.active);
2396
2397         if (dev->board.has_msp34xx) {
2398                 /* Send a reset to other chips via gpio */
2399                 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7);
2400                 if (ret < 0) {
2401                         em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n",
2402                                       __func__, ret);
2403                         goto unregister_dev;
2404                 }
2405                 msleep(3);
2406
2407                 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff);
2408                 if (ret < 0) {
2409                         em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n",
2410                                       __func__, ret);
2411                         goto unregister_dev;
2412                 }
2413                 msleep(3);
2414         }
2415
2416         /* set default norm */
2417         v4l2->norm = V4L2_STD_PAL;
2418         v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
2419         v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
2420
2421         /* Analog specific initialization */
2422         v4l2->format = &format[0];
2423
2424         maxw = norm_maxw(dev);
2425         /* MaxPacketSize for em2800 is too small to capture at full resolution
2426          * use half of maxw as the scaler can only scale to 50% */
2427         if (dev->board.is_em2800)
2428                 maxw /= 2;
2429
2430         em28xx_set_video_format(dev, format[0].fourcc,
2431                                 maxw, norm_maxh(dev));
2432
2433         video_mux(dev, 0);
2434
2435         /* Audio defaults */
2436         dev->mute = 1;
2437         dev->volume = 0x1f;
2438
2439 /*      em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
2440         val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2441         em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2442                          (EM28XX_XCLK_AUDIO_UNMUTE | val));
2443
2444         em28xx_set_outfmt(dev);
2445
2446         /* Add image controls */
2447         /* NOTE: at this point, the subdevices are already registered, so bridge
2448          * controls are only added/enabled when no subdevice provides them */
2449         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST))
2450                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2451                                   V4L2_CID_CONTRAST,
2452                                   0, 0x1f, 1, CONTRAST_DEFAULT);
2453         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS))
2454                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2455                                   V4L2_CID_BRIGHTNESS,
2456                                   -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT);
2457         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION))
2458                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2459                                   V4L2_CID_SATURATION,
2460                                   0, 0x1f, 1, SATURATION_DEFAULT);
2461         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE))
2462                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2463                                   V4L2_CID_BLUE_BALANCE,
2464                                   -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT);
2465         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE))
2466                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2467                                   V4L2_CID_RED_BALANCE,
2468                                   -0x30, 0x30, 1, RED_BALANCE_DEFAULT);
2469         if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS))
2470                 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
2471                                   V4L2_CID_SHARPNESS,
2472                                   0, 0x0f, 1, SHARPNESS_DEFAULT);
2473
2474         /* Reset image controls */
2475         em28xx_colorlevels_set_default(dev);
2476         v4l2_ctrl_handler_setup(hdl);
2477         ret = hdl->error;
2478         if (ret)
2479                 goto unregister_dev;
2480
2481         /* allocate and fill video video_device struct */
2482         em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video");
2483         mutex_init(&v4l2->vb_queue_lock);
2484         mutex_init(&v4l2->vb_vbi_queue_lock);
2485         v4l2->vdev.queue = &v4l2->vb_vidq;
2486         v4l2->vdev.queue->lock = &v4l2->vb_queue_lock;
2487
2488         /* disable inapplicable ioctls */
2489         if (dev->board.is_webcam) {
2490                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD);
2491                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD);
2492                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD);
2493         } else {
2494                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM);
2495         }
2496         if (dev->tuner_type == TUNER_ABSENT) {
2497                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER);
2498                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER);
2499                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY);
2500                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY);
2501         }
2502         if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2503                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO);
2504                 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO);
2505         }
2506
2507         /* register v4l2 video video_device */
2508         ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER,
2509                                     video_nr[dev->devno]);
2510         if (ret) {
2511                 em28xx_errdev("unable to register video device (error=%i).\n",
2512                               ret);
2513                 goto unregister_dev;
2514         }
2515
2516         /* Allocate and fill vbi video_device struct */
2517         if (em28xx_vbi_supported(dev) == 1) {
2518                 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template,
2519                                 "vbi");
2520
2521                 v4l2->vbi_dev.queue = &v4l2->vb_vbiq;
2522                 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock;
2523
2524                 /* disable inapplicable ioctls */
2525                 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM);
2526                 if (dev->tuner_type == TUNER_ABSENT) {
2527                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER);
2528                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER);
2529                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY);
2530                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY);
2531                 }
2532                 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) {
2533                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO);
2534                         v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO);
2535                 }
2536
2537                 /* register v4l2 vbi video_device */
2538                 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI,
2539                                             vbi_nr[dev->devno]);
2540                 if (ret < 0) {
2541                         em28xx_errdev("unable to register vbi device\n");
2542                         goto unregister_dev;
2543                 }
2544         }
2545
2546         if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2547                 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template,
2548                                    "radio");
2549                 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO,
2550                                             radio_nr[dev->devno]);
2551                 if (ret < 0) {
2552                         em28xx_errdev("can't register radio device\n");
2553                         goto unregister_dev;
2554                 }
2555                 em28xx_info("Registered radio device as %s\n",
2556                             video_device_node_name(&v4l2->radio_dev));
2557         }
2558
2559         em28xx_info("V4L2 video device registered as %s\n",
2560                     video_device_node_name(&v4l2->vdev));
2561
2562         if (video_is_registered(&v4l2->vbi_dev))
2563                 em28xx_info("V4L2 VBI device registered as %s\n",
2564                             video_device_node_name(&v4l2->vbi_dev));
2565
2566         /* Save some power by putting tuner to sleep */
2567         v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0);
2568
2569         /* initialize videobuf2 stuff */
2570         em28xx_vb2_setup(dev);
2571
2572         em28xx_info("V4L2 extension successfully initialized\n");
2573
2574         kref_get(&dev->ref);
2575
2576         mutex_unlock(&dev->lock);
2577         return 0;
2578
2579 unregister_dev:
2580         v4l2_ctrl_handler_free(&v4l2->ctrl_handler);
2581         v4l2_device_unregister(&v4l2->v4l2_dev);
2582 err:
2583         dev->v4l2 = NULL;
2584         kref_put(&v4l2->ref, em28xx_free_v4l2);
2585         mutex_unlock(&dev->lock);
2586         return ret;
2587 }
2588
2589 static struct em28xx_ops v4l2_ops = {
2590         .id   = EM28XX_V4L2,
2591         .name = "Em28xx v4l2 Extension",
2592         .init = em28xx_v4l2_init,
2593         .fini = em28xx_v4l2_fini,
2594         .suspend = em28xx_v4l2_suspend,
2595         .resume = em28xx_v4l2_resume,
2596 };
2597
2598 static int __init em28xx_video_register(void)
2599 {
2600         return em28xx_register_extension(&v4l2_ops);
2601 }
2602
2603 static void __exit em28xx_video_unregister(void)
2604 {
2605         em28xx_unregister_extension(&v4l2_ops);
2606 }
2607
2608 module_init(em28xx_video_register);
2609 module_exit(em28xx_video_unregister);