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