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