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