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

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