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