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 /* ------------------------------------------------------------------ 870 Videobuf2 operations 871 ------------------------------------------------------------------*/ 872 873 static int queue_setup(struct vb2_queue *vq, 874 unsigned int *nbuffers, unsigned int *nplanes, 875 unsigned int sizes[], void *alloc_ctxs[]) 876 { 877 struct em28xx *dev = vb2_get_drv_priv(vq); 878 struct em28xx_v4l2 *v4l2 = dev->v4l2; 879 unsigned long size = 880 (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3; 881 882 if (*nplanes) 883 return sizes[0] < size ? -EINVAL : 0; 884 *nplanes = 1; 885 sizes[0] = size; 886 return 0; 887 } 888 889 static int 890 buffer_prepare(struct vb2_buffer *vb) 891 { 892 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 893 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 894 struct em28xx_v4l2 *v4l2 = dev->v4l2; 895 unsigned long size; 896 897 em28xx_videodbg("%s, field=%d\n", __func__, vbuf->field); 898 899 size = (v4l2->width * v4l2->height * v4l2->format->depth + 7) >> 3; 900 901 if (vb2_plane_size(vb, 0) < size) { 902 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n", 903 __func__, vb2_plane_size(vb, 0), size); 904 return -EINVAL; 905 } 906 vb2_set_plane_payload(vb, 0, size); 907 908 return 0; 909 } 910 911 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count) 912 { 913 struct em28xx *dev = vb2_get_drv_priv(vq); 914 struct em28xx_v4l2 *v4l2 = dev->v4l2; 915 struct v4l2_frequency f; 916 struct v4l2_fh *owner; 917 int rc = 0; 918 919 em28xx_videodbg("%s\n", __func__); 920 921 /* Make sure streaming is not already in progress for this type 922 of filehandle (e.g. video, vbi) */ 923 rc = res_get(dev, vq->type); 924 if (rc) 925 return rc; 926 927 if (v4l2->streaming_users == 0) { 928 /* First active streaming user, so allocate all the URBs */ 929 930 /* Allocate the USB bandwidth */ 931 em28xx_set_alternate(dev); 932 933 /* Needed, since GPIO might have disabled power of 934 some i2c device 935 */ 936 em28xx_wake_i2c(dev); 937 938 v4l2->capture_type = -1; 939 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE, 940 dev->analog_xfer_bulk, 941 EM28XX_NUM_BUFS, 942 dev->max_pkt_size, 943 dev->packet_multiplier, 944 em28xx_urb_data_copy); 945 if (rc < 0) 946 return rc; 947 948 /* 949 * djh: it's not clear whether this code is still needed. I'm 950 * leaving it in here for now entirely out of concern for 951 * backward compatibility (the old code did it) 952 */ 953 954 /* Ask tuner to go to analog or radio mode */ 955 memset(&f, 0, sizeof(f)); 956 f.frequency = v4l2->frequency; 957 owner = (struct v4l2_fh *)vq->owner; 958 if (owner && owner->vdev->vfl_type == VFL_TYPE_RADIO) 959 f.type = V4L2_TUNER_RADIO; 960 else 961 f.type = V4L2_TUNER_ANALOG_TV; 962 v4l2_device_call_all(&v4l2->v4l2_dev, 963 0, tuner, s_frequency, &f); 964 965 /* Enable video stream at TV decoder */ 966 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 1); 967 } 968 969 v4l2->streaming_users++; 970 971 return rc; 972 } 973 974 static void em28xx_stop_streaming(struct vb2_queue *vq) 975 { 976 struct em28xx *dev = vb2_get_drv_priv(vq); 977 struct em28xx_v4l2 *v4l2 = dev->v4l2; 978 struct em28xx_dmaqueue *vidq = &dev->vidq; 979 unsigned long flags = 0; 980 981 em28xx_videodbg("%s\n", __func__); 982 983 res_free(dev, vq->type); 984 985 if (v4l2->streaming_users-- == 1) { 986 /* Disable video stream at TV decoder */ 987 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0); 988 989 /* Last active user, so shutdown all the URBS */ 990 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 991 } 992 993 spin_lock_irqsave(&dev->slock, flags); 994 if (dev->usb_ctl.vid_buf != NULL) { 995 vb2_buffer_done(&dev->usb_ctl.vid_buf->vb.vb2_buf, 996 VB2_BUF_STATE_ERROR); 997 dev->usb_ctl.vid_buf = NULL; 998 } 999 while (!list_empty(&vidq->active)) { 1000 struct em28xx_buffer *buf; 1001 1002 buf = list_entry(vidq->active.next, struct em28xx_buffer, list); 1003 list_del(&buf->list); 1004 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 1005 } 1006 spin_unlock_irqrestore(&dev->slock, flags); 1007 } 1008 1009 void em28xx_stop_vbi_streaming(struct vb2_queue *vq) 1010 { 1011 struct em28xx *dev = vb2_get_drv_priv(vq); 1012 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1013 struct em28xx_dmaqueue *vbiq = &dev->vbiq; 1014 unsigned long flags = 0; 1015 1016 em28xx_videodbg("%s\n", __func__); 1017 1018 res_free(dev, vq->type); 1019 1020 if (v4l2->streaming_users-- == 1) { 1021 /* Disable video stream at TV decoder */ 1022 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_stream, 0); 1023 1024 /* Last active user, so shutdown all the URBS */ 1025 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1026 } 1027 1028 spin_lock_irqsave(&dev->slock, flags); 1029 if (dev->usb_ctl.vbi_buf != NULL) { 1030 vb2_buffer_done(&dev->usb_ctl.vbi_buf->vb.vb2_buf, 1031 VB2_BUF_STATE_ERROR); 1032 dev->usb_ctl.vbi_buf = NULL; 1033 } 1034 while (!list_empty(&vbiq->active)) { 1035 struct em28xx_buffer *buf; 1036 1037 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list); 1038 list_del(&buf->list); 1039 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 1040 } 1041 spin_unlock_irqrestore(&dev->slock, flags); 1042 } 1043 1044 static void 1045 buffer_queue(struct vb2_buffer *vb) 1046 { 1047 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1048 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 1049 struct em28xx_buffer *buf = 1050 container_of(vbuf, struct em28xx_buffer, vb); 1051 struct em28xx_dmaqueue *vidq = &dev->vidq; 1052 unsigned long flags = 0; 1053 1054 em28xx_videodbg("%s\n", __func__); 1055 buf->mem = vb2_plane_vaddr(vb, 0); 1056 buf->length = vb2_plane_size(vb, 0); 1057 1058 spin_lock_irqsave(&dev->slock, flags); 1059 list_add_tail(&buf->list, &vidq->active); 1060 spin_unlock_irqrestore(&dev->slock, flags); 1061 } 1062 1063 static struct vb2_ops em28xx_video_qops = { 1064 .queue_setup = queue_setup, 1065 .buf_prepare = buffer_prepare, 1066 .buf_queue = buffer_queue, 1067 .start_streaming = em28xx_start_analog_streaming, 1068 .stop_streaming = em28xx_stop_streaming, 1069 .wait_prepare = vb2_ops_wait_prepare, 1070 .wait_finish = vb2_ops_wait_finish, 1071 }; 1072 1073 static int em28xx_vb2_setup(struct em28xx *dev) 1074 { 1075 int rc; 1076 struct vb2_queue *q; 1077 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1078 1079 /* Setup Videobuf2 for Video capture */ 1080 q = &v4l2->vb_vidq; 1081 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1082 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1083 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1084 q->drv_priv = dev; 1085 q->buf_struct_size = sizeof(struct em28xx_buffer); 1086 q->ops = &em28xx_video_qops; 1087 q->mem_ops = &vb2_vmalloc_memops; 1088 1089 rc = vb2_queue_init(q); 1090 if (rc < 0) 1091 return rc; 1092 1093 /* Setup Videobuf2 for VBI capture */ 1094 q = &v4l2->vb_vbiq; 1095 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 1096 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR; 1097 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1098 q->drv_priv = dev; 1099 q->buf_struct_size = sizeof(struct em28xx_buffer); 1100 q->ops = &em28xx_vbi_qops; 1101 q->mem_ops = &vb2_vmalloc_memops; 1102 1103 rc = vb2_queue_init(q); 1104 if (rc < 0) 1105 return rc; 1106 1107 return 0; 1108 } 1109 1110 /********************* v4l2 interface **************************************/ 1111 1112 static void video_mux(struct em28xx *dev, int index) 1113 { 1114 struct v4l2_device *v4l2_dev = &dev->v4l2->v4l2_dev; 1115 1116 dev->ctl_input = index; 1117 dev->ctl_ainput = INPUT(index)->amux; 1118 dev->ctl_aoutput = INPUT(index)->aout; 1119 1120 if (!dev->ctl_aoutput) 1121 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1122 1123 v4l2_device_call_all(v4l2_dev, 0, video, s_routing, 1124 INPUT(index)->vmux, 0, 0); 1125 1126 if (dev->board.has_msp34xx) { 1127 if (dev->i2s_speed) { 1128 v4l2_device_call_all(v4l2_dev, 0, audio, 1129 s_i2s_clock_freq, dev->i2s_speed); 1130 } 1131 /* Note: this is msp3400 specific */ 1132 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing, 1133 dev->ctl_ainput, 1134 MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0); 1135 } 1136 1137 if (dev->board.adecoder != EM28XX_NOADECODER) { 1138 v4l2_device_call_all(v4l2_dev, 0, audio, s_routing, 1139 dev->ctl_ainput, dev->ctl_aoutput, 0); 1140 } 1141 1142 em28xx_audio_analog_set(dev); 1143 } 1144 1145 static void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv) 1146 { 1147 struct em28xx *dev = priv; 1148 1149 /* 1150 * In the case of non-AC97 volume controls, we still need 1151 * to do some setups at em28xx, in order to mute/unmute 1152 * and to adjust audio volume. However, the value ranges 1153 * should be checked by the corresponding V4L subdriver. 1154 */ 1155 switch (ctrl->id) { 1156 case V4L2_CID_AUDIO_MUTE: 1157 dev->mute = ctrl->val; 1158 em28xx_audio_analog_set(dev); 1159 break; 1160 case V4L2_CID_AUDIO_VOLUME: 1161 dev->volume = ctrl->val; 1162 em28xx_audio_analog_set(dev); 1163 break; 1164 } 1165 } 1166 1167 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl) 1168 { 1169 struct em28xx_v4l2 *v4l2 = 1170 container_of(ctrl->handler, struct em28xx_v4l2, ctrl_handler); 1171 struct em28xx *dev = v4l2->dev; 1172 int ret = -EINVAL; 1173 1174 switch (ctrl->id) { 1175 case V4L2_CID_AUDIO_MUTE: 1176 dev->mute = ctrl->val; 1177 ret = em28xx_audio_analog_set(dev); 1178 break; 1179 case V4L2_CID_AUDIO_VOLUME: 1180 dev->volume = ctrl->val; 1181 ret = em28xx_audio_analog_set(dev); 1182 break; 1183 case V4L2_CID_CONTRAST: 1184 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val); 1185 break; 1186 case V4L2_CID_BRIGHTNESS: 1187 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val); 1188 break; 1189 case V4L2_CID_SATURATION: 1190 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val); 1191 break; 1192 case V4L2_CID_BLUE_BALANCE: 1193 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val); 1194 break; 1195 case V4L2_CID_RED_BALANCE: 1196 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val); 1197 break; 1198 case V4L2_CID_SHARPNESS: 1199 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val); 1200 break; 1201 } 1202 1203 return (ret < 0) ? ret : 0; 1204 } 1205 1206 static const struct v4l2_ctrl_ops em28xx_ctrl_ops = { 1207 .s_ctrl = em28xx_s_ctrl, 1208 }; 1209 1210 static void size_to_scale(struct em28xx *dev, 1211 unsigned int width, unsigned int height, 1212 unsigned int *hscale, unsigned int *vscale) 1213 { 1214 unsigned int maxw = norm_maxw(dev); 1215 unsigned int maxh = norm_maxh(dev); 1216 1217 *hscale = (((unsigned long)maxw) << 12) / width - 4096L; 1218 if (*hscale > EM28XX_HVSCALE_MAX) 1219 *hscale = EM28XX_HVSCALE_MAX; 1220 1221 *vscale = (((unsigned long)maxh) << 12) / height - 4096L; 1222 if (*vscale > EM28XX_HVSCALE_MAX) 1223 *vscale = EM28XX_HVSCALE_MAX; 1224 } 1225 1226 static void scale_to_size(struct em28xx *dev, 1227 unsigned int hscale, unsigned int vscale, 1228 unsigned int *width, unsigned int *height) 1229 { 1230 unsigned int maxw = norm_maxw(dev); 1231 unsigned int maxh = norm_maxh(dev); 1232 1233 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 1234 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 1235 } 1236 1237 /* ------------------------------------------------------------------ 1238 IOCTL vidioc handling 1239 ------------------------------------------------------------------*/ 1240 1241 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 1242 struct v4l2_format *f) 1243 { 1244 struct em28xx *dev = video_drvdata(file); 1245 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1246 1247 f->fmt.pix.width = v4l2->width; 1248 f->fmt.pix.height = v4l2->height; 1249 f->fmt.pix.pixelformat = v4l2->format->fourcc; 1250 f->fmt.pix.bytesperline = (v4l2->width * v4l2->format->depth + 7) >> 3; 1251 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * v4l2->height; 1252 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1253 1254 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */ 1255 if (v4l2->progressive) 1256 f->fmt.pix.field = V4L2_FIELD_NONE; 1257 else 1258 f->fmt.pix.field = v4l2->interlaced_fieldmode ? 1259 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1260 return 0; 1261 } 1262 1263 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc) 1264 { 1265 unsigned int i; 1266 1267 for (i = 0; i < ARRAY_SIZE(format); i++) 1268 if (format[i].fourcc == fourcc) 1269 return &format[i]; 1270 1271 return NULL; 1272 } 1273 1274 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 1275 struct v4l2_format *f) 1276 { 1277 struct em28xx *dev = video_drvdata(file); 1278 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1279 unsigned int width = f->fmt.pix.width; 1280 unsigned int height = f->fmt.pix.height; 1281 unsigned int maxw = norm_maxw(dev); 1282 unsigned int maxh = norm_maxh(dev); 1283 unsigned int hscale, vscale; 1284 struct em28xx_fmt *fmt; 1285 1286 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1287 if (!fmt) { 1288 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1289 f->fmt.pix.pixelformat); 1290 return -EINVAL; 1291 } 1292 1293 if (dev->board.is_em2800) { 1294 /* the em2800 can only scale down to 50% */ 1295 height = height > (3 * maxh / 4) ? maxh : maxh / 2; 1296 width = width > (3 * maxw / 4) ? maxw : maxw / 2; 1297 /* 1298 * MaxPacketSize for em2800 is too small to capture at full 1299 * resolution use half of maxw as the scaler can only scale 1300 * to 50% 1301 */ 1302 if (width == maxw && height == maxh) 1303 width /= 2; 1304 } else { 1305 /* width must even because of the YUYV format 1306 height must be even because of interlacing */ 1307 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1308 1, 0); 1309 } 1310 1311 size_to_scale(dev, width, height, &hscale, &vscale); 1312 scale_to_size(dev, hscale, vscale, &width, &height); 1313 1314 f->fmt.pix.width = width; 1315 f->fmt.pix.height = height; 1316 f->fmt.pix.pixelformat = fmt->fourcc; 1317 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3; 1318 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height; 1319 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1320 if (v4l2->progressive) 1321 f->fmt.pix.field = V4L2_FIELD_NONE; 1322 else 1323 f->fmt.pix.field = v4l2->interlaced_fieldmode ? 1324 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1325 f->fmt.pix.priv = 0; 1326 1327 return 0; 1328 } 1329 1330 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc, 1331 unsigned width, unsigned height) 1332 { 1333 struct em28xx_fmt *fmt; 1334 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1335 1336 fmt = format_by_fourcc(fourcc); 1337 if (!fmt) 1338 return -EINVAL; 1339 1340 v4l2->format = fmt; 1341 v4l2->width = width; 1342 v4l2->height = height; 1343 1344 /* set new image size */ 1345 size_to_scale(dev, v4l2->width, v4l2->height, 1346 &v4l2->hscale, &v4l2->vscale); 1347 1348 em28xx_resolution_set(dev); 1349 1350 return 0; 1351 } 1352 1353 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1354 struct v4l2_format *f) 1355 { 1356 struct em28xx *dev = video_drvdata(file); 1357 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1358 1359 if (vb2_is_busy(&v4l2->vb_vidq)) 1360 return -EBUSY; 1361 1362 vidioc_try_fmt_vid_cap(file, priv, f); 1363 1364 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat, 1365 f->fmt.pix.width, f->fmt.pix.height); 1366 } 1367 1368 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm) 1369 { 1370 struct em28xx *dev = video_drvdata(file); 1371 1372 *norm = dev->v4l2->norm; 1373 1374 return 0; 1375 } 1376 1377 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm) 1378 { 1379 struct em28xx *dev = video_drvdata(file); 1380 1381 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, video, querystd, norm); 1382 1383 return 0; 1384 } 1385 1386 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm) 1387 { 1388 struct em28xx *dev = video_drvdata(file); 1389 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1390 struct v4l2_format f; 1391 1392 if (norm == v4l2->norm) 1393 return 0; 1394 1395 if (v4l2->streaming_users > 0) 1396 return -EBUSY; 1397 1398 v4l2->norm = norm; 1399 1400 /* Adjusts width/height, if needed */ 1401 f.fmt.pix.width = 720; 1402 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576; 1403 vidioc_try_fmt_vid_cap(file, priv, &f); 1404 1405 /* set new image size */ 1406 v4l2->width = f.fmt.pix.width; 1407 v4l2->height = f.fmt.pix.height; 1408 size_to_scale(dev, v4l2->width, v4l2->height, 1409 &v4l2->hscale, &v4l2->vscale); 1410 1411 em28xx_resolution_set(dev); 1412 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 1413 1414 return 0; 1415 } 1416 1417 static int vidioc_g_parm(struct file *file, void *priv, 1418 struct v4l2_streamparm *p) 1419 { 1420 struct em28xx *dev = video_drvdata(file); 1421 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1422 int rc = 0; 1423 1424 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1425 if (dev->board.is_webcam) 1426 rc = v4l2_device_call_until_err(&v4l2->v4l2_dev, 0, 1427 video, g_parm, p); 1428 else 1429 v4l2_video_std_frame_period(v4l2->norm, 1430 &p->parm.capture.timeperframe); 1431 1432 return rc; 1433 } 1434 1435 static int vidioc_s_parm(struct file *file, void *priv, 1436 struct v4l2_streamparm *p) 1437 { 1438 struct em28xx *dev = video_drvdata(file); 1439 1440 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1441 return v4l2_device_call_until_err(&dev->v4l2->v4l2_dev, 1442 0, video, s_parm, p); 1443 } 1444 1445 static const char *iname[] = { 1446 [EM28XX_VMUX_COMPOSITE1] = "Composite1", 1447 [EM28XX_VMUX_COMPOSITE2] = "Composite2", 1448 [EM28XX_VMUX_COMPOSITE3] = "Composite3", 1449 [EM28XX_VMUX_COMPOSITE4] = "Composite4", 1450 [EM28XX_VMUX_SVIDEO] = "S-Video", 1451 [EM28XX_VMUX_TELEVISION] = "Television", 1452 [EM28XX_VMUX_CABLE] = "Cable TV", 1453 [EM28XX_VMUX_DVB] = "DVB", 1454 [EM28XX_VMUX_DEBUG] = "for debug only", 1455 }; 1456 1457 static int vidioc_enum_input(struct file *file, void *priv, 1458 struct v4l2_input *i) 1459 { 1460 struct em28xx *dev = video_drvdata(file); 1461 unsigned int n; 1462 1463 n = i->index; 1464 if (n >= MAX_EM28XX_INPUT) 1465 return -EINVAL; 1466 if (0 == INPUT(n)->type) 1467 return -EINVAL; 1468 1469 i->index = n; 1470 i->type = V4L2_INPUT_TYPE_CAMERA; 1471 1472 strcpy(i->name, iname[INPUT(n)->type]); 1473 1474 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) || 1475 (EM28XX_VMUX_CABLE == INPUT(n)->type)) 1476 i->type = V4L2_INPUT_TYPE_TUNER; 1477 1478 i->std = dev->v4l2->vdev.tvnorms; 1479 /* webcams do not have the STD API */ 1480 if (dev->board.is_webcam) 1481 i->capabilities = 0; 1482 1483 return 0; 1484 } 1485 1486 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1487 { 1488 struct em28xx *dev = video_drvdata(file); 1489 1490 *i = dev->ctl_input; 1491 1492 return 0; 1493 } 1494 1495 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1496 { 1497 struct em28xx *dev = video_drvdata(file); 1498 1499 if (i >= MAX_EM28XX_INPUT) 1500 return -EINVAL; 1501 if (0 == INPUT(i)->type) 1502 return -EINVAL; 1503 1504 video_mux(dev, i); 1505 return 0; 1506 } 1507 1508 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1509 { 1510 struct em28xx *dev = video_drvdata(file); 1511 1512 switch (a->index) { 1513 case EM28XX_AMUX_VIDEO: 1514 strcpy(a->name, "Television"); 1515 break; 1516 case EM28XX_AMUX_LINE_IN: 1517 strcpy(a->name, "Line In"); 1518 break; 1519 case EM28XX_AMUX_VIDEO2: 1520 strcpy(a->name, "Television alt"); 1521 break; 1522 case EM28XX_AMUX_PHONE: 1523 strcpy(a->name, "Phone"); 1524 break; 1525 case EM28XX_AMUX_MIC: 1526 strcpy(a->name, "Mic"); 1527 break; 1528 case EM28XX_AMUX_CD: 1529 strcpy(a->name, "CD"); 1530 break; 1531 case EM28XX_AMUX_AUX: 1532 strcpy(a->name, "Aux"); 1533 break; 1534 case EM28XX_AMUX_PCM_OUT: 1535 strcpy(a->name, "PCM"); 1536 break; 1537 default: 1538 return -EINVAL; 1539 } 1540 1541 a->index = dev->ctl_ainput; 1542 a->capability = V4L2_AUDCAP_STEREO; 1543 1544 return 0; 1545 } 1546 1547 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1548 { 1549 struct em28xx *dev = video_drvdata(file); 1550 1551 if (a->index >= MAX_EM28XX_INPUT) 1552 return -EINVAL; 1553 if (0 == INPUT(a->index)->type) 1554 return -EINVAL; 1555 1556 dev->ctl_ainput = INPUT(a->index)->amux; 1557 dev->ctl_aoutput = INPUT(a->index)->aout; 1558 1559 if (!dev->ctl_aoutput) 1560 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1561 1562 return 0; 1563 } 1564 1565 static int vidioc_g_tuner(struct file *file, void *priv, 1566 struct v4l2_tuner *t) 1567 { 1568 struct em28xx *dev = video_drvdata(file); 1569 1570 if (0 != t->index) 1571 return -EINVAL; 1572 1573 strcpy(t->name, "Tuner"); 1574 1575 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1576 return 0; 1577 } 1578 1579 static int vidioc_s_tuner(struct file *file, void *priv, 1580 const struct v4l2_tuner *t) 1581 { 1582 struct em28xx *dev = video_drvdata(file); 1583 1584 if (0 != t->index) 1585 return -EINVAL; 1586 1587 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1588 return 0; 1589 } 1590 1591 static int vidioc_g_frequency(struct file *file, void *priv, 1592 struct v4l2_frequency *f) 1593 { 1594 struct em28xx *dev = video_drvdata(file); 1595 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1596 1597 if (0 != f->tuner) 1598 return -EINVAL; 1599 1600 f->frequency = v4l2->frequency; 1601 return 0; 1602 } 1603 1604 static int vidioc_s_frequency(struct file *file, void *priv, 1605 const struct v4l2_frequency *f) 1606 { 1607 struct v4l2_frequency new_freq = *f; 1608 struct em28xx *dev = video_drvdata(file); 1609 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1610 1611 if (0 != f->tuner) 1612 return -EINVAL; 1613 1614 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f); 1615 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq); 1616 v4l2->frequency = new_freq.frequency; 1617 1618 return 0; 1619 } 1620 1621 #ifdef CONFIG_VIDEO_ADV_DEBUG 1622 static int vidioc_g_chip_info(struct file *file, void *priv, 1623 struct v4l2_dbg_chip_info *chip) 1624 { 1625 struct em28xx *dev = video_drvdata(file); 1626 1627 if (chip->match.addr > 1) 1628 return -EINVAL; 1629 if (chip->match.addr == 1) 1630 strlcpy(chip->name, "ac97", sizeof(chip->name)); 1631 else 1632 strlcpy(chip->name, 1633 dev->v4l2->v4l2_dev.name, sizeof(chip->name)); 1634 return 0; 1635 } 1636 1637 static int em28xx_reg_len(int reg) 1638 { 1639 switch (reg) { 1640 case EM28XX_R40_AC97LSB: 1641 case EM28XX_R30_HSCALELOW: 1642 case EM28XX_R32_VSCALELOW: 1643 return 2; 1644 default: 1645 return 1; 1646 } 1647 } 1648 1649 static int vidioc_g_register(struct file *file, void *priv, 1650 struct v4l2_dbg_register *reg) 1651 { 1652 struct em28xx *dev = video_drvdata(file); 1653 int ret; 1654 1655 if (reg->match.addr > 1) 1656 return -EINVAL; 1657 if (reg->match.addr) { 1658 ret = em28xx_read_ac97(dev, reg->reg); 1659 if (ret < 0) 1660 return ret; 1661 1662 reg->val = ret; 1663 reg->size = 1; 1664 return 0; 1665 } 1666 1667 /* Match host */ 1668 reg->size = em28xx_reg_len(reg->reg); 1669 if (reg->size == 1) { 1670 ret = em28xx_read_reg(dev, reg->reg); 1671 1672 if (ret < 0) 1673 return ret; 1674 1675 reg->val = ret; 1676 } else { 1677 __le16 val = 0; 1678 1679 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS, 1680 reg->reg, (char *)&val, 2); 1681 if (ret < 0) 1682 return ret; 1683 1684 reg->val = le16_to_cpu(val); 1685 } 1686 1687 return 0; 1688 } 1689 1690 static int vidioc_s_register(struct file *file, void *priv, 1691 const struct v4l2_dbg_register *reg) 1692 { 1693 struct em28xx *dev = video_drvdata(file); 1694 __le16 buf; 1695 1696 if (reg->match.addr > 1) 1697 return -EINVAL; 1698 if (reg->match.addr) 1699 return em28xx_write_ac97(dev, reg->reg, reg->val); 1700 1701 /* Match host */ 1702 buf = cpu_to_le16(reg->val); 1703 1704 return em28xx_write_regs(dev, reg->reg, (char *)&buf, 1705 em28xx_reg_len(reg->reg)); 1706 } 1707 #endif 1708 1709 static int vidioc_querycap(struct file *file, void *priv, 1710 struct v4l2_capability *cap) 1711 { 1712 struct video_device *vdev = video_devdata(file); 1713 struct em28xx *dev = video_drvdata(file); 1714 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1715 1716 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1717 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 1718 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1719 1720 if (vdev->vfl_type == VFL_TYPE_GRABBER) 1721 cap->device_caps = V4L2_CAP_READWRITE | 1722 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1723 else if (vdev->vfl_type == VFL_TYPE_RADIO) 1724 cap->device_caps = V4L2_CAP_RADIO; 1725 else 1726 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE; 1727 1728 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE) 1729 cap->device_caps |= V4L2_CAP_AUDIO; 1730 1731 if (dev->tuner_type != TUNER_ABSENT) 1732 cap->device_caps |= V4L2_CAP_TUNER; 1733 1734 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS | 1735 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1736 if (video_is_registered(&v4l2->vbi_dev)) 1737 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 1738 if (video_is_registered(&v4l2->radio_dev)) 1739 cap->capabilities |= V4L2_CAP_RADIO; 1740 return 0; 1741 } 1742 1743 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1744 struct v4l2_fmtdesc *f) 1745 { 1746 if (unlikely(f->index >= ARRAY_SIZE(format))) 1747 return -EINVAL; 1748 1749 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1750 f->pixelformat = format[f->index].fourcc; 1751 1752 return 0; 1753 } 1754 1755 static int vidioc_enum_framesizes(struct file *file, void *priv, 1756 struct v4l2_frmsizeenum *fsize) 1757 { 1758 struct em28xx *dev = video_drvdata(file); 1759 struct em28xx_fmt *fmt; 1760 unsigned int maxw = norm_maxw(dev); 1761 unsigned int maxh = norm_maxh(dev); 1762 1763 fmt = format_by_fourcc(fsize->pixel_format); 1764 if (!fmt) { 1765 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1766 fsize->pixel_format); 1767 return -EINVAL; 1768 } 1769 1770 if (dev->board.is_em2800) { 1771 if (fsize->index > 1) 1772 return -EINVAL; 1773 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1774 fsize->discrete.width = maxw / (1 + fsize->index); 1775 fsize->discrete.height = maxh / (1 + fsize->index); 1776 return 0; 1777 } 1778 1779 if (fsize->index != 0) 1780 return -EINVAL; 1781 1782 /* Report a continuous range */ 1783 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 1784 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX, 1785 &fsize->stepwise.min_width, &fsize->stepwise.min_height); 1786 if (fsize->stepwise.min_width < 48) 1787 fsize->stepwise.min_width = 48; 1788 if (fsize->stepwise.min_height < 38) 1789 fsize->stepwise.min_height = 38; 1790 fsize->stepwise.max_width = maxw; 1791 fsize->stepwise.max_height = maxh; 1792 fsize->stepwise.step_width = 1; 1793 fsize->stepwise.step_height = 1; 1794 return 0; 1795 } 1796 1797 /* RAW VBI ioctls */ 1798 1799 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1800 struct v4l2_format *format) 1801 { 1802 struct em28xx *dev = video_drvdata(file); 1803 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1804 1805 format->fmt.vbi.samples_per_line = v4l2->vbi_width; 1806 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1807 format->fmt.vbi.offset = 0; 1808 format->fmt.vbi.flags = 0; 1809 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1810 format->fmt.vbi.count[0] = v4l2->vbi_height; 1811 format->fmt.vbi.count[1] = v4l2->vbi_height; 1812 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved)); 1813 1814 /* Varies by video standard (NTSC, PAL, etc.) */ 1815 if (v4l2->norm & V4L2_STD_525_60) { 1816 /* NTSC */ 1817 format->fmt.vbi.start[0] = 10; 1818 format->fmt.vbi.start[1] = 273; 1819 } else if (v4l2->norm & V4L2_STD_625_50) { 1820 /* PAL */ 1821 format->fmt.vbi.start[0] = 6; 1822 format->fmt.vbi.start[1] = 318; 1823 } 1824 1825 return 0; 1826 } 1827 1828 /* ----------------------------------------------------------- */ 1829 /* RADIO ESPECIFIC IOCTLS */ 1830 /* ----------------------------------------------------------- */ 1831 1832 static int radio_g_tuner(struct file *file, void *priv, 1833 struct v4l2_tuner *t) 1834 { 1835 struct em28xx *dev = video_drvdata(file); 1836 1837 if (unlikely(t->index > 0)) 1838 return -EINVAL; 1839 1840 strcpy(t->name, "Radio"); 1841 1842 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1843 1844 return 0; 1845 } 1846 1847 static int radio_s_tuner(struct file *file, void *priv, 1848 const struct v4l2_tuner *t) 1849 { 1850 struct em28xx *dev = video_drvdata(file); 1851 1852 if (0 != t->index) 1853 return -EINVAL; 1854 1855 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1856 1857 return 0; 1858 } 1859 1860 /* 1861 * em28xx_free_v4l2() - Free struct em28xx_v4l2 1862 * 1863 * @ref: struct kref for struct em28xx_v4l2 1864 * 1865 * Called when all users of struct em28xx_v4l2 are gone 1866 */ 1867 static void em28xx_free_v4l2(struct kref *ref) 1868 { 1869 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref); 1870 1871 v4l2->dev->v4l2 = NULL; 1872 kfree(v4l2); 1873 } 1874 1875 /* 1876 * em28xx_v4l2_open() 1877 * inits the device and starts isoc transfer 1878 */ 1879 static int em28xx_v4l2_open(struct file *filp) 1880 { 1881 struct video_device *vdev = video_devdata(filp); 1882 struct em28xx *dev = video_drvdata(filp); 1883 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1884 enum v4l2_buf_type fh_type = 0; 1885 int ret; 1886 1887 switch (vdev->vfl_type) { 1888 case VFL_TYPE_GRABBER: 1889 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1890 break; 1891 case VFL_TYPE_VBI: 1892 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 1893 break; 1894 case VFL_TYPE_RADIO: 1895 break; 1896 default: 1897 return -EINVAL; 1898 } 1899 1900 em28xx_videodbg("open dev=%s type=%s users=%d\n", 1901 video_device_node_name(vdev), v4l2_type_names[fh_type], 1902 v4l2->users); 1903 1904 if (mutex_lock_interruptible(&dev->lock)) 1905 return -ERESTARTSYS; 1906 1907 ret = v4l2_fh_open(filp); 1908 if (ret) { 1909 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n", 1910 __func__, ret); 1911 mutex_unlock(&dev->lock); 1912 return ret; 1913 } 1914 1915 if (v4l2->users == 0) { 1916 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 1917 1918 if (vdev->vfl_type != VFL_TYPE_RADIO) 1919 em28xx_resolution_set(dev); 1920 1921 /* 1922 * Needed, since GPIO might have disabled power 1923 * of some i2c devices 1924 */ 1925 em28xx_wake_i2c(dev); 1926 } 1927 1928 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1929 em28xx_videodbg("video_open: setting radio device\n"); 1930 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio); 1931 } 1932 1933 kref_get(&dev->ref); 1934 kref_get(&v4l2->ref); 1935 v4l2->users++; 1936 1937 mutex_unlock(&dev->lock); 1938 1939 return 0; 1940 } 1941 1942 /* 1943 * em28xx_v4l2_fini() 1944 * unregisters the v4l2,i2c and usb devices 1945 * called when the device gets disconected or at module unload 1946 */ 1947 static int em28xx_v4l2_fini(struct em28xx *dev) 1948 { 1949 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1950 1951 if (dev->is_audio_only) { 1952 /* Shouldn't initialize IR for this interface */ 1953 return 0; 1954 } 1955 1956 if (!dev->has_video) { 1957 /* This device does not support the v4l2 extension */ 1958 return 0; 1959 } 1960 1961 if (v4l2 == NULL) 1962 return 0; 1963 1964 em28xx_info("Closing video extension\n"); 1965 1966 mutex_lock(&dev->lock); 1967 1968 v4l2_device_disconnect(&v4l2->v4l2_dev); 1969 1970 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1971 1972 if (video_is_registered(&v4l2->radio_dev)) { 1973 em28xx_info("V4L2 device %s deregistered\n", 1974 video_device_node_name(&v4l2->radio_dev)); 1975 video_unregister_device(&v4l2->radio_dev); 1976 } 1977 if (video_is_registered(&v4l2->vbi_dev)) { 1978 em28xx_info("V4L2 device %s deregistered\n", 1979 video_device_node_name(&v4l2->vbi_dev)); 1980 video_unregister_device(&v4l2->vbi_dev); 1981 } 1982 if (video_is_registered(&v4l2->vdev)) { 1983 em28xx_info("V4L2 device %s deregistered\n", 1984 video_device_node_name(&v4l2->vdev)); 1985 video_unregister_device(&v4l2->vdev); 1986 } 1987 1988 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 1989 v4l2_device_unregister(&v4l2->v4l2_dev); 1990 1991 if (v4l2->clk) { 1992 v4l2_clk_unregister_fixed(v4l2->clk); 1993 v4l2->clk = NULL; 1994 } 1995 1996 kref_put(&v4l2->ref, em28xx_free_v4l2); 1997 1998 mutex_unlock(&dev->lock); 1999 2000 kref_put(&dev->ref, em28xx_free_device); 2001 2002 return 0; 2003 } 2004 2005 static int em28xx_v4l2_suspend(struct em28xx *dev) 2006 { 2007 if (dev->is_audio_only) 2008 return 0; 2009 2010 if (!dev->has_video) 2011 return 0; 2012 2013 em28xx_info("Suspending video extension\n"); 2014 em28xx_stop_urbs(dev); 2015 return 0; 2016 } 2017 2018 static int em28xx_v4l2_resume(struct em28xx *dev) 2019 { 2020 if (dev->is_audio_only) 2021 return 0; 2022 2023 if (!dev->has_video) 2024 return 0; 2025 2026 em28xx_info("Resuming video extension\n"); 2027 /* what do we do here */ 2028 return 0; 2029 } 2030 2031 /* 2032 * em28xx_v4l2_close() 2033 * stops streaming and deallocates all resources allocated by the v4l2 2034 * calls and ioctls 2035 */ 2036 static int em28xx_v4l2_close(struct file *filp) 2037 { 2038 struct em28xx *dev = video_drvdata(filp); 2039 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2040 int errCode; 2041 2042 em28xx_videodbg("users=%d\n", v4l2->users); 2043 2044 vb2_fop_release(filp); 2045 mutex_lock(&dev->lock); 2046 2047 if (v4l2->users == 1) { 2048 /* No sense to try to write to the device */ 2049 if (dev->disconnected) 2050 goto exit; 2051 2052 /* Save some power by putting tuner to sleep */ 2053 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2054 2055 /* do this before setting alternate! */ 2056 em28xx_set_mode(dev, EM28XX_SUSPEND); 2057 2058 /* set alternate 0 */ 2059 dev->alt = 0; 2060 em28xx_videodbg("setting alternate 0\n"); 2061 errCode = usb_set_interface(dev->udev, 0, 0); 2062 if (errCode < 0) { 2063 em28xx_errdev("cannot change alternate number to " 2064 "0 (error=%i)\n", errCode); 2065 } 2066 } 2067 2068 exit: 2069 v4l2->users--; 2070 kref_put(&v4l2->ref, em28xx_free_v4l2); 2071 mutex_unlock(&dev->lock); 2072 kref_put(&dev->ref, em28xx_free_device); 2073 2074 return 0; 2075 } 2076 2077 static const struct v4l2_file_operations em28xx_v4l_fops = { 2078 .owner = THIS_MODULE, 2079 .open = em28xx_v4l2_open, 2080 .release = em28xx_v4l2_close, 2081 .read = vb2_fop_read, 2082 .poll = vb2_fop_poll, 2083 .mmap = vb2_fop_mmap, 2084 .unlocked_ioctl = video_ioctl2, 2085 }; 2086 2087 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2088 .vidioc_querycap = vidioc_querycap, 2089 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2090 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2091 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2092 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2093 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2094 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2095 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2096 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2097 .vidioc_g_audio = vidioc_g_audio, 2098 .vidioc_s_audio = vidioc_s_audio, 2099 2100 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2101 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2102 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 2103 .vidioc_querybuf = vb2_ioctl_querybuf, 2104 .vidioc_qbuf = vb2_ioctl_qbuf, 2105 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2106 2107 .vidioc_g_std = vidioc_g_std, 2108 .vidioc_querystd = vidioc_querystd, 2109 .vidioc_s_std = vidioc_s_std, 2110 .vidioc_g_parm = vidioc_g_parm, 2111 .vidioc_s_parm = vidioc_s_parm, 2112 .vidioc_enum_input = vidioc_enum_input, 2113 .vidioc_g_input = vidioc_g_input, 2114 .vidioc_s_input = vidioc_s_input, 2115 .vidioc_streamon = vb2_ioctl_streamon, 2116 .vidioc_streamoff = vb2_ioctl_streamoff, 2117 .vidioc_g_tuner = vidioc_g_tuner, 2118 .vidioc_s_tuner = vidioc_s_tuner, 2119 .vidioc_g_frequency = vidioc_g_frequency, 2120 .vidioc_s_frequency = vidioc_s_frequency, 2121 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2122 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2123 #ifdef CONFIG_VIDEO_ADV_DEBUG 2124 .vidioc_g_chip_info = vidioc_g_chip_info, 2125 .vidioc_g_register = vidioc_g_register, 2126 .vidioc_s_register = vidioc_s_register, 2127 #endif 2128 }; 2129 2130 static const struct video_device em28xx_video_template = { 2131 .fops = &em28xx_v4l_fops, 2132 .ioctl_ops = &video_ioctl_ops, 2133 .release = video_device_release_empty, 2134 .tvnorms = V4L2_STD_ALL, 2135 }; 2136 2137 static const struct v4l2_file_operations radio_fops = { 2138 .owner = THIS_MODULE, 2139 .open = em28xx_v4l2_open, 2140 .release = em28xx_v4l2_close, 2141 .unlocked_ioctl = video_ioctl2, 2142 }; 2143 2144 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2145 .vidioc_querycap = vidioc_querycap, 2146 .vidioc_g_tuner = radio_g_tuner, 2147 .vidioc_s_tuner = radio_s_tuner, 2148 .vidioc_g_frequency = vidioc_g_frequency, 2149 .vidioc_s_frequency = vidioc_s_frequency, 2150 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2151 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2152 #ifdef CONFIG_VIDEO_ADV_DEBUG 2153 .vidioc_g_chip_info = vidioc_g_chip_info, 2154 .vidioc_g_register = vidioc_g_register, 2155 .vidioc_s_register = vidioc_s_register, 2156 #endif 2157 }; 2158 2159 static struct video_device em28xx_radio_template = { 2160 .fops = &radio_fops, 2161 .ioctl_ops = &radio_ioctl_ops, 2162 .release = video_device_release_empty, 2163 }; 2164 2165 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */ 2166 static unsigned short saa711x_addrs[] = { 2167 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */ 2168 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */ 2169 I2C_CLIENT_END }; 2170 2171 static unsigned short tvp5150_addrs[] = { 2172 0xb8 >> 1, 2173 0xba >> 1, 2174 I2C_CLIENT_END 2175 }; 2176 2177 static unsigned short msp3400_addrs[] = { 2178 0x80 >> 1, 2179 0x88 >> 1, 2180 I2C_CLIENT_END 2181 }; 2182 2183 /******************************** usb interface ******************************/ 2184 2185 static void em28xx_vdev_init(struct em28xx *dev, 2186 struct video_device *vfd, 2187 const struct video_device *template, 2188 const char *type_name) 2189 { 2190 *vfd = *template; 2191 vfd->v4l2_dev = &dev->v4l2->v4l2_dev; 2192 vfd->lock = &dev->lock; 2193 if (dev->board.is_webcam) 2194 vfd->tvnorms = 0; 2195 2196 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 2197 dev->name, type_name); 2198 2199 video_set_drvdata(vfd, dev); 2200 } 2201 2202 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr) 2203 { 2204 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2205 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev; 2206 struct tuner_setup tun_setup; 2207 struct v4l2_frequency f; 2208 2209 memset(&tun_setup, 0, sizeof(tun_setup)); 2210 2211 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 2212 tun_setup.tuner_callback = em28xx_tuner_callback; 2213 2214 if (dev->board.radio.type) { 2215 tun_setup.type = dev->board.radio.type; 2216 tun_setup.addr = dev->board.radio_addr; 2217 2218 v4l2_device_call_all(v4l2_dev, 2219 0, tuner, s_type_addr, &tun_setup); 2220 } 2221 2222 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) { 2223 tun_setup.type = dev->tuner_type; 2224 tun_setup.addr = tuner_addr; 2225 2226 v4l2_device_call_all(v4l2_dev, 2227 0, tuner, s_type_addr, &tun_setup); 2228 } 2229 2230 if (dev->board.tda9887_conf) { 2231 struct v4l2_priv_tun_config tda9887_cfg; 2232 2233 tda9887_cfg.tuner = TUNER_TDA9887; 2234 tda9887_cfg.priv = &dev->board.tda9887_conf; 2235 2236 v4l2_device_call_all(v4l2_dev, 2237 0, tuner, s_config, &tda9887_cfg); 2238 } 2239 2240 if (dev->tuner_type == TUNER_XC2028) { 2241 struct v4l2_priv_tun_config xc2028_cfg; 2242 struct xc2028_ctrl ctl; 2243 2244 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg)); 2245 memset(&ctl, 0, sizeof(ctl)); 2246 2247 em28xx_setup_xc3028(dev, &ctl); 2248 2249 xc2028_cfg.tuner = TUNER_XC2028; 2250 xc2028_cfg.priv = &ctl; 2251 2252 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg); 2253 } 2254 2255 /* configure tuner */ 2256 f.tuner = 0; 2257 f.type = V4L2_TUNER_ANALOG_TV; 2258 f.frequency = 9076; /* just a magic number */ 2259 v4l2->frequency = f.frequency; 2260 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f); 2261 } 2262 2263 static int em28xx_v4l2_init(struct em28xx *dev) 2264 { 2265 u8 val; 2266 int ret; 2267 unsigned int maxw; 2268 struct v4l2_ctrl_handler *hdl; 2269 struct em28xx_v4l2 *v4l2; 2270 2271 if (dev->is_audio_only) { 2272 /* Shouldn't initialize IR for this interface */ 2273 return 0; 2274 } 2275 2276 if (!dev->has_video) { 2277 /* This device does not support the v4l2 extension */ 2278 return 0; 2279 } 2280 2281 em28xx_info("Registering V4L2 extension\n"); 2282 2283 mutex_lock(&dev->lock); 2284 2285 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL); 2286 if (v4l2 == NULL) { 2287 em28xx_info("em28xx_v4l: memory allocation failed\n"); 2288 mutex_unlock(&dev->lock); 2289 return -ENOMEM; 2290 } 2291 kref_init(&v4l2->ref); 2292 v4l2->dev = dev; 2293 dev->v4l2 = v4l2; 2294 2295 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev); 2296 if (ret < 0) { 2297 em28xx_errdev("Call to v4l2_device_register() failed!\n"); 2298 goto err; 2299 } 2300 2301 hdl = &v4l2->ctrl_handler; 2302 v4l2_ctrl_handler_init(hdl, 8); 2303 v4l2->v4l2_dev.ctrl_handler = hdl; 2304 2305 if (dev->board.is_webcam) 2306 v4l2->progressive = true; 2307 2308 /* 2309 * Default format, used for tvp5150 or saa711x output formats 2310 */ 2311 v4l2->vinmode = 0x10; 2312 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED | 2313 EM28XX_VINCTRL_CCIR656_ENABLE; 2314 2315 /* request some modules */ 2316 2317 if (dev->board.has_msp34xx) 2318 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2319 &dev->i2c_adap[dev->def_i2c_bus], 2320 "msp3400", 0, msp3400_addrs); 2321 2322 if (dev->board.decoder == EM28XX_SAA711X) 2323 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2324 &dev->i2c_adap[dev->def_i2c_bus], 2325 "saa7115_auto", 0, saa711x_addrs); 2326 2327 if (dev->board.decoder == EM28XX_TVP5150) 2328 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2329 &dev->i2c_adap[dev->def_i2c_bus], 2330 "tvp5150", 0, tvp5150_addrs); 2331 2332 if (dev->board.adecoder == EM28XX_TVAUDIO) 2333 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2334 &dev->i2c_adap[dev->def_i2c_bus], 2335 "tvaudio", dev->board.tvaudio_addr, NULL); 2336 2337 /* Initialize tuner and camera */ 2338 2339 if (dev->board.tuner_type != TUNER_ABSENT) { 2340 unsigned short tuner_addr = dev->board.tuner_addr; 2341 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT); 2342 2343 if (dev->board.radio.type) 2344 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2345 &dev->i2c_adap[dev->def_i2c_bus], 2346 "tuner", dev->board.radio_addr, 2347 NULL); 2348 2349 if (has_demod) 2350 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2351 &dev->i2c_adap[dev->def_i2c_bus], 2352 "tuner", 0, 2353 v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 2354 if (tuner_addr == 0) { 2355 enum v4l2_i2c_tuner_type type = 2356 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; 2357 struct v4l2_subdev *sd; 2358 2359 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2360 &dev->i2c_adap[dev->def_i2c_bus], 2361 "tuner", 0, 2362 v4l2_i2c_tuner_addrs(type)); 2363 2364 if (sd) 2365 tuner_addr = v4l2_i2c_subdev_addr(sd); 2366 } else { 2367 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2368 &dev->i2c_adap[dev->def_i2c_bus], 2369 "tuner", tuner_addr, NULL); 2370 } 2371 2372 em28xx_tuner_setup(dev, tuner_addr); 2373 } 2374 2375 if (dev->em28xx_sensor != EM28XX_NOSENSOR) 2376 em28xx_init_camera(dev); 2377 2378 /* Configure audio */ 2379 ret = em28xx_audio_setup(dev); 2380 if (ret < 0) { 2381 em28xx_errdev("%s: Error while setting audio - error [%d]!\n", 2382 __func__, ret); 2383 goto unregister_dev; 2384 } 2385 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) { 2386 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2387 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 2388 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2389 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f); 2390 } else { 2391 /* install the em28xx notify callback */ 2392 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE), 2393 em28xx_ctrl_notify, dev); 2394 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME), 2395 em28xx_ctrl_notify, dev); 2396 } 2397 2398 /* wake i2c devices */ 2399 em28xx_wake_i2c(dev); 2400 2401 /* init video dma queues */ 2402 INIT_LIST_HEAD(&dev->vidq.active); 2403 INIT_LIST_HEAD(&dev->vbiq.active); 2404 2405 if (dev->board.has_msp34xx) { 2406 /* Send a reset to other chips via gpio */ 2407 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7); 2408 if (ret < 0) { 2409 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n", 2410 __func__, ret); 2411 goto unregister_dev; 2412 } 2413 msleep(3); 2414 2415 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff); 2416 if (ret < 0) { 2417 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n", 2418 __func__, ret); 2419 goto unregister_dev; 2420 } 2421 msleep(3); 2422 } 2423 2424 /* set default norm */ 2425 v4l2->norm = V4L2_STD_PAL; 2426 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 2427 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT; 2428 2429 /* Analog specific initialization */ 2430 v4l2->format = &format[0]; 2431 2432 maxw = norm_maxw(dev); 2433 /* MaxPacketSize for em2800 is too small to capture at full resolution 2434 * use half of maxw as the scaler can only scale to 50% */ 2435 if (dev->board.is_em2800) 2436 maxw /= 2; 2437 2438 em28xx_set_video_format(dev, format[0].fourcc, 2439 maxw, norm_maxh(dev)); 2440 2441 video_mux(dev, 0); 2442 2443 /* Audio defaults */ 2444 dev->mute = 1; 2445 dev->volume = 0x1f; 2446 2447 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 2448 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 2449 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 2450 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 2451 2452 em28xx_set_outfmt(dev); 2453 2454 /* Add image controls */ 2455 /* NOTE: at this point, the subdevices are already registered, so bridge 2456 * controls are only added/enabled when no subdevice provides them */ 2457 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST)) 2458 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2459 V4L2_CID_CONTRAST, 2460 0, 0x1f, 1, CONTRAST_DEFAULT); 2461 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS)) 2462 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2463 V4L2_CID_BRIGHTNESS, 2464 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT); 2465 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION)) 2466 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2467 V4L2_CID_SATURATION, 2468 0, 0x1f, 1, SATURATION_DEFAULT); 2469 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE)) 2470 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2471 V4L2_CID_BLUE_BALANCE, 2472 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT); 2473 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE)) 2474 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2475 V4L2_CID_RED_BALANCE, 2476 -0x30, 0x30, 1, RED_BALANCE_DEFAULT); 2477 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS)) 2478 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2479 V4L2_CID_SHARPNESS, 2480 0, 0x0f, 1, SHARPNESS_DEFAULT); 2481 2482 /* Reset image controls */ 2483 em28xx_colorlevels_set_default(dev); 2484 v4l2_ctrl_handler_setup(hdl); 2485 ret = hdl->error; 2486 if (ret) 2487 goto unregister_dev; 2488 2489 /* allocate and fill video video_device struct */ 2490 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video"); 2491 mutex_init(&v4l2->vb_queue_lock); 2492 mutex_init(&v4l2->vb_vbi_queue_lock); 2493 v4l2->vdev.queue = &v4l2->vb_vidq; 2494 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock; 2495 2496 /* disable inapplicable ioctls */ 2497 if (dev->board.is_webcam) { 2498 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD); 2499 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD); 2500 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD); 2501 } else { 2502 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM); 2503 } 2504 if (dev->tuner_type == TUNER_ABSENT) { 2505 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER); 2506 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER); 2507 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY); 2508 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY); 2509 } 2510 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2511 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO); 2512 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO); 2513 } 2514 2515 /* register v4l2 video video_device */ 2516 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER, 2517 video_nr[dev->devno]); 2518 if (ret) { 2519 em28xx_errdev("unable to register video device (error=%i).\n", 2520 ret); 2521 goto unregister_dev; 2522 } 2523 2524 /* Allocate and fill vbi video_device struct */ 2525 if (em28xx_vbi_supported(dev) == 1) { 2526 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template, 2527 "vbi"); 2528 2529 v4l2->vbi_dev.queue = &v4l2->vb_vbiq; 2530 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock; 2531 2532 /* disable inapplicable ioctls */ 2533 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM); 2534 if (dev->tuner_type == TUNER_ABSENT) { 2535 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER); 2536 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER); 2537 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY); 2538 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY); 2539 } 2540 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2541 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO); 2542 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO); 2543 } 2544 2545 /* register v4l2 vbi video_device */ 2546 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI, 2547 vbi_nr[dev->devno]); 2548 if (ret < 0) { 2549 em28xx_errdev("unable to register vbi device\n"); 2550 goto unregister_dev; 2551 } 2552 } 2553 2554 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2555 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template, 2556 "radio"); 2557 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO, 2558 radio_nr[dev->devno]); 2559 if (ret < 0) { 2560 em28xx_errdev("can't register radio device\n"); 2561 goto unregister_dev; 2562 } 2563 em28xx_info("Registered radio device as %s\n", 2564 video_device_node_name(&v4l2->radio_dev)); 2565 } 2566 2567 em28xx_info("V4L2 video device registered as %s\n", 2568 video_device_node_name(&v4l2->vdev)); 2569 2570 if (video_is_registered(&v4l2->vbi_dev)) 2571 em28xx_info("V4L2 VBI device registered as %s\n", 2572 video_device_node_name(&v4l2->vbi_dev)); 2573 2574 /* Save some power by putting tuner to sleep */ 2575 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2576 2577 /* initialize videobuf2 stuff */ 2578 em28xx_vb2_setup(dev); 2579 2580 em28xx_info("V4L2 extension successfully initialized\n"); 2581 2582 kref_get(&dev->ref); 2583 2584 mutex_unlock(&dev->lock); 2585 return 0; 2586 2587 unregister_dev: 2588 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 2589 v4l2_device_unregister(&v4l2->v4l2_dev); 2590 err: 2591 dev->v4l2 = NULL; 2592 kref_put(&v4l2->ref, em28xx_free_v4l2); 2593 mutex_unlock(&dev->lock); 2594 return ret; 2595 } 2596 2597 static struct em28xx_ops v4l2_ops = { 2598 .id = EM28XX_V4L2, 2599 .name = "Em28xx v4l2 Extension", 2600 .init = em28xx_v4l2_init, 2601 .fini = em28xx_v4l2_fini, 2602 .suspend = em28xx_v4l2_suspend, 2603 .resume = em28xx_v4l2_resume, 2604 }; 2605 2606 static int __init em28xx_video_register(void) 2607 { 2608 return em28xx_register_extension(&v4l2_ops); 2609 } 2610 2611 static void __exit em28xx_video_unregister(void) 2612 { 2613 em28xx_unregister_extension(&v4l2_ops); 2614 } 2615 2616 module_init(em28xx_video_register); 2617 module_exit(em28xx_video_unregister); 2618