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