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