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 <media/v4l2-common.h> 42 #include <media/v4l2-ioctl.h> 43 #include <media/v4l2-event.h> 44 #include <media/v4l2-chip-ident.h> 45 #include <media/msp3400.h> 46 #include <media/tuner.h> 47 48 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \ 49 "Markus Rechberger <mrechberger@gmail.com>, " \ 50 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \ 51 "Sascha Sommer <saschasommer@freenet.de>" 52 53 #define DRIVER_DESC "Empia em28xx based USB video device driver" 54 55 #define EM28XX_VERSION "0.2.0" 56 57 #define em28xx_videodbg(fmt, arg...) do {\ 58 if (video_debug) \ 59 printk(KERN_INFO "%s %s :"fmt, \ 60 dev->name, __func__ , ##arg); } while (0) 61 62 static unsigned int isoc_debug; 63 module_param(isoc_debug, int, 0644); 64 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]"); 65 66 #define em28xx_isocdbg(fmt, arg...) \ 67 do {\ 68 if (isoc_debug) { \ 69 printk(KERN_INFO "%s %s :"fmt, \ 70 dev->name, __func__ , ##arg); \ 71 } \ 72 } while (0) 73 74 MODULE_AUTHOR(DRIVER_AUTHOR); 75 MODULE_DESCRIPTION(DRIVER_DESC); 76 MODULE_LICENSE("GPL"); 77 MODULE_VERSION(EM28XX_VERSION); 78 79 80 #define EM25XX_FRMDATAHDR_BYTE1 0x02 81 #define EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE 0x20 82 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_END 0x02 83 #define EM25XX_FRMDATAHDR_BYTE2_FRAME_ID 0x01 84 #define EM25XX_FRMDATAHDR_BYTE2_MASK (EM25XX_FRMDATAHDR_BYTE2_STILL_IMAGE | \ 85 EM25XX_FRMDATAHDR_BYTE2_FRAME_END | \ 86 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID) 87 88 89 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 90 static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 91 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U }; 92 93 module_param_array(video_nr, int, NULL, 0444); 94 module_param_array(vbi_nr, int, NULL, 0444); 95 module_param_array(radio_nr, int, NULL, 0444); 96 MODULE_PARM_DESC(video_nr, "video device numbers"); 97 MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 98 MODULE_PARM_DESC(radio_nr, "radio device numbers"); 99 100 static unsigned int video_debug; 101 module_param(video_debug, int, 0644); 102 MODULE_PARM_DESC(video_debug, "enable debug messages [video]"); 103 104 /* supported video standards */ 105 static struct em28xx_fmt format[] = { 106 { 107 .name = "16 bpp YUY2, 4:2:2, packed", 108 .fourcc = V4L2_PIX_FMT_YUYV, 109 .depth = 16, 110 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V, 111 }, { 112 .name = "16 bpp RGB 565, LE", 113 .fourcc = V4L2_PIX_FMT_RGB565, 114 .depth = 16, 115 .reg = EM28XX_OUTFMT_RGB_16_656, 116 }, { 117 .name = "8 bpp Bayer BGBG..GRGR", 118 .fourcc = V4L2_PIX_FMT_SBGGR8, 119 .depth = 8, 120 .reg = EM28XX_OUTFMT_RGB_8_BGBG, 121 }, { 122 .name = "8 bpp Bayer GRGR..BGBG", 123 .fourcc = V4L2_PIX_FMT_SGRBG8, 124 .depth = 8, 125 .reg = EM28XX_OUTFMT_RGB_8_GRGR, 126 }, { 127 .name = "8 bpp Bayer GBGB..RGRG", 128 .fourcc = V4L2_PIX_FMT_SGBRG8, 129 .depth = 8, 130 .reg = EM28XX_OUTFMT_RGB_8_GBGB, 131 }, { 132 .name = "12 bpp YUV411", 133 .fourcc = V4L2_PIX_FMT_YUV411P, 134 .depth = 12, 135 .reg = EM28XX_OUTFMT_YUV411, 136 }, 137 }; 138 139 /* ------------------------------------------------------------------ 140 DMA and thread functions 141 ------------------------------------------------------------------*/ 142 143 /* 144 * Finish the current buffer 145 */ 146 static inline void finish_buffer(struct em28xx *dev, 147 struct em28xx_buffer *buf) 148 { 149 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field); 150 151 buf->vb.v4l2_buf.sequence = dev->field_count++; 152 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED; 153 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp); 154 155 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE); 156 } 157 158 /* 159 * Copy picture data from USB buffer to videobuf buffer 160 */ 161 static void em28xx_copy_video(struct em28xx *dev, 162 struct em28xx_buffer *buf, 163 unsigned char *usb_buf, 164 unsigned long len) 165 { 166 void *fieldstart, *startwrite, *startread; 167 int linesdone, currlinedone, offset, lencopy, remain; 168 int bytesperline = dev->width << 1; 169 170 if (buf->pos + len > buf->length) 171 len = buf->length - buf->pos; 172 173 startread = usb_buf; 174 remain = len; 175 176 if (dev->progressive || buf->top_field) 177 fieldstart = buf->vb_buf; 178 else /* interlaced mode, even nr. of lines */ 179 fieldstart = buf->vb_buf + bytesperline; 180 181 linesdone = buf->pos / bytesperline; 182 currlinedone = buf->pos % bytesperline; 183 184 if (dev->progressive) 185 offset = linesdone * bytesperline + currlinedone; 186 else 187 offset = linesdone * bytesperline * 2 + currlinedone; 188 189 startwrite = fieldstart + offset; 190 lencopy = bytesperline - currlinedone; 191 lencopy = lencopy > remain ? remain : lencopy; 192 193 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) { 194 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n", 195 ((char *)startwrite + lencopy) - 196 ((char *)buf->vb_buf + buf->length)); 197 remain = (char *)buf->vb_buf + buf->length - 198 (char *)startwrite; 199 lencopy = remain; 200 } 201 if (lencopy <= 0) 202 return; 203 memcpy(startwrite, startread, lencopy); 204 205 remain -= lencopy; 206 207 while (remain > 0) { 208 if (dev->progressive) 209 startwrite += lencopy; 210 else 211 startwrite += lencopy + bytesperline; 212 startread += lencopy; 213 if (bytesperline > remain) 214 lencopy = remain; 215 else 216 lencopy = bytesperline; 217 218 if ((char *)startwrite + lencopy > (char *)buf->vb_buf + 219 buf->length) { 220 em28xx_isocdbg("Overflow of %zi bytes past buffer end" 221 "(2)\n", 222 ((char *)startwrite + lencopy) - 223 ((char *)buf->vb_buf + buf->length)); 224 lencopy = remain = (char *)buf->vb_buf + buf->length - 225 (char *)startwrite; 226 } 227 if (lencopy <= 0) 228 break; 229 230 memcpy(startwrite, startread, lencopy); 231 232 remain -= lencopy; 233 } 234 235 buf->pos += len; 236 } 237 238 /* 239 * Copy VBI data from USB buffer to videobuf buffer 240 */ 241 static void em28xx_copy_vbi(struct em28xx *dev, 242 struct em28xx_buffer *buf, 243 unsigned char *usb_buf, 244 unsigned long len) 245 { 246 unsigned int offset; 247 248 if (buf->pos + len > buf->length) 249 len = buf->length - buf->pos; 250 251 offset = buf->pos; 252 /* Make sure the bottom field populates the second half of the frame */ 253 if (buf->top_field == 0) 254 offset += dev->vbi_width * dev->vbi_height; 255 256 memcpy(buf->vb_buf + offset, usb_buf, len); 257 buf->pos += len; 258 } 259 260 static inline void print_err_status(struct em28xx *dev, 261 int packet, int status) 262 { 263 char *errmsg = "Unknown"; 264 265 switch (status) { 266 case -ENOENT: 267 errmsg = "unlinked synchronuously"; 268 break; 269 case -ECONNRESET: 270 errmsg = "unlinked asynchronuously"; 271 break; 272 case -ENOSR: 273 errmsg = "Buffer error (overrun)"; 274 break; 275 case -EPIPE: 276 errmsg = "Stalled (device not responding)"; 277 break; 278 case -EOVERFLOW: 279 errmsg = "Babble (bad cable?)"; 280 break; 281 case -EPROTO: 282 errmsg = "Bit-stuff error (bad cable?)"; 283 break; 284 case -EILSEQ: 285 errmsg = "CRC/Timeout (could be anything)"; 286 break; 287 case -ETIME: 288 errmsg = "Device does not respond"; 289 break; 290 } 291 if (packet < 0) { 292 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg); 293 } else { 294 em28xx_isocdbg("URB packet %d, status %d [%s].\n", 295 packet, status, errmsg); 296 } 297 } 298 299 /* 300 * get the next available buffer from dma queue 301 */ 302 static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev, 303 struct em28xx_dmaqueue *dma_q) 304 { 305 struct em28xx_buffer *buf; 306 307 if (list_empty(&dma_q->active)) { 308 em28xx_isocdbg("No active queue to serve\n"); 309 return NULL; 310 } 311 312 /* Get the next buffer */ 313 buf = list_entry(dma_q->active.next, struct em28xx_buffer, list); 314 /* Cleans up buffer - Useful for testing for frame/URB loss */ 315 list_del(&buf->list); 316 buf->pos = 0; 317 buf->vb_buf = buf->mem; 318 319 return buf; 320 } 321 322 /* 323 * Finish the current buffer if completed and prepare for the next field 324 */ 325 static struct em28xx_buffer * 326 finish_field_prepare_next(struct em28xx *dev, 327 struct em28xx_buffer *buf, 328 struct em28xx_dmaqueue *dma_q) 329 { 330 if (dev->progressive || dev->top_field) { /* Brand new frame */ 331 if (buf != NULL) 332 finish_buffer(dev, buf); 333 buf = get_next_buf(dev, dma_q); 334 } 335 if (buf != NULL) { 336 buf->top_field = dev->top_field; 337 buf->pos = 0; 338 } 339 340 return buf; 341 } 342 343 /* 344 * Process data packet according to the em2710/em2750/em28xx frame data format 345 */ 346 static inline void process_frame_data_em28xx(struct em28xx *dev, 347 unsigned char *data_pkt, 348 unsigned int data_len) 349 { 350 struct em28xx_buffer *buf = dev->usb_ctl.vid_buf; 351 struct em28xx_buffer *vbi_buf = dev->usb_ctl.vbi_buf; 352 struct em28xx_dmaqueue *dma_q = &dev->vidq; 353 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq; 354 355 /* capture type 0 = vbi start 356 capture type 1 = vbi in progress 357 capture type 2 = video start 358 capture type 3 = video in progress */ 359 if (data_len >= 4) { 360 /* NOTE: Headers are always 4 bytes and 361 * never split across packets */ 362 if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 && 363 data_pkt[2] == 0x88 && data_pkt[3] == 0x88) { 364 /* Continuation */ 365 data_pkt += 4; 366 data_len -= 4; 367 } else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) { 368 /* Field start (VBI mode) */ 369 dev->capture_type = 0; 370 dev->vbi_read = 0; 371 em28xx_isocdbg("VBI START HEADER !!!\n"); 372 dev->top_field = !(data_pkt[2] & 1); 373 data_pkt += 4; 374 data_len -= 4; 375 } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) { 376 /* Field start (VBI disabled) */ 377 dev->capture_type = 2; 378 em28xx_isocdbg("VIDEO START HEADER !!!\n"); 379 dev->top_field = !(data_pkt[2] & 1); 380 data_pkt += 4; 381 data_len -= 4; 382 } 383 } 384 /* NOTE: With bulk transfers, intermediate data packets 385 * have no continuation header */ 386 387 if (dev->capture_type == 0) { 388 vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q); 389 dev->usb_ctl.vbi_buf = vbi_buf; 390 dev->capture_type = 1; 391 } 392 393 if (dev->capture_type == 1) { 394 int vbi_size = dev->vbi_width * dev->vbi_height; 395 int vbi_data_len = ((dev->vbi_read + data_len) > vbi_size) ? 396 (vbi_size - dev->vbi_read) : data_len; 397 398 /* Copy VBI data */ 399 if (vbi_buf != NULL) 400 em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len); 401 dev->vbi_read += vbi_data_len; 402 403 if (vbi_data_len < data_len) { 404 /* Continue with copying video data */ 405 dev->capture_type = 2; 406 data_pkt += vbi_data_len; 407 data_len -= vbi_data_len; 408 } 409 } 410 411 if (dev->capture_type == 2) { 412 buf = finish_field_prepare_next(dev, buf, dma_q); 413 dev->usb_ctl.vid_buf = buf; 414 dev->capture_type = 3; 415 } 416 417 if (dev->capture_type == 3 && buf != NULL && data_len > 0) 418 em28xx_copy_video(dev, buf, data_pkt, data_len); 419 } 420 421 /* 422 * Process data packet according to the em25xx/em276x/7x/8x frame data format 423 */ 424 static inline void process_frame_data_em25xx(struct em28xx *dev, 425 unsigned char *data_pkt, 426 unsigned int data_len) 427 { 428 struct em28xx_buffer *buf = dev->usb_ctl.vid_buf; 429 struct em28xx_dmaqueue *dmaq = &dev->vidq; 430 bool frame_end = 0; 431 432 /* Check for header */ 433 /* NOTE: at least with bulk transfers, only the first packet 434 * has a header and has always set the FRAME_END bit */ 435 if (data_len >= 2) { /* em25xx header is only 2 bytes long */ 436 if ((data_pkt[0] == EM25XX_FRMDATAHDR_BYTE1) && 437 ((data_pkt[1] & ~EM25XX_FRMDATAHDR_BYTE2_MASK) == 0x00)) { 438 dev->top_field = !(data_pkt[1] & 439 EM25XX_FRMDATAHDR_BYTE2_FRAME_ID); 440 frame_end = data_pkt[1] & 441 EM25XX_FRMDATAHDR_BYTE2_FRAME_END; 442 data_pkt += 2; 443 data_len -= 2; 444 } 445 446 /* Finish field and prepare next (BULK only) */ 447 if (dev->analog_xfer_bulk && frame_end) { 448 buf = finish_field_prepare_next(dev, buf, dmaq); 449 dev->usb_ctl.vid_buf = buf; 450 } 451 /* NOTE: in ISOC mode when a new frame starts and buf==NULL, 452 * we COULD already prepare a buffer here to avoid skipping the 453 * first frame. 454 */ 455 } 456 457 /* Copy data */ 458 if (buf != NULL && data_len > 0) 459 em28xx_copy_video(dev, buf, data_pkt, data_len); 460 461 /* Finish frame (ISOC only) => avoids lag of 1 frame */ 462 if (!dev->analog_xfer_bulk && frame_end) { 463 buf = finish_field_prepare_next(dev, buf, dmaq); 464 dev->usb_ctl.vid_buf = buf; 465 } 466 467 /* NOTE: Tested with USB bulk transfers only ! 468 * The wording in the datasheet suggests that isoc might work different. 469 * The current code assumes that with isoc transfers each packet has a 470 * header like with the other em28xx devices. 471 */ 472 /* NOTE: Support for interlaced mode is pure theory. It has not been 473 * tested and it is unknown if these devices actually support it. */ 474 /* NOTE: No VBI support yet (these chips likely do not support VBI). */ 475 } 476 477 /* Processes and copies the URB data content (video and VBI data) */ 478 static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb) 479 { 480 int xfer_bulk, num_packets, i; 481 unsigned char *usb_data_pkt; 482 unsigned int usb_data_len; 483 484 if (!dev) 485 return 0; 486 487 if (dev->disconnected) 488 return 0; 489 490 if (urb->status < 0) 491 print_err_status(dev, -1, urb->status); 492 493 xfer_bulk = usb_pipebulk(urb->pipe); 494 495 if (xfer_bulk) /* bulk */ 496 num_packets = 1; 497 else /* isoc */ 498 num_packets = urb->number_of_packets; 499 500 for (i = 0; i < num_packets; i++) { 501 if (xfer_bulk) { /* bulk */ 502 usb_data_len = urb->actual_length; 503 504 usb_data_pkt = urb->transfer_buffer; 505 } else { /* isoc */ 506 if (urb->iso_frame_desc[i].status < 0) { 507 print_err_status(dev, i, 508 urb->iso_frame_desc[i].status); 509 if (urb->iso_frame_desc[i].status != -EPROTO) 510 continue; 511 } 512 513 usb_data_len = urb->iso_frame_desc[i].actual_length; 514 if (usb_data_len > dev->max_pkt_size) { 515 em28xx_isocdbg("packet bigger than packet size"); 516 continue; 517 } 518 519 usb_data_pkt = urb->transfer_buffer + 520 urb->iso_frame_desc[i].offset; 521 } 522 523 if (usb_data_len == 0) { 524 /* NOTE: happens very often with isoc transfers */ 525 /* em28xx_usbdbg("packet %d is empty",i); - spammy */ 526 continue; 527 } 528 529 if (dev->is_em25xx) 530 process_frame_data_em25xx(dev, 531 usb_data_pkt, usb_data_len); 532 else 533 process_frame_data_em28xx(dev, 534 usb_data_pkt, usb_data_len); 535 536 } 537 return 1; 538 } 539 540 541 static int get_ressource(enum v4l2_buf_type f_type) 542 { 543 switch (f_type) { 544 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 545 return EM28XX_RESOURCE_VIDEO; 546 case V4L2_BUF_TYPE_VBI_CAPTURE: 547 return EM28XX_RESOURCE_VBI; 548 default: 549 BUG(); 550 return 0; 551 } 552 } 553 554 /* Usage lock check functions */ 555 static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type) 556 { 557 int res_type = get_ressource(f_type); 558 559 /* is it free? */ 560 if (dev->resources & res_type) { 561 /* no, someone else uses it */ 562 return -EBUSY; 563 } 564 565 /* it's free, grab it */ 566 dev->resources |= res_type; 567 em28xx_videodbg("res: get %d\n", res_type); 568 return 0; 569 } 570 571 static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type) 572 { 573 int res_type = get_ressource(f_type); 574 575 dev->resources &= ~res_type; 576 em28xx_videodbg("res: put %d\n", res_type); 577 } 578 579 /* ------------------------------------------------------------------ 580 Videobuf2 operations 581 ------------------------------------------------------------------*/ 582 583 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt, 584 unsigned int *nbuffers, unsigned int *nplanes, 585 unsigned int sizes[], void *alloc_ctxs[]) 586 { 587 struct em28xx *dev = vb2_get_drv_priv(vq); 588 unsigned long size; 589 590 if (fmt) 591 size = fmt->fmt.pix.sizeimage; 592 else 593 size = (dev->width * dev->height * dev->format->depth + 7) >> 3; 594 595 if (size == 0) 596 return -EINVAL; 597 598 if (0 == *nbuffers) 599 *nbuffers = 32; 600 601 *nplanes = 1; 602 sizes[0] = size; 603 604 return 0; 605 } 606 607 static int 608 buffer_prepare(struct vb2_buffer *vb) 609 { 610 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 611 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb); 612 unsigned long size; 613 614 em28xx_videodbg("%s, field=%d\n", __func__, vb->v4l2_buf.field); 615 616 size = (dev->width * dev->height * dev->format->depth + 7) >> 3; 617 618 if (vb2_plane_size(vb, 0) < size) { 619 em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n", 620 __func__, vb2_plane_size(vb, 0), size); 621 return -EINVAL; 622 } 623 vb2_set_plane_payload(&buf->vb, 0, size); 624 625 return 0; 626 } 627 628 int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count) 629 { 630 struct em28xx *dev = vb2_get_drv_priv(vq); 631 struct v4l2_frequency f; 632 int rc = 0; 633 634 em28xx_videodbg("%s\n", __func__); 635 636 /* Make sure streaming is not already in progress for this type 637 of filehandle (e.g. video, vbi) */ 638 rc = res_get(dev, vq->type); 639 if (rc) 640 return rc; 641 642 if (dev->streaming_users++ == 0) { 643 /* First active streaming user, so allocate all the URBs */ 644 645 /* Allocate the USB bandwidth */ 646 em28xx_set_alternate(dev); 647 648 /* Needed, since GPIO might have disabled power of 649 some i2c device 650 */ 651 em28xx_wake_i2c(dev); 652 653 dev->capture_type = -1; 654 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE, 655 dev->analog_xfer_bulk, 656 EM28XX_NUM_BUFS, 657 dev->max_pkt_size, 658 dev->packet_multiplier, 659 em28xx_urb_data_copy); 660 if (rc < 0) 661 goto fail; 662 663 /* 664 * djh: it's not clear whether this code is still needed. I'm 665 * leaving it in here for now entirely out of concern for 666 * backward compatibility (the old code did it) 667 */ 668 669 /* Ask tuner to go to analog or radio mode */ 670 memset(&f, 0, sizeof(f)); 671 f.frequency = dev->ctl_freq; 672 if (vq->owner && vq->owner->vdev->vfl_type == VFL_TYPE_RADIO) 673 f.type = V4L2_TUNER_RADIO; 674 else 675 f.type = V4L2_TUNER_ANALOG_TV; 676 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f); 677 } 678 679 fail: 680 return rc; 681 } 682 683 static int em28xx_stop_streaming(struct vb2_queue *vq) 684 { 685 struct em28xx *dev = vb2_get_drv_priv(vq); 686 struct em28xx_dmaqueue *vidq = &dev->vidq; 687 unsigned long flags = 0; 688 689 em28xx_videodbg("%s\n", __func__); 690 691 res_free(dev, vq->type); 692 693 if (dev->streaming_users-- == 1) { 694 /* Last active user, so shutdown all the URBS */ 695 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 696 } 697 698 spin_lock_irqsave(&dev->slock, flags); 699 while (!list_empty(&vidq->active)) { 700 struct em28xx_buffer *buf; 701 buf = list_entry(vidq->active.next, struct em28xx_buffer, list); 702 list_del(&buf->list); 703 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 704 } 705 dev->usb_ctl.vid_buf = NULL; 706 spin_unlock_irqrestore(&dev->slock, flags); 707 708 return 0; 709 } 710 711 int em28xx_stop_vbi_streaming(struct vb2_queue *vq) 712 { 713 struct em28xx *dev = vb2_get_drv_priv(vq); 714 struct em28xx_dmaqueue *vbiq = &dev->vbiq; 715 unsigned long flags = 0; 716 717 em28xx_videodbg("%s\n", __func__); 718 719 res_free(dev, vq->type); 720 721 if (dev->streaming_users-- == 1) { 722 /* Last active user, so shutdown all the URBS */ 723 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 724 } 725 726 spin_lock_irqsave(&dev->slock, flags); 727 while (!list_empty(&vbiq->active)) { 728 struct em28xx_buffer *buf; 729 buf = list_entry(vbiq->active.next, struct em28xx_buffer, list); 730 list_del(&buf->list); 731 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 732 } 733 dev->usb_ctl.vbi_buf = NULL; 734 spin_unlock_irqrestore(&dev->slock, flags); 735 736 return 0; 737 } 738 739 static void 740 buffer_queue(struct vb2_buffer *vb) 741 { 742 struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue); 743 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb); 744 struct em28xx_dmaqueue *vidq = &dev->vidq; 745 unsigned long flags = 0; 746 747 em28xx_videodbg("%s\n", __func__); 748 buf->mem = vb2_plane_vaddr(vb, 0); 749 buf->length = vb2_plane_size(vb, 0); 750 751 spin_lock_irqsave(&dev->slock, flags); 752 list_add_tail(&buf->list, &vidq->active); 753 spin_unlock_irqrestore(&dev->slock, flags); 754 } 755 756 static struct vb2_ops em28xx_video_qops = { 757 .queue_setup = queue_setup, 758 .buf_prepare = buffer_prepare, 759 .buf_queue = buffer_queue, 760 .start_streaming = em28xx_start_analog_streaming, 761 .stop_streaming = em28xx_stop_streaming, 762 .wait_prepare = vb2_ops_wait_prepare, 763 .wait_finish = vb2_ops_wait_finish, 764 }; 765 766 int em28xx_vb2_setup(struct em28xx *dev) 767 { 768 int rc; 769 struct vb2_queue *q; 770 771 /* Setup Videobuf2 for Video capture */ 772 q = &dev->vb_vidq; 773 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 774 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 775 q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 776 q->drv_priv = dev; 777 q->buf_struct_size = sizeof(struct em28xx_buffer); 778 q->ops = &em28xx_video_qops; 779 q->mem_ops = &vb2_vmalloc_memops; 780 781 rc = vb2_queue_init(q); 782 if (rc < 0) 783 return rc; 784 785 /* Setup Videobuf2 for VBI capture */ 786 q = &dev->vb_vbiq; 787 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 788 q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR; 789 q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 790 q->drv_priv = dev; 791 q->buf_struct_size = sizeof(struct em28xx_buffer); 792 q->ops = &em28xx_vbi_qops; 793 q->mem_ops = &vb2_vmalloc_memops; 794 795 rc = vb2_queue_init(q); 796 if (rc < 0) 797 return rc; 798 799 return 0; 800 } 801 802 /********************* v4l2 interface **************************************/ 803 804 static void video_mux(struct em28xx *dev, int index) 805 { 806 dev->ctl_input = index; 807 dev->ctl_ainput = INPUT(index)->amux; 808 dev->ctl_aoutput = INPUT(index)->aout; 809 810 if (!dev->ctl_aoutput) 811 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 812 813 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing, 814 INPUT(index)->vmux, 0, 0); 815 816 if (dev->board.has_msp34xx) { 817 if (dev->i2s_speed) { 818 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, 819 s_i2s_clock_freq, dev->i2s_speed); 820 } 821 /* Note: this is msp3400 specific */ 822 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing, 823 dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0); 824 } 825 826 if (dev->board.adecoder != EM28XX_NOADECODER) { 827 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing, 828 dev->ctl_ainput, dev->ctl_aoutput, 0); 829 } 830 831 em28xx_audio_analog_set(dev); 832 } 833 834 void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv) 835 { 836 struct em28xx *dev = priv; 837 838 /* 839 * In the case of non-AC97 volume controls, we still need 840 * to do some setups at em28xx, in order to mute/unmute 841 * and to adjust audio volume. However, the value ranges 842 * should be checked by the corresponding V4L subdriver. 843 */ 844 switch (ctrl->id) { 845 case V4L2_CID_AUDIO_MUTE: 846 dev->mute = ctrl->val; 847 em28xx_audio_analog_set(dev); 848 break; 849 case V4L2_CID_AUDIO_VOLUME: 850 dev->volume = ctrl->val; 851 em28xx_audio_analog_set(dev); 852 break; 853 } 854 } 855 856 static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl) 857 { 858 struct em28xx *dev = container_of(ctrl->handler, struct em28xx, ctrl_handler); 859 int ret = -EINVAL; 860 861 switch (ctrl->id) { 862 case V4L2_CID_AUDIO_MUTE: 863 dev->mute = ctrl->val; 864 ret = em28xx_audio_analog_set(dev); 865 break; 866 case V4L2_CID_AUDIO_VOLUME: 867 dev->volume = ctrl->val; 868 ret = em28xx_audio_analog_set(dev); 869 break; 870 case V4L2_CID_CONTRAST: 871 ret = em28xx_write_reg(dev, EM28XX_R20_YGAIN, ctrl->val); 872 break; 873 case V4L2_CID_BRIGHTNESS: 874 ret = em28xx_write_reg(dev, EM28XX_R21_YOFFSET, ctrl->val); 875 break; 876 case V4L2_CID_SATURATION: 877 ret = em28xx_write_reg(dev, EM28XX_R22_UVGAIN, ctrl->val); 878 break; 879 case V4L2_CID_BLUE_BALANCE: 880 ret = em28xx_write_reg(dev, EM28XX_R23_UOFFSET, ctrl->val); 881 break; 882 case V4L2_CID_RED_BALANCE: 883 ret = em28xx_write_reg(dev, EM28XX_R24_VOFFSET, ctrl->val); 884 break; 885 case V4L2_CID_SHARPNESS: 886 ret = em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, ctrl->val); 887 break; 888 } 889 890 return (ret < 0) ? ret : 0; 891 } 892 893 const struct v4l2_ctrl_ops em28xx_ctrl_ops = { 894 .s_ctrl = em28xx_s_ctrl, 895 }; 896 897 static void size_to_scale(struct em28xx *dev, 898 unsigned int width, unsigned int height, 899 unsigned int *hscale, unsigned int *vscale) 900 { 901 unsigned int maxw = norm_maxw(dev); 902 unsigned int maxh = norm_maxh(dev); 903 904 *hscale = (((unsigned long)maxw) << 12) / width - 4096L; 905 if (*hscale > EM28XX_HVSCALE_MAX) 906 *hscale = EM28XX_HVSCALE_MAX; 907 908 *vscale = (((unsigned long)maxh) << 12) / height - 4096L; 909 if (*vscale > EM28XX_HVSCALE_MAX) 910 *vscale = EM28XX_HVSCALE_MAX; 911 } 912 913 static void scale_to_size(struct em28xx *dev, 914 unsigned int hscale, unsigned int vscale, 915 unsigned int *width, unsigned int *height) 916 { 917 unsigned int maxw = norm_maxw(dev); 918 unsigned int maxh = norm_maxh(dev); 919 920 *width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 921 *height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 922 } 923 924 /* ------------------------------------------------------------------ 925 IOCTL vidioc handling 926 ------------------------------------------------------------------*/ 927 928 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 929 struct v4l2_format *f) 930 { 931 struct em28xx_fh *fh = priv; 932 struct em28xx *dev = fh->dev; 933 934 f->fmt.pix.width = dev->width; 935 f->fmt.pix.height = dev->height; 936 f->fmt.pix.pixelformat = dev->format->fourcc; 937 f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3; 938 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height; 939 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 940 941 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */ 942 if (dev->progressive) 943 f->fmt.pix.field = V4L2_FIELD_NONE; 944 else 945 f->fmt.pix.field = dev->interlaced ? 946 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 947 return 0; 948 } 949 950 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc) 951 { 952 unsigned int i; 953 954 for (i = 0; i < ARRAY_SIZE(format); i++) 955 if (format[i].fourcc == fourcc) 956 return &format[i]; 957 958 return NULL; 959 } 960 961 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 962 struct v4l2_format *f) 963 { 964 struct em28xx_fh *fh = priv; 965 struct em28xx *dev = fh->dev; 966 unsigned int width = f->fmt.pix.width; 967 unsigned int height = f->fmt.pix.height; 968 unsigned int maxw = norm_maxw(dev); 969 unsigned int maxh = norm_maxh(dev); 970 unsigned int hscale, vscale; 971 struct em28xx_fmt *fmt; 972 973 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 974 if (!fmt) { 975 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 976 f->fmt.pix.pixelformat); 977 return -EINVAL; 978 } 979 980 if (dev->board.is_em2800) { 981 /* the em2800 can only scale down to 50% */ 982 height = height > (3 * maxh / 4) ? maxh : maxh / 2; 983 width = width > (3 * maxw / 4) ? maxw : maxw / 2; 984 /* 985 * MaxPacketSize for em2800 is too small to capture at full 986 * resolution use half of maxw as the scaler can only scale 987 * to 50% 988 */ 989 if (width == maxw && height == maxh) 990 width /= 2; 991 } else { 992 /* width must even because of the YUYV format 993 height must be even because of interlacing */ 994 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 995 1, 0); 996 } 997 998 size_to_scale(dev, width, height, &hscale, &vscale); 999 scale_to_size(dev, hscale, hscale, &width, &height); 1000 1001 f->fmt.pix.width = width; 1002 f->fmt.pix.height = height; 1003 f->fmt.pix.pixelformat = fmt->fourcc; 1004 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3; 1005 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height; 1006 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1007 if (dev->progressive) 1008 f->fmt.pix.field = V4L2_FIELD_NONE; 1009 else 1010 f->fmt.pix.field = dev->interlaced ? 1011 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1012 1013 return 0; 1014 } 1015 1016 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc, 1017 unsigned width, unsigned height) 1018 { 1019 struct em28xx_fmt *fmt; 1020 1021 fmt = format_by_fourcc(fourcc); 1022 if (!fmt) 1023 return -EINVAL; 1024 1025 dev->format = fmt; 1026 dev->width = width; 1027 dev->height = height; 1028 1029 /* set new image size */ 1030 size_to_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale); 1031 1032 em28xx_resolution_set(dev); 1033 1034 return 0; 1035 } 1036 1037 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1038 struct v4l2_format *f) 1039 { 1040 struct em28xx *dev = video_drvdata(file); 1041 1042 if (dev->streaming_users > 0) 1043 return -EBUSY; 1044 1045 vidioc_try_fmt_vid_cap(file, priv, f); 1046 1047 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat, 1048 f->fmt.pix.width, f->fmt.pix.height); 1049 } 1050 1051 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm) 1052 { 1053 struct em28xx_fh *fh = priv; 1054 struct em28xx *dev = fh->dev; 1055 1056 *norm = dev->norm; 1057 1058 return 0; 1059 } 1060 1061 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm) 1062 { 1063 struct em28xx_fh *fh = priv; 1064 struct em28xx *dev = fh->dev; 1065 1066 v4l2_device_call_all(&dev->v4l2_dev, 0, video, querystd, norm); 1067 1068 return 0; 1069 } 1070 1071 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm) 1072 { 1073 struct em28xx_fh *fh = priv; 1074 struct em28xx *dev = fh->dev; 1075 struct v4l2_format f; 1076 1077 if (norm == dev->norm) 1078 return 0; 1079 1080 if (dev->streaming_users > 0) 1081 return -EBUSY; 1082 1083 dev->norm = norm; 1084 1085 /* Adjusts width/height, if needed */ 1086 f.fmt.pix.width = 720; 1087 f.fmt.pix.height = (norm & V4L2_STD_525_60) ? 480 : 576; 1088 vidioc_try_fmt_vid_cap(file, priv, &f); 1089 1090 /* set new image size */ 1091 dev->width = f.fmt.pix.width; 1092 dev->height = f.fmt.pix.height; 1093 size_to_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale); 1094 1095 em28xx_resolution_set(dev); 1096 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm); 1097 1098 return 0; 1099 } 1100 1101 static int vidioc_g_parm(struct file *file, void *priv, 1102 struct v4l2_streamparm *p) 1103 { 1104 struct em28xx_fh *fh = priv; 1105 struct em28xx *dev = fh->dev; 1106 int rc = 0; 1107 1108 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1109 if (dev->board.is_webcam) 1110 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0, 1111 video, g_parm, p); 1112 else 1113 v4l2_video_std_frame_period(dev->norm, 1114 &p->parm.capture.timeperframe); 1115 1116 return rc; 1117 } 1118 1119 static int vidioc_s_parm(struct file *file, void *priv, 1120 struct v4l2_streamparm *p) 1121 { 1122 struct em28xx_fh *fh = priv; 1123 struct em28xx *dev = fh->dev; 1124 1125 p->parm.capture.readbuffers = EM28XX_MIN_BUF; 1126 return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p); 1127 } 1128 1129 static const char *iname[] = { 1130 [EM28XX_VMUX_COMPOSITE1] = "Composite1", 1131 [EM28XX_VMUX_COMPOSITE2] = "Composite2", 1132 [EM28XX_VMUX_COMPOSITE3] = "Composite3", 1133 [EM28XX_VMUX_COMPOSITE4] = "Composite4", 1134 [EM28XX_VMUX_SVIDEO] = "S-Video", 1135 [EM28XX_VMUX_TELEVISION] = "Television", 1136 [EM28XX_VMUX_CABLE] = "Cable TV", 1137 [EM28XX_VMUX_DVB] = "DVB", 1138 [EM28XX_VMUX_DEBUG] = "for debug only", 1139 }; 1140 1141 static int vidioc_enum_input(struct file *file, void *priv, 1142 struct v4l2_input *i) 1143 { 1144 struct em28xx_fh *fh = priv; 1145 struct em28xx *dev = fh->dev; 1146 unsigned int n; 1147 1148 n = i->index; 1149 if (n >= MAX_EM28XX_INPUT) 1150 return -EINVAL; 1151 if (0 == INPUT(n)->type) 1152 return -EINVAL; 1153 1154 i->index = n; 1155 i->type = V4L2_INPUT_TYPE_CAMERA; 1156 1157 strcpy(i->name, iname[INPUT(n)->type]); 1158 1159 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) || 1160 (EM28XX_VMUX_CABLE == INPUT(n)->type)) 1161 i->type = V4L2_INPUT_TYPE_TUNER; 1162 1163 i->std = dev->vdev->tvnorms; 1164 /* webcams do not have the STD API */ 1165 if (dev->board.is_webcam) 1166 i->capabilities = 0; 1167 1168 return 0; 1169 } 1170 1171 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1172 { 1173 struct em28xx_fh *fh = priv; 1174 struct em28xx *dev = fh->dev; 1175 1176 *i = dev->ctl_input; 1177 1178 return 0; 1179 } 1180 1181 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1182 { 1183 struct em28xx_fh *fh = priv; 1184 struct em28xx *dev = fh->dev; 1185 1186 if (i >= MAX_EM28XX_INPUT) 1187 return -EINVAL; 1188 if (0 == INPUT(i)->type) 1189 return -EINVAL; 1190 1191 video_mux(dev, i); 1192 return 0; 1193 } 1194 1195 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1196 { 1197 struct em28xx_fh *fh = priv; 1198 struct em28xx *dev = fh->dev; 1199 1200 switch (a->index) { 1201 case EM28XX_AMUX_VIDEO: 1202 strcpy(a->name, "Television"); 1203 break; 1204 case EM28XX_AMUX_LINE_IN: 1205 strcpy(a->name, "Line In"); 1206 break; 1207 case EM28XX_AMUX_VIDEO2: 1208 strcpy(a->name, "Television alt"); 1209 break; 1210 case EM28XX_AMUX_PHONE: 1211 strcpy(a->name, "Phone"); 1212 break; 1213 case EM28XX_AMUX_MIC: 1214 strcpy(a->name, "Mic"); 1215 break; 1216 case EM28XX_AMUX_CD: 1217 strcpy(a->name, "CD"); 1218 break; 1219 case EM28XX_AMUX_AUX: 1220 strcpy(a->name, "Aux"); 1221 break; 1222 case EM28XX_AMUX_PCM_OUT: 1223 strcpy(a->name, "PCM"); 1224 break; 1225 default: 1226 return -EINVAL; 1227 } 1228 1229 a->index = dev->ctl_ainput; 1230 a->capability = V4L2_AUDCAP_STEREO; 1231 1232 return 0; 1233 } 1234 1235 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1236 { 1237 struct em28xx_fh *fh = priv; 1238 struct em28xx *dev = fh->dev; 1239 1240 if (a->index >= MAX_EM28XX_INPUT) 1241 return -EINVAL; 1242 if (0 == INPUT(a->index)->type) 1243 return -EINVAL; 1244 1245 dev->ctl_ainput = INPUT(a->index)->amux; 1246 dev->ctl_aoutput = INPUT(a->index)->aout; 1247 1248 if (!dev->ctl_aoutput) 1249 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1250 1251 return 0; 1252 } 1253 1254 static int vidioc_g_tuner(struct file *file, void *priv, 1255 struct v4l2_tuner *t) 1256 { 1257 struct em28xx_fh *fh = priv; 1258 struct em28xx *dev = fh->dev; 1259 1260 if (0 != t->index) 1261 return -EINVAL; 1262 1263 strcpy(t->name, "Tuner"); 1264 1265 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t); 1266 return 0; 1267 } 1268 1269 static int vidioc_s_tuner(struct file *file, void *priv, 1270 const struct v4l2_tuner *t) 1271 { 1272 struct em28xx_fh *fh = priv; 1273 struct em28xx *dev = fh->dev; 1274 1275 if (0 != t->index) 1276 return -EINVAL; 1277 1278 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t); 1279 return 0; 1280 } 1281 1282 static int vidioc_g_frequency(struct file *file, void *priv, 1283 struct v4l2_frequency *f) 1284 { 1285 struct em28xx_fh *fh = priv; 1286 struct em28xx *dev = fh->dev; 1287 1288 if (0 != f->tuner) 1289 return -EINVAL; 1290 1291 f->frequency = dev->ctl_freq; 1292 return 0; 1293 } 1294 1295 static int vidioc_s_frequency(struct file *file, void *priv, 1296 const struct v4l2_frequency *f) 1297 { 1298 struct v4l2_frequency new_freq = *f; 1299 struct em28xx_fh *fh = priv; 1300 struct em28xx *dev = fh->dev; 1301 1302 if (0 != f->tuner) 1303 return -EINVAL; 1304 1305 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f); 1306 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq); 1307 dev->ctl_freq = new_freq.frequency; 1308 1309 return 0; 1310 } 1311 1312 static int vidioc_g_chip_ident(struct file *file, void *priv, 1313 struct v4l2_dbg_chip_ident *chip) 1314 { 1315 struct em28xx_fh *fh = priv; 1316 struct em28xx *dev = fh->dev; 1317 1318 chip->ident = V4L2_IDENT_NONE; 1319 chip->revision = 0; 1320 if (chip->match.type == V4L2_CHIP_MATCH_BRIDGE) { 1321 if (chip->match.addr > 1) 1322 return -EINVAL; 1323 return 0; 1324 } 1325 if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER && 1326 chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR) 1327 return -EINVAL; 1328 1329 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip); 1330 1331 return 0; 1332 } 1333 1334 static int vidioc_g_chip_name(struct file *file, void *priv, 1335 struct v4l2_dbg_chip_name *chip) 1336 { 1337 struct em28xx_fh *fh = priv; 1338 struct em28xx *dev = fh->dev; 1339 1340 if (chip->match.addr > 1) 1341 return -EINVAL; 1342 if (chip->match.addr == 1) 1343 strlcpy(chip->name, "ac97", sizeof(chip->name)); 1344 else 1345 strlcpy(chip->name, dev->v4l2_dev.name, sizeof(chip->name)); 1346 return 0; 1347 } 1348 1349 #ifdef CONFIG_VIDEO_ADV_DEBUG 1350 static int em28xx_reg_len(int reg) 1351 { 1352 switch (reg) { 1353 case EM28XX_R40_AC97LSB: 1354 case EM28XX_R30_HSCALELOW: 1355 case EM28XX_R32_VSCALELOW: 1356 return 2; 1357 default: 1358 return 1; 1359 } 1360 } 1361 1362 static int vidioc_g_register(struct file *file, void *priv, 1363 struct v4l2_dbg_register *reg) 1364 { 1365 struct em28xx_fh *fh = priv; 1366 struct em28xx *dev = fh->dev; 1367 int ret; 1368 1369 switch (reg->match.type) { 1370 case V4L2_CHIP_MATCH_BRIDGE: 1371 if (reg->match.addr > 1) 1372 return -EINVAL; 1373 if (!reg->match.addr) 1374 break; 1375 /* fall-through */ 1376 case V4L2_CHIP_MATCH_AC97: 1377 ret = em28xx_read_ac97(dev, reg->reg); 1378 if (ret < 0) 1379 return ret; 1380 1381 reg->val = ret; 1382 reg->size = 1; 1383 return 0; 1384 case V4L2_CHIP_MATCH_I2C_DRIVER: 1385 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg); 1386 return 0; 1387 case V4L2_CHIP_MATCH_I2C_ADDR: 1388 /* TODO: is this correct? */ 1389 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg); 1390 return 0; 1391 default: 1392 return -EINVAL; 1393 } 1394 1395 /* Match host */ 1396 reg->size = em28xx_reg_len(reg->reg); 1397 if (reg->size == 1) { 1398 ret = em28xx_read_reg(dev, reg->reg); 1399 1400 if (ret < 0) 1401 return ret; 1402 1403 reg->val = ret; 1404 } else { 1405 __le16 val = 0; 1406 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS, 1407 reg->reg, (char *)&val, 2); 1408 if (ret < 0) 1409 return ret; 1410 1411 reg->val = le16_to_cpu(val); 1412 } 1413 1414 return 0; 1415 } 1416 1417 static int vidioc_s_register(struct file *file, void *priv, 1418 const struct v4l2_dbg_register *reg) 1419 { 1420 struct em28xx_fh *fh = priv; 1421 struct em28xx *dev = fh->dev; 1422 __le16 buf; 1423 1424 switch (reg->match.type) { 1425 case V4L2_CHIP_MATCH_BRIDGE: 1426 if (reg->match.addr > 1) 1427 return -EINVAL; 1428 if (!reg->match.addr) 1429 break; 1430 /* fall-through */ 1431 case V4L2_CHIP_MATCH_AC97: 1432 return em28xx_write_ac97(dev, reg->reg, reg->val); 1433 case V4L2_CHIP_MATCH_I2C_DRIVER: 1434 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg); 1435 return 0; 1436 case V4L2_CHIP_MATCH_I2C_ADDR: 1437 /* TODO: is this correct? */ 1438 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg); 1439 return 0; 1440 default: 1441 return -EINVAL; 1442 } 1443 1444 /* Match host */ 1445 buf = cpu_to_le16(reg->val); 1446 1447 return em28xx_write_regs(dev, reg->reg, (char *)&buf, 1448 em28xx_reg_len(reg->reg)); 1449 } 1450 #endif 1451 1452 1453 static int vidioc_querycap(struct file *file, void *priv, 1454 struct v4l2_capability *cap) 1455 { 1456 struct video_device *vdev = video_devdata(file); 1457 struct em28xx_fh *fh = priv; 1458 struct em28xx *dev = fh->dev; 1459 1460 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1461 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 1462 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1463 1464 if (vdev->vfl_type == VFL_TYPE_GRABBER) 1465 cap->device_caps = V4L2_CAP_READWRITE | 1466 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1467 else if (vdev->vfl_type == VFL_TYPE_RADIO) 1468 cap->device_caps = V4L2_CAP_RADIO; 1469 else 1470 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE; 1471 1472 if (dev->audio_mode.has_audio) 1473 cap->device_caps |= V4L2_CAP_AUDIO; 1474 1475 if (dev->tuner_type != TUNER_ABSENT) 1476 cap->device_caps |= V4L2_CAP_TUNER; 1477 1478 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS | 1479 V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1480 if (dev->vbi_dev) 1481 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 1482 if (dev->radio_dev) 1483 cap->capabilities |= V4L2_CAP_RADIO; 1484 return 0; 1485 } 1486 1487 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1488 struct v4l2_fmtdesc *f) 1489 { 1490 if (unlikely(f->index >= ARRAY_SIZE(format))) 1491 return -EINVAL; 1492 1493 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1494 f->pixelformat = format[f->index].fourcc; 1495 1496 return 0; 1497 } 1498 1499 static int vidioc_enum_framesizes(struct file *file, void *priv, 1500 struct v4l2_frmsizeenum *fsize) 1501 { 1502 struct em28xx_fh *fh = priv; 1503 struct em28xx *dev = fh->dev; 1504 struct em28xx_fmt *fmt; 1505 unsigned int maxw = norm_maxw(dev); 1506 unsigned int maxh = norm_maxh(dev); 1507 1508 fmt = format_by_fourcc(fsize->pixel_format); 1509 if (!fmt) { 1510 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1511 fsize->pixel_format); 1512 return -EINVAL; 1513 } 1514 1515 if (dev->board.is_em2800) { 1516 if (fsize->index > 1) 1517 return -EINVAL; 1518 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1519 fsize->discrete.width = maxw / (1 + fsize->index); 1520 fsize->discrete.height = maxh / (1 + fsize->index); 1521 return 0; 1522 } 1523 1524 if (fsize->index != 0) 1525 return -EINVAL; 1526 1527 /* Report a continuous range */ 1528 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 1529 scale_to_size(dev, EM28XX_HVSCALE_MAX, EM28XX_HVSCALE_MAX, 1530 &fsize->stepwise.min_width, &fsize->stepwise.min_height); 1531 if (fsize->stepwise.min_width < 48) 1532 fsize->stepwise.min_width = 48; 1533 if (fsize->stepwise.min_height < 38) 1534 fsize->stepwise.min_height = 38; 1535 fsize->stepwise.max_width = maxw; 1536 fsize->stepwise.max_height = maxh; 1537 fsize->stepwise.step_width = 1; 1538 fsize->stepwise.step_height = 1; 1539 return 0; 1540 } 1541 1542 /* RAW VBI ioctls */ 1543 1544 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1545 struct v4l2_format *format) 1546 { 1547 struct em28xx_fh *fh = priv; 1548 struct em28xx *dev = fh->dev; 1549 1550 format->fmt.vbi.samples_per_line = dev->vbi_width; 1551 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1552 format->fmt.vbi.offset = 0; 1553 format->fmt.vbi.flags = 0; 1554 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1555 format->fmt.vbi.count[0] = dev->vbi_height; 1556 format->fmt.vbi.count[1] = dev->vbi_height; 1557 memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved)); 1558 1559 /* Varies by video standard (NTSC, PAL, etc.) */ 1560 if (dev->norm & V4L2_STD_525_60) { 1561 /* NTSC */ 1562 format->fmt.vbi.start[0] = 10; 1563 format->fmt.vbi.start[1] = 273; 1564 } else if (dev->norm & V4L2_STD_625_50) { 1565 /* PAL */ 1566 format->fmt.vbi.start[0] = 6; 1567 format->fmt.vbi.start[1] = 318; 1568 } 1569 1570 return 0; 1571 } 1572 1573 /* ----------------------------------------------------------- */ 1574 /* RADIO ESPECIFIC IOCTLS */ 1575 /* ----------------------------------------------------------- */ 1576 1577 static int radio_g_tuner(struct file *file, void *priv, 1578 struct v4l2_tuner *t) 1579 { 1580 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev; 1581 1582 if (unlikely(t->index > 0)) 1583 return -EINVAL; 1584 1585 strcpy(t->name, "Radio"); 1586 1587 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t); 1588 1589 return 0; 1590 } 1591 1592 static int radio_s_tuner(struct file *file, void *priv, 1593 const struct v4l2_tuner *t) 1594 { 1595 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev; 1596 1597 if (0 != t->index) 1598 return -EINVAL; 1599 1600 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t); 1601 1602 return 0; 1603 } 1604 1605 /* 1606 * em28xx_v4l2_open() 1607 * inits the device and starts isoc transfer 1608 */ 1609 static int em28xx_v4l2_open(struct file *filp) 1610 { 1611 struct video_device *vdev = video_devdata(filp); 1612 struct em28xx *dev = video_drvdata(filp); 1613 enum v4l2_buf_type fh_type = 0; 1614 struct em28xx_fh *fh; 1615 1616 switch (vdev->vfl_type) { 1617 case VFL_TYPE_GRABBER: 1618 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1619 break; 1620 case VFL_TYPE_VBI: 1621 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 1622 break; 1623 } 1624 1625 em28xx_videodbg("open dev=%s type=%s users=%d\n", 1626 video_device_node_name(vdev), v4l2_type_names[fh_type], 1627 dev->users); 1628 1629 1630 if (mutex_lock_interruptible(&dev->lock)) 1631 return -ERESTARTSYS; 1632 fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL); 1633 if (!fh) { 1634 em28xx_errdev("em28xx-video.c: Out of memory?!\n"); 1635 mutex_unlock(&dev->lock); 1636 return -ENOMEM; 1637 } 1638 v4l2_fh_init(&fh->fh, vdev); 1639 fh->dev = dev; 1640 fh->type = fh_type; 1641 filp->private_data = fh; 1642 1643 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) { 1644 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 1645 em28xx_resolution_set(dev); 1646 1647 /* Needed, since GPIO might have disabled power of 1648 some i2c device 1649 */ 1650 em28xx_wake_i2c(dev); 1651 1652 } 1653 1654 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1655 em28xx_videodbg("video_open: setting radio device\n"); 1656 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio); 1657 } 1658 1659 dev->users++; 1660 1661 mutex_unlock(&dev->lock); 1662 v4l2_fh_add(&fh->fh); 1663 1664 return 0; 1665 } 1666 1667 /* 1668 * em28xx_realease_resources() 1669 * unregisters the v4l2,i2c and usb devices 1670 * called when the device gets disconected or at module unload 1671 */ 1672 void em28xx_release_analog_resources(struct em28xx *dev) 1673 { 1674 1675 /*FIXME: I2C IR should be disconnected */ 1676 1677 if (dev->radio_dev) { 1678 if (video_is_registered(dev->radio_dev)) 1679 video_unregister_device(dev->radio_dev); 1680 else 1681 video_device_release(dev->radio_dev); 1682 dev->radio_dev = NULL; 1683 } 1684 if (dev->vbi_dev) { 1685 em28xx_info("V4L2 device %s deregistered\n", 1686 video_device_node_name(dev->vbi_dev)); 1687 if (video_is_registered(dev->vbi_dev)) 1688 video_unregister_device(dev->vbi_dev); 1689 else 1690 video_device_release(dev->vbi_dev); 1691 dev->vbi_dev = NULL; 1692 } 1693 if (dev->vdev) { 1694 em28xx_info("V4L2 device %s deregistered\n", 1695 video_device_node_name(dev->vdev)); 1696 if (video_is_registered(dev->vdev)) 1697 video_unregister_device(dev->vdev); 1698 else 1699 video_device_release(dev->vdev); 1700 dev->vdev = NULL; 1701 } 1702 } 1703 1704 /* 1705 * em28xx_v4l2_close() 1706 * stops streaming and deallocates all resources allocated by the v4l2 1707 * calls and ioctls 1708 */ 1709 static int em28xx_v4l2_close(struct file *filp) 1710 { 1711 struct em28xx_fh *fh = filp->private_data; 1712 struct em28xx *dev = fh->dev; 1713 int errCode; 1714 1715 em28xx_videodbg("users=%d\n", dev->users); 1716 1717 mutex_lock(&dev->lock); 1718 vb2_fop_release(filp); 1719 1720 if (dev->users == 1) { 1721 /* the device is already disconnect, 1722 free the remaining resources */ 1723 if (dev->disconnected) { 1724 em28xx_release_resources(dev); 1725 kfree(dev->alt_max_pkt_size_isoc); 1726 mutex_unlock(&dev->lock); 1727 kfree(dev); 1728 return 0; 1729 } 1730 1731 /* Save some power by putting tuner to sleep */ 1732 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0); 1733 1734 /* do this before setting alternate! */ 1735 em28xx_set_mode(dev, EM28XX_SUSPEND); 1736 1737 /* set alternate 0 */ 1738 dev->alt = 0; 1739 em28xx_videodbg("setting alternate 0\n"); 1740 errCode = usb_set_interface(dev->udev, 0, 0); 1741 if (errCode < 0) { 1742 em28xx_errdev("cannot change alternate number to " 1743 "0 (error=%i)\n", errCode); 1744 } 1745 } 1746 1747 dev->users--; 1748 mutex_unlock(&dev->lock); 1749 return 0; 1750 } 1751 1752 static const struct v4l2_file_operations em28xx_v4l_fops = { 1753 .owner = THIS_MODULE, 1754 .open = em28xx_v4l2_open, 1755 .release = em28xx_v4l2_close, 1756 .read = vb2_fop_read, 1757 .poll = vb2_fop_poll, 1758 .mmap = vb2_fop_mmap, 1759 .unlocked_ioctl = video_ioctl2, 1760 }; 1761 1762 static const struct v4l2_ioctl_ops video_ioctl_ops = { 1763 .vidioc_querycap = vidioc_querycap, 1764 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1765 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1766 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1767 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1768 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 1769 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 1770 .vidioc_s_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 1771 .vidioc_enum_framesizes = vidioc_enum_framesizes, 1772 .vidioc_g_audio = vidioc_g_audio, 1773 .vidioc_s_audio = vidioc_s_audio, 1774 1775 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1776 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1777 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 1778 .vidioc_querybuf = vb2_ioctl_querybuf, 1779 .vidioc_qbuf = vb2_ioctl_qbuf, 1780 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1781 1782 .vidioc_g_std = vidioc_g_std, 1783 .vidioc_querystd = vidioc_querystd, 1784 .vidioc_s_std = vidioc_s_std, 1785 .vidioc_g_parm = vidioc_g_parm, 1786 .vidioc_s_parm = vidioc_s_parm, 1787 .vidioc_enum_input = vidioc_enum_input, 1788 .vidioc_g_input = vidioc_g_input, 1789 .vidioc_s_input = vidioc_s_input, 1790 .vidioc_streamon = vb2_ioctl_streamon, 1791 .vidioc_streamoff = vb2_ioctl_streamoff, 1792 .vidioc_g_tuner = vidioc_g_tuner, 1793 .vidioc_s_tuner = vidioc_s_tuner, 1794 .vidioc_g_frequency = vidioc_g_frequency, 1795 .vidioc_s_frequency = vidioc_s_frequency, 1796 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1797 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1798 .vidioc_g_chip_ident = vidioc_g_chip_ident, 1799 .vidioc_g_chip_name = vidioc_g_chip_name, 1800 #ifdef CONFIG_VIDEO_ADV_DEBUG 1801 .vidioc_g_register = vidioc_g_register, 1802 .vidioc_s_register = vidioc_s_register, 1803 #endif 1804 }; 1805 1806 static const struct video_device em28xx_video_template = { 1807 .fops = &em28xx_v4l_fops, 1808 .release = video_device_release_empty, 1809 .ioctl_ops = &video_ioctl_ops, 1810 1811 .tvnorms = V4L2_STD_ALL, 1812 }; 1813 1814 static const struct v4l2_file_operations radio_fops = { 1815 .owner = THIS_MODULE, 1816 .open = em28xx_v4l2_open, 1817 .release = em28xx_v4l2_close, 1818 .unlocked_ioctl = video_ioctl2, 1819 }; 1820 1821 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 1822 .vidioc_querycap = vidioc_querycap, 1823 .vidioc_g_tuner = radio_g_tuner, 1824 .vidioc_s_tuner = radio_s_tuner, 1825 .vidioc_g_frequency = vidioc_g_frequency, 1826 .vidioc_s_frequency = vidioc_s_frequency, 1827 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1828 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1829 .vidioc_g_chip_ident = vidioc_g_chip_ident, 1830 .vidioc_g_chip_name = vidioc_g_chip_name, 1831 #ifdef CONFIG_VIDEO_ADV_DEBUG 1832 .vidioc_g_register = vidioc_g_register, 1833 .vidioc_s_register = vidioc_s_register, 1834 #endif 1835 }; 1836 1837 static struct video_device em28xx_radio_template = { 1838 .name = "em28xx-radio", 1839 .fops = &radio_fops, 1840 .ioctl_ops = &radio_ioctl_ops, 1841 }; 1842 1843 /******************************** usb interface ******************************/ 1844 1845 1846 1847 static struct video_device *em28xx_vdev_init(struct em28xx *dev, 1848 const struct video_device *template, 1849 const char *type_name) 1850 { 1851 struct video_device *vfd; 1852 1853 vfd = video_device_alloc(); 1854 if (NULL == vfd) 1855 return NULL; 1856 1857 *vfd = *template; 1858 vfd->v4l2_dev = &dev->v4l2_dev; 1859 vfd->debug = video_debug; 1860 vfd->lock = &dev->lock; 1861 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1862 if (dev->board.is_webcam) 1863 vfd->tvnorms = 0; 1864 1865 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 1866 dev->name, type_name); 1867 1868 video_set_drvdata(vfd, dev); 1869 return vfd; 1870 } 1871 1872 int em28xx_register_analog_devices(struct em28xx *dev) 1873 { 1874 u8 val; 1875 int ret; 1876 unsigned int maxw; 1877 1878 printk(KERN_INFO "%s: v4l2 driver version %s\n", 1879 dev->name, EM28XX_VERSION); 1880 1881 /* set default norm */ 1882 dev->norm = V4L2_STD_PAL; 1883 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm); 1884 dev->interlaced = EM28XX_INTERLACED_DEFAULT; 1885 1886 /* Analog specific initialization */ 1887 dev->format = &format[0]; 1888 1889 maxw = norm_maxw(dev); 1890 /* MaxPacketSize for em2800 is too small to capture at full resolution 1891 * use half of maxw as the scaler can only scale to 50% */ 1892 if (dev->board.is_em2800) 1893 maxw /= 2; 1894 1895 em28xx_set_video_format(dev, format[0].fourcc, 1896 maxw, norm_maxh(dev)); 1897 1898 video_mux(dev, 0); 1899 1900 /* Audio defaults */ 1901 dev->mute = 1; 1902 dev->volume = 0x1f; 1903 1904 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 1905 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 1906 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 1907 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 1908 1909 em28xx_set_outfmt(dev); 1910 em28xx_compression_disable(dev); 1911 1912 /* Add image controls */ 1913 /* NOTE: at this point, the subdevices are already registered, so bridge 1914 * controls are only added/enabled when no subdevice provides them */ 1915 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_CONTRAST)) 1916 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1917 V4L2_CID_CONTRAST, 1918 0, 0x1f, 1, CONTRAST_DEFAULT); 1919 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_BRIGHTNESS)) 1920 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1921 V4L2_CID_BRIGHTNESS, 1922 -0x80, 0x7f, 1, BRIGHTNESS_DEFAULT); 1923 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_SATURATION)) 1924 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1925 V4L2_CID_SATURATION, 1926 0, 0x1f, 1, SATURATION_DEFAULT); 1927 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_BLUE_BALANCE)) 1928 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1929 V4L2_CID_BLUE_BALANCE, 1930 -0x30, 0x30, 1, BLUE_BALANCE_DEFAULT); 1931 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_RED_BALANCE)) 1932 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1933 V4L2_CID_RED_BALANCE, 1934 -0x30, 0x30, 1, RED_BALANCE_DEFAULT); 1935 if (NULL == v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_SHARPNESS)) 1936 v4l2_ctrl_new_std(&dev->ctrl_handler, &em28xx_ctrl_ops, 1937 V4L2_CID_SHARPNESS, 1938 0, 0x0f, 1, SHARPNESS_DEFAULT); 1939 1940 /* Reset image controls */ 1941 em28xx_colorlevels_set_default(dev); 1942 v4l2_ctrl_handler_setup(&dev->ctrl_handler); 1943 if (dev->ctrl_handler.error) 1944 return dev->ctrl_handler.error; 1945 1946 /* allocate and fill video video_device struct */ 1947 dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video"); 1948 if (!dev->vdev) { 1949 em28xx_errdev("cannot allocate video_device.\n"); 1950 return -ENODEV; 1951 } 1952 dev->vdev->queue = &dev->vb_vidq; 1953 dev->vdev->queue->lock = &dev->vb_queue_lock; 1954 1955 /* disable inapplicable ioctls */ 1956 if (dev->board.is_webcam) { 1957 v4l2_disable_ioctl(dev->vdev, VIDIOC_QUERYSTD); 1958 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_STD); 1959 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_STD); 1960 } else { 1961 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM); 1962 } 1963 if (dev->tuner_type == TUNER_ABSENT) { 1964 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_TUNER); 1965 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_TUNER); 1966 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_FREQUENCY); 1967 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_FREQUENCY); 1968 } 1969 if (!dev->audio_mode.has_audio) { 1970 v4l2_disable_ioctl(dev->vdev, VIDIOC_G_AUDIO); 1971 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_AUDIO); 1972 } 1973 1974 /* register v4l2 video video_device */ 1975 ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER, 1976 video_nr[dev->devno]); 1977 if (ret) { 1978 em28xx_errdev("unable to register video device (error=%i).\n", 1979 ret); 1980 return ret; 1981 } 1982 1983 /* Allocate and fill vbi video_device struct */ 1984 if (em28xx_vbi_supported(dev) == 1) { 1985 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template, 1986 "vbi"); 1987 1988 dev->vbi_dev->queue = &dev->vb_vbiq; 1989 dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock; 1990 1991 /* disable inapplicable ioctls */ 1992 v4l2_disable_ioctl(dev->vdev, VIDIOC_S_PARM); 1993 if (dev->tuner_type == TUNER_ABSENT) { 1994 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_TUNER); 1995 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_TUNER); 1996 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_FREQUENCY); 1997 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_FREQUENCY); 1998 } 1999 if (!dev->audio_mode.has_audio) { 2000 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_G_AUDIO); 2001 v4l2_disable_ioctl(dev->vbi_dev, VIDIOC_S_AUDIO); 2002 } 2003 2004 /* register v4l2 vbi video_device */ 2005 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, 2006 vbi_nr[dev->devno]); 2007 if (ret < 0) { 2008 em28xx_errdev("unable to register vbi device\n"); 2009 return ret; 2010 } 2011 } 2012 2013 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2014 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template, 2015 "radio"); 2016 if (!dev->radio_dev) { 2017 em28xx_errdev("cannot allocate video_device.\n"); 2018 return -ENODEV; 2019 } 2020 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO, 2021 radio_nr[dev->devno]); 2022 if (ret < 0) { 2023 em28xx_errdev("can't register radio device\n"); 2024 return ret; 2025 } 2026 em28xx_info("Registered radio device as %s\n", 2027 video_device_node_name(dev->radio_dev)); 2028 } 2029 2030 em28xx_info("V4L2 video device registered as %s\n", 2031 video_device_node_name(dev->vdev)); 2032 2033 if (dev->vbi_dev) 2034 em28xx_info("V4L2 VBI device registered as %s\n", 2035 video_device_node_name(dev->vbi_dev)); 2036 2037 return 0; 2038 } 2039