1 /* 2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB 3 video capture devices 4 5 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it> 6 Markus Rechberger <mrechberger@gmail.com> 7 Mauro Carvalho Chehab <mchehab@infradead.org> 8 Sascha Sommer <saschasommer@freenet.de> 9 Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com> 10 11 Some parts based on SN9C10x PC Camera Controllers GPL driver made 12 by Luca Risolia <luca.risolia@studio.unibo.it> 13 14 This program is free software; you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation; either version 2 of the License, or 17 (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, 20 but WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 GNU General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 27 */ 28 29 #include <linux/init.h> 30 #include <linux/list.h> 31 #include <linux/module.h> 32 #include <linux/kernel.h> 33 #include <linux/bitmap.h> 34 #include <linux/usb.h> 35 #include <linux/i2c.h> 36 #include <linux/mm.h> 37 #include <linux/mutex.h> 38 #include <linux/slab.h> 39 40 #include "em28xx.h" 41 #include "em28xx-v4l.h" 42 #include <media/v4l2-common.h> 43 #include <media/v4l2-ioctl.h> 44 #include <media/v4l2-event.h> 45 #include <media/v4l2-clk.h> 46 #include <media/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 printk(KERN_INFO "%s %s :"fmt, \ 69 dev->name, __func__ , ##arg); } while (0) 70 71 #define em28xx_isocdbg(fmt, arg...) \ 72 do {\ 73 if (isoc_debug) { \ 74 printk(KERN_INFO "%s %s :"fmt, \ 75 dev->name, __func__ , ##arg); \ 76 } \ 77 } while (0) 78 79 MODULE_AUTHOR(DRIVER_AUTHOR); 80 MODULE_DESCRIPTION(DRIVER_DESC " - v4l2 interface"); 81 MODULE_LICENSE("GPL"); 82 MODULE_VERSION(EM28XX_VERSION); 83 84 #define EM25XX_FRMDATAHDR_BYTE1 0x02 85 #define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE 0x20 86 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_END 0x02 87 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID 0x01 88 #define EM25XX_FRMDATAHDR_BYTE2_MASK (EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \ 89 EM25XX_FRMDATAHDR_BYTE2_FRAME_END | \ 90 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID) 91 92 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 93 static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 94 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 95 96 module_param_array(video_nr, int, NULL, 0444); 97 module_param_array(vbi_nr, int, NULL, 0444); 98 module_param_array(radio_nr, int, NULL, 0444); 99 MODULE_PARM_DESC(video_nr, "video device numbers"); 100 MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 101 MODULE_PARM_DESC(radio_nr, "radio device numbers"); 102 103 static unsigned int video_debug; 104 module_param(video_debug, int, 0644); 105 MODULE_PARM_DESC(video_debug, "enable debug messages [video]"); 106 107 /* supported video standards */ 108 static struct em28xx_fmt format[] = { 109 { 110 .name = "16 bpp YUY2, 4:2:2, packed", 111 .fourcc = V4L2_PIX_FMT_YUYV, 112 .depth = 16, 113 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V, 114 }, { 115 .name = "16 bpp RGB 565, LE", 116 .fourcc = V4L2_PIX_FMT_RGB565, 117 .depth = 16, 118 .reg = EM28XX_OUTFMT_RGB_16_656, 119 }, { 120 .name = "8 bpp Bayer BGBG..GRGR", 121 .fourcc = V4L2_PIX_FMT_SBGGR8, 122 .depth = 8, 123 .reg = EM28XX_OUTFMT_RGB_8_BGBG, 124 }, { 125 .name = "8 bpp Bayer GRGR..BGBG", 126 .fourcc = V4L2_PIX_FMT_SGRBG8, 127 .depth = 8, 128 .reg = EM28XX_OUTFMT_RGB_8_GRGR, 129 }, { 130 .name = "8 bpp Bayer GBGB..RGRG", 131 .fourcc = V4L2_PIX_FMT_SGBRG8, 132 .depth = 8, 133 .reg = EM28XX_OUTFMT_RGB_8_GBGB, 134 }, { 135 .name = "12 bpp YUV411", 136 .fourcc = V4L2_PIX_FMT_YUV411P, 137 .depth = 12, 138 .reg = EM28XX_OUTFMT_YUV411, 139 }, 140 }; 141 142 /*FIXME: maxw should be dependent of alt mode */ 143 static inline unsigned int norm_maxw(struct em28xx *dev) 144 { 145 struct em28xx_v4l2 *v4l2 = dev->v4l2; 146 147 if (dev->board.is_webcam) 148 return v4l2->sensor_xres; 149 150 if (dev->board.max_range_640_480) 151 return 640; 152 153 return 720; 154 } 155 156 static inline unsigned int norm_maxh(struct em28xx *dev) 157 { 158 struct em28xx_v4l2 *v4l2 = dev->v4l2; 159 160 if (dev->board.is_webcam) 161 return v4l2->sensor_yres; 162 163 if (dev->board.max_range_640_480) 164 return 480; 165 166 return (v4l2->norm & V4L2_STD_625_50) ? 576 : 480; 167 } 168 169 static int em28xx_vbi_supported(struct em28xx *dev) 170 { 171 /* Modprobe option to manually disable */ 172 if (disable_vbi == 1) 173 return 0; 174 175 if (dev->board.is_webcam) 176 return 0; 177 178 /* FIXME: check subdevices for VBI support */ 179 180 if (dev->chip_id == CHIP_ID_EM2860 || 181 dev->chip_id == CHIP_ID_EM2883) 182 return 1; 183 184 /* Version of em28xx that does not support VBI */ 185 return 0; 186 } 187 188 /* 189 * em28xx_wake_i2c() 190 * configure i2c attached devices 191 */ 192 static void em28xx_wake_i2c(struct em28xx *dev) 193 { 194 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev; 195 196 v4l2_device_call_all(v4l2_dev, 0, core, reset, 0); 197 v4l2_device_call_all(v4l2_dev, 0, video, s_routing, 198 INPUT(dev->ctl_input)->vmux, 0, 0); 199 } 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 em28xx_errdev("cannot change alternate number to %d (error=%i)\n", 417 dev->alt, errCode); 418 return errCode; 419 } 420 return 0; 421 } 422 423 /* ------------------------------------------------------------------ 424 DMA and thread functions 425 ------------------------------------------------------------------*/ 426 427 /* 428 * Finish the current buffer 429 */ 430 static inline void finish_buffer(struct em28xx *dev, 431 struct em28xx_buffer *buf) 432 { 433 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field); 434 435 buf->vb.sequence = dev->v4l2->field_count++; 436 if (dev->v4l2->progressive) 437 buf->vb.field = V4L2_FIELD_NONE; 438 else 439 buf->vb.field = V4L2_FIELD_INTERLACED; 440 buf->vb.vb2_buf.timestamp = ktime_get_ns(); 441 442 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE); 443 } 444 445 /* 446 * Copy picture data from USB buffer to videobuf buffer 447 */ 448 static void em28xx_copy_video(struct em28xx *dev, 449 struct em28xx_buffer *buf, 450 unsigned char *usb_buf, 451 unsigned long len) 452 { 453 struct em28xx_v4l2 *v4l2 = dev->v4l2; 454 void *fieldstart, *startwrite, *startread; 455 int linesdone, currlinedone, offset, lencopy, remain; 456 int bytesperline = v4l2->width << 1; 457 458 if (buf->pos + len > buf->length) 459 len = buf->length - buf->pos; 460 461 startread = usb_buf; 462 remain = len; 463 464 if (v4l2->progressive || buf->top_field) 465 fieldstart = buf->vb_buf; 466 else /* interlaced mode, even nr. of lines */ 467 fieldstart = buf->vb_buf + bytesperline; 468 469 linesdone = buf->pos / bytesperline; 470 currlinedone = buf->pos % bytesperline; 471 472 if (v4l2->progressive) 473 offset = linesdone * bytesperline + currlinedone; 474 else 475 offset = linesdone * bytesperline * 2 + currlinedone; 476 477 startwrite = fieldstart + offset; 478 lencopy = bytesperline - currlinedone; 479 lencopy = lencopy > remain ? remain : lencopy; 480 481 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) { 482 em28xx_isocdbg("Overflow of %zu bytes past buffer end (1)\n", 483 ((char *)startwrite + lencopy) - 484 ((char *)buf->vb_buf + buf->length)); 485 remain = (char *)buf->vb_buf + buf->length - 486 (char *)startwrite; 487 lencopy = remain; 488 } 489 if (lencopy <= 0) 490 return; 491 memcpy(startwrite, startread, lencopy); 492 493 remain -= lencopy; 494 495 while (remain > 0) { 496 if (v4l2->progressive) 497 startwrite += lencopy; 498 else 499 startwrite += lencopy + bytesperline; 500 startread += lencopy; 501 if (bytesperline > remain) 502 lencopy = remain; 503 else 504 lencopy = bytesperline; 505 506 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + 507 buf->length) { 508 em28xx_isocdbg("Overflow of %zu bytes past buffer end" 509 "(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 pr_err("Couldn't change link %s->%s to %s. Error %d\n", 930 source->name, sink->name, 931 flags ? "enabled" : "disabled", 932 ret); 933 return ret; 934 } else 935 em28xx_videodbg("link %s->%s was %s\n", 936 source->name, sink->name, 937 flags ? "ENABLED" : "disabled"); 938 } 939 #endif 940 return 0; 941 } 942 943 static const char * const iname[] = { 944 [EM28XX_VMUX_COMPOSITE] = "Composite", 945 [EM28XX_VMUX_SVIDEO] = "S-Video", 946 [EM28XX_VMUX_TELEVISION] = "Television", 947 [EM28XX_RADIO] = "Radio", 948 }; 949 950 static void em28xx_v4l2_create_entities(struct em28xx *dev) 951 { 952 #if defined(CONFIG_MEDIA_CONTROLLER) 953 struct em28xx_v4l2 *v4l2 = dev->v4l2; 954 int ret, i; 955 956 /* Initialize Video, VBI and Radio pads */ 957 v4l2->video_pad.flags = MEDIA_PAD_FL_SINK; 958 ret = media_entity_pads_init(&v4l2->vdev.entity, 1, &v4l2->video_pad); 959 if (ret < 0) 960 pr_err("failed to initialize video media entity!\n"); 961 962 if (em28xx_vbi_supported(dev)) { 963 v4l2->vbi_pad.flags = MEDIA_PAD_FL_SINK; 964 ret = media_entity_pads_init(&v4l2->vbi_dev.entity, 1, 965 &v4l2->vbi_pad); 966 if (ret < 0) 967 pr_err("failed to initialize vbi media entity!\n"); 968 } 969 970 /* Webcams don't have input connectors */ 971 if (dev->board.is_webcam) 972 return; 973 974 /* Create entities for each input connector */ 975 for (i = 0; i < MAX_EM28XX_INPUT; i++) { 976 struct media_entity *ent = &dev->input_ent[i]; 977 978 if (!INPUT(i)->type) 979 break; 980 981 ent->name = iname[INPUT(i)->type]; 982 ent->flags = MEDIA_ENT_FL_CONNECTOR; 983 dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE; 984 985 switch (INPUT(i)->type) { 986 case EM28XX_VMUX_COMPOSITE: 987 ent->function = MEDIA_ENT_F_CONN_COMPOSITE; 988 break; 989 case EM28XX_VMUX_SVIDEO: 990 ent->function = MEDIA_ENT_F_CONN_SVIDEO; 991 break; 992 default: /* EM28XX_VMUX_TELEVISION or EM28XX_RADIO */ 993 if (dev->tuner_type != TUNER_ABSENT) 994 ent->function = MEDIA_ENT_F_CONN_RF; 995 break; 996 } 997 998 ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]); 999 if (ret < 0) 1000 pr_err("failed to initialize input pad[%d]!\n", i); 1001 1002 ret = media_device_register_entity(dev->media_dev, ent); 1003 if (ret < 0) 1004 pr_err("failed to register input entity %d!\n", i); 1005 } 1006 #endif 1007 } 1008 1009 1010 /* ------------------------------------------------------------------ 1011 Videobuf2 operations 1012 ------------------------------------------------------------------*/ 1013 1014 static int queue_setup(struct vb2_queue *vq, 1015 unsigned int *nbuffers, unsigned int *nplanes, 1016 unsigned int sizes[], void *alloc_ctxs[]) 1017 { 1018 struct em28xx *dev = vb2_get_drv_priv(vq); 1019 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1020 unsigned long size = 1021 (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3; 1022 1023 if (*nplanes) 1024 return sizes[0] < size ? -EINVAL : 0; 1025 *nplanes = 1; 1026 sizes[0] = size; 1027 1028 em28xx_enable_analog_tuner(dev); 1029 1030 return 0; 1031 } 1032 1033 static int 1034 buffer_prepare(struct vb2_buffer *vb) 1035 { 1036 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1037 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 1038 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1039 unsigned long size; 1040 1041 em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field); 1042 1043 size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3; 1044 1045 if (vb2_plane_size(vb, 0) < size) { 1046 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n", 1047 __func__, vb2_plane_size(vb, 0), size); 1048 return -EINVAL; 1049 } 1050 vb2_set_plane_payload(vb, 0, size); 1051 1052 return 0; 1053 } 1054 1055 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count) 1056 { 1057 struct em28xx *dev = vb2_get_drv_priv(vq); 1058 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1059 struct v4l2_frequency f; 1060 struct v4l2_fh *owner; 1061 int rc = 0; 1062 1063 em28xx_videodbg("%s\n", __func__); 1064 1065 /* Make sure streaming is not already in progress for this type 1066 of filehandle (e.g. video, vbi) */ 1067 rc = res_get(dev, vq->type); 1068 if (rc) 1069 return rc; 1070 1071 if (v4l2->streaming_users == 0) { 1072 /* First active streaming user, so allocate all the URBs */ 1073 1074 /* Allocate the USB bandwidth */ 1075 em28xx_set_alternate(dev); 1076 1077 /* Needed, since GPIO might have disabled power of 1078 some i2c device 1079 */ 1080 em28xx_wake_i2c(dev); 1081 1082 v4l2->capture_type = -1; 1083 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE, 1084 dev->analog_xfer_bulk, 1085 EM28XX_NUM_BUFS, 1086 dev->max_pkt_size, 1087 dev->packet_multiplier, 1088 em28xx_urb_data_copy); 1089 if (rc < 0) 1090 return rc; 1091 1092 /* 1093 * djh: it's not clear whether this code is still needed. I'm 1094 * leaving it in here for now entirely out of concern for 1095 * backward compatibility (the old code did it) 1096 */ 1097 1098 /* Ask tuner to go to analog or radio mode */ 1099 memset(&f, 0, sizeof(f)); 1100 f.frequency = v4l2->frequency; 1101 owner = (struct v4l2_fh *)vq->owner; 1102 if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO) 1103 f.type = V4L2_TUNER_RADIO; 1104 else 1105 f.type = V4L2_TUNER_ANALOG_TV; 1106 v4l2_device_call_all(&v4l2->v4l2_dev, 1107 0, tuner, s_frequency, &f); 1108 1109 /* Enable video stream at TV decoder */ 1110 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1); 1111 } 1112 1113 v4l2->streaming_users++; 1114 1115 return rc; 1116 } 1117 1118 static void em28xx_stop_streaming(struct vb2_queue *vq) 1119 { 1120 struct em28xx *dev = vb2_get_drv_priv(vq); 1121 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1122 struct em28xx_dmaqueue *vidq = &dev->vidq; 1123 unsigned long flags = 0; 1124 1125 em28xx_videodbg("%s\n", __func__); 1126 1127 res_free(dev, vq->type); 1128 1129 if (v4l2->streaming_users-- == 1) { 1130 /* Disable video stream at TV decoder */ 1131 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0); 1132 1133 /* Last active user, so shutdown all the URBS */ 1134 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1135 } 1136 1137 spin_lock_irqsave(&dev->slock, flags); 1138 if (dev->usb_ctl.vid_buf != NULL) { 1139 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf, 1140 VB2_BUF_STATE_ERROR); 1141 dev->usb_ctl.vid_buf = NULL; 1142 } 1143 while (!list_empty(&vidq->active)) { 1144 struct em28xx_buffer *buf; 1145 1146 buf = list_entry(vidq->active.next, struct em28xx_buffer, list); 1147 list_del(&buf->list); 1148 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 1149 } 1150 spin_unlock_irqrestore(&dev->slock, flags); 1151 } 1152 1153 void em28xx_stop_vbi_streaming(struct vb2_queue *vq) 1154 { 1155 struct em28xx *dev = vb2_get_drv_priv(vq); 1156 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1157 struct em28xx_dmaqueue *vbiq = &dev->vbiq; 1158 unsigned long flags = 0; 1159 1160 em28xx_videodbg("%s\n", __func__); 1161 1162 res_free(dev, vq->type); 1163 1164 if (v4l2->streaming_users-- == 1) { 1165 /* Disable video stream at TV decoder */ 1166 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0); 1167 1168 /* Last active user, so shutdown all the URBS */ 1169 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1170 } 1171 1172 spin_lock_irqsave(&dev->slock, flags); 1173 if (dev->usb_ctl.vbi_buf != NULL) { 1174 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf, 1175 VB2_BUF_STATE_ERROR); 1176 dev->usb_ctl.vbi_buf = NULL; 1177 } 1178 while (!list_empty(&vbiq->active)) { 1179 struct em28xx_buffer *buf; 1180 1181 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list); 1182 list_del(&buf->list); 1183 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 1184 } 1185 spin_unlock_irqrestore(&dev->slock, flags); 1186 } 1187 1188 static void 1189 buffer_queue(struct vb2_buffer *vb) 1190 { 1191 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1192 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 1193 struct em28xx_buffer *buf = 1194 container_of(vbuf, struct em28xx_buffer, vb); 1195 struct em28xx_dmaqueue *vidq = &dev->vidq; 1196 unsigned long flags = 0; 1197 1198 em28xx_videodbg("%s\n", __func__); 1199 buf->mem = vb2_plane_vaddr(vb, 0); 1200 buf->length = vb2_plane_size(vb, 0); 1201 1202 spin_lock_irqsave(&dev->slock, flags); 1203 list_add_tail(&buf->list, &vidq->active); 1204 spin_unlock_irqrestore(&dev->slock, flags); 1205 } 1206 1207 static struct vb2_ops em28xx_video_qops = { 1208 .queue_setup = queue_setup, 1209 .buf_prepare = buffer_prepare, 1210 .buf_queue = buffer_queue, 1211 .start_streaming = em28xx_start_analog_streaming, 1212 .stop_streaming = em28xx_stop_streaming, 1213 .wait_prepare = vb2_ops_wait_prepare, 1214 .wait_finish = vb2_ops_wait_finish, 1215 }; 1216 1217 static int em28xx_vb2_setup(struct em28xx *dev) 1218 { 1219 int rc; 1220 struct vb2_queue *q; 1221 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1222 1223 /* Setup Videobuf2 for Video capture */ 1224 q = &v4l2->vb_vidq; 1225 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1226 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1227 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1228 q->drv_priv = dev; 1229 q->buf_struct_size = sizeof(struct em28xx_buffer); 1230 q->ops = &em28xx_video_qops; 1231 q->mem_ops = &vb2_vmalloc_memops; 1232 1233 rc = vb2_queue_init(q); 1234 if (rc < 0) 1235 return rc; 1236 1237 /* Setup Videobuf2 for VBI capture */ 1238 q = &v4l2->vb_vbiq; 1239 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 1240 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR; 1241 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1242 q->drv_priv = dev; 1243 q->buf_struct_size = sizeof(struct em28xx_buffer); 1244 q->ops = &em28xx_vbi_qops; 1245 q->mem_ops = &vb2_vmalloc_memops; 1246 1247 rc = vb2_queue_init(q); 1248 if (rc < 0) 1249 return rc; 1250 1251 return 0; 1252 } 1253 1254 /********************* v4l2 interface **************************************/ 1255 1256 static void video_mux(struct em28xx *dev, int index) 1257 { 1258 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev; 1259 1260 dev->ctl_input = index; 1261 dev->ctl_ainput = INPUT(index)->amux; 1262 dev->ctl_aoutput = INPUT(index)->aout; 1263 1264 if (!dev->ctl_aoutput) 1265 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1266 1267 v4l2_device_call_all(v4l2_dev, 0, video, s_routing, 1268 INPUT(index)->vmux, 0, 0); 1269 1270 if (dev->board.has_msp34xx) { 1271 if (dev->i2s_speed) { 1272 v4l2_device_call_all(v4l2_dev, 0, audio, 1273 s_i2s_clock_freq, dev->i2s_speed); 1274 } 1275 /* Note: this is msp3400 specific */ 1276 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing, 1277 dev->ctl_ainput, 1278 MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0); 1279 } 1280 1281 if (dev->board.adecoder != EM28XX_NOADECODER) { 1282 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing, 1283 dev->ctl_ainput, dev->ctl_aoutput, 0); 1284 } 1285 1286 em28xx_audio_analog_set(dev); 1287 } 1288 1289 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv) 1290 { 1291 struct em28xx *dev = priv; 1292 1293 /* 1294 * In the case of non-AC97 volume controls, we still need 1295 * to do some setups at em28xx, in order to mute/unmute 1296 * and to adjust audio volume. However, the value ranges 1297 * should be checked by the corresponding V4L subdriver. 1298 */ 1299 switch (ctrl->id) { 1300 case V4L2_CID_AUDIO_MUTE: 1301 dev->mute = ctrl->val; 1302 em28xx_audio_analog_set(dev); 1303 break; 1304 case V4L2_CID_AUDIO_VOLUME: 1305 dev->volume = ctrl->val; 1306 em28xx_audio_analog_set(dev); 1307 break; 1308 } 1309 } 1310 1311 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl) 1312 { 1313 struct em28xx_v4l2 *v4l2 = 1314 container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler); 1315 struct em28xx *dev = v4l2->dev; 1316 int ret = -EINVAL; 1317 1318 switch (ctrl->id) { 1319 case V4L2_CID_AUDIO_MUTE: 1320 dev->mute = ctrl->val; 1321 ret = em28xx_audio_analog_set(dev); 1322 break; 1323 case V4L2_CID_AUDIO_VOLUME: 1324 dev->volume = ctrl->val; 1325 ret = em28xx_audio_analog_set(dev); 1326 break; 1327 case V4L2_CID_CONTRAST: 1328 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val); 1329 break; 1330 case V4L2_CID_BRIGHTNESS: 1331 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val); 1332 break; 1333 case V4L2_CID_SATURATION: 1334 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val); 1335 break; 1336 case V4L2_CID_BLUE_BALANCE: 1337 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val); 1338 break; 1339 case V4L2_CID_RED_BALANCE: 1340 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val); 1341 break; 1342 case V4L2_CID_SHARPNESS: 1343 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val); 1344 break; 1345 } 1346 1347 return (ret < 0) ? ret : 0; 1348 } 1349 1350 static const struct v4l2_ctrl_ops em28xx_ctrl_ops = { 1351 .s_ctrl = em28xx_s_ctrl, 1352 }; 1353 1354 static void size_to_scale(struct em28xx *dev, 1355 unsigned int width, unsigned int height, 1356 unsigned int *hscale, unsigned int *vscale) 1357 { 1358 unsigned int maxw = norm_maxw(dev); 1359 unsigned int maxh = norm_maxh(dev); 1360 1361 *hscale = (((unsigned long)maxw) << 12) / width - 4096L; 1362 if (*hscale > EM28XX_HVSCALE_MAX) 1363 *hscale = EM28XX_HVSCALE_MAX; 1364 1365 *vscale = (((unsigned long)maxh) << 12) / height - 4096L; 1366 if (*vscale > EM28XX_HVSCALE_MAX) 1367 *vscale = EM28XX_HVSCALE_MAX; 1368 } 1369 1370 static void scale_to_size(struct em28xx *dev, 1371 unsigned int hscale, unsigned int vscale, 1372 unsigned int *width, unsigned int *height) 1373 { 1374 unsigned int maxw = norm_maxw(dev); 1375 unsigned int maxh = norm_maxh(dev); 1376 1377 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 1378 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 1379 1380 /* Don't let width or height to be zero */ 1381 if (*width < 1) 1382 *width = 1; 1383 if (*height < 1) 1384 *height = 1; 1385 } 1386 1387 /* ------------------------------------------------------------------ 1388 IOCTL vidioc handling 1389 ------------------------------------------------------------------*/ 1390 1391 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 1392 struct v4l2_format *f) 1393 { 1394 struct em28xx *dev = video_drvdata(file); 1395 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1396 1397 f->fmt.pix.width = v4l2->width; 1398 f->fmt.pix.height = v4l2->height; 1399 f->fmt.pix.pixelformat = v4l2->format->fourcc; 1400 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3; 1401 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height; 1402 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1403 1404 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */ 1405 if (v4l2->progressive) 1406 f->fmt.pix.field = V4L2_FIELD_NONE; 1407 else 1408 f->fmt.pix.field = v4l2->interlaced_fieldmode ? 1409 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1410 return 0; 1411 } 1412 1413 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc) 1414 { 1415 unsigned int i; 1416 1417 for (i = 0; i < ARRAY_SIZE(format); i++) 1418 if (format[i].fourcc == fourcc) 1419 return &format[i]; 1420 1421 return NULL; 1422 } 1423 1424 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 1425 struct v4l2_format *f) 1426 { 1427 struct em28xx *dev = video_drvdata(file); 1428 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1429 unsigned int width = f->fmt.pix.width; 1430 unsigned int height = f->fmt.pix.height; 1431 unsigned int maxw = norm_maxw(dev); 1432 unsigned int maxh = norm_maxh(dev); 1433 unsigned int hscale, vscale; 1434 struct em28xx_fmt *fmt; 1435 1436 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1437 if (!fmt) { 1438 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1439 f->fmt.pix.pixelformat); 1440 return -EINVAL; 1441 } 1442 1443 if (dev->board.is_em2800) { 1444 /* the em2800 can only scale down to 50% */ 1445 height = height > (3 * maxh / 4) ? maxh : maxh / 2; 1446 width = width > (3 * maxw / 4) ? maxw : maxw / 2; 1447 /* 1448 * MaxPacketSize for em2800 is too small to capture at full 1449 * resolution use half of maxw as the scaler can only scale 1450 * to 50% 1451 */ 1452 if (width == maxw && height == maxh) 1453 width /= 2; 1454 } else { 1455 /* width must even because of the YUYV format 1456 height must be even because of interlacing */ 1457 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1458 1, 0); 1459 } 1460 /* Avoid division by zero at size_to_scale */ 1461 if (width < 1) 1462 width = 1; 1463 if (height < 1) 1464 height = 1; 1465 1466 size_to_scale(dev, width, height, &hscale, &vscale); 1467 scale_to_size(dev, hscale, vscale, &width, &height); 1468 1469 f->fmt.pix.width = width; 1470 f->fmt.pix.height = height; 1471 f->fmt.pix.pixelformat = fmt->fourcc; 1472 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3; 1473 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height; 1474 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1475 if (v4l2->progressive) 1476 f->fmt.pix.field = V4L2_FIELD_NONE; 1477 else 1478 f->fmt.pix.field = v4l2->interlaced_fieldmode ? 1479 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1480 f->fmt.pix.priv = 0; 1481 1482 return 0; 1483 } 1484 1485 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc, 1486 unsigned width, unsigned height) 1487 { 1488 struct em28xx_fmt *fmt; 1489 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1490 1491 fmt = format_by_fourcc(fourcc); 1492 if (!fmt) 1493 return -EINVAL; 1494 1495 v4l2->format = fmt; 1496 v4l2->width = width; 1497 v4l2->height = height; 1498 1499 /* set new image size */ 1500 size_to_scale(dev, v4l2->width, v4l2->height, 1501 &v4l2->hscale, &v4l2->vscale); 1502 1503 em28xx_resolution_set(dev); 1504 1505 return 0; 1506 } 1507 1508 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1509 struct v4l2_format *f) 1510 { 1511 struct em28xx *dev = video_drvdata(file); 1512 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1513 1514 if (vb2_is_busy(&v4l2->vb_vidq)) 1515 return -EBUSY; 1516 1517 vidioc_try_fmt_vid_cap(file, priv, f); 1518 1519 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat, 1520 f->fmt.pix.width, f->fmt.pix.height); 1521 } 1522 1523 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm) 1524 { 1525 struct em28xx *dev = video_drvdata(file); 1526 1527 *norm = dev->v4l2->norm; 1528 1529 return 0; 1530 } 1531 1532 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm) 1533 { 1534 struct em28xx *dev = video_drvdata(file); 1535 1536 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm); 1537 1538 return 0; 1539 } 1540 1541 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm) 1542 { 1543 struct em28xx *dev = video_drvdata(file); 1544 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1545 struct v4l2_format f; 1546 1547 if (norm == v4l2->norm) 1548 return 0; 1549 1550 if (v4l2->streaming_users > 0) 1551 return -EBUSY; 1552 1553 v4l2->norm = norm; 1554 1555 /* Adjusts width/height, if needed */ 1556 f.fmt.pix.width = 720; 1557 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576; 1558 vidioc_try_fmt_vid_cap(file, priv, &f); 1559 1560 /* set new image size */ 1561 v4l2->width = f.fmt.pix.width; 1562 v4l2->height = f.fmt.pix.height; 1563 size_to_scale(dev, v4l2->width, v4l2->height, 1564 &v4l2->hscale, &v4l2->vscale); 1565 1566 em28xx_resolution_set(dev); 1567 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 1568 1569 return 0; 1570 } 1571 1572 static int vidioc_g_parm(struct file *file, void *priv, 1573 struct v4l2_streamparm *p) 1574 { 1575 struct em28xx *dev = video_drvdata(file); 1576 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1577 int rc = 0; 1578 1579 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1580 if (dev->board.is_webcam) 1581 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0, 1582 video, g_parm, p); 1583 else 1584 v4l2_video_std_frame_period(v4l2->norm, 1585 &p->parm.capture.timeperframe); 1586 1587 return rc; 1588 } 1589 1590 static int vidioc_s_parm(struct file *file, void *priv, 1591 struct v4l2_streamparm *p) 1592 { 1593 struct em28xx *dev = video_drvdata(file); 1594 1595 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1596 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev, 1597 0, video, s_parm, p); 1598 } 1599 1600 static int vidioc_enum_input(struct file *file, void *priv, 1601 struct v4l2_input *i) 1602 { 1603 struct em28xx *dev = video_drvdata(file); 1604 unsigned int n; 1605 1606 n = i->index; 1607 if (n >= MAX_EM28XX_INPUT) 1608 return -EINVAL; 1609 if (0 == INPUT(n)->type) 1610 return -EINVAL; 1611 1612 i->index = n; 1613 i->type = V4L2_INPUT_TYPE_CAMERA; 1614 1615 strcpy(i->name, iname[INPUT(n)->type]); 1616 1617 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type)) 1618 i->type = V4L2_INPUT_TYPE_TUNER; 1619 1620 i->std = dev->v4l2->vdev.tvnorms; 1621 /* webcams do not have the STD API */ 1622 if (dev->board.is_webcam) 1623 i->capabilities = 0; 1624 1625 return 0; 1626 } 1627 1628 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1629 { 1630 struct em28xx *dev = video_drvdata(file); 1631 1632 *i = dev->ctl_input; 1633 1634 return 0; 1635 } 1636 1637 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1638 { 1639 struct em28xx *dev = video_drvdata(file); 1640 1641 if (i >= MAX_EM28XX_INPUT) 1642 return -EINVAL; 1643 if (0 == INPUT(i)->type) 1644 return -EINVAL; 1645 1646 video_mux(dev, i); 1647 return 0; 1648 } 1649 1650 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1651 { 1652 struct em28xx *dev = video_drvdata(file); 1653 1654 switch (a->index) { 1655 case EM28XX_AMUX_VIDEO: 1656 strcpy(a->name, "Television"); 1657 break; 1658 case EM28XX_AMUX_LINE_IN: 1659 strcpy(a->name, "Line In"); 1660 break; 1661 case EM28XX_AMUX_VIDEO2: 1662 strcpy(a->name, "Television alt"); 1663 break; 1664 case EM28XX_AMUX_PHONE: 1665 strcpy(a->name, "Phone"); 1666 break; 1667 case EM28XX_AMUX_MIC: 1668 strcpy(a->name, "Mic"); 1669 break; 1670 case EM28XX_AMUX_CD: 1671 strcpy(a->name, "CD"); 1672 break; 1673 case EM28XX_AMUX_AUX: 1674 strcpy(a->name, "Aux"); 1675 break; 1676 case EM28XX_AMUX_PCM_OUT: 1677 strcpy(a->name, "PCM"); 1678 break; 1679 default: 1680 return -EINVAL; 1681 } 1682 1683 a->index = dev->ctl_ainput; 1684 a->capability = V4L2_AUDCAP_STEREO; 1685 1686 return 0; 1687 } 1688 1689 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1690 { 1691 struct em28xx *dev = video_drvdata(file); 1692 1693 if (a->index >= MAX_EM28XX_INPUT) 1694 return -EINVAL; 1695 if (0 == INPUT(a->index)->type) 1696 return -EINVAL; 1697 1698 dev->ctl_ainput = INPUT(a->index)->amux; 1699 dev->ctl_aoutput = INPUT(a->index)->aout; 1700 1701 if (!dev->ctl_aoutput) 1702 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1703 1704 return 0; 1705 } 1706 1707 static int vidioc_g_tuner(struct file *file, void *priv, 1708 struct v4l2_tuner *t) 1709 { 1710 struct em28xx *dev = video_drvdata(file); 1711 1712 if (0 != t->index) 1713 return -EINVAL; 1714 1715 strcpy(t->name, "Tuner"); 1716 1717 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1718 return 0; 1719 } 1720 1721 static int vidioc_s_tuner(struct file *file, void *priv, 1722 const struct v4l2_tuner *t) 1723 { 1724 struct em28xx *dev = video_drvdata(file); 1725 1726 if (0 != t->index) 1727 return -EINVAL; 1728 1729 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1730 return 0; 1731 } 1732 1733 static int vidioc_g_frequency(struct file *file, void *priv, 1734 struct v4l2_frequency *f) 1735 { 1736 struct em28xx *dev = video_drvdata(file); 1737 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1738 1739 if (0 != f->tuner) 1740 return -EINVAL; 1741 1742 f->frequency = v4l2->frequency; 1743 return 0; 1744 } 1745 1746 static int vidioc_s_frequency(struct file *file, void *priv, 1747 const struct v4l2_frequency *f) 1748 { 1749 struct v4l2_frequency new_freq = *f; 1750 struct em28xx *dev = video_drvdata(file); 1751 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1752 1753 if (0 != f->tuner) 1754 return -EINVAL; 1755 1756 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f); 1757 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq); 1758 v4l2->frequency = new_freq.frequency; 1759 1760 return 0; 1761 } 1762 1763 #ifdef CONFIG_VIDEO_ADV_DEBUG 1764 static int vidioc_g_chip_info(struct file *file, void *priv, 1765 struct v4l2_dbg_chip_info *chip) 1766 { 1767 struct em28xx *dev = video_drvdata(file); 1768 1769 if (chip->match.addr > 1) 1770 return -EINVAL; 1771 if (chip->match.addr == 1) 1772 strlcpy(chip->name, "ac97", sizeof(chip->name)); 1773 else 1774 strlcpy(chip->name, 1775 dev->v4l2->v4l2_dev.name, sizeof(chip->name)); 1776 return 0; 1777 } 1778 1779 static int em28xx_reg_len(int reg) 1780 { 1781 switch (reg) { 1782 case EM28XX_R40_AC97LSB: 1783 case EM28XX_R30_HSCALELOW: 1784 case EM28XX_R32_VSCALELOW: 1785 return 2; 1786 default: 1787 return 1; 1788 } 1789 } 1790 1791 static int vidioc_g_register(struct file *file, void *priv, 1792 struct v4l2_dbg_register *reg) 1793 { 1794 struct em28xx *dev = video_drvdata(file); 1795 int ret; 1796 1797 if (reg->match.addr > 1) 1798 return -EINVAL; 1799 if (reg->match.addr) { 1800 ret = em28xx_read_ac97(dev, reg->reg); 1801 if (ret < 0) 1802 return ret; 1803 1804 reg->val = ret; 1805 reg->size = 1; 1806 return 0; 1807 } 1808 1809 /* Match host */ 1810 reg->size = em28xx_reg_len(reg->reg); 1811 if (reg->size == 1) { 1812 ret = em28xx_read_reg(dev, reg->reg); 1813 1814 if (ret < 0) 1815 return ret; 1816 1817 reg->val = ret; 1818 } else { 1819 __le16 val = 0; 1820 1821 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS, 1822 reg->reg, (char *)&val, 2); 1823 if (ret < 0) 1824 return ret; 1825 1826 reg->val = le16_to_cpu(val); 1827 } 1828 1829 return 0; 1830 } 1831 1832 static int vidioc_s_register(struct file *file, void *priv, 1833 const struct v4l2_dbg_register *reg) 1834 { 1835 struct em28xx *dev = video_drvdata(file); 1836 __le16 buf; 1837 1838 if (reg->match.addr > 1) 1839 return -EINVAL; 1840 if (reg->match.addr) 1841 return em28xx_write_ac97(dev, reg->reg, reg->val); 1842 1843 /* Match host */ 1844 buf = cpu_to_le16(reg->val); 1845 1846 return em28xx_write_regs(dev, reg->reg, (char *)&buf, 1847 em28xx_reg_len(reg->reg)); 1848 } 1849 #endif 1850 1851 static int vidioc_querycap(struct file *file, void *priv, 1852 struct v4l2_capability *cap) 1853 { 1854 struct video_device *vdev = video_devdata(file); 1855 struct em28xx *dev = video_drvdata(file); 1856 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1857 1858 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1859 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 1860 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1861 1862 if (vdev->vfl_type == VFL_TYPE_GRABBER) 1863 cap->device_caps = V4L2_CAP_READWRITE | 1864 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1865 else if (vdev->vfl_type == VFL_TYPE_RADIO) 1866 cap->device_caps = V4L2_CAP_RADIO; 1867 else 1868 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE; 1869 1870 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE) 1871 cap->device_caps |= V4L2_CAP_AUDIO; 1872 1873 if (dev->tuner_type != TUNER_ABSENT) 1874 cap->device_caps |= V4L2_CAP_TUNER; 1875 1876 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS | 1877 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1878 if (video_is_registered(&v4l2->vbi_dev)) 1879 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 1880 if (video_is_registered(&v4l2->radio_dev)) 1881 cap->capabilities |= V4L2_CAP_RADIO; 1882 return 0; 1883 } 1884 1885 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1886 struct v4l2_fmtdesc *f) 1887 { 1888 if (unlikely(f->index >= ARRAY_SIZE(format))) 1889 return -EINVAL; 1890 1891 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1892 f->pixelformat = format[f->index].fourcc; 1893 1894 return 0; 1895 } 1896 1897 static int vidioc_enum_framesizes(struct file *file, void *priv, 1898 struct v4l2_frmsizeenum *fsize) 1899 { 1900 struct em28xx *dev = video_drvdata(file); 1901 struct em28xx_fmt *fmt; 1902 unsigned int maxw = norm_maxw(dev); 1903 unsigned int maxh = norm_maxh(dev); 1904 1905 fmt = format_by_fourcc(fsize->pixel_format); 1906 if (!fmt) { 1907 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1908 fsize->pixel_format); 1909 return -EINVAL; 1910 } 1911 1912 if (dev->board.is_em2800) { 1913 if (fsize->index > 1) 1914 return -EINVAL; 1915 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1916 fsize->discrete.width = maxw / (1 + fsize->index); 1917 fsize->discrete.height = maxh / (1 + fsize->index); 1918 return 0; 1919 } 1920 1921 if (fsize->index != 0) 1922 return -EINVAL; 1923 1924 /* Report a continuous range */ 1925 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 1926 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX, 1927 &fsize->stepwise.min_width, &fsize->stepwise.min_height); 1928 if (fsize->stepwise.min_width < 48) 1929 fsize->stepwise.min_width = 48; 1930 if (fsize->stepwise.min_height < 38) 1931 fsize->stepwise.min_height = 38; 1932 fsize->stepwise.max_width = maxw; 1933 fsize->stepwise.max_height = maxh; 1934 fsize->stepwise.step_width = 1; 1935 fsize->stepwise.step_height = 1; 1936 return 0; 1937 } 1938 1939 /* RAW VBI ioctls */ 1940 1941 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1942 struct v4l2_format *format) 1943 { 1944 struct em28xx *dev = video_drvdata(file); 1945 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1946 1947 format->fmt.vbi.samples_per_line = v4l2->vbi_width; 1948 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1949 format->fmt.vbi.offset = 0; 1950 format->fmt.vbi.flags = 0; 1951 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1952 format->fmt.vbi.count[0] = v4l2->vbi_height; 1953 format->fmt.vbi.count[1] = v4l2->vbi_height; 1954 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved)); 1955 1956 /* Varies by video standard (NTSC, PAL, etc.) */ 1957 if (v4l2->norm & V4L2_STD_525_60) { 1958 /* NTSC */ 1959 format->fmt.vbi.start[0] = 10; 1960 format->fmt.vbi.start[1] = 273; 1961 } else if (v4l2->norm & V4L2_STD_625_50) { 1962 /* PAL */ 1963 format->fmt.vbi.start[0] = 6; 1964 format->fmt.vbi.start[1] = 318; 1965 } 1966 1967 return 0; 1968 } 1969 1970 /* ----------------------------------------------------------- */ 1971 /* RADIO ESPECIFIC IOCTLS */ 1972 /* ----------------------------------------------------------- */ 1973 1974 static int radio_g_tuner(struct file *file, void *priv, 1975 struct v4l2_tuner *t) 1976 { 1977 struct em28xx *dev = video_drvdata(file); 1978 1979 if (unlikely(t->index > 0)) 1980 return -EINVAL; 1981 1982 strcpy(t->name, "Radio"); 1983 1984 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1985 1986 return 0; 1987 } 1988 1989 static int radio_s_tuner(struct file *file, void *priv, 1990 const struct v4l2_tuner *t) 1991 { 1992 struct em28xx *dev = video_drvdata(file); 1993 1994 if (0 != t->index) 1995 return -EINVAL; 1996 1997 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1998 1999 return 0; 2000 } 2001 2002 /* 2003 * em28xx_free_v4l2() - Free struct em28xx_v4l2 2004 * 2005 * @ref: struct kref for struct em28xx_v4l2 2006 * 2007 * Called when all users of struct em28xx_v4l2 are gone 2008 */ 2009 static void em28xx_free_v4l2(struct kref *ref) 2010 { 2011 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref); 2012 2013 v4l2->dev->v4l2 = NULL; 2014 kfree(v4l2); 2015 } 2016 2017 /* 2018 * em28xx_v4l2_open() 2019 * inits the device and starts isoc transfer 2020 */ 2021 static int em28xx_v4l2_open(struct file *filp) 2022 { 2023 struct video_device *vdev = video_devdata(filp); 2024 struct em28xx *dev = video_drvdata(filp); 2025 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2026 enum v4l2_buf_type fh_type = 0; 2027 int ret; 2028 2029 switch (vdev->vfl_type) { 2030 case VFL_TYPE_GRABBER: 2031 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2032 break; 2033 case VFL_TYPE_VBI: 2034 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 2035 break; 2036 case VFL_TYPE_RADIO: 2037 break; 2038 default: 2039 return -EINVAL; 2040 } 2041 2042 em28xx_videodbg("open dev=%s type=%s users=%d\n", 2043 video_device_node_name(vdev), v4l2_type_names[fh_type], 2044 v4l2->users); 2045 2046 if (mutex_lock_interruptible(&dev->lock)) 2047 return -ERESTARTSYS; 2048 2049 ret = v4l2_fh_open(filp); 2050 if (ret) { 2051 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n", 2052 __func__, ret); 2053 mutex_unlock(&dev->lock); 2054 return ret; 2055 } 2056 2057 if (v4l2->users == 0) { 2058 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 2059 2060 if (vdev->vfl_type != VFL_TYPE_RADIO) 2061 em28xx_resolution_set(dev); 2062 2063 /* 2064 * Needed, since GPIO might have disabled power 2065 * of some i2c devices 2066 */ 2067 em28xx_wake_i2c(dev); 2068 } 2069 2070 if (vdev->vfl_type == VFL_TYPE_RADIO) { 2071 em28xx_videodbg("video_open: setting radio device\n"); 2072 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio); 2073 } 2074 2075 kref_get(&dev->ref); 2076 kref_get(&v4l2->ref); 2077 v4l2->users++; 2078 2079 mutex_unlock(&dev->lock); 2080 2081 return 0; 2082 } 2083 2084 /* 2085 * em28xx_v4l2_fini() 2086 * unregisters the v4l2,i2c and usb devices 2087 * called when the device gets disconected or at module unload 2088 */ 2089 static int em28xx_v4l2_fini(struct em28xx *dev) 2090 { 2091 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2092 2093 if (dev->is_audio_only) { 2094 /* Shouldn't initialize IR for this interface */ 2095 return 0; 2096 } 2097 2098 if (!dev->has_video) { 2099 /* This device does not support the v4l2 extension */ 2100 return 0; 2101 } 2102 2103 if (v4l2 == NULL) 2104 return 0; 2105 2106 em28xx_info("Closing video extension\n"); 2107 2108 mutex_lock(&dev->lock); 2109 2110 v4l2_device_disconnect(&v4l2->v4l2_dev); 2111 2112 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 2113 2114 em28xx_v4l2_media_release(dev); 2115 2116 if (video_is_registered(&v4l2->radio_dev)) { 2117 em28xx_info("V4L2 device %s deregistered\n", 2118 video_device_node_name(&v4l2->radio_dev)); 2119 video_unregister_device(&v4l2->radio_dev); 2120 } 2121 if (video_is_registered(&v4l2->vbi_dev)) { 2122 em28xx_info("V4L2 device %s deregistered\n", 2123 video_device_node_name(&v4l2->vbi_dev)); 2124 video_unregister_device(&v4l2->vbi_dev); 2125 } 2126 if (video_is_registered(&v4l2->vdev)) { 2127 em28xx_info("V4L2 device %s deregistered\n", 2128 video_device_node_name(&v4l2->vdev)); 2129 video_unregister_device(&v4l2->vdev); 2130 } 2131 2132 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 2133 v4l2_device_unregister(&v4l2->v4l2_dev); 2134 2135 if (v4l2->clk) { 2136 v4l2_clk_unregister_fixed(v4l2->clk); 2137 v4l2->clk = NULL; 2138 } 2139 2140 kref_put(&v4l2->ref, em28xx_free_v4l2); 2141 2142 mutex_unlock(&dev->lock); 2143 2144 kref_put(&dev->ref, em28xx_free_device); 2145 2146 return 0; 2147 } 2148 2149 static int em28xx_v4l2_suspend(struct em28xx *dev) 2150 { 2151 if (dev->is_audio_only) 2152 return 0; 2153 2154 if (!dev->has_video) 2155 return 0; 2156 2157 em28xx_info("Suspending video extension\n"); 2158 em28xx_stop_urbs(dev); 2159 return 0; 2160 } 2161 2162 static int em28xx_v4l2_resume(struct em28xx *dev) 2163 { 2164 if (dev->is_audio_only) 2165 return 0; 2166 2167 if (!dev->has_video) 2168 return 0; 2169 2170 em28xx_info("Resuming video extension\n"); 2171 /* what do we do here */ 2172 return 0; 2173 } 2174 2175 /* 2176 * em28xx_v4l2_close() 2177 * stops streaming and deallocates all resources allocated by the v4l2 2178 * calls and ioctls 2179 */ 2180 static int em28xx_v4l2_close(struct file *filp) 2181 { 2182 struct em28xx *dev = video_drvdata(filp); 2183 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2184 int errCode; 2185 2186 em28xx_videodbg("users=%d\n", v4l2->users); 2187 2188 vb2_fop_release(filp); 2189 mutex_lock(&dev->lock); 2190 2191 if (v4l2->users == 1) { 2192 /* No sense to try to write to the device */ 2193 if (dev->disconnected) 2194 goto exit; 2195 2196 /* Save some power by putting tuner to sleep */ 2197 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2198 2199 /* do this before setting alternate! */ 2200 em28xx_set_mode(dev, EM28XX_SUSPEND); 2201 2202 /* set alternate 0 */ 2203 dev->alt = 0; 2204 em28xx_videodbg("setting alternate 0\n"); 2205 errCode = usb_set_interface(dev->udev, 0, 0); 2206 if (errCode < 0) { 2207 em28xx_errdev("cannot change alternate number to " 2208 "0 (error=%i)\n", errCode); 2209 } 2210 } 2211 2212 exit: 2213 v4l2->users--; 2214 kref_put(&v4l2->ref, em28xx_free_v4l2); 2215 mutex_unlock(&dev->lock); 2216 kref_put(&dev->ref, em28xx_free_device); 2217 2218 return 0; 2219 } 2220 2221 static const struct v4l2_file_operations em28xx_v4l_fops = { 2222 .owner = THIS_MODULE, 2223 .open = em28xx_v4l2_open, 2224 .release = em28xx_v4l2_close, 2225 .read = vb2_fop_read, 2226 .poll = vb2_fop_poll, 2227 .mmap = vb2_fop_mmap, 2228 .unlocked_ioctl = video_ioctl2, 2229 }; 2230 2231 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2232 .vidioc_querycap = vidioc_querycap, 2233 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2234 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2235 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2236 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2237 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2238 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2239 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2240 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2241 .vidioc_g_audio = vidioc_g_audio, 2242 .vidioc_s_audio = vidioc_s_audio, 2243 2244 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2245 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2246 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 2247 .vidioc_querybuf = vb2_ioctl_querybuf, 2248 .vidioc_qbuf = vb2_ioctl_qbuf, 2249 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2250 2251 .vidioc_g_std = vidioc_g_std, 2252 .vidioc_querystd = vidioc_querystd, 2253 .vidioc_s_std = vidioc_s_std, 2254 .vidioc_g_parm = vidioc_g_parm, 2255 .vidioc_s_parm = vidioc_s_parm, 2256 .vidioc_enum_input = vidioc_enum_input, 2257 .vidioc_g_input = vidioc_g_input, 2258 .vidioc_s_input = vidioc_s_input, 2259 .vidioc_streamon = vb2_ioctl_streamon, 2260 .vidioc_streamoff = vb2_ioctl_streamoff, 2261 .vidioc_g_tuner = vidioc_g_tuner, 2262 .vidioc_s_tuner = vidioc_s_tuner, 2263 .vidioc_g_frequency = vidioc_g_frequency, 2264 .vidioc_s_frequency = vidioc_s_frequency, 2265 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2266 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2267 #ifdef CONFIG_VIDEO_ADV_DEBUG 2268 .vidioc_g_chip_info = vidioc_g_chip_info, 2269 .vidioc_g_register = vidioc_g_register, 2270 .vidioc_s_register = vidioc_s_register, 2271 #endif 2272 }; 2273 2274 static const struct video_device em28xx_video_template = { 2275 .fops = &em28xx_v4l_fops, 2276 .ioctl_ops = &video_ioctl_ops, 2277 .release = video_device_release_empty, 2278 .tvnorms = V4L2_STD_ALL, 2279 }; 2280 2281 static const struct v4l2_file_operations radio_fops = { 2282 .owner = THIS_MODULE, 2283 .open = em28xx_v4l2_open, 2284 .release = em28xx_v4l2_close, 2285 .unlocked_ioctl = video_ioctl2, 2286 }; 2287 2288 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2289 .vidioc_querycap = vidioc_querycap, 2290 .vidioc_g_tuner = radio_g_tuner, 2291 .vidioc_s_tuner = radio_s_tuner, 2292 .vidioc_g_frequency = vidioc_g_frequency, 2293 .vidioc_s_frequency = vidioc_s_frequency, 2294 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2295 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2296 #ifdef CONFIG_VIDEO_ADV_DEBUG 2297 .vidioc_g_chip_info = vidioc_g_chip_info, 2298 .vidioc_g_register = vidioc_g_register, 2299 .vidioc_s_register = vidioc_s_register, 2300 #endif 2301 }; 2302 2303 static struct video_device em28xx_radio_template = { 2304 .fops = &radio_fops, 2305 .ioctl_ops = &radio_ioctl_ops, 2306 .release = video_device_release_empty, 2307 }; 2308 2309 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */ 2310 static unsigned short saa711x_addrs[] = { 2311 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */ 2312 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */ 2313 I2C_CLIENT_END }; 2314 2315 static unsigned short tvp5150_addrs[] = { 2316 0xb8 >> 1, 2317 0xba >> 1, 2318 I2C_CLIENT_END 2319 }; 2320 2321 static unsigned short msp3400_addrs[] = { 2322 0x80 >> 1, 2323 0x88 >> 1, 2324 I2C_CLIENT_END 2325 }; 2326 2327 /******************************** usb interface ******************************/ 2328 2329 static void em28xx_vdev_init(struct em28xx *dev, 2330 struct video_device *vfd, 2331 const struct video_device *template, 2332 const char *type_name) 2333 { 2334 *vfd = *template; 2335 vfd->v4l2_dev = &dev->v4l2->v4l2_dev; 2336 vfd->lock = &dev->lock; 2337 if (dev->board.is_webcam) 2338 vfd->tvnorms = 0; 2339 2340 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 2341 dev->name, type_name); 2342 2343 video_set_drvdata(vfd, dev); 2344 } 2345 2346 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr) 2347 { 2348 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2349 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev; 2350 struct tuner_setup tun_setup; 2351 struct v4l2_frequency f; 2352 2353 memset(&tun_setup, 0, sizeof(tun_setup)); 2354 2355 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 2356 tun_setup.tuner_callback = em28xx_tuner_callback; 2357 2358 if (dev->board.radio.type) { 2359 tun_setup.type = dev->board.radio.type; 2360 tun_setup.addr = dev->board.radio_addr; 2361 2362 v4l2_device_call_all(v4l2_dev, 2363 0, tuner, s_type_addr, &tun_setup); 2364 } 2365 2366 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) { 2367 tun_setup.type = dev->tuner_type; 2368 tun_setup.addr = tuner_addr; 2369 2370 v4l2_device_call_all(v4l2_dev, 2371 0, tuner, s_type_addr, &tun_setup); 2372 } 2373 2374 if (dev->board.tda9887_conf) { 2375 struct v4l2_priv_tun_config tda9887_cfg; 2376 2377 tda9887_cfg.tuner = TUNER_TDA9887; 2378 tda9887_cfg.priv = &dev->board.tda9887_conf; 2379 2380 v4l2_device_call_all(v4l2_dev, 2381 0, tuner, s_config, &tda9887_cfg); 2382 } 2383 2384 if (dev->tuner_type == TUNER_XC2028) { 2385 struct v4l2_priv_tun_config xc2028_cfg; 2386 struct xc2028_ctrl ctl; 2387 2388 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg)); 2389 memset(&ctl, 0, sizeof(ctl)); 2390 2391 em28xx_setup_xc3028(dev, &ctl); 2392 2393 xc2028_cfg.tuner = TUNER_XC2028; 2394 xc2028_cfg.priv = &ctl; 2395 2396 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg); 2397 } 2398 2399 /* configure tuner */ 2400 f.tuner = 0; 2401 f.type = V4L2_TUNER_ANALOG_TV; 2402 f.frequency = 9076; /* just a magic number */ 2403 v4l2->frequency = f.frequency; 2404 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f); 2405 } 2406 2407 static int em28xx_v4l2_init(struct em28xx *dev) 2408 { 2409 u8 val; 2410 int ret; 2411 unsigned int maxw; 2412 struct v4l2_ctrl_handler *hdl; 2413 struct em28xx_v4l2 *v4l2; 2414 2415 if (dev->is_audio_only) { 2416 /* Shouldn't initialize IR for this interface */ 2417 return 0; 2418 } 2419 2420 if (!dev->has_video) { 2421 /* This device does not support the v4l2 extension */ 2422 return 0; 2423 } 2424 2425 em28xx_info("Registering V4L2 extension\n"); 2426 2427 mutex_lock(&dev->lock); 2428 2429 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL); 2430 if (v4l2 == NULL) { 2431 em28xx_info("em28xx_v4l: memory allocation failed\n"); 2432 mutex_unlock(&dev->lock); 2433 return -ENOMEM; 2434 } 2435 kref_init(&v4l2->ref); 2436 v4l2->dev = dev; 2437 dev->v4l2 = v4l2; 2438 2439 #ifdef CONFIG_MEDIA_CONTROLLER 2440 v4l2->v4l2_dev.mdev = dev->media_dev; 2441 #endif 2442 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev); 2443 if (ret < 0) { 2444 em28xx_errdev("Call to v4l2_device_register() failed!\n"); 2445 goto err; 2446 } 2447 2448 hdl = &v4l2->ctrl_handler; 2449 v4l2_ctrl_handler_init(hdl, 8); 2450 v4l2->v4l2_dev.ctrl_handler = hdl; 2451 2452 if (dev->board.is_webcam) 2453 v4l2->progressive = true; 2454 2455 /* 2456 * Default format, used for tvp5150 or saa711x output formats 2457 */ 2458 v4l2->vinmode = 0x10; 2459 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED | 2460 EM28XX_VINCTRL_CCIR656_ENABLE; 2461 2462 /* request some modules */ 2463 2464 if (dev->board.has_msp34xx) 2465 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2466 &dev->i2c_adap[dev->def_i2c_bus], 2467 "msp3400", 0, msp3400_addrs); 2468 2469 if (dev->board.decoder == EM28XX_SAA711X) 2470 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2471 &dev->i2c_adap[dev->def_i2c_bus], 2472 "saa7115_auto", 0, saa711x_addrs); 2473 2474 if (dev->board.decoder == EM28XX_TVP5150) 2475 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2476 &dev->i2c_adap[dev->def_i2c_bus], 2477 "tvp5150", 0, tvp5150_addrs); 2478 2479 if (dev->board.adecoder == EM28XX_TVAUDIO) 2480 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2481 &dev->i2c_adap[dev->def_i2c_bus], 2482 "tvaudio", dev->board.tvaudio_addr, NULL); 2483 2484 /* Initialize tuner and camera */ 2485 2486 if (dev->board.tuner_type != TUNER_ABSENT) { 2487 unsigned short tuner_addr = dev->board.tuner_addr; 2488 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT); 2489 2490 if (dev->board.radio.type) 2491 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2492 &dev->i2c_adap[dev->def_i2c_bus], 2493 "tuner", dev->board.radio_addr, 2494 NULL); 2495 2496 if (has_demod) 2497 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2498 &dev->i2c_adap[dev->def_i2c_bus], 2499 "tuner", 0, 2500 v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 2501 if (tuner_addr == 0) { 2502 enum v4l2_i2c_tuner_type type = 2503 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; 2504 struct v4l2_subdev *sd; 2505 2506 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2507 &dev->i2c_adap[dev->def_i2c_bus], 2508 "tuner", 0, 2509 v4l2_i2c_tuner_addrs(type)); 2510 2511 if (sd) 2512 tuner_addr = v4l2_i2c_subdev_addr(sd); 2513 } else { 2514 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2515 &dev->i2c_adap[dev->def_i2c_bus], 2516 "tuner", tuner_addr, NULL); 2517 } 2518 2519 em28xx_tuner_setup(dev, tuner_addr); 2520 } 2521 2522 if (dev->em28xx_sensor != EM28XX_NOSENSOR) 2523 em28xx_init_camera(dev); 2524 2525 /* Configure audio */ 2526 ret = em28xx_audio_setup(dev); 2527 if (ret < 0) { 2528 em28xx_errdev("%s: Error while setting audio - error [%d]!\n", 2529 __func__, ret); 2530 goto unregister_dev; 2531 } 2532 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) { 2533 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2534 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 2535 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2536 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f); 2537 } else { 2538 /* install the em28xx notify callback */ 2539 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE), 2540 em28xx_ctrl_notify, dev); 2541 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME), 2542 em28xx_ctrl_notify, dev); 2543 } 2544 2545 /* wake i2c devices */ 2546 em28xx_wake_i2c(dev); 2547 2548 /* init video dma queues */ 2549 INIT_LIST_HEAD(&dev->vidq.active); 2550 INIT_LIST_HEAD(&dev->vbiq.active); 2551 2552 if (dev->board.has_msp34xx) { 2553 /* Send a reset to other chips via gpio */ 2554 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7); 2555 if (ret < 0) { 2556 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n", 2557 __func__, ret); 2558 goto unregister_dev; 2559 } 2560 msleep(3); 2561 2562 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff); 2563 if (ret < 0) { 2564 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n", 2565 __func__, ret); 2566 goto unregister_dev; 2567 } 2568 msleep(3); 2569 } 2570 2571 /* set default norm */ 2572 v4l2->norm = V4L2_STD_PAL; 2573 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 2574 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT; 2575 2576 /* Analog specific initialization */ 2577 v4l2->format = &format[0]; 2578 2579 maxw = norm_maxw(dev); 2580 /* MaxPacketSize for em2800 is too small to capture at full resolution 2581 * use half of maxw as the scaler can only scale to 50% */ 2582 if (dev->board.is_em2800) 2583 maxw /= 2; 2584 2585 em28xx_set_video_format(dev, format[0].fourcc, 2586 maxw, norm_maxh(dev)); 2587 2588 video_mux(dev, 0); 2589 2590 /* Audio defaults */ 2591 dev->mute = 1; 2592 dev->volume = 0x1f; 2593 2594 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 2595 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 2596 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 2597 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 2598 2599 em28xx_set_outfmt(dev); 2600 2601 /* Add image controls */ 2602 /* NOTE: at this point, the subdevices are already registered, so bridge 2603 * controls are only added/enabled when no subdevice provides them */ 2604 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST)) 2605 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2606 V4L2_CID_CONTRAST, 2607 0, 0x1f, 1, CONTRAST_DEFAULT); 2608 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS)) 2609 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2610 V4L2_CID_BRIGHTNESS, 2611 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT); 2612 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION)) 2613 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2614 V4L2_CID_SATURATION, 2615 0, 0x1f, 1, SATURATION_DEFAULT); 2616 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE)) 2617 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2618 V4L2_CID_BLUE_BALANCE, 2619 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT); 2620 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE)) 2621 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2622 V4L2_CID_RED_BALANCE, 2623 -0x30, 0x30, 1, RED_BALANCE_DEFAULT); 2624 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS)) 2625 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2626 V4L2_CID_SHARPNESS, 2627 0, 0x0f, 1, SHARPNESS_DEFAULT); 2628 2629 /* Reset image controls */ 2630 em28xx_colorlevels_set_default(dev); 2631 v4l2_ctrl_handler_setup(hdl); 2632 ret = hdl->error; 2633 if (ret) 2634 goto unregister_dev; 2635 2636 /* allocate and fill video video_device struct */ 2637 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video"); 2638 mutex_init(&v4l2->vb_queue_lock); 2639 mutex_init(&v4l2->vb_vbi_queue_lock); 2640 v4l2->vdev.queue = &v4l2->vb_vidq; 2641 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock; 2642 2643 /* disable inapplicable ioctls */ 2644 if (dev->board.is_webcam) { 2645 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD); 2646 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD); 2647 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD); 2648 } else { 2649 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM); 2650 } 2651 if (dev->tuner_type == TUNER_ABSENT) { 2652 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER); 2653 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER); 2654 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY); 2655 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY); 2656 } 2657 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2658 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO); 2659 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO); 2660 } 2661 2662 /* register v4l2 video video_device */ 2663 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER, 2664 video_nr[dev->devno]); 2665 if (ret) { 2666 em28xx_errdev("unable to register video device (error=%i).\n", 2667 ret); 2668 goto unregister_dev; 2669 } 2670 2671 /* Allocate and fill vbi video_device struct */ 2672 if (em28xx_vbi_supported(dev) == 1) { 2673 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template, 2674 "vbi"); 2675 2676 v4l2->vbi_dev.queue = &v4l2->vb_vbiq; 2677 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock; 2678 2679 /* disable inapplicable ioctls */ 2680 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM); 2681 if (dev->tuner_type == TUNER_ABSENT) { 2682 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER); 2683 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER); 2684 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY); 2685 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY); 2686 } 2687 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2688 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO); 2689 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO); 2690 } 2691 2692 /* register v4l2 vbi video_device */ 2693 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI, 2694 vbi_nr[dev->devno]); 2695 if (ret < 0) { 2696 em28xx_errdev("unable to register vbi device\n"); 2697 goto unregister_dev; 2698 } 2699 } 2700 2701 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2702 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template, 2703 "radio"); 2704 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO, 2705 radio_nr[dev->devno]); 2706 if (ret < 0) { 2707 em28xx_errdev("can't register radio device\n"); 2708 goto unregister_dev; 2709 } 2710 em28xx_info("Registered radio device as %s\n", 2711 video_device_node_name(&v4l2->radio_dev)); 2712 } 2713 2714 /* Init entities at the Media Controller */ 2715 em28xx_v4l2_create_entities(dev); 2716 2717 #ifdef CONFIG_MEDIA_CONTROLLER 2718 ret = v4l2_mc_create_media_graph(dev->media_dev); 2719 if (ret) { 2720 em28xx_errdev("failed to create media graph\n"); 2721 em28xx_v4l2_media_release(dev); 2722 goto unregister_dev; 2723 } 2724 #endif 2725 2726 em28xx_info("V4L2 video device registered as %s\n", 2727 video_device_node_name(&v4l2->vdev)); 2728 2729 if (video_is_registered(&v4l2->vbi_dev)) 2730 em28xx_info("V4L2 VBI device registered as %s\n", 2731 video_device_node_name(&v4l2->vbi_dev)); 2732 2733 /* Save some power by putting tuner to sleep */ 2734 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2735 2736 /* initialize videobuf2 stuff */ 2737 em28xx_vb2_setup(dev); 2738 2739 em28xx_info("V4L2 extension successfully initialized\n"); 2740 2741 kref_get(&dev->ref); 2742 2743 mutex_unlock(&dev->lock); 2744 return 0; 2745 2746 unregister_dev: 2747 if (video_is_registered(&v4l2->radio_dev)) { 2748 em28xx_info("V4L2 device %s deregistered\n", 2749 video_device_node_name(&v4l2->radio_dev)); 2750 video_unregister_device(&v4l2->radio_dev); 2751 } 2752 if (video_is_registered(&v4l2->vbi_dev)) { 2753 em28xx_info("V4L2 device %s deregistered\n", 2754 video_device_node_name(&v4l2->vbi_dev)); 2755 video_unregister_device(&v4l2->vbi_dev); 2756 } 2757 if (video_is_registered(&v4l2->vdev)) { 2758 em28xx_info("V4L2 device %s deregistered\n", 2759 video_device_node_name(&v4l2->vdev)); 2760 video_unregister_device(&v4l2->vdev); 2761 } 2762 2763 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 2764 v4l2_device_unregister(&v4l2->v4l2_dev); 2765 err: 2766 dev->v4l2 = NULL; 2767 kref_put(&v4l2->ref, em28xx_free_v4l2); 2768 mutex_unlock(&dev->lock); 2769 return ret; 2770 } 2771 2772 static struct em28xx_ops v4l2_ops = { 2773 .id = EM28XX_V4L2, 2774 .name = "Em28xx v4l2 Extension", 2775 .init = em28xx_v4l2_init, 2776 .fini = em28xx_v4l2_fini, 2777 .suspend = em28xx_v4l2_suspend, 2778 .resume = em28xx_v4l2_resume, 2779 }; 2780 2781 static int __init em28xx_video_register(void) 2782 { 2783 return em28xx_register_extension(&v4l2_ops); 2784 } 2785 2786 static void __exit em28xx_video_unregister(void) 2787 { 2788 em28xx_unregister_extension(&v4l2_ops); 2789 } 2790 2791 module_init(em28xx_video_register); 2792 module_exit(em28xx_video_unregister); 2793