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

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