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