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