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