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 (v4l2->streaming_users > 0) 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\n", 1887 video_device_node_name(vdev), v4l2_type_names[fh_type]); 1888 1889 if (mutex_lock_interruptible(&dev->lock)) 1890 return -ERESTARTSYS; 1891 1892 ret = v4l2_fh_open(filp); 1893 if (ret) { 1894 em28xx_errdev("%s: v4l2_fh_open() returned error %d\n", 1895 __func__, ret); 1896 mutex_unlock(&dev->lock); 1897 return ret; 1898 } 1899 1900 if (v4l2_fh_is_singular_file(filp)) { 1901 em28xx_videodbg("first opened filehandle, initializing device\n"); 1902 1903 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 1904 1905 if (vdev->vfl_type != VFL_TYPE_RADIO) 1906 em28xx_resolution_set(dev); 1907 1908 /* 1909 * Needed, since GPIO might have disabled power 1910 * of some i2c devices 1911 */ 1912 em28xx_wake_i2c(dev); 1913 } else { 1914 em28xx_videodbg("further filehandles are already opened\n"); 1915 } 1916 1917 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1918 em28xx_videodbg("video_open: setting radio device\n"); 1919 v4l2_device_call_all(&v4l2->v4l2_dev, 0, tuner, s_radio); 1920 } 1921 1922 kref_get(&dev->ref); 1923 kref_get(&v4l2->ref); 1924 1925 mutex_unlock(&dev->lock); 1926 1927 return 0; 1928 } 1929 1930 /* 1931 * em28xx_v4l2_fini() 1932 * unregisters the v4l2,i2c and usb devices 1933 * called when the device gets disconected or at module unload 1934 */ 1935 static int em28xx_v4l2_fini(struct em28xx *dev) 1936 { 1937 struct em28xx_v4l2 *v4l2 = dev->v4l2; 1938 1939 if (dev->is_audio_only) { 1940 /* Shouldn't initialize IR for this interface */ 1941 return 0; 1942 } 1943 1944 if (!dev->has_video) { 1945 /* This device does not support the v4l2 extension */ 1946 return 0; 1947 } 1948 1949 if (v4l2 == NULL) 1950 return 0; 1951 1952 em28xx_info("Closing video extension"); 1953 1954 mutex_lock(&dev->lock); 1955 1956 v4l2_device_disconnect(&v4l2->v4l2_dev); 1957 1958 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 1959 1960 if (v4l2->radio_dev) { 1961 em28xx_info("V4L2 device %s deregistered\n", 1962 video_device_node_name(v4l2->radio_dev)); 1963 video_unregister_device(v4l2->radio_dev); 1964 } 1965 if (v4l2->vbi_dev) { 1966 em28xx_info("V4L2 device %s deregistered\n", 1967 video_device_node_name(v4l2->vbi_dev)); 1968 video_unregister_device(v4l2->vbi_dev); 1969 } 1970 if (v4l2->vdev) { 1971 em28xx_info("V4L2 device %s deregistered\n", 1972 video_device_node_name(v4l2->vdev)); 1973 video_unregister_device(v4l2->vdev); 1974 } 1975 1976 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 1977 v4l2_device_unregister(&v4l2->v4l2_dev); 1978 1979 if (v4l2->clk) { 1980 v4l2_clk_unregister_fixed(v4l2->clk); 1981 v4l2->clk = NULL; 1982 } 1983 1984 kref_put(&v4l2->ref, em28xx_free_v4l2); 1985 1986 mutex_unlock(&dev->lock); 1987 1988 kref_put(&dev->ref, em28xx_free_device); 1989 1990 return 0; 1991 } 1992 1993 static int em28xx_v4l2_suspend(struct em28xx *dev) 1994 { 1995 if (dev->is_audio_only) 1996 return 0; 1997 1998 if (!dev->has_video) 1999 return 0; 2000 2001 em28xx_info("Suspending video extension"); 2002 em28xx_stop_urbs(dev); 2003 return 0; 2004 } 2005 2006 static int em28xx_v4l2_resume(struct em28xx *dev) 2007 { 2008 if (dev->is_audio_only) 2009 return 0; 2010 2011 if (!dev->has_video) 2012 return 0; 2013 2014 em28xx_info("Resuming video extension"); 2015 /* what do we do here */ 2016 return 0; 2017 } 2018 2019 /* 2020 * em28xx_v4l2_close() 2021 * stops streaming and deallocates all resources allocated by the v4l2 2022 * calls and ioctls 2023 */ 2024 static int em28xx_v4l2_close(struct file *filp) 2025 { 2026 struct em28xx *dev = video_drvdata(filp); 2027 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2028 int errCode; 2029 2030 mutex_lock(&dev->lock); 2031 2032 if (v4l2_fh_is_singular_file(filp)) { 2033 em28xx_videodbg("last opened filehandle, shutting down device\n"); 2034 2035 /* No sense to try to write to the device */ 2036 if (dev->disconnected) 2037 goto exit; 2038 2039 /* Save some power by putting tuner to sleep */ 2040 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2041 2042 /* do this before setting alternate! */ 2043 em28xx_set_mode(dev, EM28XX_SUSPEND); 2044 2045 /* set alternate 0 */ 2046 dev->alt = 0; 2047 em28xx_videodbg("setting alternate 0\n"); 2048 errCode = usb_set_interface(dev->udev, 0, 0); 2049 if (errCode < 0) { 2050 em28xx_errdev("cannot change alternate number to " 2051 "0 (error=%i)\n", errCode); 2052 } 2053 } else { 2054 em28xx_videodbg("further opened filehandles left\n"); 2055 } 2056 2057 exit: 2058 vb2_fop_release(filp); 2059 kref_put(&v4l2->ref, em28xx_free_v4l2); 2060 mutex_unlock(&dev->lock); 2061 kref_put(&dev->ref, em28xx_free_device); 2062 2063 return 0; 2064 } 2065 2066 static const struct v4l2_file_operations em28xx_v4l_fops = { 2067 .owner = THIS_MODULE, 2068 .open = em28xx_v4l2_open, 2069 .release = em28xx_v4l2_close, 2070 .read = vb2_fop_read, 2071 .poll = vb2_fop_poll, 2072 .mmap = vb2_fop_mmap, 2073 .unlocked_ioctl = video_ioctl2, 2074 }; 2075 2076 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2077 .vidioc_querycap = vidioc_querycap, 2078 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2079 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2080 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2081 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2082 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2083 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2084 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2085 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2086 .vidioc_g_audio = vidioc_g_audio, 2087 .vidioc_s_audio = vidioc_s_audio, 2088 2089 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2090 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2091 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 2092 .vidioc_querybuf = vb2_ioctl_querybuf, 2093 .vidioc_qbuf = vb2_ioctl_qbuf, 2094 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2095 2096 .vidioc_g_std = vidioc_g_std, 2097 .vidioc_querystd = vidioc_querystd, 2098 .vidioc_s_std = vidioc_s_std, 2099 .vidioc_g_parm = vidioc_g_parm, 2100 .vidioc_s_parm = vidioc_s_parm, 2101 .vidioc_enum_input = vidioc_enum_input, 2102 .vidioc_g_input = vidioc_g_input, 2103 .vidioc_s_input = vidioc_s_input, 2104 .vidioc_streamon = vb2_ioctl_streamon, 2105 .vidioc_streamoff = vb2_ioctl_streamoff, 2106 .vidioc_g_tuner = vidioc_g_tuner, 2107 .vidioc_s_tuner = vidioc_s_tuner, 2108 .vidioc_g_frequency = vidioc_g_frequency, 2109 .vidioc_s_frequency = vidioc_s_frequency, 2110 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2111 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2112 #ifdef CONFIG_VIDEO_ADV_DEBUG 2113 .vidioc_g_chip_info = vidioc_g_chip_info, 2114 .vidioc_g_register = vidioc_g_register, 2115 .vidioc_s_register = vidioc_s_register, 2116 #endif 2117 }; 2118 2119 static const struct video_device em28xx_video_template = { 2120 .fops = &em28xx_v4l_fops, 2121 .ioctl_ops = &video_ioctl_ops, 2122 .release = video_device_release, 2123 .tvnorms = V4L2_STD_ALL, 2124 }; 2125 2126 static const struct v4l2_file_operations radio_fops = { 2127 .owner = THIS_MODULE, 2128 .open = em28xx_v4l2_open, 2129 .release = em28xx_v4l2_close, 2130 .unlocked_ioctl = video_ioctl2, 2131 }; 2132 2133 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2134 .vidioc_querycap = vidioc_querycap, 2135 .vidioc_g_tuner = radio_g_tuner, 2136 .vidioc_s_tuner = radio_s_tuner, 2137 .vidioc_g_frequency = vidioc_g_frequency, 2138 .vidioc_s_frequency = vidioc_s_frequency, 2139 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2140 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2141 #ifdef CONFIG_VIDEO_ADV_DEBUG 2142 .vidioc_g_chip_info = vidioc_g_chip_info, 2143 .vidioc_g_register = vidioc_g_register, 2144 .vidioc_s_register = vidioc_s_register, 2145 #endif 2146 }; 2147 2148 static struct video_device em28xx_radio_template = { 2149 .fops = &radio_fops, 2150 .ioctl_ops = &radio_ioctl_ops, 2151 .release = video_device_release, 2152 }; 2153 2154 /* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */ 2155 static unsigned short saa711x_addrs[] = { 2156 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */ 2157 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */ 2158 I2C_CLIENT_END }; 2159 2160 static unsigned short tvp5150_addrs[] = { 2161 0xb8 >> 1, 2162 0xba >> 1, 2163 I2C_CLIENT_END 2164 }; 2165 2166 static unsigned short msp3400_addrs[] = { 2167 0x80 >> 1, 2168 0x88 >> 1, 2169 I2C_CLIENT_END 2170 }; 2171 2172 /******************************** usb interface ******************************/ 2173 2174 static struct video_device *em28xx_vdev_init(struct em28xx *dev, 2175 const struct video_device *template, 2176 const char *type_name) 2177 { 2178 struct video_device *vfd; 2179 2180 vfd = video_device_alloc(); 2181 if (NULL == vfd) 2182 return NULL; 2183 2184 *vfd = *template; 2185 vfd->v4l2_dev = &dev->v4l2->v4l2_dev; 2186 vfd->debug = video_debug; 2187 vfd->lock = &dev->lock; 2188 if (dev->board.is_webcam) 2189 vfd->tvnorms = 0; 2190 2191 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 2192 dev->name, type_name); 2193 2194 video_set_drvdata(vfd, dev); 2195 return vfd; 2196 } 2197 2198 static void em28xx_tuner_setup(struct em28xx *dev, unsigned short tuner_addr) 2199 { 2200 struct em28xx_v4l2 *v4l2 = dev->v4l2; 2201 struct v4l2_device *v4l2_dev = &v4l2->v4l2_dev; 2202 struct tuner_setup tun_setup; 2203 struct v4l2_frequency f; 2204 2205 memset(&tun_setup, 0, sizeof(tun_setup)); 2206 2207 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 2208 tun_setup.tuner_callback = em28xx_tuner_callback; 2209 2210 if (dev->board.radio.type) { 2211 tun_setup.type = dev->board.radio.type; 2212 tun_setup.addr = dev->board.radio_addr; 2213 2214 v4l2_device_call_all(v4l2_dev, 2215 0, tuner, s_type_addr, &tun_setup); 2216 } 2217 2218 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) { 2219 tun_setup.type = dev->tuner_type; 2220 tun_setup.addr = tuner_addr; 2221 2222 v4l2_device_call_all(v4l2_dev, 2223 0, tuner, s_type_addr, &tun_setup); 2224 } 2225 2226 if (dev->board.tda9887_conf) { 2227 struct v4l2_priv_tun_config tda9887_cfg; 2228 2229 tda9887_cfg.tuner = TUNER_TDA9887; 2230 tda9887_cfg.priv = &dev->board.tda9887_conf; 2231 2232 v4l2_device_call_all(v4l2_dev, 2233 0, tuner, s_config, &tda9887_cfg); 2234 } 2235 2236 if (dev->tuner_type == TUNER_XC2028) { 2237 struct v4l2_priv_tun_config xc2028_cfg; 2238 struct xc2028_ctrl ctl; 2239 2240 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg)); 2241 memset(&ctl, 0, sizeof(ctl)); 2242 2243 em28xx_setup_xc3028(dev, &ctl); 2244 2245 xc2028_cfg.tuner = TUNER_XC2028; 2246 xc2028_cfg.priv = &ctl; 2247 2248 v4l2_device_call_all(v4l2_dev, 0, tuner, s_config, &xc2028_cfg); 2249 } 2250 2251 /* configure tuner */ 2252 f.tuner = 0; 2253 f.type = V4L2_TUNER_ANALOG_TV; 2254 f.frequency = 9076; /* just a magic number */ 2255 v4l2->frequency = f.frequency; 2256 v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency, &f); 2257 } 2258 2259 static int em28xx_v4l2_init(struct em28xx *dev) 2260 { 2261 u8 val; 2262 int ret; 2263 unsigned int maxw; 2264 struct v4l2_ctrl_handler *hdl; 2265 struct em28xx_v4l2 *v4l2; 2266 2267 if (dev->is_audio_only) { 2268 /* Shouldn't initialize IR for this interface */ 2269 return 0; 2270 } 2271 2272 if (!dev->has_video) { 2273 /* This device does not support the v4l2 extension */ 2274 return 0; 2275 } 2276 2277 em28xx_info("Registering V4L2 extension\n"); 2278 2279 mutex_lock(&dev->lock); 2280 2281 v4l2 = kzalloc(sizeof(struct em28xx_v4l2), GFP_KERNEL); 2282 if (v4l2 == NULL) { 2283 em28xx_info("em28xx_v4l: memory allocation failed\n"); 2284 mutex_unlock(&dev->lock); 2285 return -ENOMEM; 2286 } 2287 kref_init(&v4l2->ref); 2288 v4l2->dev = dev; 2289 dev->v4l2 = v4l2; 2290 2291 ret = v4l2_device_register(&dev->udev->dev, &v4l2->v4l2_dev); 2292 if (ret < 0) { 2293 em28xx_errdev("Call to v4l2_device_register() failed!\n"); 2294 goto err; 2295 } 2296 2297 hdl = &v4l2->ctrl_handler; 2298 v4l2_ctrl_handler_init(hdl, 8); 2299 v4l2->v4l2_dev.ctrl_handler = hdl; 2300 2301 if (dev->board.is_webcam) 2302 v4l2->progressive = 1; 2303 2304 /* 2305 * Default format, used for tvp5150 or saa711x output formats 2306 */ 2307 v4l2->vinmode = 0x10; 2308 v4l2->vinctl = EM28XX_VINCTRL_INTERLACED | 2309 EM28XX_VINCTRL_CCIR656_ENABLE; 2310 2311 /* request some modules */ 2312 2313 if (dev->board.has_msp34xx) 2314 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2315 &dev->i2c_adap[dev->def_i2c_bus], 2316 "msp3400", 0, msp3400_addrs); 2317 2318 if (dev->board.decoder == EM28XX_SAA711X) 2319 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2320 &dev->i2c_adap[dev->def_i2c_bus], 2321 "saa7115_auto", 0, saa711x_addrs); 2322 2323 if (dev->board.decoder == EM28XX_TVP5150) 2324 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2325 &dev->i2c_adap[dev->def_i2c_bus], 2326 "tvp5150", 0, tvp5150_addrs); 2327 2328 if (dev->board.adecoder == EM28XX_TVAUDIO) 2329 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2330 &dev->i2c_adap[dev->def_i2c_bus], 2331 "tvaudio", dev->board.tvaudio_addr, NULL); 2332 2333 /* Initialize tuner and camera */ 2334 2335 if (dev->board.tuner_type != TUNER_ABSENT) { 2336 unsigned short tuner_addr = dev->board.tuner_addr; 2337 int has_demod = (dev->board.tda9887_conf & TDA9887_PRESENT); 2338 2339 if (dev->board.radio.type) 2340 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2341 &dev->i2c_adap[dev->def_i2c_bus], 2342 "tuner", dev->board.radio_addr, NULL); 2343 2344 if (has_demod) 2345 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2346 &dev->i2c_adap[dev->def_i2c_bus], "tuner", 2347 0, 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], "tuner", 2355 0, v4l2_i2c_tuner_addrs(type)); 2356 2357 if (sd) 2358 tuner_addr = v4l2_i2c_subdev_addr(sd); 2359 } else { 2360 v4l2_i2c_new_subdev(&v4l2->v4l2_dev, 2361 &dev->i2c_adap[dev->def_i2c_bus], 2362 "tuner", tuner_addr, NULL); 2363 } 2364 2365 em28xx_tuner_setup(dev, tuner_addr); 2366 } 2367 2368 if (dev->em28xx_sensor != EM28XX_NOSENSOR) 2369 em28xx_init_camera(dev); 2370 2371 /* Configure audio */ 2372 ret = em28xx_audio_setup(dev); 2373 if (ret < 0) { 2374 em28xx_errdev("%s: Error while setting audio - error [%d]!\n", 2375 __func__, ret); 2376 goto unregister_dev; 2377 } 2378 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) { 2379 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2380 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 2381 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2382 V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f); 2383 } else { 2384 /* install the em28xx notify callback */ 2385 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE), 2386 em28xx_ctrl_notify, dev); 2387 v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME), 2388 em28xx_ctrl_notify, dev); 2389 } 2390 2391 /* wake i2c devices */ 2392 em28xx_wake_i2c(dev); 2393 2394 /* init video dma queues */ 2395 INIT_LIST_HEAD(&dev->vidq.active); 2396 INIT_LIST_HEAD(&dev->vbiq.active); 2397 2398 if (dev->board.has_msp34xx) { 2399 /* Send a reset to other chips via gpio */ 2400 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xf7); 2401 if (ret < 0) { 2402 em28xx_errdev("%s: em28xx_write_reg - msp34xx(1) failed! error [%d]\n", 2403 __func__, ret); 2404 goto unregister_dev; 2405 } 2406 msleep(3); 2407 2408 ret = em28xx_write_reg(dev, EM2820_R08_GPIO_CTRL, 0xff); 2409 if (ret < 0) { 2410 em28xx_errdev("%s: em28xx_write_reg - msp34xx(2) failed! error [%d]\n", 2411 __func__, ret); 2412 goto unregister_dev; 2413 } 2414 msleep(3); 2415 } 2416 2417 /* set default norm */ 2418 v4l2->norm = V4L2_STD_PAL; 2419 v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm); 2420 v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT; 2421 2422 /* Analog specific initialization */ 2423 v4l2->format = &format[0]; 2424 2425 maxw = norm_maxw(dev); 2426 /* MaxPacketSize for em2800 is too small to capture at full resolution 2427 * use half of maxw as the scaler can only scale to 50% */ 2428 if (dev->board.is_em2800) 2429 maxw /= 2; 2430 2431 em28xx_set_video_format(dev, format[0].fourcc, 2432 maxw, norm_maxh(dev)); 2433 2434 video_mux(dev, 0); 2435 2436 /* Audio defaults */ 2437 dev->mute = 1; 2438 dev->volume = 0x1f; 2439 2440 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 2441 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 2442 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 2443 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 2444 2445 em28xx_set_outfmt(dev); 2446 2447 /* Add image controls */ 2448 /* NOTE: at this point, the subdevices are already registered, so bridge 2449 * controls are only added/enabled when no subdevice provides them */ 2450 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_CONTRAST)) 2451 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2452 V4L2_CID_CONTRAST, 2453 0, 0x1f, 1, CONTRAST_DEFAULT); 2454 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BRIGHTNESS)) 2455 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2456 V4L2_CID_BRIGHTNESS, 2457 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT); 2458 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SATURATION)) 2459 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2460 V4L2_CID_SATURATION, 2461 0, 0x1f, 1, SATURATION_DEFAULT); 2462 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_BLUE_BALANCE)) 2463 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2464 V4L2_CID_BLUE_BALANCE, 2465 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT); 2466 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_RED_BALANCE)) 2467 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2468 V4L2_CID_RED_BALANCE, 2469 -0x30, 0x30, 1, RED_BALANCE_DEFAULT); 2470 if (NULL == v4l2_ctrl_find(hdl, V4L2_CID_SHARPNESS)) 2471 v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops, 2472 V4L2_CID_SHARPNESS, 2473 0, 0x0f, 1, SHARPNESS_DEFAULT); 2474 2475 /* Reset image controls */ 2476 em28xx_colorlevels_set_default(dev); 2477 v4l2_ctrl_handler_setup(hdl); 2478 ret = hdl->error; 2479 if (ret) 2480 goto unregister_dev; 2481 2482 /* allocate and fill video video_device struct */ 2483 v4l2->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video"); 2484 if (!v4l2->vdev) { 2485 em28xx_errdev("cannot allocate video_device.\n"); 2486 ret = -ENODEV; 2487 goto unregister_dev; 2488 } 2489 mutex_init(&v4l2->vb_queue_lock); 2490 mutex_init(&v4l2->vb_vbi_queue_lock); 2491 v4l2->vdev->queue = &v4l2->vb_vidq; 2492 v4l2->vdev->queue->lock = &v4l2->vb_queue_lock; 2493 2494 /* disable inapplicable ioctls */ 2495 if (dev->board.is_webcam) { 2496 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_QUERYSTD); 2497 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_STD); 2498 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_STD); 2499 } else { 2500 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_PARM); 2501 } 2502 if (dev->tuner_type == TUNER_ABSENT) { 2503 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_TUNER); 2504 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_TUNER); 2505 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_FREQUENCY); 2506 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_FREQUENCY); 2507 } 2508 if (!dev->audio_mode.has_audio) { 2509 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_G_AUDIO); 2510 v4l2_disable_ioctl(v4l2->vdev, VIDIOC_S_AUDIO); 2511 } 2512 2513 /* register v4l2 video video_device */ 2514 ret = video_register_device(v4l2->vdev, VFL_TYPE_GRABBER, 2515 video_nr[dev->devno]); 2516 if (ret) { 2517 em28xx_errdev("unable to register video device (error=%i).\n", 2518 ret); 2519 goto unregister_dev; 2520 } 2521 2522 /* Allocate and fill vbi video_device struct */ 2523 if (em28xx_vbi_supported(dev) == 1) { 2524 v4l2->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template, 2525 "vbi"); 2526 2527 v4l2->vbi_dev->queue = &v4l2->vb_vbiq; 2528 v4l2->vbi_dev->queue->lock = &v4l2->vb_vbi_queue_lock; 2529 2530 /* disable inapplicable ioctls */ 2531 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_PARM); 2532 if (dev->tuner_type == TUNER_ABSENT) { 2533 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_TUNER); 2534 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_TUNER); 2535 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_FREQUENCY); 2536 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_FREQUENCY); 2537 } 2538 if (!dev->audio_mode.has_audio) { 2539 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_G_AUDIO); 2540 v4l2_disable_ioctl(v4l2->vbi_dev, VIDIOC_S_AUDIO); 2541 } 2542 2543 /* register v4l2 vbi video_device */ 2544 ret = video_register_device(v4l2->vbi_dev, VFL_TYPE_VBI, 2545 vbi_nr[dev->devno]); 2546 if (ret < 0) { 2547 em28xx_errdev("unable to register vbi device\n"); 2548 goto unregister_dev; 2549 } 2550 } 2551 2552 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2553 v4l2->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template, 2554 "radio"); 2555 if (!v4l2->radio_dev) { 2556 em28xx_errdev("cannot allocate video_device.\n"); 2557 ret = -ENODEV; 2558 goto unregister_dev; 2559 } 2560 ret = video_register_device(v4l2->radio_dev, VFL_TYPE_RADIO, 2561 radio_nr[dev->devno]); 2562 if (ret < 0) { 2563 em28xx_errdev("can't register radio device\n"); 2564 goto unregister_dev; 2565 } 2566 em28xx_info("Registered radio device as %s\n", 2567 video_device_node_name(v4l2->radio_dev)); 2568 } 2569 2570 em28xx_info("V4L2 video device registered as %s\n", 2571 video_device_node_name(v4l2->vdev)); 2572 2573 if (v4l2->vbi_dev) 2574 em28xx_info("V4L2 VBI device registered as %s\n", 2575 video_device_node_name(v4l2->vbi_dev)); 2576 2577 /* Save some power by putting tuner to sleep */ 2578 v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_power, 0); 2579 2580 /* initialize videobuf2 stuff */ 2581 em28xx_vb2_setup(dev); 2582 2583 em28xx_info("V4L2 extension successfully initialized\n"); 2584 2585 kref_get(&dev->ref); 2586 2587 mutex_unlock(&dev->lock); 2588 return 0; 2589 2590 unregister_dev: 2591 v4l2_ctrl_handler_free(&v4l2->ctrl_handler); 2592 v4l2_device_unregister(&v4l2->v4l2_dev); 2593 err: 2594 dev->v4l2 = NULL; 2595 kref_put(&v4l2->ref, em28xx_free_v4l2); 2596 mutex_unlock(&dev->lock); 2597 return ret; 2598 } 2599 2600 static struct em28xx_ops v4l2_ops = { 2601 .id = EM28XX_V4L2, 2602 .name = "Em28xx v4l2 Extension", 2603 .init = em28xx_v4l2_init, 2604 .fini = em28xx_v4l2_fini, 2605 .suspend = em28xx_v4l2_suspend, 2606 .resume = em28xx_v4l2_resume, 2607 }; 2608 2609 static int __init em28xx_video_register(void) 2610 { 2611 return em28xx_register_extension(&v4l2_ops); 2612 } 2613 2614 static void __exit em28xx_video_unregister(void) 2615 { 2616 em28xx_unregister_extension(&v4l2_ops); 2617 } 2618 2619 module_init(em28xx_video_register); 2620 module_exit(em28xx_video_unregister); 2621