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