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