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-chip-ident.h> 44 #include <media/msp3400.h> 45 #include <media/tuner.h> 46 47 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \ 48 "Markus Rechberger <mrechberger@gmail.com>, " \ 49 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \ 50 "Sascha Sommer <saschasommer@freenet.de>" 51 52 #define DRIVER_DESC "Empia em28xx based USB video device driver" 53 54 #define EM28XX_VERSION "0.1.3" 55 56 #define em28xx_videodbg(fmt, arg...) do {\ 57 if (video_debug) \ 58 printk(KERN_INFO "%s %s :"fmt, \ 59 dev->name, __func__ , ##arg); } while (0) 60 61 static unsigned int isoc_debug; 62 module_param(isoc_debug, int, 0644); 63 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]"); 64 65 #define em28xx_isocdbg(fmt, arg...) \ 66 do {\ 67 if (isoc_debug) { \ 68 printk(KERN_INFO "%s %s :"fmt, \ 69 dev->name, __func__ , ##arg); \ 70 } \ 71 } while (0) 72 73 MODULE_AUTHOR(DRIVER_AUTHOR); 74 MODULE_DESCRIPTION(DRIVER_DESC); 75 MODULE_LICENSE("GPL"); 76 MODULE_VERSION(EM28XX_VERSION); 77 78 static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 79 static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 80 static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 81 82 module_param_array(video_nr, int, NULL, 0444); 83 module_param_array(vbi_nr, int, NULL, 0444); 84 module_param_array(radio_nr, int, NULL, 0444); 85 MODULE_PARM_DESC(video_nr, "video device numbers"); 86 MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 87 MODULE_PARM_DESC(radio_nr, "radio device numbers"); 88 89 static unsigned int video_debug; 90 module_param(video_debug, int, 0644); 91 MODULE_PARM_DESC(video_debug, "enable debug messages [video]"); 92 93 /* supported video standards */ 94 static struct em28xx_fmt format[] = { 95 { 96 .name = "16 bpp YUY2, 4:2:2, packed", 97 .fourcc = V4L2_PIX_FMT_YUYV, 98 .depth = 16, 99 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V, 100 }, { 101 .name = "16 bpp RGB 565, LE", 102 .fourcc = V4L2_PIX_FMT_RGB565, 103 .depth = 16, 104 .reg = EM28XX_OUTFMT_RGB_16_656, 105 }, { 106 .name = "8 bpp Bayer BGBG..GRGR", 107 .fourcc = V4L2_PIX_FMT_SBGGR8, 108 .depth = 8, 109 .reg = EM28XX_OUTFMT_RGB_8_BGBG, 110 }, { 111 .name = "8 bpp Bayer GRGR..BGBG", 112 .fourcc = V4L2_PIX_FMT_SGRBG8, 113 .depth = 8, 114 .reg = EM28XX_OUTFMT_RGB_8_GRGR, 115 }, { 116 .name = "8 bpp Bayer GBGB..RGRG", 117 .fourcc = V4L2_PIX_FMT_SGBRG8, 118 .depth = 8, 119 .reg = EM28XX_OUTFMT_RGB_8_GBGB, 120 }, { 121 .name = "12 bpp YUV411", 122 .fourcc = V4L2_PIX_FMT_YUV411P, 123 .depth = 12, 124 .reg = EM28XX_OUTFMT_YUV411, 125 }, 126 }; 127 128 /* supported controls */ 129 /* Common to all boards */ 130 static struct v4l2_queryctrl ac97_qctrl[] = { 131 { 132 .id = V4L2_CID_AUDIO_VOLUME, 133 .type = V4L2_CTRL_TYPE_INTEGER, 134 .name = "Volume", 135 .minimum = 0x0, 136 .maximum = 0x1f, 137 .step = 0x1, 138 .default_value = 0x1f, 139 .flags = V4L2_CTRL_FLAG_SLIDER, 140 }, { 141 .id = V4L2_CID_AUDIO_MUTE, 142 .type = V4L2_CTRL_TYPE_BOOLEAN, 143 .name = "Mute", 144 .minimum = 0, 145 .maximum = 1, 146 .step = 1, 147 .default_value = 1, 148 .flags = 0, 149 } 150 }; 151 152 /* ------------------------------------------------------------------ 153 DMA and thread functions 154 ------------------------------------------------------------------*/ 155 156 /* 157 * Announces that a buffer were filled and request the next 158 */ 159 static inline void buffer_filled(struct em28xx *dev, 160 struct em28xx_dmaqueue *dma_q, 161 struct em28xx_buffer *buf) 162 { 163 /* Advice that buffer was filled */ 164 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i); 165 buf->vb.state = VIDEOBUF_DONE; 166 buf->vb.field_count++; 167 v4l2_get_timestamp(&buf->vb.ts); 168 169 dev->usb_ctl.vid_buf = NULL; 170 171 list_del(&buf->vb.queue); 172 wake_up(&buf->vb.done); 173 } 174 175 static inline void vbi_buffer_filled(struct em28xx *dev, 176 struct em28xx_dmaqueue *dma_q, 177 struct em28xx_buffer *buf) 178 { 179 /* Advice that buffer was filled */ 180 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i); 181 182 buf->vb.state = VIDEOBUF_DONE; 183 buf->vb.field_count++; 184 v4l2_get_timestamp(&buf->vb.ts); 185 186 dev->usb_ctl.vbi_buf = NULL; 187 188 list_del(&buf->vb.queue); 189 wake_up(&buf->vb.done); 190 } 191 192 /* 193 * Identify the buffer header type and properly handles 194 */ 195 static void em28xx_copy_video(struct em28xx *dev, 196 struct em28xx_dmaqueue *dma_q, 197 struct em28xx_buffer *buf, 198 unsigned char *p, 199 unsigned char *outp, unsigned long len) 200 { 201 void *fieldstart, *startwrite, *startread; 202 int linesdone, currlinedone, offset, lencopy, remain; 203 int bytesperline = dev->width << 1; 204 205 if (dma_q->pos + len > buf->vb.size) 206 len = buf->vb.size - dma_q->pos; 207 208 startread = p; 209 remain = len; 210 211 if (dev->progressive || buf->top_field) 212 fieldstart = outp; 213 else /* interlaced mode, even nr. of lines */ 214 fieldstart = outp + bytesperline; 215 216 linesdone = dma_q->pos / bytesperline; 217 currlinedone = dma_q->pos % bytesperline; 218 219 if (dev->progressive) 220 offset = linesdone * bytesperline + currlinedone; 221 else 222 offset = linesdone * bytesperline * 2 + currlinedone; 223 224 startwrite = fieldstart + offset; 225 lencopy = bytesperline - currlinedone; 226 lencopy = lencopy > remain ? remain : lencopy; 227 228 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) { 229 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n", 230 ((char *)startwrite + lencopy) - 231 ((char *)outp + buf->vb.size)); 232 remain = (char *)outp + buf->vb.size - (char *)startwrite; 233 lencopy = remain; 234 } 235 if (lencopy <= 0) 236 return; 237 memcpy(startwrite, startread, lencopy); 238 239 remain -= lencopy; 240 241 while (remain > 0) { 242 if (dev->progressive) 243 startwrite += lencopy; 244 else 245 startwrite += lencopy + bytesperline; 246 startread += lencopy; 247 if (bytesperline > remain) 248 lencopy = remain; 249 else 250 lencopy = bytesperline; 251 252 if ((char *)startwrite + lencopy > (char *)outp + 253 buf->vb.size) { 254 em28xx_isocdbg("Overflow of %zi bytes past buffer end" 255 "(2)\n", 256 ((char *)startwrite + lencopy) - 257 ((char *)outp + buf->vb.size)); 258 lencopy = remain = (char *)outp + buf->vb.size - 259 (char *)startwrite; 260 } 261 if (lencopy <= 0) 262 break; 263 264 memcpy(startwrite, startread, lencopy); 265 266 remain -= lencopy; 267 } 268 269 dma_q->pos += len; 270 } 271 272 static void em28xx_copy_vbi(struct em28xx *dev, 273 struct em28xx_dmaqueue *dma_q, 274 struct em28xx_buffer *buf, 275 unsigned char *p, 276 unsigned char *outp, unsigned long len) 277 { 278 void *startwrite, *startread; 279 int offset; 280 int bytesperline; 281 282 if (dev == NULL) { 283 em28xx_isocdbg("dev is null\n"); 284 return; 285 } 286 bytesperline = dev->vbi_width; 287 288 if (dma_q == NULL) { 289 em28xx_isocdbg("dma_q is null\n"); 290 return; 291 } 292 if (buf == NULL) { 293 return; 294 } 295 if (p == NULL) { 296 em28xx_isocdbg("p is null\n"); 297 return; 298 } 299 if (outp == NULL) { 300 em28xx_isocdbg("outp is null\n"); 301 return; 302 } 303 304 if (dma_q->pos + len > buf->vb.size) 305 len = buf->vb.size - dma_q->pos; 306 307 startread = p; 308 309 startwrite = outp + dma_q->pos; 310 offset = dma_q->pos; 311 312 /* Make sure the bottom field populates the second half of the frame */ 313 if (buf->top_field == 0) { 314 startwrite += bytesperline * dev->vbi_height; 315 offset += bytesperline * dev->vbi_height; 316 } 317 318 memcpy(startwrite, startread, len); 319 dma_q->pos += len; 320 } 321 322 static inline void print_err_status(struct em28xx *dev, 323 int packet, int status) 324 { 325 char *errmsg = "Unknown"; 326 327 switch (status) { 328 case -ENOENT: 329 errmsg = "unlinked synchronuously"; 330 break; 331 case -ECONNRESET: 332 errmsg = "unlinked asynchronuously"; 333 break; 334 case -ENOSR: 335 errmsg = "Buffer error (overrun)"; 336 break; 337 case -EPIPE: 338 errmsg = "Stalled (device not responding)"; 339 break; 340 case -EOVERFLOW: 341 errmsg = "Babble (bad cable?)"; 342 break; 343 case -EPROTO: 344 errmsg = "Bit-stuff error (bad cable?)"; 345 break; 346 case -EILSEQ: 347 errmsg = "CRC/Timeout (could be anything)"; 348 break; 349 case -ETIME: 350 errmsg = "Device does not respond"; 351 break; 352 } 353 if (packet < 0) { 354 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg); 355 } else { 356 em28xx_isocdbg("URB packet %d, status %d [%s].\n", 357 packet, status, errmsg); 358 } 359 } 360 361 /* 362 * video-buf generic routine to get the next available buffer 363 */ 364 static inline void get_next_buf(struct em28xx_dmaqueue *dma_q, 365 struct em28xx_buffer **buf) 366 { 367 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq); 368 char *outp; 369 370 if (list_empty(&dma_q->active)) { 371 em28xx_isocdbg("No active queue to serve\n"); 372 dev->usb_ctl.vid_buf = NULL; 373 *buf = NULL; 374 return; 375 } 376 377 /* Get the next buffer */ 378 *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue); 379 380 /* Cleans up buffer - Useful for testing for frame/URB loss */ 381 outp = videobuf_to_vmalloc(&(*buf)->vb); 382 memset(outp, 0, (*buf)->vb.size); 383 384 dev->usb_ctl.vid_buf = *buf; 385 386 return; 387 } 388 389 /* 390 * video-buf generic routine to get the next available VBI buffer 391 */ 392 static inline void vbi_get_next_buf(struct em28xx_dmaqueue *dma_q, 393 struct em28xx_buffer **buf) 394 { 395 struct em28xx *dev = container_of(dma_q, struct em28xx, vbiq); 396 char *outp; 397 398 if (list_empty(&dma_q->active)) { 399 em28xx_isocdbg("No active queue to serve\n"); 400 dev->usb_ctl.vbi_buf = NULL; 401 *buf = NULL; 402 return; 403 } 404 405 /* Get the next buffer */ 406 *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue); 407 /* Cleans up buffer - Useful for testing for frame/URB loss */ 408 outp = videobuf_to_vmalloc(&(*buf)->vb); 409 memset(outp, 0x00, (*buf)->vb.size); 410 411 dev->usb_ctl.vbi_buf = *buf; 412 413 return; 414 } 415 416 /* Processes and copies the URB data content to a frame buffer queue */ 417 static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb) 418 { 419 struct em28xx_buffer *buf; 420 struct em28xx_dmaqueue *dma_q = &dev->vidq; 421 int xfer_bulk, num_packets, i, rc = 1; 422 unsigned int actual_length, len = 0; 423 unsigned char *p, *outp = NULL; 424 425 if (!dev) 426 return 0; 427 428 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED)) 429 return 0; 430 431 if (urb->status < 0) 432 print_err_status(dev, -1, urb->status); 433 434 xfer_bulk = usb_pipebulk(urb->pipe); 435 436 buf = dev->usb_ctl.vid_buf; 437 if (buf != NULL) 438 outp = videobuf_to_vmalloc(&buf->vb); 439 440 if (xfer_bulk) /* bulk */ 441 num_packets = 1; 442 else /* isoc */ 443 num_packets = urb->number_of_packets; 444 445 for (i = 0; i < num_packets; i++) { 446 if (xfer_bulk) { /* bulk */ 447 actual_length = urb->actual_length; 448 449 p = urb->transfer_buffer; 450 } else { /* isoc */ 451 if (urb->iso_frame_desc[i].status < 0) { 452 print_err_status(dev, i, 453 urb->iso_frame_desc[i].status); 454 if (urb->iso_frame_desc[i].status != -EPROTO) 455 continue; 456 } 457 458 actual_length = urb->iso_frame_desc[i].actual_length; 459 if (actual_length > dev->max_pkt_size) { 460 em28xx_isocdbg("packet bigger than packet size"); 461 continue; 462 } 463 464 p = urb->transfer_buffer + 465 urb->iso_frame_desc[i].offset; 466 } 467 468 if (actual_length <= 0) { 469 /* NOTE: happens very often with isoc transfers */ 470 /* em28xx_usbdbg("packet %d is empty",i); - spammy */ 471 continue; 472 } 473 474 /* FIXME: incomplete buffer checks where removed to make 475 logic simpler. Impacts of those changes should be evaluated 476 */ 477 if (p[0] == 0x33 && p[1] == 0x95 && p[2] == 0x00) { 478 em28xx_isocdbg("VBI HEADER!!!\n"); 479 /* FIXME: Should add vbi copy */ 480 continue; 481 } 482 if (p[0] == 0x22 && p[1] == 0x5a) { 483 em28xx_isocdbg("Video frame %d, length=%i, %s\n", p[2], 484 len, (p[2] & 1) ? "odd" : "even"); 485 486 if (dev->progressive || !(p[2] & 1)) { 487 if (buf != NULL) 488 buffer_filled(dev, dma_q, buf); 489 get_next_buf(dma_q, &buf); 490 if (buf == NULL) 491 outp = NULL; 492 else 493 outp = videobuf_to_vmalloc(&buf->vb); 494 } 495 496 if (buf != NULL) { 497 if (p[2] & 1) 498 buf->top_field = 0; 499 else 500 buf->top_field = 1; 501 } 502 503 dma_q->pos = 0; 504 } 505 if (buf != NULL) { 506 if (p[0] != 0x88 && p[0] != 0x22) { 507 /* NOTE: no intermediate data packet header 508 * 88 88 88 88 when using bulk transfers */ 509 em28xx_isocdbg("frame is not complete\n"); 510 len = actual_length; 511 } else { 512 len = actual_length - 4; 513 p += 4; 514 } 515 em28xx_copy_video(dev, dma_q, buf, p, outp, len); 516 } 517 } 518 return rc; 519 } 520 521 /* Version of the urb data handler that takes into account a mixture of 522 video and VBI data */ 523 static inline int em28xx_urb_data_copy_vbi(struct em28xx *dev, struct urb *urb) 524 { 525 struct em28xx_buffer *buf, *vbi_buf; 526 struct em28xx_dmaqueue *dma_q = &dev->vidq; 527 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq; 528 int xfer_bulk, vbi_size, num_packets, i, rc = 1; 529 unsigned int actual_length, len = 0; 530 unsigned char *p, *outp = NULL, *vbioutp = NULL; 531 532 if (!dev) 533 return 0; 534 535 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED)) 536 return 0; 537 538 if (urb->status < 0) 539 print_err_status(dev, -1, urb->status); 540 541 xfer_bulk = usb_pipebulk(urb->pipe); 542 543 buf = dev->usb_ctl.vid_buf; 544 if (buf != NULL) 545 outp = videobuf_to_vmalloc(&buf->vb); 546 547 vbi_buf = dev->usb_ctl.vbi_buf; 548 if (vbi_buf != NULL) 549 vbioutp = videobuf_to_vmalloc(&vbi_buf->vb); 550 551 if (xfer_bulk) /* bulk */ 552 num_packets = 1; 553 else /* isoc */ 554 num_packets = urb->number_of_packets; 555 556 for (i = 0; i < num_packets; i++) { 557 if (xfer_bulk) { /* bulk */ 558 actual_length = urb->actual_length; 559 560 p = urb->transfer_buffer; 561 } else { /* isoc */ 562 if (urb->iso_frame_desc[i].status < 0) { 563 print_err_status(dev, i, 564 urb->iso_frame_desc[i].status); 565 if (urb->iso_frame_desc[i].status != -EPROTO) 566 continue; 567 } 568 569 actual_length = urb->iso_frame_desc[i].actual_length; 570 if (actual_length > dev->max_pkt_size) { 571 em28xx_isocdbg("packet bigger than packet size"); 572 continue; 573 } 574 575 p = urb->transfer_buffer + 576 urb->iso_frame_desc[i].offset; 577 } 578 579 if (actual_length == 0) { 580 /* NOTE: happens very often with isoc transfers */ 581 /* em28xx_usbdbg("packet %d is empty",i); - spammy */ 582 continue; 583 } 584 585 /* capture type 0 = vbi start 586 capture type 1 = video start 587 capture type 2 = video in progress */ 588 len = actual_length; 589 if (len >= 4) { 590 /* NOTE: headers are always 4 bytes and 591 * never split across packets */ 592 if (p[0] == 0x33 && p[1] == 0x95) { 593 dev->capture_type = 0; 594 dev->vbi_read = 0; 595 em28xx_isocdbg("VBI START HEADER!!!\n"); 596 dev->top_field = !(p[2] & 1); 597 p += 4; 598 len -= 4; 599 } else if (p[0] == 0x88 && p[1] == 0x88 && 600 p[2] == 0x88 && p[3] == 0x88) { 601 /* continuation */ 602 p += 4; 603 len -= 4; 604 } else if (p[0] == 0x22 && p[1] == 0x5a) { 605 /* start video */ 606 dev->capture_type = 1; 607 dev->top_field = !(p[2] & 1); 608 p += 4; 609 len -= 4; 610 } 611 } 612 /* NOTE: with bulk transfers, intermediate data packets 613 * have no continuation header */ 614 615 vbi_size = dev->vbi_width * dev->vbi_height; 616 617 if (dev->capture_type == 0) { 618 if (dev->vbi_read >= vbi_size) { 619 /* We've already read all the VBI data, so 620 treat the rest as video */ 621 em28xx_isocdbg("dev->vbi_read > vbi_size\n"); 622 } else if ((dev->vbi_read + len) < vbi_size) { 623 /* This entire frame is VBI data */ 624 if (dev->vbi_read == 0 && dev->top_field) { 625 /* Brand new frame */ 626 if (vbi_buf != NULL) 627 vbi_buffer_filled(dev, 628 vbi_dma_q, 629 vbi_buf); 630 vbi_get_next_buf(vbi_dma_q, &vbi_buf); 631 if (vbi_buf == NULL) 632 vbioutp = NULL; 633 else 634 vbioutp = videobuf_to_vmalloc( 635 &vbi_buf->vb); 636 } 637 638 if (dev->vbi_read == 0) { 639 vbi_dma_q->pos = 0; 640 if (vbi_buf != NULL) 641 vbi_buf->top_field = dev->top_field; 642 } 643 644 dev->vbi_read += len; 645 em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p, 646 vbioutp, len); 647 } else { 648 /* Some of this frame is VBI data and some is 649 video data */ 650 int vbi_data_len = vbi_size - dev->vbi_read; 651 dev->vbi_read += vbi_data_len; 652 em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p, 653 vbioutp, vbi_data_len); 654 dev->capture_type = 1; 655 p += vbi_data_len; 656 len -= vbi_data_len; 657 } 658 } 659 660 if (dev->capture_type == 1) { 661 dev->capture_type = 2; 662 if (dev->progressive || dev->top_field) { 663 if (buf != NULL) 664 buffer_filled(dev, dma_q, buf); 665 get_next_buf(dma_q, &buf); 666 if (buf == NULL) 667 outp = NULL; 668 else 669 outp = videobuf_to_vmalloc(&buf->vb); 670 } 671 if (buf != NULL) 672 buf->top_field = dev->top_field; 673 674 dma_q->pos = 0; 675 } 676 677 if (buf != NULL && dev->capture_type == 2 && len > 0) 678 em28xx_copy_video(dev, dma_q, buf, p, outp, len); 679 } 680 return rc; 681 } 682 683 684 /* ------------------------------------------------------------------ 685 Videobuf operations 686 ------------------------------------------------------------------*/ 687 688 static int 689 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size) 690 { 691 struct em28xx_fh *fh = vq->priv_data; 692 struct em28xx *dev = fh->dev; 693 struct v4l2_frequency f; 694 695 *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7) 696 >> 3; 697 698 if (0 == *count) 699 *count = EM28XX_DEF_BUF; 700 701 if (*count < EM28XX_MIN_BUF) 702 *count = EM28XX_MIN_BUF; 703 704 /* Ask tuner to go to analog or radio mode */ 705 memset(&f, 0, sizeof(f)); 706 f.frequency = dev->ctl_freq; 707 f.type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; 708 709 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f); 710 711 return 0; 712 } 713 714 /* This is called *without* dev->slock held; please keep it that way */ 715 static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf) 716 { 717 struct em28xx_fh *fh = vq->priv_data; 718 struct em28xx *dev = fh->dev; 719 unsigned long flags = 0; 720 if (in_interrupt()) 721 BUG(); 722 723 /* We used to wait for the buffer to finish here, but this didn't work 724 because, as we were keeping the state as VIDEOBUF_QUEUED, 725 videobuf_queue_cancel marked it as finished for us. 726 (Also, it could wedge forever if the hardware was misconfigured.) 727 728 This should be safe; by the time we get here, the buffer isn't 729 queued anymore. If we ever start marking the buffers as 730 VIDEOBUF_ACTIVE, it won't be, though. 731 */ 732 spin_lock_irqsave(&dev->slock, flags); 733 if (dev->usb_ctl.vid_buf == buf) 734 dev->usb_ctl.vid_buf = NULL; 735 spin_unlock_irqrestore(&dev->slock, flags); 736 737 videobuf_vmalloc_free(&buf->vb); 738 buf->vb.state = VIDEOBUF_NEEDS_INIT; 739 } 740 741 static int 742 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, 743 enum v4l2_field field) 744 { 745 struct em28xx_fh *fh = vq->priv_data; 746 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb); 747 struct em28xx *dev = fh->dev; 748 int rc = 0, urb_init = 0; 749 750 buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth 751 + 7) >> 3; 752 753 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 754 return -EINVAL; 755 756 buf->vb.width = dev->width; 757 buf->vb.height = dev->height; 758 buf->vb.field = field; 759 760 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 761 rc = videobuf_iolock(vq, &buf->vb, NULL); 762 if (rc < 0) 763 goto fail; 764 } 765 766 if (!dev->usb_ctl.analog_bufs.num_bufs) 767 urb_init = 1; 768 769 if (urb_init) { 770 dev->capture_type = -1; 771 if (em28xx_vbi_supported(dev) == 1) 772 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE, 773 dev->analog_xfer_bulk, 774 EM28XX_NUM_BUFS, 775 dev->max_pkt_size, 776 dev->packet_multiplier, 777 em28xx_urb_data_copy_vbi); 778 else 779 rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE, 780 dev->analog_xfer_bulk, 781 EM28XX_NUM_BUFS, 782 dev->max_pkt_size, 783 dev->packet_multiplier, 784 em28xx_urb_data_copy); 785 if (rc < 0) 786 goto fail; 787 } 788 789 buf->vb.state = VIDEOBUF_PREPARED; 790 return 0; 791 792 fail: 793 free_buffer(vq, buf); 794 return rc; 795 } 796 797 static void 798 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) 799 { 800 struct em28xx_buffer *buf = container_of(vb, 801 struct em28xx_buffer, 802 vb); 803 struct em28xx_fh *fh = vq->priv_data; 804 struct em28xx *dev = fh->dev; 805 struct em28xx_dmaqueue *vidq = &dev->vidq; 806 807 buf->vb.state = VIDEOBUF_QUEUED; 808 list_add_tail(&buf->vb.queue, &vidq->active); 809 810 } 811 812 static void buffer_release(struct videobuf_queue *vq, 813 struct videobuf_buffer *vb) 814 { 815 struct em28xx_buffer *buf = container_of(vb, 816 struct em28xx_buffer, 817 vb); 818 struct em28xx_fh *fh = vq->priv_data; 819 struct em28xx *dev = (struct em28xx *)fh->dev; 820 821 em28xx_isocdbg("em28xx: called buffer_release\n"); 822 823 free_buffer(vq, buf); 824 } 825 826 static struct videobuf_queue_ops em28xx_video_qops = { 827 .buf_setup = buffer_setup, 828 .buf_prepare = buffer_prepare, 829 .buf_queue = buffer_queue, 830 .buf_release = buffer_release, 831 }; 832 833 /********************* v4l2 interface **************************************/ 834 835 static void video_mux(struct em28xx *dev, int index) 836 { 837 dev->ctl_input = index; 838 dev->ctl_ainput = INPUT(index)->amux; 839 dev->ctl_aoutput = INPUT(index)->aout; 840 841 if (!dev->ctl_aoutput) 842 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 843 844 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing, 845 INPUT(index)->vmux, 0, 0); 846 847 if (dev->board.has_msp34xx) { 848 if (dev->i2s_speed) { 849 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, 850 s_i2s_clock_freq, dev->i2s_speed); 851 } 852 /* Note: this is msp3400 specific */ 853 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing, 854 dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0); 855 } 856 857 if (dev->board.adecoder != EM28XX_NOADECODER) { 858 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing, 859 dev->ctl_ainput, dev->ctl_aoutput, 0); 860 } 861 862 em28xx_audio_analog_set(dev); 863 } 864 865 /* Usage lock check functions */ 866 static int res_get(struct em28xx_fh *fh, unsigned int bit) 867 { 868 struct em28xx *dev = fh->dev; 869 870 if (fh->resources & bit) 871 /* have it already allocated */ 872 return 1; 873 874 /* is it free? */ 875 if (dev->resources & bit) { 876 /* no, someone else uses it */ 877 return 0; 878 } 879 /* it's free, grab it */ 880 fh->resources |= bit; 881 dev->resources |= bit; 882 em28xx_videodbg("res: get %d\n", bit); 883 return 1; 884 } 885 886 static int res_check(struct em28xx_fh *fh, unsigned int bit) 887 { 888 return fh->resources & bit; 889 } 890 891 static int res_locked(struct em28xx *dev, unsigned int bit) 892 { 893 return dev->resources & bit; 894 } 895 896 static void res_free(struct em28xx_fh *fh, unsigned int bits) 897 { 898 struct em28xx *dev = fh->dev; 899 900 BUG_ON((fh->resources & bits) != bits); 901 902 fh->resources &= ~bits; 903 dev->resources &= ~bits; 904 em28xx_videodbg("res: put %d\n", bits); 905 } 906 907 static int get_ressource(struct em28xx_fh *fh) 908 { 909 switch (fh->type) { 910 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 911 return EM28XX_RESOURCE_VIDEO; 912 case V4L2_BUF_TYPE_VBI_CAPTURE: 913 return EM28XX_RESOURCE_VBI; 914 default: 915 BUG(); 916 return 0; 917 } 918 } 919 920 /* 921 * ac97_queryctrl() 922 * return the ac97 supported controls 923 */ 924 static int ac97_queryctrl(struct v4l2_queryctrl *qc) 925 { 926 int i; 927 928 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) { 929 if (qc->id && qc->id == ac97_qctrl[i].id) { 930 memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc)); 931 return 0; 932 } 933 } 934 935 /* Control is not ac97 related */ 936 return 1; 937 } 938 939 /* 940 * ac97_get_ctrl() 941 * return the current values for ac97 mute and volume 942 */ 943 static int ac97_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl) 944 { 945 switch (ctrl->id) { 946 case V4L2_CID_AUDIO_MUTE: 947 ctrl->value = dev->mute; 948 return 0; 949 case V4L2_CID_AUDIO_VOLUME: 950 ctrl->value = dev->volume; 951 return 0; 952 default: 953 /* Control is not ac97 related */ 954 return 1; 955 } 956 } 957 958 /* 959 * ac97_set_ctrl() 960 * set values for ac97 mute and volume 961 */ 962 static int ac97_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl) 963 { 964 int i; 965 966 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) 967 if (ctrl->id == ac97_qctrl[i].id) 968 goto handle; 969 970 /* Announce that hasn't handle it */ 971 return 1; 972 973 handle: 974 if (ctrl->value < ac97_qctrl[i].minimum || 975 ctrl->value > ac97_qctrl[i].maximum) 976 return -ERANGE; 977 978 switch (ctrl->id) { 979 case V4L2_CID_AUDIO_MUTE: 980 dev->mute = ctrl->value; 981 break; 982 case V4L2_CID_AUDIO_VOLUME: 983 dev->volume = ctrl->value; 984 break; 985 } 986 987 return em28xx_audio_analog_set(dev); 988 } 989 990 static int check_dev(struct em28xx *dev) 991 { 992 if (dev->state & DEV_DISCONNECTED) { 993 em28xx_errdev("v4l2 ioctl: device not present\n"); 994 return -ENODEV; 995 } 996 997 if (dev->state & DEV_MISCONFIGURED) { 998 em28xx_errdev("v4l2 ioctl: device is misconfigured; " 999 "close and open it again\n"); 1000 return -EIO; 1001 } 1002 return 0; 1003 } 1004 1005 static void get_scale(struct em28xx *dev, 1006 unsigned int width, unsigned int height, 1007 unsigned int *hscale, unsigned int *vscale) 1008 { 1009 unsigned int maxw = norm_maxw(dev); 1010 unsigned int maxh = norm_maxh(dev); 1011 1012 *hscale = (((unsigned long)maxw) << 12) / width - 4096L; 1013 if (*hscale >= 0x4000) 1014 *hscale = 0x3fff; 1015 1016 *vscale = (((unsigned long)maxh) << 12) / height - 4096L; 1017 if (*vscale >= 0x4000) 1018 *vscale = 0x3fff; 1019 } 1020 1021 /* ------------------------------------------------------------------ 1022 IOCTL vidioc handling 1023 ------------------------------------------------------------------*/ 1024 1025 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 1026 struct v4l2_format *f) 1027 { 1028 struct em28xx_fh *fh = priv; 1029 struct em28xx *dev = fh->dev; 1030 1031 f->fmt.pix.width = dev->width; 1032 f->fmt.pix.height = dev->height; 1033 f->fmt.pix.pixelformat = dev->format->fourcc; 1034 f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3; 1035 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height; 1036 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1037 1038 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */ 1039 if (dev->progressive) 1040 f->fmt.pix.field = V4L2_FIELD_NONE; 1041 else 1042 f->fmt.pix.field = dev->interlaced ? 1043 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1044 return 0; 1045 } 1046 1047 static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc) 1048 { 1049 unsigned int i; 1050 1051 for (i = 0; i < ARRAY_SIZE(format); i++) 1052 if (format[i].fourcc == fourcc) 1053 return &format[i]; 1054 1055 return NULL; 1056 } 1057 1058 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 1059 struct v4l2_format *f) 1060 { 1061 struct em28xx_fh *fh = priv; 1062 struct em28xx *dev = fh->dev; 1063 unsigned int width = f->fmt.pix.width; 1064 unsigned int height = f->fmt.pix.height; 1065 unsigned int maxw = norm_maxw(dev); 1066 unsigned int maxh = norm_maxh(dev); 1067 unsigned int hscale, vscale; 1068 struct em28xx_fmt *fmt; 1069 1070 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1071 if (!fmt) { 1072 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1073 f->fmt.pix.pixelformat); 1074 return -EINVAL; 1075 } 1076 1077 if (dev->board.is_em2800) { 1078 /* the em2800 can only scale down to 50% */ 1079 height = height > (3 * maxh / 4) ? maxh : maxh / 2; 1080 width = width > (3 * maxw / 4) ? maxw : maxw / 2; 1081 /* MaxPacketSize for em2800 is too small to capture at full resolution 1082 * use half of maxw as the scaler can only scale to 50% */ 1083 if (width == maxw && height == maxh) 1084 width /= 2; 1085 } else { 1086 /* width must even because of the YUYV format 1087 height must be even because of interlacing */ 1088 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1089 1, 0); 1090 } 1091 1092 get_scale(dev, width, height, &hscale, &vscale); 1093 1094 width = (((unsigned long)maxw) << 12) / (hscale + 4096L); 1095 height = (((unsigned long)maxh) << 12) / (vscale + 4096L); 1096 1097 f->fmt.pix.width = width; 1098 f->fmt.pix.height = height; 1099 f->fmt.pix.pixelformat = fmt->fourcc; 1100 f->fmt.pix.bytesperline = (dev->width * fmt->depth + 7) >> 3; 1101 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height; 1102 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1103 if (dev->progressive) 1104 f->fmt.pix.field = V4L2_FIELD_NONE; 1105 else 1106 f->fmt.pix.field = dev->interlaced ? 1107 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; 1108 1109 return 0; 1110 } 1111 1112 static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc, 1113 unsigned width, unsigned height) 1114 { 1115 struct em28xx_fmt *fmt; 1116 1117 fmt = format_by_fourcc(fourcc); 1118 if (!fmt) 1119 return -EINVAL; 1120 1121 dev->format = fmt; 1122 dev->width = width; 1123 dev->height = height; 1124 1125 /* set new image size */ 1126 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale); 1127 1128 em28xx_set_alternate(dev); 1129 em28xx_resolution_set(dev); 1130 1131 return 0; 1132 } 1133 1134 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1135 struct v4l2_format *f) 1136 { 1137 struct em28xx_fh *fh = priv; 1138 struct em28xx *dev = fh->dev; 1139 int rc; 1140 1141 rc = check_dev(dev); 1142 if (rc < 0) 1143 return rc; 1144 1145 vidioc_try_fmt_vid_cap(file, priv, f); 1146 1147 if (videobuf_queue_is_busy(&fh->vb_vidq)) { 1148 em28xx_errdev("%s queue busy\n", __func__); 1149 return -EBUSY; 1150 } 1151 1152 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat, 1153 f->fmt.pix.width, f->fmt.pix.height); 1154 } 1155 1156 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm) 1157 { 1158 struct em28xx_fh *fh = priv; 1159 struct em28xx *dev = fh->dev; 1160 int rc; 1161 1162 rc = check_dev(dev); 1163 if (rc < 0) 1164 return rc; 1165 1166 *norm = dev->norm; 1167 1168 return 0; 1169 } 1170 1171 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm) 1172 { 1173 struct em28xx_fh *fh = priv; 1174 struct em28xx *dev = fh->dev; 1175 int rc; 1176 1177 rc = check_dev(dev); 1178 if (rc < 0) 1179 return rc; 1180 1181 v4l2_device_call_all(&dev->v4l2_dev, 0, video, querystd, norm); 1182 1183 return 0; 1184 } 1185 1186 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm) 1187 { 1188 struct em28xx_fh *fh = priv; 1189 struct em28xx *dev = fh->dev; 1190 struct v4l2_format f; 1191 int rc; 1192 1193 rc = check_dev(dev); 1194 if (rc < 0) 1195 return rc; 1196 1197 dev->norm = *norm; 1198 1199 /* Adjusts width/height, if needed */ 1200 f.fmt.pix.width = dev->width; 1201 f.fmt.pix.height = dev->height; 1202 vidioc_try_fmt_vid_cap(file, priv, &f); 1203 1204 /* set new image size */ 1205 dev->width = f.fmt.pix.width; 1206 dev->height = f.fmt.pix.height; 1207 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale); 1208 1209 em28xx_resolution_set(dev); 1210 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm); 1211 1212 return 0; 1213 } 1214 1215 static int vidioc_g_parm(struct file *file, void *priv, 1216 struct v4l2_streamparm *p) 1217 { 1218 struct em28xx_fh *fh = priv; 1219 struct em28xx *dev = fh->dev; 1220 int rc = 0; 1221 1222 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1223 return -EINVAL; 1224 1225 if (dev->board.is_webcam) 1226 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0, 1227 video, g_parm, p); 1228 else 1229 v4l2_video_std_frame_period(dev->norm, 1230 &p->parm.capture.timeperframe); 1231 1232 return rc; 1233 } 1234 1235 static int vidioc_s_parm(struct file *file, void *priv, 1236 struct v4l2_streamparm *p) 1237 { 1238 struct em28xx_fh *fh = priv; 1239 struct em28xx *dev = fh->dev; 1240 1241 if (!dev->board.is_webcam) 1242 return -EINVAL; 1243 1244 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1245 return -EINVAL; 1246 1247 return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p); 1248 } 1249 1250 static const char *iname[] = { 1251 [EM28XX_VMUX_COMPOSITE1] = "Composite1", 1252 [EM28XX_VMUX_COMPOSITE2] = "Composite2", 1253 [EM28XX_VMUX_COMPOSITE3] = "Composite3", 1254 [EM28XX_VMUX_COMPOSITE4] = "Composite4", 1255 [EM28XX_VMUX_SVIDEO] = "S-Video", 1256 [EM28XX_VMUX_TELEVISION] = "Television", 1257 [EM28XX_VMUX_CABLE] = "Cable TV", 1258 [EM28XX_VMUX_DVB] = "DVB", 1259 [EM28XX_VMUX_DEBUG] = "for debug only", 1260 }; 1261 1262 static int vidioc_enum_input(struct file *file, void *priv, 1263 struct v4l2_input *i) 1264 { 1265 struct em28xx_fh *fh = priv; 1266 struct em28xx *dev = fh->dev; 1267 unsigned int n; 1268 1269 n = i->index; 1270 if (n >= MAX_EM28XX_INPUT) 1271 return -EINVAL; 1272 if (0 == INPUT(n)->type) 1273 return -EINVAL; 1274 1275 i->index = n; 1276 i->type = V4L2_INPUT_TYPE_CAMERA; 1277 1278 strcpy(i->name, iname[INPUT(n)->type]); 1279 1280 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) || 1281 (EM28XX_VMUX_CABLE == INPUT(n)->type)) 1282 i->type = V4L2_INPUT_TYPE_TUNER; 1283 1284 i->std = dev->vdev->tvnorms; 1285 1286 return 0; 1287 } 1288 1289 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1290 { 1291 struct em28xx_fh *fh = priv; 1292 struct em28xx *dev = fh->dev; 1293 1294 *i = dev->ctl_input; 1295 1296 return 0; 1297 } 1298 1299 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1300 { 1301 struct em28xx_fh *fh = priv; 1302 struct em28xx *dev = fh->dev; 1303 int rc; 1304 1305 rc = check_dev(dev); 1306 if (rc < 0) 1307 return rc; 1308 1309 if (i >= MAX_EM28XX_INPUT) 1310 return -EINVAL; 1311 if (0 == INPUT(i)->type) 1312 return -EINVAL; 1313 1314 video_mux(dev, i); 1315 return 0; 1316 } 1317 1318 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1319 { 1320 struct em28xx_fh *fh = priv; 1321 struct em28xx *dev = fh->dev; 1322 1323 if (!dev->audio_mode.has_audio) 1324 return -EINVAL; 1325 1326 switch (a->index) { 1327 case EM28XX_AMUX_VIDEO: 1328 strcpy(a->name, "Television"); 1329 break; 1330 case EM28XX_AMUX_LINE_IN: 1331 strcpy(a->name, "Line In"); 1332 break; 1333 case EM28XX_AMUX_VIDEO2: 1334 strcpy(a->name, "Television alt"); 1335 break; 1336 case EM28XX_AMUX_PHONE: 1337 strcpy(a->name, "Phone"); 1338 break; 1339 case EM28XX_AMUX_MIC: 1340 strcpy(a->name, "Mic"); 1341 break; 1342 case EM28XX_AMUX_CD: 1343 strcpy(a->name, "CD"); 1344 break; 1345 case EM28XX_AMUX_AUX: 1346 strcpy(a->name, "Aux"); 1347 break; 1348 case EM28XX_AMUX_PCM_OUT: 1349 strcpy(a->name, "PCM"); 1350 break; 1351 default: 1352 return -EINVAL; 1353 } 1354 1355 a->index = dev->ctl_ainput; 1356 a->capability = V4L2_AUDCAP_STEREO; 1357 1358 return 0; 1359 } 1360 1361 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1362 { 1363 struct em28xx_fh *fh = priv; 1364 struct em28xx *dev = fh->dev; 1365 1366 1367 if (!dev->audio_mode.has_audio) 1368 return -EINVAL; 1369 1370 if (a->index >= MAX_EM28XX_INPUT) 1371 return -EINVAL; 1372 if (0 == INPUT(a->index)->type) 1373 return -EINVAL; 1374 1375 dev->ctl_ainput = INPUT(a->index)->amux; 1376 dev->ctl_aoutput = INPUT(a->index)->aout; 1377 1378 if (!dev->ctl_aoutput) 1379 dev->ctl_aoutput = EM28XX_AOUT_MASTER; 1380 1381 return 0; 1382 } 1383 1384 static int vidioc_queryctrl(struct file *file, void *priv, 1385 struct v4l2_queryctrl *qc) 1386 { 1387 struct em28xx_fh *fh = priv; 1388 struct em28xx *dev = fh->dev; 1389 int id = qc->id; 1390 int rc; 1391 1392 rc = check_dev(dev); 1393 if (rc < 0) 1394 return rc; 1395 1396 memset(qc, 0, sizeof(*qc)); 1397 1398 qc->id = id; 1399 1400 /* enumerate AC97 controls */ 1401 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) { 1402 rc = ac97_queryctrl(qc); 1403 if (!rc) 1404 return 0; 1405 } 1406 1407 /* enumerate V4L2 device controls */ 1408 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc); 1409 1410 if (qc->type) 1411 return 0; 1412 else 1413 return -EINVAL; 1414 } 1415 1416 /* 1417 * FIXME: This is an indirect way to check if a control exists at a 1418 * subdev. Instead of that hack, maybe the better would be to change all 1419 * subdevs to return -ENOIOCTLCMD, if an ioctl is not supported. 1420 */ 1421 static int check_subdev_ctrl(struct em28xx *dev, int id) 1422 { 1423 struct v4l2_queryctrl qc; 1424 1425 memset(&qc, 0, sizeof(qc)); 1426 qc.id = id; 1427 1428 /* enumerate V4L2 device controls */ 1429 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, &qc); 1430 1431 if (qc.type) 1432 return 0; 1433 else 1434 return -EINVAL; 1435 } 1436 1437 static int vidioc_g_ctrl(struct file *file, void *priv, 1438 struct v4l2_control *ctrl) 1439 { 1440 struct em28xx_fh *fh = priv; 1441 struct em28xx *dev = fh->dev; 1442 int rc; 1443 1444 rc = check_dev(dev); 1445 if (rc < 0) 1446 return rc; 1447 rc = 0; 1448 1449 /* Set an AC97 control */ 1450 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) 1451 rc = ac97_get_ctrl(dev, ctrl); 1452 else 1453 rc = 1; 1454 1455 /* It were not an AC97 control. Sends it to the v4l2 dev interface */ 1456 if (rc == 1) { 1457 if (check_subdev_ctrl(dev, ctrl->id)) 1458 return -EINVAL; 1459 1460 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl); 1461 rc = 0; 1462 } 1463 1464 return rc; 1465 } 1466 1467 static int vidioc_s_ctrl(struct file *file, void *priv, 1468 struct v4l2_control *ctrl) 1469 { 1470 struct em28xx_fh *fh = priv; 1471 struct em28xx *dev = fh->dev; 1472 int rc; 1473 1474 rc = check_dev(dev); 1475 if (rc < 0) 1476 return rc; 1477 1478 /* Set an AC97 control */ 1479 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) 1480 rc = ac97_set_ctrl(dev, ctrl); 1481 else 1482 rc = 1; 1483 1484 /* It isn't an AC97 control. Sends it to the v4l2 dev interface */ 1485 if (rc == 1) { 1486 rc = check_subdev_ctrl(dev, ctrl->id); 1487 if (!rc) 1488 v4l2_device_call_all(&dev->v4l2_dev, 0, 1489 core, s_ctrl, ctrl); 1490 /* 1491 * In the case of non-AC97 volume controls, we still need 1492 * to do some setups at em28xx, in order to mute/unmute 1493 * and to adjust audio volume. However, the value ranges 1494 * should be checked by the corresponding V4L subdriver. 1495 */ 1496 switch (ctrl->id) { 1497 case V4L2_CID_AUDIO_MUTE: 1498 dev->mute = ctrl->value; 1499 rc = em28xx_audio_analog_set(dev); 1500 break; 1501 case V4L2_CID_AUDIO_VOLUME: 1502 dev->volume = ctrl->value; 1503 rc = em28xx_audio_analog_set(dev); 1504 } 1505 } 1506 return (rc < 0) ? rc : 0; 1507 } 1508 1509 static int vidioc_g_tuner(struct file *file, void *priv, 1510 struct v4l2_tuner *t) 1511 { 1512 struct em28xx_fh *fh = priv; 1513 struct em28xx *dev = fh->dev; 1514 int rc; 1515 1516 rc = check_dev(dev); 1517 if (rc < 0) 1518 return rc; 1519 1520 if (0 != t->index) 1521 return -EINVAL; 1522 1523 strcpy(t->name, "Tuner"); 1524 t->type = V4L2_TUNER_ANALOG_TV; 1525 1526 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t); 1527 return 0; 1528 } 1529 1530 static int vidioc_s_tuner(struct file *file, void *priv, 1531 struct v4l2_tuner *t) 1532 { 1533 struct em28xx_fh *fh = priv; 1534 struct em28xx *dev = fh->dev; 1535 int rc; 1536 1537 rc = check_dev(dev); 1538 if (rc < 0) 1539 return rc; 1540 1541 if (0 != t->index) 1542 return -EINVAL; 1543 1544 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t); 1545 return 0; 1546 } 1547 1548 static int vidioc_g_frequency(struct file *file, void *priv, 1549 struct v4l2_frequency *f) 1550 { 1551 struct em28xx_fh *fh = priv; 1552 struct em28xx *dev = fh->dev; 1553 1554 f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; 1555 f->frequency = dev->ctl_freq; 1556 return 0; 1557 } 1558 1559 static int vidioc_s_frequency(struct file *file, void *priv, 1560 struct v4l2_frequency *f) 1561 { 1562 struct em28xx_fh *fh = priv; 1563 struct em28xx *dev = fh->dev; 1564 int rc; 1565 1566 rc = check_dev(dev); 1567 if (rc < 0) 1568 return rc; 1569 1570 if (0 != f->tuner) 1571 return -EINVAL; 1572 1573 if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV)) 1574 return -EINVAL; 1575 if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO)) 1576 return -EINVAL; 1577 1578 dev->ctl_freq = f->frequency; 1579 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f); 1580 1581 return 0; 1582 } 1583 1584 #ifdef CONFIG_VIDEO_ADV_DEBUG 1585 static int em28xx_reg_len(int reg) 1586 { 1587 switch (reg) { 1588 case EM28XX_R40_AC97LSB: 1589 case EM28XX_R30_HSCALELOW: 1590 case EM28XX_R32_VSCALELOW: 1591 return 2; 1592 default: 1593 return 1; 1594 } 1595 } 1596 1597 static int vidioc_g_chip_ident(struct file *file, void *priv, 1598 struct v4l2_dbg_chip_ident *chip) 1599 { 1600 struct em28xx_fh *fh = priv; 1601 struct em28xx *dev = fh->dev; 1602 1603 chip->ident = V4L2_IDENT_NONE; 1604 chip->revision = 0; 1605 1606 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip); 1607 1608 return 0; 1609 } 1610 1611 1612 static int vidioc_g_register(struct file *file, void *priv, 1613 struct v4l2_dbg_register *reg) 1614 { 1615 struct em28xx_fh *fh = priv; 1616 struct em28xx *dev = fh->dev; 1617 int ret; 1618 1619 switch (reg->match.type) { 1620 case V4L2_CHIP_MATCH_AC97: 1621 ret = em28xx_read_ac97(dev, reg->reg); 1622 if (ret < 0) 1623 return ret; 1624 1625 reg->val = ret; 1626 reg->size = 1; 1627 return 0; 1628 case V4L2_CHIP_MATCH_I2C_DRIVER: 1629 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg); 1630 return 0; 1631 case V4L2_CHIP_MATCH_I2C_ADDR: 1632 /* TODO: is this correct? */ 1633 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg); 1634 return 0; 1635 default: 1636 if (!v4l2_chip_match_host(®->match)) 1637 return -EINVAL; 1638 } 1639 1640 /* Match host */ 1641 reg->size = em28xx_reg_len(reg->reg); 1642 if (reg->size == 1) { 1643 ret = em28xx_read_reg(dev, reg->reg); 1644 1645 if (ret < 0) 1646 return ret; 1647 1648 reg->val = ret; 1649 } else { 1650 __le16 val = 0; 1651 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS, 1652 reg->reg, (char *)&val, 2); 1653 if (ret < 0) 1654 return ret; 1655 1656 reg->val = le16_to_cpu(val); 1657 } 1658 1659 return 0; 1660 } 1661 1662 static int vidioc_s_register(struct file *file, void *priv, 1663 struct v4l2_dbg_register *reg) 1664 { 1665 struct em28xx_fh *fh = priv; 1666 struct em28xx *dev = fh->dev; 1667 __le16 buf; 1668 1669 switch (reg->match.type) { 1670 case V4L2_CHIP_MATCH_AC97: 1671 return em28xx_write_ac97(dev, reg->reg, reg->val); 1672 case V4L2_CHIP_MATCH_I2C_DRIVER: 1673 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg); 1674 return 0; 1675 case V4L2_CHIP_MATCH_I2C_ADDR: 1676 /* TODO: is this correct? */ 1677 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg); 1678 return 0; 1679 default: 1680 if (!v4l2_chip_match_host(®->match)) 1681 return -EINVAL; 1682 } 1683 1684 /* Match host */ 1685 buf = cpu_to_le16(reg->val); 1686 1687 return em28xx_write_regs(dev, reg->reg, (char *)&buf, 1688 em28xx_reg_len(reg->reg)); 1689 } 1690 #endif 1691 1692 1693 static int vidioc_cropcap(struct file *file, void *priv, 1694 struct v4l2_cropcap *cc) 1695 { 1696 struct em28xx_fh *fh = priv; 1697 struct em28xx *dev = fh->dev; 1698 1699 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1700 return -EINVAL; 1701 1702 cc->bounds.left = 0; 1703 cc->bounds.top = 0; 1704 cc->bounds.width = dev->width; 1705 cc->bounds.height = dev->height; 1706 cc->defrect = cc->bounds; 1707 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */ 1708 cc->pixelaspect.denominator = 59; 1709 1710 return 0; 1711 } 1712 1713 static int vidioc_streamon(struct file *file, void *priv, 1714 enum v4l2_buf_type type) 1715 { 1716 struct em28xx_fh *fh = priv; 1717 struct em28xx *dev = fh->dev; 1718 int rc = -EINVAL; 1719 1720 rc = check_dev(dev); 1721 if (rc < 0) 1722 return rc; 1723 1724 if (unlikely(type != fh->type)) 1725 return -EINVAL; 1726 1727 em28xx_videodbg("vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n", 1728 fh, type, fh->resources, dev->resources); 1729 1730 if (unlikely(!res_get(fh, get_ressource(fh)))) 1731 return -EBUSY; 1732 1733 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1734 rc = videobuf_streamon(&fh->vb_vidq); 1735 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) 1736 rc = videobuf_streamon(&fh->vb_vbiq); 1737 1738 return rc; 1739 } 1740 1741 static int vidioc_streamoff(struct file *file, void *priv, 1742 enum v4l2_buf_type type) 1743 { 1744 struct em28xx_fh *fh = priv; 1745 struct em28xx *dev = fh->dev; 1746 int rc; 1747 1748 rc = check_dev(dev); 1749 if (rc < 0) 1750 return rc; 1751 1752 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 1753 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) 1754 return -EINVAL; 1755 if (type != fh->type) 1756 return -EINVAL; 1757 1758 em28xx_videodbg("vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n", 1759 fh, type, fh->resources, dev->resources); 1760 1761 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 1762 if (res_check(fh, EM28XX_RESOURCE_VIDEO)) { 1763 videobuf_streamoff(&fh->vb_vidq); 1764 res_free(fh, EM28XX_RESOURCE_VIDEO); 1765 } 1766 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 1767 if (res_check(fh, EM28XX_RESOURCE_VBI)) { 1768 videobuf_streamoff(&fh->vb_vbiq); 1769 res_free(fh, EM28XX_RESOURCE_VBI); 1770 } 1771 } 1772 1773 return 0; 1774 } 1775 1776 static int vidioc_querycap(struct file *file, void *priv, 1777 struct v4l2_capability *cap) 1778 { 1779 struct em28xx_fh *fh = priv; 1780 struct em28xx *dev = fh->dev; 1781 1782 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1783 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 1784 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1785 1786 cap->capabilities = 1787 V4L2_CAP_SLICED_VBI_CAPTURE | 1788 V4L2_CAP_VIDEO_CAPTURE | 1789 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1790 1791 if (dev->vbi_dev) 1792 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 1793 1794 if (dev->audio_mode.has_audio) 1795 cap->capabilities |= V4L2_CAP_AUDIO; 1796 1797 if (dev->tuner_type != TUNER_ABSENT) 1798 cap->capabilities |= V4L2_CAP_TUNER; 1799 1800 return 0; 1801 } 1802 1803 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1804 struct v4l2_fmtdesc *f) 1805 { 1806 if (unlikely(f->index >= ARRAY_SIZE(format))) 1807 return -EINVAL; 1808 1809 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1810 f->pixelformat = format[f->index].fourcc; 1811 1812 return 0; 1813 } 1814 1815 static int vidioc_enum_framesizes(struct file *file, void *priv, 1816 struct v4l2_frmsizeenum *fsize) 1817 { 1818 struct em28xx_fh *fh = priv; 1819 struct em28xx *dev = fh->dev; 1820 struct em28xx_fmt *fmt; 1821 unsigned int maxw = norm_maxw(dev); 1822 unsigned int maxh = norm_maxh(dev); 1823 1824 fmt = format_by_fourcc(fsize->pixel_format); 1825 if (!fmt) { 1826 em28xx_videodbg("Fourcc format (%08x) invalid.\n", 1827 fsize->pixel_format); 1828 return -EINVAL; 1829 } 1830 1831 if (dev->board.is_em2800) { 1832 if (fsize->index > 1) 1833 return -EINVAL; 1834 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1835 fsize->discrete.width = maxw / (1 + fsize->index); 1836 fsize->discrete.height = maxh / (1 + fsize->index); 1837 return 0; 1838 } 1839 1840 if (fsize->index != 0) 1841 return -EINVAL; 1842 1843 /* Report a continuous range */ 1844 fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; 1845 fsize->stepwise.min_width = 48; 1846 fsize->stepwise.min_height = 32; 1847 fsize->stepwise.max_width = maxw; 1848 fsize->stepwise.max_height = maxh; 1849 fsize->stepwise.step_width = 1; 1850 fsize->stepwise.step_height = 1; 1851 return 0; 1852 } 1853 1854 /* Sliced VBI ioctls */ 1855 static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv, 1856 struct v4l2_format *f) 1857 { 1858 struct em28xx_fh *fh = priv; 1859 struct em28xx *dev = fh->dev; 1860 int rc; 1861 1862 rc = check_dev(dev); 1863 if (rc < 0) 1864 return rc; 1865 1866 f->fmt.sliced.service_set = 0; 1867 v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced); 1868 1869 if (f->fmt.sliced.service_set == 0) 1870 rc = -EINVAL; 1871 1872 return rc; 1873 } 1874 1875 static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv, 1876 struct v4l2_format *f) 1877 { 1878 struct em28xx_fh *fh = priv; 1879 struct em28xx *dev = fh->dev; 1880 int rc; 1881 1882 rc = check_dev(dev); 1883 if (rc < 0) 1884 return rc; 1885 1886 v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced); 1887 1888 if (f->fmt.sliced.service_set == 0) 1889 return -EINVAL; 1890 1891 return 0; 1892 } 1893 1894 /* RAW VBI ioctls */ 1895 1896 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1897 struct v4l2_format *format) 1898 { 1899 struct em28xx_fh *fh = priv; 1900 struct em28xx *dev = fh->dev; 1901 1902 format->fmt.vbi.samples_per_line = dev->vbi_width; 1903 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1904 format->fmt.vbi.offset = 0; 1905 format->fmt.vbi.flags = 0; 1906 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1907 format->fmt.vbi.count[0] = dev->vbi_height; 1908 format->fmt.vbi.count[1] = dev->vbi_height; 1909 1910 /* Varies by video standard (NTSC, PAL, etc.) */ 1911 if (dev->norm & V4L2_STD_525_60) { 1912 /* NTSC */ 1913 format->fmt.vbi.start[0] = 10; 1914 format->fmt.vbi.start[1] = 273; 1915 } else if (dev->norm & V4L2_STD_625_50) { 1916 /* PAL */ 1917 format->fmt.vbi.start[0] = 6; 1918 format->fmt.vbi.start[1] = 318; 1919 } 1920 1921 return 0; 1922 } 1923 1924 static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv, 1925 struct v4l2_format *format) 1926 { 1927 struct em28xx_fh *fh = priv; 1928 struct em28xx *dev = fh->dev; 1929 1930 format->fmt.vbi.samples_per_line = dev->vbi_width; 1931 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1932 format->fmt.vbi.offset = 0; 1933 format->fmt.vbi.flags = 0; 1934 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; 1935 format->fmt.vbi.count[0] = dev->vbi_height; 1936 format->fmt.vbi.count[1] = dev->vbi_height; 1937 1938 /* Varies by video standard (NTSC, PAL, etc.) */ 1939 if (dev->norm & V4L2_STD_525_60) { 1940 /* NTSC */ 1941 format->fmt.vbi.start[0] = 10; 1942 format->fmt.vbi.start[1] = 273; 1943 } else if (dev->norm & V4L2_STD_625_50) { 1944 /* PAL */ 1945 format->fmt.vbi.start[0] = 6; 1946 format->fmt.vbi.start[1] = 318; 1947 } 1948 1949 return 0; 1950 } 1951 1952 static int vidioc_reqbufs(struct file *file, void *priv, 1953 struct v4l2_requestbuffers *rb) 1954 { 1955 struct em28xx_fh *fh = priv; 1956 struct em28xx *dev = fh->dev; 1957 int rc; 1958 1959 rc = check_dev(dev); 1960 if (rc < 0) 1961 return rc; 1962 1963 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1964 return videobuf_reqbufs(&fh->vb_vidq, rb); 1965 else 1966 return videobuf_reqbufs(&fh->vb_vbiq, rb); 1967 } 1968 1969 static int vidioc_querybuf(struct file *file, void *priv, 1970 struct v4l2_buffer *b) 1971 { 1972 struct em28xx_fh *fh = priv; 1973 struct em28xx *dev = fh->dev; 1974 int rc; 1975 1976 rc = check_dev(dev); 1977 if (rc < 0) 1978 return rc; 1979 1980 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 1981 return videobuf_querybuf(&fh->vb_vidq, b); 1982 else { 1983 /* FIXME: I'm not sure yet whether this is a bug in zvbi or 1984 the videobuf framework, but we probably shouldn't be 1985 returning a buffer larger than that which was asked for. 1986 At a minimum, it causes a crash in zvbi since it does 1987 a memcpy based on the source buffer length */ 1988 int result = videobuf_querybuf(&fh->vb_vbiq, b); 1989 b->length = dev->vbi_width * dev->vbi_height * 2; 1990 1991 return result; 1992 } 1993 } 1994 1995 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 1996 { 1997 struct em28xx_fh *fh = priv; 1998 struct em28xx *dev = fh->dev; 1999 int rc; 2000 2001 rc = check_dev(dev); 2002 if (rc < 0) 2003 return rc; 2004 2005 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2006 return videobuf_qbuf(&fh->vb_vidq, b); 2007 else 2008 return videobuf_qbuf(&fh->vb_vbiq, b); 2009 } 2010 2011 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2012 { 2013 struct em28xx_fh *fh = priv; 2014 struct em28xx *dev = fh->dev; 2015 int rc; 2016 2017 rc = check_dev(dev); 2018 if (rc < 0) 2019 return rc; 2020 2021 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2022 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & 2023 O_NONBLOCK); 2024 else 2025 return videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags & 2026 O_NONBLOCK); 2027 } 2028 2029 /* ----------------------------------------------------------- */ 2030 /* RADIO ESPECIFIC IOCTLS */ 2031 /* ----------------------------------------------------------- */ 2032 2033 static int radio_querycap(struct file *file, void *priv, 2034 struct v4l2_capability *cap) 2035 { 2036 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev; 2037 2038 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 2039 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card)); 2040 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 2041 2042 cap->capabilities = V4L2_CAP_TUNER; 2043 return 0; 2044 } 2045 2046 static int radio_g_tuner(struct file *file, void *priv, 2047 struct v4l2_tuner *t) 2048 { 2049 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev; 2050 2051 if (unlikely(t->index > 0)) 2052 return -EINVAL; 2053 2054 strcpy(t->name, "Radio"); 2055 t->type = V4L2_TUNER_RADIO; 2056 2057 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t); 2058 2059 return 0; 2060 } 2061 2062 static int radio_enum_input(struct file *file, void *priv, 2063 struct v4l2_input *i) 2064 { 2065 if (i->index != 0) 2066 return -EINVAL; 2067 strcpy(i->name, "Radio"); 2068 i->type = V4L2_INPUT_TYPE_TUNER; 2069 2070 return 0; 2071 } 2072 2073 static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 2074 { 2075 if (unlikely(a->index)) 2076 return -EINVAL; 2077 2078 strcpy(a->name, "Radio"); 2079 return 0; 2080 } 2081 2082 static int radio_s_tuner(struct file *file, void *priv, 2083 struct v4l2_tuner *t) 2084 { 2085 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev; 2086 2087 if (0 != t->index) 2088 return -EINVAL; 2089 2090 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t); 2091 2092 return 0; 2093 } 2094 2095 static int radio_s_audio(struct file *file, void *fh, 2096 const struct v4l2_audio *a) 2097 { 2098 return 0; 2099 } 2100 2101 static int radio_s_input(struct file *file, void *fh, unsigned int i) 2102 { 2103 return 0; 2104 } 2105 2106 static int radio_queryctrl(struct file *file, void *priv, 2107 struct v4l2_queryctrl *qc) 2108 { 2109 int i; 2110 2111 if (qc->id < V4L2_CID_BASE || 2112 qc->id >= V4L2_CID_LASTP1) 2113 return -EINVAL; 2114 2115 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) { 2116 if (qc->id && qc->id == ac97_qctrl[i].id) { 2117 memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc)); 2118 return 0; 2119 } 2120 } 2121 2122 return -EINVAL; 2123 } 2124 2125 /* 2126 * em28xx_v4l2_open() 2127 * inits the device and starts isoc transfer 2128 */ 2129 static int em28xx_v4l2_open(struct file *filp) 2130 { 2131 int errCode = 0, radio = 0; 2132 struct video_device *vdev = video_devdata(filp); 2133 struct em28xx *dev = video_drvdata(filp); 2134 enum v4l2_buf_type fh_type = 0; 2135 struct em28xx_fh *fh; 2136 enum v4l2_field field; 2137 2138 switch (vdev->vfl_type) { 2139 case VFL_TYPE_GRABBER: 2140 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2141 break; 2142 case VFL_TYPE_VBI: 2143 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 2144 break; 2145 case VFL_TYPE_RADIO: 2146 radio = 1; 2147 break; 2148 } 2149 2150 em28xx_videodbg("open dev=%s type=%s users=%d\n", 2151 video_device_node_name(vdev), v4l2_type_names[fh_type], 2152 dev->users); 2153 2154 2155 if (mutex_lock_interruptible(&dev->lock)) 2156 return -ERESTARTSYS; 2157 fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL); 2158 if (!fh) { 2159 em28xx_errdev("em28xx-video.c: Out of memory?!\n"); 2160 mutex_unlock(&dev->lock); 2161 return -ENOMEM; 2162 } 2163 fh->dev = dev; 2164 fh->radio = radio; 2165 fh->type = fh_type; 2166 filp->private_data = fh; 2167 2168 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) { 2169 em28xx_set_mode(dev, EM28XX_ANALOG_MODE); 2170 em28xx_set_alternate(dev); 2171 em28xx_resolution_set(dev); 2172 2173 /* Needed, since GPIO might have disabled power of 2174 some i2c device 2175 */ 2176 em28xx_wake_i2c(dev); 2177 2178 } 2179 if (fh->radio) { 2180 em28xx_videodbg("video_open: setting radio device\n"); 2181 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio); 2182 } 2183 2184 dev->users++; 2185 2186 if (dev->progressive) 2187 field = V4L2_FIELD_NONE; 2188 else 2189 field = V4L2_FIELD_INTERLACED; 2190 2191 videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops, 2192 NULL, &dev->slock, 2193 V4L2_BUF_TYPE_VIDEO_CAPTURE, field, 2194 sizeof(struct em28xx_buffer), fh, &dev->lock); 2195 2196 videobuf_queue_vmalloc_init(&fh->vb_vbiq, &em28xx_vbi_qops, 2197 NULL, &dev->slock, 2198 V4L2_BUF_TYPE_VBI_CAPTURE, 2199 V4L2_FIELD_SEQ_TB, 2200 sizeof(struct em28xx_buffer), fh, &dev->lock); 2201 mutex_unlock(&dev->lock); 2202 2203 return errCode; 2204 } 2205 2206 /* 2207 * em28xx_realease_resources() 2208 * unregisters the v4l2,i2c and usb devices 2209 * called when the device gets disconected or at module unload 2210 */ 2211 void em28xx_release_analog_resources(struct em28xx *dev) 2212 { 2213 2214 /*FIXME: I2C IR should be disconnected */ 2215 2216 if (dev->radio_dev) { 2217 if (video_is_registered(dev->radio_dev)) 2218 video_unregister_device(dev->radio_dev); 2219 else 2220 video_device_release(dev->radio_dev); 2221 dev->radio_dev = NULL; 2222 } 2223 if (dev->vbi_dev) { 2224 em28xx_info("V4L2 device %s deregistered\n", 2225 video_device_node_name(dev->vbi_dev)); 2226 if (video_is_registered(dev->vbi_dev)) 2227 video_unregister_device(dev->vbi_dev); 2228 else 2229 video_device_release(dev->vbi_dev); 2230 dev->vbi_dev = NULL; 2231 } 2232 if (dev->vdev) { 2233 em28xx_info("V4L2 device %s deregistered\n", 2234 video_device_node_name(dev->vdev)); 2235 if (video_is_registered(dev->vdev)) 2236 video_unregister_device(dev->vdev); 2237 else 2238 video_device_release(dev->vdev); 2239 dev->vdev = NULL; 2240 } 2241 } 2242 2243 /* 2244 * em28xx_v4l2_close() 2245 * stops streaming and deallocates all resources allocated by the v4l2 2246 * calls and ioctls 2247 */ 2248 static int em28xx_v4l2_close(struct file *filp) 2249 { 2250 struct em28xx_fh *fh = filp->private_data; 2251 struct em28xx *dev = fh->dev; 2252 int errCode; 2253 2254 em28xx_videodbg("users=%d\n", dev->users); 2255 2256 mutex_lock(&dev->lock); 2257 if (res_check(fh, EM28XX_RESOURCE_VIDEO)) { 2258 videobuf_stop(&fh->vb_vidq); 2259 res_free(fh, EM28XX_RESOURCE_VIDEO); 2260 } 2261 2262 if (res_check(fh, EM28XX_RESOURCE_VBI)) { 2263 videobuf_stop(&fh->vb_vbiq); 2264 res_free(fh, EM28XX_RESOURCE_VBI); 2265 } 2266 2267 if (dev->users == 1) { 2268 /* the device is already disconnect, 2269 free the remaining resources */ 2270 if (dev->state & DEV_DISCONNECTED) { 2271 em28xx_release_resources(dev); 2272 kfree(dev->alt_max_pkt_size_isoc); 2273 mutex_unlock(&dev->lock); 2274 kfree(dev); 2275 kfree(fh); 2276 return 0; 2277 } 2278 2279 /* Save some power by putting tuner to sleep */ 2280 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0); 2281 2282 /* do this before setting alternate! */ 2283 em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE); 2284 em28xx_set_mode(dev, EM28XX_SUSPEND); 2285 2286 /* set alternate 0 */ 2287 dev->alt = 0; 2288 em28xx_videodbg("setting alternate 0\n"); 2289 errCode = usb_set_interface(dev->udev, 0, 0); 2290 if (errCode < 0) { 2291 em28xx_errdev("cannot change alternate number to " 2292 "0 (error=%i)\n", errCode); 2293 } 2294 } 2295 2296 videobuf_mmap_free(&fh->vb_vidq); 2297 videobuf_mmap_free(&fh->vb_vbiq); 2298 kfree(fh); 2299 dev->users--; 2300 mutex_unlock(&dev->lock); 2301 return 0; 2302 } 2303 2304 /* 2305 * em28xx_v4l2_read() 2306 * will allocate buffers when called for the first time 2307 */ 2308 static ssize_t 2309 em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count, 2310 loff_t *pos) 2311 { 2312 struct em28xx_fh *fh = filp->private_data; 2313 struct em28xx *dev = fh->dev; 2314 int rc; 2315 2316 rc = check_dev(dev); 2317 if (rc < 0) 2318 return rc; 2319 2320 if (mutex_lock_interruptible(&dev->lock)) 2321 return -ERESTARTSYS; 2322 /* FIXME: read() is not prepared to allow changing the video 2323 resolution while streaming. Seems a bug at em28xx_set_fmt 2324 */ 2325 2326 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2327 if (res_locked(dev, EM28XX_RESOURCE_VIDEO)) 2328 rc = -EBUSY; 2329 else 2330 rc = videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0, 2331 filp->f_flags & O_NONBLOCK); 2332 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2333 if (!res_get(fh, EM28XX_RESOURCE_VBI)) 2334 rc = -EBUSY; 2335 else 2336 rc = videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0, 2337 filp->f_flags & O_NONBLOCK); 2338 } 2339 mutex_unlock(&dev->lock); 2340 2341 return rc; 2342 } 2343 2344 /* 2345 * em28xx_poll() 2346 * will allocate buffers when called for the first time 2347 */ 2348 static unsigned int em28xx_poll(struct file *filp, poll_table *wait) 2349 { 2350 struct em28xx_fh *fh = filp->private_data; 2351 struct em28xx *dev = fh->dev; 2352 int rc; 2353 2354 rc = check_dev(dev); 2355 if (rc < 0) 2356 return rc; 2357 2358 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2359 if (!res_get(fh, EM28XX_RESOURCE_VIDEO)) 2360 return POLLERR; 2361 return videobuf_poll_stream(filp, &fh->vb_vidq, wait); 2362 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2363 if (!res_get(fh, EM28XX_RESOURCE_VBI)) 2364 return POLLERR; 2365 return videobuf_poll_stream(filp, &fh->vb_vbiq, wait); 2366 } else { 2367 return POLLERR; 2368 } 2369 } 2370 2371 static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table *wait) 2372 { 2373 struct em28xx_fh *fh = filp->private_data; 2374 struct em28xx *dev = fh->dev; 2375 unsigned int res; 2376 2377 mutex_lock(&dev->lock); 2378 res = em28xx_poll(filp, wait); 2379 mutex_unlock(&dev->lock); 2380 return res; 2381 } 2382 2383 /* 2384 * em28xx_v4l2_mmap() 2385 */ 2386 static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma) 2387 { 2388 struct em28xx_fh *fh = filp->private_data; 2389 struct em28xx *dev = fh->dev; 2390 int rc; 2391 2392 rc = check_dev(dev); 2393 if (rc < 0) 2394 return rc; 2395 2396 if (mutex_lock_interruptible(&dev->lock)) 2397 return -ERESTARTSYS; 2398 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2399 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma); 2400 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) 2401 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma); 2402 mutex_unlock(&dev->lock); 2403 2404 em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n", 2405 (unsigned long)vma->vm_start, 2406 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start, 2407 rc); 2408 2409 return rc; 2410 } 2411 2412 static const struct v4l2_file_operations em28xx_v4l_fops = { 2413 .owner = THIS_MODULE, 2414 .open = em28xx_v4l2_open, 2415 .release = em28xx_v4l2_close, 2416 .read = em28xx_v4l2_read, 2417 .poll = em28xx_v4l2_poll, 2418 .mmap = em28xx_v4l2_mmap, 2419 .unlocked_ioctl = video_ioctl2, 2420 }; 2421 2422 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2423 .vidioc_querycap = vidioc_querycap, 2424 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2425 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2426 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2427 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2428 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2429 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap, 2430 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2431 .vidioc_g_audio = vidioc_g_audio, 2432 .vidioc_s_audio = vidioc_s_audio, 2433 .vidioc_cropcap = vidioc_cropcap, 2434 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap, 2435 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap, 2436 .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap, 2437 2438 .vidioc_reqbufs = vidioc_reqbufs, 2439 .vidioc_querybuf = vidioc_querybuf, 2440 .vidioc_qbuf = vidioc_qbuf, 2441 .vidioc_dqbuf = vidioc_dqbuf, 2442 .vidioc_g_std = vidioc_g_std, 2443 .vidioc_querystd = vidioc_querystd, 2444 .vidioc_s_std = vidioc_s_std, 2445 .vidioc_g_parm = vidioc_g_parm, 2446 .vidioc_s_parm = vidioc_s_parm, 2447 .vidioc_enum_input = vidioc_enum_input, 2448 .vidioc_g_input = vidioc_g_input, 2449 .vidioc_s_input = vidioc_s_input, 2450 .vidioc_queryctrl = vidioc_queryctrl, 2451 .vidioc_g_ctrl = vidioc_g_ctrl, 2452 .vidioc_s_ctrl = vidioc_s_ctrl, 2453 .vidioc_streamon = vidioc_streamon, 2454 .vidioc_streamoff = vidioc_streamoff, 2455 .vidioc_g_tuner = vidioc_g_tuner, 2456 .vidioc_s_tuner = vidioc_s_tuner, 2457 .vidioc_g_frequency = vidioc_g_frequency, 2458 .vidioc_s_frequency = vidioc_s_frequency, 2459 #ifdef CONFIG_VIDEO_ADV_DEBUG 2460 .vidioc_g_register = vidioc_g_register, 2461 .vidioc_s_register = vidioc_s_register, 2462 .vidioc_g_chip_ident = vidioc_g_chip_ident, 2463 #endif 2464 }; 2465 2466 static const struct video_device em28xx_video_template = { 2467 .fops = &em28xx_v4l_fops, 2468 .release = video_device_release, 2469 .ioctl_ops = &video_ioctl_ops, 2470 2471 .tvnorms = V4L2_STD_ALL, 2472 .current_norm = V4L2_STD_PAL, 2473 }; 2474 2475 static const struct v4l2_file_operations radio_fops = { 2476 .owner = THIS_MODULE, 2477 .open = em28xx_v4l2_open, 2478 .release = em28xx_v4l2_close, 2479 .unlocked_ioctl = video_ioctl2, 2480 }; 2481 2482 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2483 .vidioc_querycap = radio_querycap, 2484 .vidioc_g_tuner = radio_g_tuner, 2485 .vidioc_enum_input = radio_enum_input, 2486 .vidioc_g_audio = radio_g_audio, 2487 .vidioc_s_tuner = radio_s_tuner, 2488 .vidioc_s_audio = radio_s_audio, 2489 .vidioc_s_input = radio_s_input, 2490 .vidioc_queryctrl = radio_queryctrl, 2491 .vidioc_g_ctrl = vidioc_g_ctrl, 2492 .vidioc_s_ctrl = vidioc_s_ctrl, 2493 .vidioc_g_frequency = vidioc_g_frequency, 2494 .vidioc_s_frequency = vidioc_s_frequency, 2495 #ifdef CONFIG_VIDEO_ADV_DEBUG 2496 .vidioc_g_register = vidioc_g_register, 2497 .vidioc_s_register = vidioc_s_register, 2498 #endif 2499 }; 2500 2501 static struct video_device em28xx_radio_template = { 2502 .name = "em28xx-radio", 2503 .fops = &radio_fops, 2504 .ioctl_ops = &radio_ioctl_ops, 2505 }; 2506 2507 /******************************** usb interface ******************************/ 2508 2509 2510 2511 static struct video_device *em28xx_vdev_init(struct em28xx *dev, 2512 const struct video_device *template, 2513 const char *type_name) 2514 { 2515 struct video_device *vfd; 2516 2517 vfd = video_device_alloc(); 2518 if (NULL == vfd) 2519 return NULL; 2520 2521 *vfd = *template; 2522 vfd->v4l2_dev = &dev->v4l2_dev; 2523 vfd->release = video_device_release; 2524 vfd->debug = video_debug; 2525 vfd->lock = &dev->lock; 2526 2527 snprintf(vfd->name, sizeof(vfd->name), "%s %s", 2528 dev->name, type_name); 2529 2530 video_set_drvdata(vfd, dev); 2531 return vfd; 2532 } 2533 2534 int em28xx_register_analog_devices(struct em28xx *dev) 2535 { 2536 u8 val; 2537 int ret; 2538 unsigned int maxw; 2539 2540 printk(KERN_INFO "%s: v4l2 driver version %s\n", 2541 dev->name, EM28XX_VERSION); 2542 2543 /* set default norm */ 2544 dev->norm = em28xx_video_template.current_norm; 2545 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm); 2546 dev->interlaced = EM28XX_INTERLACED_DEFAULT; 2547 2548 /* Analog specific initialization */ 2549 dev->format = &format[0]; 2550 2551 maxw = norm_maxw(dev); 2552 /* MaxPacketSize for em2800 is too small to capture at full resolution 2553 * use half of maxw as the scaler can only scale to 50% */ 2554 if (dev->board.is_em2800) 2555 maxw /= 2; 2556 2557 em28xx_set_video_format(dev, format[0].fourcc, 2558 maxw, norm_maxh(dev)); 2559 2560 video_mux(dev, 0); 2561 2562 /* Audio defaults */ 2563 dev->mute = 1; 2564 dev->volume = 0x1f; 2565 2566 /* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */ 2567 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK); 2568 em28xx_write_reg(dev, EM28XX_R0F_XCLK, 2569 (EM28XX_XCLK_AUDIO_UNMUTE | val)); 2570 2571 em28xx_set_outfmt(dev); 2572 em28xx_colorlevels_set_default(dev); 2573 em28xx_compression_disable(dev); 2574 2575 /* allocate and fill video video_device struct */ 2576 dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video"); 2577 if (!dev->vdev) { 2578 em28xx_errdev("cannot allocate video_device.\n"); 2579 return -ENODEV; 2580 } 2581 2582 /* register v4l2 video video_device */ 2583 ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER, 2584 video_nr[dev->devno]); 2585 if (ret) { 2586 em28xx_errdev("unable to register video device (error=%i).\n", 2587 ret); 2588 return ret; 2589 } 2590 2591 /* Allocate and fill vbi video_device struct */ 2592 if (em28xx_vbi_supported(dev) == 1) { 2593 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template, 2594 "vbi"); 2595 2596 /* register v4l2 vbi video_device */ 2597 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, 2598 vbi_nr[dev->devno]); 2599 if (ret < 0) { 2600 em28xx_errdev("unable to register vbi device\n"); 2601 return ret; 2602 } 2603 } 2604 2605 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) { 2606 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template, 2607 "radio"); 2608 if (!dev->radio_dev) { 2609 em28xx_errdev("cannot allocate video_device.\n"); 2610 return -ENODEV; 2611 } 2612 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO, 2613 radio_nr[dev->devno]); 2614 if (ret < 0) { 2615 em28xx_errdev("can't register radio device\n"); 2616 return ret; 2617 } 2618 em28xx_info("Registered radio device as %s\n", 2619 video_device_node_name(dev->radio_dev)); 2620 } 2621 2622 em28xx_info("V4L2 video device registered as %s\n", 2623 video_device_node_name(dev->vdev)); 2624 2625 if (dev->vbi_dev) 2626 em28xx_info("V4L2 VBI device registered as %s\n", 2627 video_device_node_name(dev->vbi_dev)); 2628 2629 return 0; 2630 } 2631