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 * const iname[] = { 1446 [EM28XX_VMUX_COMPOSITE] = "Composite", 1447 [EM28XX_VMUX_SVIDEO] = "S-Video", 1448 [EM28XX_VMUX_TELEVISION] = "Television", 1449 [EM28XX_RADIO] = "Radio", 1450 }; 1451 1452 static int vidioc_enum_input(struct file *file, void *priv, 1453 struct v4l2_input *i) 1454 { 1455 struct em28xx *dev = video_drvdata(file); 1456 unsigned int n; 1457 1458 n = i->index; 1459 if (n >= MAX_EM28XX_INPUT) 1460 return -EINVAL; 1461 if (0 == INPUT(n)->type) 1462 return -EINVAL; 1463 1464 i->index = n; 1465 i->type = V4L2_INPUT_TYPE_CAMERA; 1466 1467 strcpy(i->name, iname[INPUT(n)->type]); 1468 1469 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type)) 1470 i->type = V4L2_INPUT_TYPE_TUNER; 1471 1472 i->std = dev->v4l2->vdev.tvnorms; 1473 /* webcams do not have the STD API */ 1474 if (dev->board.is_webcam) 1475 i->capabilities = 0; 1476 1477 return 0; 1478 } 1479 1480 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1481 { 1482 struct em28xx *dev = video_drvdata(file); 1483 1484 *i = dev->ctl_input; 1485 1486 return 0; 1487 } 1488 1489 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1490 { 1491 struct em28xx *dev = video_drvdata(file); 1492 1493 if (i >= MAX_EM28XX_INPUT) 1494 return -EINVAL; 1495 if (0 == INPUT(i)->type) 1496 return -EINVAL; 1497 1498 video_mux(dev, i); 1499 return 0; 1500 } 1501 1502 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1503 { 1504 struct em28xx *dev = video_drvdata(file); 1505 1506 switch (a->index) { 1507 case EM28XX_AMUX_VIDEO: 1508 strcpy(a->name, "Television"); 1509 break; 1510 case EM28XX_AMUX_LINE_IN: 1511 strcpy(a->name, "Line In"); 1512 break; 1513 case EM28XX_AMUX_VIDEO2: 1514 strcpy(a->name, "Television alt"); 1515 break; 1516 case EM28XX_AMUX_PHONE: 1517 strcpy(a->name, "Phone"); 1518 break; 1519 case EM28XX_AMUX_MIC: 1520 strcpy(a->name, "Mic"); 1521 break; 1522 case EM28XX_AMUX_CD: 1523 strcpy(a->name, "CD"); 1524 break; 1525 case EM28XX_AMUX_AUX: 1526 strcpy(a->name, "Aux"); 1527 break; 1528 case EM28XX_AMUX_PCM_OUT: 1529 strcpy(a->name, "PCM"); 1530 break; 1531 default: 1532 return -EINVAL; 1533 } 1534 1535 a->index = dev->ctl_ainput; 1536 a->capability = V4L2_AUDCAP_STEREO; 1537 1538 return 0; 1539 } 1540 1541 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1542 { 1543 struct em28xx *dev = video_drvdata(file); 1544 1545 if (a->index >= MAX_EM28XX_INPUT) 1546 return -EINVAL; 1547 if (0 == INPUT(a->index)->type) 1548 return -EINVAL; 1549 1550 dev->ctl_ainput = INPUT(a->index)->amux; 1551 dev->ctl_aoutput = INPUT(a->index)->aout; 1552 1553 if (!dev->ctl_aoutput) 1554 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1555 1556 return 0; 1557 } 1558 1559 static int vidioc_g_tuner(struct file *file, void *priv, 1560 struct v4l2_tuner *t) 1561 { 1562 struct em28xx *dev = video_drvdata(file); 1563 1564 if (0 != t->index) 1565 return -EINVAL; 1566 1567 strcpy(t->name, "Tuner"); 1568 1569 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1570 return 0; 1571 } 1572 1573 static int vidioc_s_tuner(struct file *file, void *priv, 1574 const struct v4l2_tuner *t) 1575 { 1576 struct em28xx *dev = video_drvdata(file); 1577 1578 if (0 != t->index) 1579 return -EINVAL; 1580 1581 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1582 return 0; 1583 } 1584 1585 static int vidioc_g_frequency(struct file *file, void *priv, 1586 struct v4l2_frequency *f) 1587 { 1588 struct em28xx *dev = video_drvdata(file); 1589 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1590 1591 if (0 != f->tuner) 1592 return -EINVAL; 1593 1594 f->frequency = v4l2->frequency; 1595 return 0; 1596 } 1597 1598 static int vidioc_s_frequency(struct file *file, void *priv, 1599 const struct v4l2_frequency *f) 1600 { 1601 struct v4l2_frequency new_freq = *f; 1602 struct em28xx *dev = video_drvdata(file); 1603 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1604 1605 if (0 != f->tuner) 1606 return -EINVAL; 1607 1608 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_frequency, f); 1609 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, g_frequency, &new_freq); 1610 v4l2->frequency = new_freq.frequency; 1611 1612 return 0; 1613 } 1614 1615 #ifdef CONFIG_VIDEO_ADV_DEBUG 1616 static int vidioc_g_chip_info(struct file *file, void *priv, 1617 struct v4l2_dbg_chip_info *chip) 1618 { 1619 struct em28xx *dev = video_drvdata(file); 1620 1621 if (chip->match.addr > 1) 1622 return -EINVAL; 1623 if (chip->match.addr == 1) 1624 strlcpy(chip->name, "ac97", sizeof(chip->name)); 1625 else 1626 strlcpy(chip->name, 1627 dev->v4l2->v4l2_dev.name, sizeof(chip->name)); 1628 return 0; 1629 } 1630 1631 static int em28xx_reg_len(int reg) 1632 { 1633 switch (reg) { 1634 case EM28XX_R40_AC97LSB: 1635 case EM28XX_R30_HSCALELOW: 1636 case EM28XX_R32_VSCALELOW: 1637 return 2; 1638 default: 1639 return 1; 1640 } 1641 } 1642 1643 static int vidioc_g_register(struct file *file, void *priv, 1644 struct v4l2_dbg_register *reg) 1645 { 1646 struct em28xx *dev = video_drvdata(file); 1647 int ret; 1648 1649 if (reg->match.addr > 1) 1650 return -EINVAL; 1651 if (reg->match.addr) { 1652 ret = em28xx_read_ac97(dev, reg->reg); 1653 if (ret < 0) 1654 return ret; 1655 1656 reg->val = ret; 1657 reg->size = 1; 1658 return 0; 1659 } 1660 1661 /* Match host */ 1662 reg->size = em28xx_reg_len(reg->reg); 1663 if (reg->size == 1) { 1664 ret = em28xx_read_reg(dev, reg->reg); 1665 1666 if (ret < 0) 1667 return ret; 1668 1669 reg->val = ret; 1670 } else { 1671 __le16 val = 0; 1672 1673 ret = dev->em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS, 1674 reg->reg, (char *)&val, 2); 1675 if (ret < 0) 1676 return ret; 1677 1678 reg->val = le16_to_cpu(val); 1679 } 1680 1681 return 0; 1682 } 1683 1684 static int vidioc_s_register(struct file *file, void *priv, 1685 const struct v4l2_dbg_register *reg) 1686 { 1687 struct em28xx *dev = video_drvdata(file); 1688 __le16 buf; 1689 1690 if (reg->match.addr > 1) 1691 return -EINVAL; 1692 if (reg->match.addr) 1693 return em28xx_write_ac97(dev, reg->reg, reg->val); 1694 1695 /* Match host */ 1696 buf = cpu_to_le16(reg->val); 1697 1698 return em28xx_write_regs(dev, reg->reg, (char *)&buf, 1699 em28xx_reg_len(reg->reg)); 1700 } 1701 #endif 1702 1703 static int vidioc_querycap(struct file *file, void *priv, 1704 struct v4l2_capability *cap) 1705 { 1706 struct video_device *vdev = video_devdata(file); 1707 struct em28xx *dev = video_drvdata(file); 1708 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1709 1710 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1711 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 1712 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1713 1714 if (vdev->vfl_type == VFL_TYPE_GRABBER) 1715 cap->device_caps = V4L2_CAP_READWRITE | 1716 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1717 else if (vdev->vfl_type == VFL_TYPE_RADIO) 1718 cap->device_caps = V4L2_CAP_RADIO; 1719 else 1720 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE; 1721 1722 if (dev->int_audio_type != EM28XX_INT_AUDIO_NONE) 1723 cap->device_caps |= V4L2_CAP_AUDIO; 1724 1725 if (dev->tuner_type != TUNER_ABSENT) 1726 cap->device_caps |= V4L2_CAP_TUNER; 1727 1728 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS | 1729 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1730 if (video_is_registered(&v4l2->vbi_dev)) 1731 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 1732 if (video_is_registered(&v4l2->radio_dev)) 1733 cap->capabilities |= V4L2_CAP_RADIO; 1734 return 0; 1735 } 1736 1737 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1738 struct v4l2_fmtdesc *f) 1739 { 1740 if (unlikely(f->index >= ARRAY_SIZE(format))) 1741 return -EINVAL; 1742 1743 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1744 f->pixelformat = format[f->index].fourcc; 1745 1746 return 0; 1747 } 1748 1749 static int vidioc_enum_framesizes(struct file *file, void *priv, 1750 struct v4l2_frmsizeenum *fsize) 1751 { 1752 struct em28xx *dev = video_drvdata(file); 1753 struct em28xx_fmt *fmt; 1754 unsigned int maxw = norm_maxw(dev); 1755 unsigned int maxh = norm_maxh(dev); 1756 1757 fmt = format_by_fourcc(fsize->pixel_format); 1758 if (!fmt) { 1759 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1760 fsize->pixel_format); 1761 return -EINVAL; 1762 } 1763 1764 if (dev->board.is_em2800) { 1765 if (fsize->index > 1) 1766 return -EINVAL; 1767 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1768 fsize->discrete.width = maxw / (1 + fsize->index); 1769 fsize->discrete.height = maxh / (1 + fsize->index); 1770 return 0; 1771 } 1772 1773 if (fsize->index != 0) 1774 return -EINVAL; 1775 1776 /* Report a continuous range */ 1777 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 1778 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX, 1779 &fsize->stepwise.min_width, &fsize->stepwise.min_height); 1780 if (fsize->stepwise.min_width < 48) 1781 fsize->stepwise.min_width = 48; 1782 if (fsize->stepwise.min_height < 38) 1783 fsize->stepwise.min_height = 38; 1784 fsize->stepwise.max_width = maxw; 1785 fsize->stepwise.max_height = maxh; 1786 fsize->stepwise.step_width = 1; 1787 fsize->stepwise.step_height = 1; 1788 return 0; 1789 } 1790 1791 /* RAW VBI ioctls */ 1792 1793 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1794 struct v4l2_format *format) 1795 { 1796 struct em28xx *dev = video_drvdata(file); 1797 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1798 1799 format->fmt.vbi.samples_per_line = v4l2->vbi_width; 1800 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1801 format->fmt.vbi.offset = 0; 1802 format->fmt.vbi.flags = 0; 1803 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1804 format->fmt.vbi.count[0] = v4l2->vbi_height; 1805 format->fmt.vbi.count[1] = v4l2->vbi_height; 1806 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved)); 1807 1808 /* Varies by video standard (NTSC, PAL, etc.) */ 1809 if (v4l2->norm & V4L2_STD_525_60) { 1810 /* NTSC */ 1811 format->fmt.vbi.start[0] = 10; 1812 format->fmt.vbi.start[1] = 273; 1813 } else if (v4l2->norm & V4L2_STD_625_50) { 1814 /* PAL */ 1815 format->fmt.vbi.start[0] = 6; 1816 format->fmt.vbi.start[1] = 318; 1817 } 1818 1819 return 0; 1820 } 1821 1822 /* ----------------------------------------------------------- */ 1823 /* RADIO ESPECIFIC IOCTLS */ 1824 /* ----------------------------------------------------------- */ 1825 1826 static int radio_g_tuner(struct file *file, void *priv, 1827 struct v4l2_tuner *t) 1828 { 1829 struct em28xx *dev = video_drvdata(file); 1830 1831 if (unlikely(t->index > 0)) 1832 return -EINVAL; 1833 1834 strcpy(t->name, "Radio"); 1835 1836 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, g_tuner, t); 1837 1838 return 0; 1839 } 1840 1841 static int radio_s_tuner(struct file *file, void *priv, 1842 const struct v4l2_tuner *t) 1843 { 1844 struct em28xx *dev = video_drvdata(file); 1845 1846 if (0 != t->index) 1847 return -EINVAL; 1848 1849 v4l2_device_call_all(&dev->v4l2->v4l2_dev, 0, tuner, s_tuner, t); 1850 1851 return 0; 1852 } 1853 1854 /* 1855 * em28xx_free_v4l2() - Free struct em28xx_v4l2 1856 * 1857 * @ref: struct kref for struct em28xx_v4l2 1858 * 1859 * Called when all users of struct em28xx_v4l2 are gone 1860 */ 1861 static void em28xx_free_v4l2(struct kref *ref) 1862 { 1863 struct em28xx_v4l2 *v4l2 = container_of(ref, struct em28xx_v4l2, ref); 1864 1865 v4l2->dev->v4l2 = NULL; 1866 kfree(v4l2); 1867 } 1868 1869 /* 1870 * em28xx_v4l2_open() 1871 * inits the device and starts isoc transfer 1872 */ 1873 static int em28xx_v4l2_open(struct file *filp) 1874 { 1875 struct video_device *vdev = video_devdata(filp); 1876 struct em28xx *dev = video_drvdata(filp); 1877 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1878 enum v4l2_buf_type fh_type = 0; 1879 int ret; 1880 1881 switch (vdev->vfl_type) { 1882 case VFL_TYPE_GRABBER: 1883 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1884 break; 1885 case VFL_TYPE_VBI: 1886 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 1887 break; 1888 case VFL_TYPE_RADIO: 1889 break; 1890 default: 1891 return -EINVAL; 1892 } 1893 1894 em28xx_videodbg("open dev=%s type=%s users=%d\n", 1895 video_device_node_name(vdev), v4l2_type_names[fh_type], 1896 v4l2->users); 1897 1898 if (mutex_lock_interruptible(&dev->lock)) 1899 return -ERESTARTSYS; 1900 1901 ret = v4l2_fh_open(filp); 1902 if (ret) { 1903 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n", 1904 __func__, ret); 1905 mutex_unlock(&dev->lock); 1906 return ret; 1907 } 1908 1909 if (v4l2->users == 0) { 1910 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 1911 1912 if (vdev->vfl_type != VFL_TYPE_RADIO) 1913 em28xx_resolution_set(dev); 1914 1915 /* 1916 * Needed, since GPIO might have disabled power 1917 * of some i2c devices 1918 */ 1919 em28xx_wake_i2c(dev); 1920 } 1921 1922 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1923 em28xx_videodbg("video_open: setting radio device\n"); 1924 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio); 1925 } 1926 1927 kref_get(&dev->ref); 1928 kref_get(&v4l2->ref); 1929 v4l2->users++; 1930 1931 mutex_unlock(&dev->lock); 1932 1933 return 0; 1934 } 1935 1936 /* 1937 * em28xx_v4l2_fini() 1938 * unregisters the v4l2,i2c and usb devices 1939 * called when the device gets disconected or at module unload 1940 */ 1941 static int em28xx_v4l2_fini(struct em28xx *dev) 1942 { 1943 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1944 1945 if (dev->is_audio_only) { 1946 /* Shouldn't initialize IR for this interface */ 1947 return 0; 1948 } 1949 1950 if (!dev->has_video) { 1951 /* This device does not support the v4l2 extension */ 1952 return 0; 1953 } 1954 1955 if (v4l2 == NULL) 1956 return 0; 1957 1958 em28xx_info("Closing video extension\n"); 1959 1960 mutex_lock(&dev->lock); 1961 1962 v4l2_device_disconnect(&v4l2->v4l2_dev); 1963 1964 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1965 1966 if (video_is_registered(&v4l2->radio_dev)) { 1967 em28xx_info("V4L2 device %s deregistered\n", 1968 video_device_node_name(&v4l2->radio_dev)); 1969 video_unregister_device(&v4l2->radio_dev); 1970 } 1971 if (video_is_registered(&v4l2->vbi_dev)) { 1972 em28xx_info("V4L2 device %s deregistered\n", 1973 video_device_node_name(&v4l2->vbi_dev)); 1974 video_unregister_device(&v4l2->vbi_dev); 1975 } 1976 if (video_is_registered(&v4l2->vdev)) { 1977 em28xx_info("V4L2 device %s deregistered\n", 1978 video_device_node_name(&v4l2->vdev)); 1979 video_unregister_device(&v4l2->vdev); 1980 } 1981 1982 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 1983 v4l2_device_unregister(&v4l2->v4l2_dev); 1984 1985 if (v4l2->clk) { 1986 v4l2_clk_unregister_fixed(v4l2->clk); 1987 v4l2->clk = NULL; 1988 } 1989 1990 kref_put(&v4l2->ref, em28xx_free_v4l2); 1991 1992 mutex_unlock(&dev->lock); 1993 1994 kref_put(&dev->ref, em28xx_free_device); 1995 1996 return 0; 1997 } 1998 1999 static int em28xx_v4l2_suspend(struct em28xx *dev) 2000 { 2001 if (dev->is_audio_only) 2002 return 0; 2003 2004 if (!dev->has_video) 2005 return 0; 2006 2007 em28xx_info("Suspending video extension\n"); 2008 em28xx_stop_urbs(dev); 2009 return 0; 2010 } 2011 2012 static int em28xx_v4l2_resume(struct em28xx *dev) 2013 { 2014 if (dev->is_audio_only) 2015 return 0; 2016 2017 if (!dev->has_video) 2018 return 0; 2019 2020 em28xx_info("Resuming video extension\n"); 2021 /* what do we do here */ 2022 return 0; 2023 } 2024 2025 /* 2026 * em28xx_v4l2_close() 2027 * stops streaming and deallocates all resources allocated by the v4l2 2028 * calls and ioctls 2029 */ 2030 static int em28xx_v4l2_close(struct file *filp) 2031 { 2032 struct em28xx *dev = video_drvdata(filp); 2033 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2034 int errCode; 2035 2036 em28xx_videodbg("users=%d\n", v4l2->users); 2037 2038 vb2_fop_release(filp); 2039 mutex_lock(&dev->lock); 2040 2041 if (v4l2->users == 1) { 2042 /* No sense to try to write to the device */ 2043 if (dev->disconnected) 2044 goto exit; 2045 2046 /* Save some power by putting tuner to sleep */ 2047 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2048 2049 /* do this before setting alternate! */ 2050 em28xx_set_mode(dev, EM28XX_SUSPEND); 2051 2052 /* set alternate 0 */ 2053 dev->alt = 0; 2054 em28xx_videodbg("setting alternate 0\n"); 2055 errCode = usb_set_interface(dev->udev, 0, 0); 2056 if (errCode < 0) { 2057 em28xx_errdev("cannot change alternate number to " 2058 "0 (error=%i)\n", errCode); 2059 } 2060 } 2061 2062 exit: 2063 v4l2->users--; 2064 kref_put(&v4l2->ref, em28xx_free_v4l2); 2065 mutex_unlock(&dev->lock); 2066 kref_put(&dev->ref, em28xx_free_device); 2067 2068 return 0; 2069 } 2070 2071 static const struct v4l2_file_operations em28xx_v4l_fops = { 2072 .owner = THIS_MODULE, 2073 .open = em28xx_v4l2_open, 2074 .release = em28xx_v4l2_close, 2075 .read = vb2_fop_read, 2076 .poll = vb2_fop_poll, 2077 .mmap = vb2_fop_mmap, 2078 .unlocked_ioctl = video_ioctl2, 2079 }; 2080 2081 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2082 .vidioc_querycap = vidioc_querycap, 2083 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2084 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2085 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2086 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2087 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2088 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2089 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2090 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2091 .vidioc_g_audio = vidioc_g_audio, 2092 .vidioc_s_audio = vidioc_s_audio, 2093 2094 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2095 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2096 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 2097 .vidioc_querybuf = vb2_ioctl_querybuf, 2098 .vidioc_qbuf = vb2_ioctl_qbuf, 2099 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2100 2101 .vidioc_g_std = vidioc_g_std, 2102 .vidioc_querystd = vidioc_querystd, 2103 .vidioc_s_std = vidioc_s_std, 2104 .vidioc_g_parm = vidioc_g_parm, 2105 .vidioc_s_parm = vidioc_s_parm, 2106 .vidioc_enum_input = vidioc_enum_input, 2107 .vidioc_g_input = vidioc_g_input, 2108 .vidioc_s_input = vidioc_s_input, 2109 .vidioc_streamon = vb2_ioctl_streamon, 2110 .vidioc_streamoff = vb2_ioctl_streamoff, 2111 .vidioc_g_tuner = vidioc_g_tuner, 2112 .vidioc_s_tuner = vidioc_s_tuner, 2113 .vidioc_g_frequency = vidioc_g_frequency, 2114 .vidioc_s_frequency = vidioc_s_frequency, 2115 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2116 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2117 #ifdef CONFIG_VIDEO_ADV_DEBUG 2118 .vidioc_g_chip_info = vidioc_g_chip_info, 2119 .vidioc_g_register = vidioc_g_register, 2120 .vidioc_s_register = vidioc_s_register, 2121 #endif 2122 }; 2123 2124 static const struct video_device em28xx_video_template = { 2125 .fops = &em28xx_v4l_fops, 2126 .ioctl_ops = &video_ioctl_ops, 2127 .release = video_device_release_empty, 2128 .tvnorms = V4L2_STD_ALL, 2129 }; 2130 2131 static const struct v4l2_file_operations radio_fops = { 2132 .owner = THIS_MODULE, 2133 .open = em28xx_v4l2_open, 2134 .release = em28xx_v4l2_close, 2135 .unlocked_ioctl = video_ioctl2, 2136 }; 2137 2138 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2139 .vidioc_querycap = vidioc_querycap, 2140 .vidioc_g_tuner = radio_g_tuner, 2141 .vidioc_s_tuner = radio_s_tuner, 2142 .vidioc_g_frequency = vidioc_g_frequency, 2143 .vidioc_s_frequency = vidioc_s_frequency, 2144 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2145 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2146 #ifdef CONFIG_VIDEO_ADV_DEBUG 2147 .vidioc_g_chip_info = vidioc_g_chip_info, 2148 .vidioc_g_register = vidioc_g_register, 2149 .vidioc_s_register = vidioc_s_register, 2150 #endif 2151 }; 2152 2153 static struct video_device em28xx_radio_template = { 2154 .fops = &radio_fops, 2155 .ioctl_ops = &radio_ioctl_ops, 2156 .release = video_device_release_empty, 2157 }; 2158 2159 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */ 2160 static unsigned short saa711x_addrs[] = { 2161 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */ 2162 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */ 2163 I2C_CLIENT_END }; 2164 2165 static unsigned short tvp5150_addrs[] = { 2166 0xb8 >> 1, 2167 0xba >> 1, 2168 I2C_CLIENT_END 2169 }; 2170 2171 static unsigned short msp3400_addrs[] = { 2172 0x80 >> 1, 2173 0x88 >> 1, 2174 I2C_CLIENT_END 2175 }; 2176 2177 /******************************** usb interface ******************************/ 2178 2179 static void em28xx_vdev_init(struct em28xx *dev, 2180 struct video_device *vfd, 2181 const struct video_device *template, 2182 const char *type_name) 2183 { 2184 *vfd = *template; 2185 vfd->v4l2_dev = &dev->v4l2->v4l2_dev; 2186 vfd->lock = &dev->lock; 2187 if (dev->board.is_webcam) 2188 vfd->tvnorms = 0; 2189 2190 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 2191 dev->name, type_name); 2192 2193 video_set_drvdata(vfd, dev); 2194 } 2195 2196 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr) 2197 { 2198 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2199 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev; 2200 struct tuner_setup tun_setup; 2201 struct v4l2_frequency f; 2202 2203 memset(&tun_setup, 0, sizeof(tun_setup)); 2204 2205 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 2206 tun_setup.tuner_callback = em28xx_tuner_callback; 2207 2208 if (dev->board.radio.type) { 2209 tun_setup.type = dev->board.radio.type; 2210 tun_setup.addr = dev->board.radio_addr; 2211 2212 v4l2_device_call_all(v4l2_dev, 2213 0, tuner, s_type_addr, &tun_setup); 2214 } 2215 2216 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) { 2217 tun_setup.type = dev->tuner_type; 2218 tun_setup.addr = tuner_addr; 2219 2220 v4l2_device_call_all(v4l2_dev, 2221 0, tuner, s_type_addr, &tun_setup); 2222 } 2223 2224 if (dev->board.tda9887_conf) { 2225 struct v4l2_priv_tun_config tda9887_cfg; 2226 2227 tda9887_cfg.tuner = TUNER_TDA9887; 2228 tda9887_cfg.priv = &dev->board.tda9887_conf; 2229 2230 v4l2_device_call_all(v4l2_dev, 2231 0, tuner, s_config, &tda9887_cfg); 2232 } 2233 2234 if (dev->tuner_type == TUNER_XC2028) { 2235 struct v4l2_priv_tun_config xc2028_cfg; 2236 struct xc2028_ctrl ctl; 2237 2238 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg)); 2239 memset(&ctl, 0, sizeof(ctl)); 2240 2241 em28xx_setup_xc3028(dev, &ctl); 2242 2243 xc2028_cfg.tuner = TUNER_XC2028; 2244 xc2028_cfg.priv = &ctl; 2245 2246 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg); 2247 } 2248 2249 /* configure tuner */ 2250 f.tuner = 0; 2251 f.type = V4L2_TUNER_ANALOG_TV; 2252 f.frequency = 9076; /* just a magic number */ 2253 v4l2->frequency = f.frequency; 2254 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f); 2255 } 2256 2257 static int em28xx_v4l2_init(struct em28xx *dev) 2258 { 2259 u8 val; 2260 int ret; 2261 unsigned int maxw; 2262 struct v4l2_ctrl_handler *hdl; 2263 struct em28xx_v4l2 *v4l2; 2264 2265 if (dev->is_audio_only) { 2266 /* Shouldn't initialize IR for this interface */ 2267 return 0; 2268 } 2269 2270 if (!dev->has_video) { 2271 /* This device does not support the v4l2 extension */ 2272 return 0; 2273 } 2274 2275 em28xx_info("Registering V4L2 extension\n"); 2276 2277 mutex_lock(&dev->lock); 2278 2279 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL); 2280 if (v4l2 == NULL) { 2281 em28xx_info("em28xx_v4l: memory allocation failed\n"); 2282 mutex_unlock(&dev->lock); 2283 return -ENOMEM; 2284 } 2285 kref_init(&v4l2->ref); 2286 v4l2->dev = dev; 2287 dev->v4l2 = v4l2; 2288 2289 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev); 2290 if (ret < 0) { 2291 em28xx_errdev("Call to v4l2_device_register() failed!\n"); 2292 goto err; 2293 } 2294 2295 hdl = &v4l2->ctrl_handler; 2296 v4l2_ctrl_handler_init(hdl, 8); 2297 v4l2->v4l2_dev.ctrl_handler = hdl; 2298 2299 if (dev->board.is_webcam) 2300 v4l2->progressive = true; 2301 2302 /* 2303 * Default format, used for tvp5150 or saa711x output formats 2304 */ 2305 v4l2->vinmode = 0x10; 2306 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED | 2307 EM28XX_VINCTRL_CCIR656_ENABLE; 2308 2309 /* request some modules */ 2310 2311 if (dev->board.has_msp34xx) 2312 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2313 &dev->i2c_adap[dev->def_i2c_bus], 2314 "msp3400", 0, msp3400_addrs); 2315 2316 if (dev->board.decoder == EM28XX_SAA711X) 2317 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2318 &dev->i2c_adap[dev->def_i2c_bus], 2319 "saa7115_auto", 0, saa711x_addrs); 2320 2321 if (dev->board.decoder == EM28XX_TVP5150) 2322 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2323 &dev->i2c_adap[dev->def_i2c_bus], 2324 "tvp5150", 0, tvp5150_addrs); 2325 2326 if (dev->board.adecoder == EM28XX_TVAUDIO) 2327 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2328 &dev->i2c_adap[dev->def_i2c_bus], 2329 "tvaudio", dev->board.tvaudio_addr, NULL); 2330 2331 /* Initialize tuner and camera */ 2332 2333 if (dev->board.tuner_type != TUNER_ABSENT) { 2334 unsigned short tuner_addr = dev->board.tuner_addr; 2335 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT); 2336 2337 if (dev->board.radio.type) 2338 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2339 &dev->i2c_adap[dev->def_i2c_bus], 2340 "tuner", dev->board.radio_addr, 2341 NULL); 2342 2343 if (has_demod) 2344 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2345 &dev->i2c_adap[dev->def_i2c_bus], 2346 "tuner", 0, 2347 v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 2348 if (tuner_addr == 0) { 2349 enum v4l2_i2c_tuner_type type = 2350 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; 2351 struct v4l2_subdev *sd; 2352 2353 sd = v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2354 &dev->i2c_adap[dev->def_i2c_bus], 2355 "tuner", 0, 2356 v4l2_i2c_tuner_addrs(type)); 2357 2358 if (sd) 2359 tuner_addr = v4l2_i2c_subdev_addr(sd); 2360 } else { 2361 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2362 &dev->i2c_adap[dev->def_i2c_bus], 2363 "tuner", tuner_addr, NULL); 2364 } 2365 2366 em28xx_tuner_setup(dev, tuner_addr); 2367 } 2368 2369 if (dev->em28xx_sensor != EM28XX_NOSENSOR) 2370 em28xx_init_camera(dev); 2371 2372 /* Configure audio */ 2373 ret = em28xx_audio_setup(dev); 2374 if (ret < 0) { 2375 em28xx_errdev("%s: Error while setting audio - error [%d]!\n", 2376 __func__, ret); 2377 goto unregister_dev; 2378 } 2379 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) { 2380 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2381 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 2382 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2383 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f); 2384 } else { 2385 /* install the em28xx notify callback */ 2386 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE), 2387 em28xx_ctrl_notify, dev); 2388 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME), 2389 em28xx_ctrl_notify, dev); 2390 } 2391 2392 /* wake i2c devices */ 2393 em28xx_wake_i2c(dev); 2394 2395 /* init video dma queues */ 2396 INIT_LIST_HEAD(&dev->vidq.active); 2397 INIT_LIST_HEAD(&dev->vbiq.active); 2398 2399 if (dev->board.has_msp34xx) { 2400 /* Send a reset to other chips via gpio */ 2401 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7); 2402 if (ret < 0) { 2403 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n", 2404 __func__, ret); 2405 goto unregister_dev; 2406 } 2407 msleep(3); 2408 2409 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff); 2410 if (ret < 0) { 2411 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n", 2412 __func__, ret); 2413 goto unregister_dev; 2414 } 2415 msleep(3); 2416 } 2417 2418 /* set default norm */ 2419 v4l2->norm = V4L2_STD_PAL; 2420 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 2421 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT; 2422 2423 /* Analog specific initialization */ 2424 v4l2->format = &format[0]; 2425 2426 maxw = norm_maxw(dev); 2427 /* MaxPacketSize for em2800 is too small to capture at full resolution 2428 * use half of maxw as the scaler can only scale to 50% */ 2429 if (dev->board.is_em2800) 2430 maxw /= 2; 2431 2432 em28xx_set_video_format(dev, format[0].fourcc, 2433 maxw, norm_maxh(dev)); 2434 2435 video_mux(dev, 0); 2436 2437 /* Audio defaults */ 2438 dev->mute = 1; 2439 dev->volume = 0x1f; 2440 2441 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 2442 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 2443 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 2444 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 2445 2446 em28xx_set_outfmt(dev); 2447 2448 /* Add image controls */ 2449 /* NOTE: at this point, the subdevices are already registered, so bridge 2450 * controls are only added/enabled when no subdevice provides them */ 2451 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST)) 2452 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2453 V4L2_CID_CONTRAST, 2454 0, 0x1f, 1, CONTRAST_DEFAULT); 2455 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS)) 2456 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2457 V4L2_CID_BRIGHTNESS, 2458 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT); 2459 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION)) 2460 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2461 V4L2_CID_SATURATION, 2462 0, 0x1f, 1, SATURATION_DEFAULT); 2463 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE)) 2464 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2465 V4L2_CID_BLUE_BALANCE, 2466 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT); 2467 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE)) 2468 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2469 V4L2_CID_RED_BALANCE, 2470 -0x30, 0x30, 1, RED_BALANCE_DEFAULT); 2471 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS)) 2472 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2473 V4L2_CID_SHARPNESS, 2474 0, 0x0f, 1, SHARPNESS_DEFAULT); 2475 2476 /* Reset image controls */ 2477 em28xx_colorlevels_set_default(dev); 2478 v4l2_ctrl_handler_setup(hdl); 2479 ret = hdl->error; 2480 if (ret) 2481 goto unregister_dev; 2482 2483 /* allocate and fill video video_device struct */ 2484 em28xx_vdev_init(dev, &v4l2->vdev, &em28xx_video_template, "video"); 2485 mutex_init(&v4l2->vb_queue_lock); 2486 mutex_init(&v4l2->vb_vbi_queue_lock); 2487 v4l2->vdev.queue = &v4l2->vb_vidq; 2488 v4l2->vdev.queue->lock = &v4l2->vb_queue_lock; 2489 2490 /* disable inapplicable ioctls */ 2491 if (dev->board.is_webcam) { 2492 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_QUERYSTD); 2493 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_STD); 2494 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_STD); 2495 } else { 2496 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_PARM); 2497 } 2498 if (dev->tuner_type == TUNER_ABSENT) { 2499 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_TUNER); 2500 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_TUNER); 2501 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_FREQUENCY); 2502 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_FREQUENCY); 2503 } 2504 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2505 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_G_AUDIO); 2506 v4l2_disable_ioctl(&v4l2->vdev, VIDIOC_S_AUDIO); 2507 } 2508 2509 /* register v4l2 video video_device */ 2510 ret = video_register_device(&v4l2->vdev, VFL_TYPE_GRABBER, 2511 video_nr[dev->devno]); 2512 if (ret) { 2513 em28xx_errdev("unable to register video device (error=%i).\n", 2514 ret); 2515 goto unregister_dev; 2516 } 2517 2518 /* Allocate and fill vbi video_device struct */ 2519 if (em28xx_vbi_supported(dev) == 1) { 2520 em28xx_vdev_init(dev, &v4l2->vbi_dev, &em28xx_video_template, 2521 "vbi"); 2522 2523 v4l2->vbi_dev.queue = &v4l2->vb_vbiq; 2524 v4l2->vbi_dev.queue->lock = &v4l2->vb_vbi_queue_lock; 2525 2526 /* disable inapplicable ioctls */ 2527 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_PARM); 2528 if (dev->tuner_type == TUNER_ABSENT) { 2529 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_TUNER); 2530 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_TUNER); 2531 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_FREQUENCY); 2532 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_FREQUENCY); 2533 } 2534 if (dev->int_audio_type == EM28XX_INT_AUDIO_NONE) { 2535 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_G_AUDIO); 2536 v4l2_disable_ioctl(&v4l2->vbi_dev, VIDIOC_S_AUDIO); 2537 } 2538 2539 /* register v4l2 vbi video_device */ 2540 ret = video_register_device(&v4l2->vbi_dev, VFL_TYPE_VBI, 2541 vbi_nr[dev->devno]); 2542 if (ret < 0) { 2543 em28xx_errdev("unable to register vbi device\n"); 2544 goto unregister_dev; 2545 } 2546 } 2547 2548 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2549 em28xx_vdev_init(dev, &v4l2->radio_dev, &em28xx_radio_template, 2550 "radio"); 2551 ret = video_register_device(&v4l2->radio_dev, VFL_TYPE_RADIO, 2552 radio_nr[dev->devno]); 2553 if (ret < 0) { 2554 em28xx_errdev("can't register radio device\n"); 2555 goto unregister_dev; 2556 } 2557 em28xx_info("Registered radio device as %s\n", 2558 video_device_node_name(&v4l2->radio_dev)); 2559 } 2560 2561 em28xx_info("V4L2 video device registered as %s\n", 2562 video_device_node_name(&v4l2->vdev)); 2563 2564 if (video_is_registered(&v4l2->vbi_dev)) 2565 em28xx_info("V4L2 VBI device registered as %s\n", 2566 video_device_node_name(&v4l2->vbi_dev)); 2567 2568 /* Save some power by putting tuner to sleep */ 2569 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2570 2571 /* initialize videobuf2 stuff */ 2572 em28xx_vb2_setup(dev); 2573 2574 em28xx_info("V4L2 extension successfully initialized\n"); 2575 2576 kref_get(&dev->ref); 2577 2578 mutex_unlock(&dev->lock); 2579 return 0; 2580 2581 unregister_dev: 2582 if (video_is_registered(&v4l2->radio_dev)) { 2583 em28xx_info("V4L2 device %s deregistered\n", 2584 video_device_node_name(&v4l2->radio_dev)); 2585 video_unregister_device(&v4l2->radio_dev); 2586 } 2587 if (video_is_registered(&v4l2->vbi_dev)) { 2588 em28xx_info("V4L2 device %s deregistered\n", 2589 video_device_node_name(&v4l2->vbi_dev)); 2590 video_unregister_device(&v4l2->vbi_dev); 2591 } 2592 if (video_is_registered(&v4l2->vdev)) { 2593 em28xx_info("V4L2 device %s deregistered\n", 2594 video_device_node_name(&v4l2->vdev)); 2595 video_unregister_device(&v4l2->vdev); 2596 } 2597 2598 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 2599 v4l2_device_unregister(&v4l2->v4l2_dev); 2600 err: 2601 dev->v4l2 = NULL; 2602 kref_put(&v4l2->ref, em28xx_free_v4l2); 2603 mutex_unlock(&dev->lock); 2604 return ret; 2605 } 2606 2607 static struct em28xx_ops v4l2_ops = { 2608 .id = EM28XX_V4L2, 2609 .name = "Em28xx v4l2 Extension", 2610 .init = em28xx_v4l2_init, 2611 .fini = em28xx_v4l2_fini, 2612 .suspend = em28xx_v4l2_suspend, 2613 .resume = em28xx_v4l2_resume, 2614 }; 2615 2616 static int __init em28xx_video_register(void) 2617 { 2618 return em28xx_register_extension(&v4l2_ops); 2619 } 2620 2621 static void __exit em28xx_video_unregister(void) 2622 { 2623 em28xx_unregister_extension(&v4l2_ops); 2624 } 2625 2626 module_init(em28xx_video_register); 2627 module_exit(em28xx_video_unregister); 2628