1 /* 2 cx231xx-video.c - driver for Conexant Cx23100/101/102 3 USB video capture devices 4 5 Copyright (C) 2008 <srinivasa.deevi at conexant dot com> 6 Based on em28xx driver 7 Based on cx23885 driver 8 Based on cx88 driver 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 */ 24 25 #include <linux/init.h> 26 #include <linux/list.h> 27 #include <linux/module.h> 28 #include <linux/kernel.h> 29 #include <linux/bitmap.h> 30 #include <linux/usb.h> 31 #include <linux/i2c.h> 32 #include <linux/mm.h> 33 #include <linux/mutex.h> 34 #include <linux/slab.h> 35 36 #include <media/v4l2-common.h> 37 #include <media/v4l2-ioctl.h> 38 #include <media/v4l2-chip-ident.h> 39 #include <media/msp3400.h> 40 #include <media/tuner.h> 41 42 #include "dvb_frontend.h" 43 44 #include "cx231xx.h" 45 #include "cx231xx-vbi.h" 46 47 #define CX231XX_VERSION "0.0.2" 48 49 #define DRIVER_AUTHOR "Srinivasa Deevi <srinivasa.deevi@conexant.com>" 50 #define DRIVER_DESC "Conexant cx231xx based USB video device driver" 51 52 #define cx231xx_videodbg(fmt, arg...) do {\ 53 if (video_debug) \ 54 printk(KERN_INFO "%s %s :"fmt, \ 55 dev->name, __func__ , ##arg); } while (0) 56 57 static unsigned int isoc_debug; 58 module_param(isoc_debug, int, 0644); 59 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]"); 60 61 #define cx231xx_isocdbg(fmt, arg...) \ 62 do {\ 63 if (isoc_debug) { \ 64 printk(KERN_INFO "%s %s :"fmt, \ 65 dev->name, __func__ , ##arg); \ 66 } \ 67 } while (0) 68 69 MODULE_AUTHOR(DRIVER_AUTHOR); 70 MODULE_DESCRIPTION(DRIVER_DESC); 71 MODULE_LICENSE("GPL"); 72 MODULE_VERSION(CX231XX_VERSION); 73 74 static unsigned int card[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 75 static unsigned int video_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 76 static unsigned int vbi_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 77 static unsigned int radio_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 78 79 module_param_array(card, int, NULL, 0444); 80 module_param_array(video_nr, int, NULL, 0444); 81 module_param_array(vbi_nr, int, NULL, 0444); 82 module_param_array(radio_nr, int, NULL, 0444); 83 84 MODULE_PARM_DESC(card, "card type"); 85 MODULE_PARM_DESC(video_nr, "video device numbers"); 86 MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 87 MODULE_PARM_DESC(radio_nr, "radio device numbers"); 88 89 static unsigned int video_debug; 90 module_param(video_debug, int, 0644); 91 MODULE_PARM_DESC(video_debug, "enable debug messages [video]"); 92 93 /* supported video standards */ 94 static struct cx231xx_fmt format[] = { 95 { 96 .name = "16bpp YUY2, 4:2:2, packed", 97 .fourcc = V4L2_PIX_FMT_YUYV, 98 .depth = 16, 99 .reg = 0, 100 }, 101 }; 102 103 /* supported controls */ 104 /* Common to all boards */ 105 106 /* ------------------------------------------------------------------- */ 107 108 static const struct v4l2_queryctrl no_ctl = { 109 .name = "42", 110 .flags = V4L2_CTRL_FLAG_DISABLED, 111 }; 112 113 static struct cx231xx_ctrl cx231xx_ctls[] = { 114 /* --- video --- */ 115 { 116 .v = { 117 .id = V4L2_CID_BRIGHTNESS, 118 .name = "Brightness", 119 .minimum = 0x00, 120 .maximum = 0xff, 121 .step = 1, 122 .default_value = 0x7f, 123 .type = V4L2_CTRL_TYPE_INTEGER, 124 }, 125 .off = 128, 126 .reg = LUMA_CTRL, 127 .mask = 0x00ff, 128 .shift = 0, 129 }, { 130 .v = { 131 .id = V4L2_CID_CONTRAST, 132 .name = "Contrast", 133 .minimum = 0, 134 .maximum = 0xff, 135 .step = 1, 136 .default_value = 0x3f, 137 .type = V4L2_CTRL_TYPE_INTEGER, 138 }, 139 .off = 0, 140 .reg = LUMA_CTRL, 141 .mask = 0xff00, 142 .shift = 8, 143 }, { 144 .v = { 145 .id = V4L2_CID_HUE, 146 .name = "Hue", 147 .minimum = 0, 148 .maximum = 0xff, 149 .step = 1, 150 .default_value = 0x7f, 151 .type = V4L2_CTRL_TYPE_INTEGER, 152 }, 153 .off = 128, 154 .reg = CHROMA_CTRL, 155 .mask = 0xff0000, 156 .shift = 16, 157 }, { 158 /* strictly, this only describes only U saturation. 159 * V saturation is handled specially through code. 160 */ 161 .v = { 162 .id = V4L2_CID_SATURATION, 163 .name = "Saturation", 164 .minimum = 0, 165 .maximum = 0xff, 166 .step = 1, 167 .default_value = 0x7f, 168 .type = V4L2_CTRL_TYPE_INTEGER, 169 }, 170 .off = 0, 171 .reg = CHROMA_CTRL, 172 .mask = 0x00ff, 173 .shift = 0, 174 }, { 175 /* --- audio --- */ 176 .v = { 177 .id = V4L2_CID_AUDIO_MUTE, 178 .name = "Mute", 179 .minimum = 0, 180 .maximum = 1, 181 .default_value = 1, 182 .type = V4L2_CTRL_TYPE_BOOLEAN, 183 }, 184 .reg = PATH1_CTL1, 185 .mask = (0x1f << 24), 186 .shift = 24, 187 }, { 188 .v = { 189 .id = V4L2_CID_AUDIO_VOLUME, 190 .name = "Volume", 191 .minimum = 0, 192 .maximum = 0x3f, 193 .step = 1, 194 .default_value = 0x3f, 195 .type = V4L2_CTRL_TYPE_INTEGER, 196 }, 197 .reg = PATH1_VOL_CTL, 198 .mask = 0xff, 199 .shift = 0, 200 } 201 }; 202 static const int CX231XX_CTLS = ARRAY_SIZE(cx231xx_ctls); 203 204 static const u32 cx231xx_user_ctrls[] = { 205 V4L2_CID_USER_CLASS, 206 V4L2_CID_BRIGHTNESS, 207 V4L2_CID_CONTRAST, 208 V4L2_CID_SATURATION, 209 V4L2_CID_HUE, 210 V4L2_CID_AUDIO_VOLUME, 211 #if 0 212 V4L2_CID_AUDIO_BALANCE, 213 #endif 214 V4L2_CID_AUDIO_MUTE, 215 0 216 }; 217 218 static const u32 *ctrl_classes[] = { 219 cx231xx_user_ctrls, 220 NULL 221 }; 222 223 /* ------------------------------------------------------------------ 224 Video buffer and parser functions 225 ------------------------------------------------------------------*/ 226 227 /* 228 * Announces that a buffer were filled and request the next 229 */ 230 static inline void buffer_filled(struct cx231xx *dev, 231 struct cx231xx_dmaqueue *dma_q, 232 struct cx231xx_buffer *buf) 233 { 234 /* Advice that buffer was filled */ 235 cx231xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i); 236 buf->vb.state = VIDEOBUF_DONE; 237 buf->vb.field_count++; 238 do_gettimeofday(&buf->vb.ts); 239 240 if (dev->USE_ISO) 241 dev->video_mode.isoc_ctl.buf = NULL; 242 else 243 dev->video_mode.bulk_ctl.buf = NULL; 244 245 list_del(&buf->vb.queue); 246 wake_up(&buf->vb.done); 247 } 248 249 static inline void print_err_status(struct cx231xx *dev, int packet, int status) 250 { 251 char *errmsg = "Unknown"; 252 253 switch (status) { 254 case -ENOENT: 255 errmsg = "unlinked synchronuously"; 256 break; 257 case -ECONNRESET: 258 errmsg = "unlinked asynchronuously"; 259 break; 260 case -ENOSR: 261 errmsg = "Buffer error (overrun)"; 262 break; 263 case -EPIPE: 264 errmsg = "Stalled (device not responding)"; 265 break; 266 case -EOVERFLOW: 267 errmsg = "Babble (bad cable?)"; 268 break; 269 case -EPROTO: 270 errmsg = "Bit-stuff error (bad cable?)"; 271 break; 272 case -EILSEQ: 273 errmsg = "CRC/Timeout (could be anything)"; 274 break; 275 case -ETIME: 276 errmsg = "Device does not respond"; 277 break; 278 } 279 if (packet < 0) { 280 cx231xx_isocdbg("URB status %d [%s].\n", status, errmsg); 281 } else { 282 cx231xx_isocdbg("URB packet %d, status %d [%s].\n", 283 packet, status, errmsg); 284 } 285 } 286 287 /* 288 * video-buf generic routine to get the next available buffer 289 */ 290 static inline void get_next_buf(struct cx231xx_dmaqueue *dma_q, 291 struct cx231xx_buffer **buf) 292 { 293 struct cx231xx_video_mode *vmode = 294 container_of(dma_q, struct cx231xx_video_mode, vidq); 295 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode); 296 297 char *outp; 298 299 if (list_empty(&dma_q->active)) { 300 cx231xx_isocdbg("No active queue to serve\n"); 301 if (dev->USE_ISO) 302 dev->video_mode.isoc_ctl.buf = NULL; 303 else 304 dev->video_mode.bulk_ctl.buf = NULL; 305 *buf = NULL; 306 return; 307 } 308 309 /* Get the next buffer */ 310 *buf = list_entry(dma_q->active.next, struct cx231xx_buffer, vb.queue); 311 312 /* Cleans up buffer - Useful for testing for frame/URB loss */ 313 outp = videobuf_to_vmalloc(&(*buf)->vb); 314 memset(outp, 0, (*buf)->vb.size); 315 316 if (dev->USE_ISO) 317 dev->video_mode.isoc_ctl.buf = *buf; 318 else 319 dev->video_mode.bulk_ctl.buf = *buf; 320 321 return; 322 } 323 324 /* 325 * Controls the isoc copy of each urb packet 326 */ 327 static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb) 328 { 329 struct cx231xx_dmaqueue *dma_q = urb->context; 330 int i, rc = 1; 331 unsigned char *p_buffer; 332 u32 bytes_parsed = 0, buffer_size = 0; 333 u8 sav_eav = 0; 334 335 if (!dev) 336 return 0; 337 338 if (dev->state & DEV_DISCONNECTED) 339 return 0; 340 341 if (urb->status < 0) { 342 print_err_status(dev, -1, urb->status); 343 if (urb->status == -ENOENT) 344 return 0; 345 } 346 347 for (i = 0; i < urb->number_of_packets; i++) { 348 int status = urb->iso_frame_desc[i].status; 349 350 if (status < 0) { 351 print_err_status(dev, i, status); 352 if (urb->iso_frame_desc[i].status != -EPROTO) 353 continue; 354 } 355 356 if (urb->iso_frame_desc[i].actual_length <= 0) { 357 /* cx231xx_isocdbg("packet %d is empty",i); - spammy */ 358 continue; 359 } 360 if (urb->iso_frame_desc[i].actual_length > 361 dev->video_mode.max_pkt_size) { 362 cx231xx_isocdbg("packet bigger than packet size"); 363 continue; 364 } 365 366 /* get buffer pointer and length */ 367 p_buffer = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 368 buffer_size = urb->iso_frame_desc[i].actual_length; 369 bytes_parsed = 0; 370 371 if (dma_q->is_partial_line) { 372 /* Handle the case of a partial line */ 373 sav_eav = dma_q->last_sav; 374 } else { 375 /* Check for a SAV/EAV overlapping 376 the buffer boundary */ 377 sav_eav = 378 cx231xx_find_boundary_SAV_EAV(p_buffer, 379 dma_q->partial_buf, 380 &bytes_parsed); 381 } 382 383 sav_eav &= 0xF0; 384 /* Get the first line if we have some portion of an SAV/EAV from 385 the last buffer or a partial line */ 386 if (sav_eav) { 387 bytes_parsed += cx231xx_get_video_line(dev, dma_q, 388 sav_eav, /* SAV/EAV */ 389 p_buffer + bytes_parsed, /* p_buffer */ 390 buffer_size - bytes_parsed);/* buf size */ 391 } 392 393 /* Now parse data that is completely in this buffer */ 394 /* dma_q->is_partial_line = 0; */ 395 396 while (bytes_parsed < buffer_size) { 397 u32 bytes_used = 0; 398 399 sav_eav = cx231xx_find_next_SAV_EAV( 400 p_buffer + bytes_parsed, /* p_buffer */ 401 buffer_size - bytes_parsed, /* buf size */ 402 &bytes_used);/* bytes used to get SAV/EAV */ 403 404 bytes_parsed += bytes_used; 405 406 sav_eav &= 0xF0; 407 if (sav_eav && (bytes_parsed < buffer_size)) { 408 bytes_parsed += cx231xx_get_video_line(dev, 409 dma_q, sav_eav, /* SAV/EAV */ 410 p_buffer + bytes_parsed,/* p_buffer */ 411 buffer_size - bytes_parsed);/*buf size*/ 412 } 413 } 414 415 /* Save the last four bytes of the buffer so we can check the 416 buffer boundary condition next time */ 417 memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4); 418 bytes_parsed = 0; 419 420 } 421 return rc; 422 } 423 424 static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb) 425 { 426 struct cx231xx_dmaqueue *dma_q = urb->context; 427 int rc = 1; 428 unsigned char *p_buffer; 429 u32 bytes_parsed = 0, buffer_size = 0; 430 u8 sav_eav = 0; 431 432 if (!dev) 433 return 0; 434 435 if (dev->state & DEV_DISCONNECTED) 436 return 0; 437 438 if (urb->status < 0) { 439 print_err_status(dev, -1, urb->status); 440 if (urb->status == -ENOENT) 441 return 0; 442 } 443 444 if (1) { 445 446 /* get buffer pointer and length */ 447 p_buffer = urb->transfer_buffer; 448 buffer_size = urb->actual_length; 449 bytes_parsed = 0; 450 451 if (dma_q->is_partial_line) { 452 /* Handle the case of a partial line */ 453 sav_eav = dma_q->last_sav; 454 } else { 455 /* Check for a SAV/EAV overlapping 456 the buffer boundary */ 457 sav_eav = 458 cx231xx_find_boundary_SAV_EAV(p_buffer, 459 dma_q->partial_buf, 460 &bytes_parsed); 461 } 462 463 sav_eav &= 0xF0; 464 /* Get the first line if we have some portion of an SAV/EAV from 465 the last buffer or a partial line */ 466 if (sav_eav) { 467 bytes_parsed += cx231xx_get_video_line(dev, dma_q, 468 sav_eav, /* SAV/EAV */ 469 p_buffer + bytes_parsed, /* p_buffer */ 470 buffer_size - bytes_parsed);/* buf size */ 471 } 472 473 /* Now parse data that is completely in this buffer */ 474 /* dma_q->is_partial_line = 0; */ 475 476 while (bytes_parsed < buffer_size) { 477 u32 bytes_used = 0; 478 479 sav_eav = cx231xx_find_next_SAV_EAV( 480 p_buffer + bytes_parsed, /* p_buffer */ 481 buffer_size - bytes_parsed, /* buf size */ 482 &bytes_used);/* bytes used to get SAV/EAV */ 483 484 bytes_parsed += bytes_used; 485 486 sav_eav &= 0xF0; 487 if (sav_eav && (bytes_parsed < buffer_size)) { 488 bytes_parsed += cx231xx_get_video_line(dev, 489 dma_q, sav_eav, /* SAV/EAV */ 490 p_buffer + bytes_parsed,/* p_buffer */ 491 buffer_size - bytes_parsed);/*buf size*/ 492 } 493 } 494 495 /* Save the last four bytes of the buffer so we can check the 496 buffer boundary condition next time */ 497 memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4); 498 bytes_parsed = 0; 499 500 } 501 return rc; 502 } 503 504 505 u8 cx231xx_find_boundary_SAV_EAV(u8 *p_buffer, u8 *partial_buf, 506 u32 *p_bytes_used) 507 { 508 u32 bytes_used; 509 u8 boundary_bytes[8]; 510 u8 sav_eav = 0; 511 512 *p_bytes_used = 0; 513 514 /* Create an array of the last 4 bytes of the last buffer and the first 515 4 bytes of the current buffer. */ 516 517 memcpy(boundary_bytes, partial_buf, 4); 518 memcpy(boundary_bytes + 4, p_buffer, 4); 519 520 /* Check for the SAV/EAV in the boundary buffer */ 521 sav_eav = cx231xx_find_next_SAV_EAV((u8 *)&boundary_bytes, 8, 522 &bytes_used); 523 524 if (sav_eav) { 525 /* found a boundary SAV/EAV. Updates the bytes used to reflect 526 only those used in the new buffer */ 527 *p_bytes_used = bytes_used - 4; 528 } 529 530 return sav_eav; 531 } 532 533 u8 cx231xx_find_next_SAV_EAV(u8 *p_buffer, u32 buffer_size, u32 *p_bytes_used) 534 { 535 u32 i; 536 u8 sav_eav = 0; 537 538 /* 539 * Don't search if the buffer size is less than 4. It causes a page 540 * fault since buffer_size - 4 evaluates to a large number in that 541 * case. 542 */ 543 if (buffer_size < 4) { 544 *p_bytes_used = buffer_size; 545 return 0; 546 } 547 548 for (i = 0; i < (buffer_size - 3); i++) { 549 550 if ((p_buffer[i] == 0xFF) && 551 (p_buffer[i + 1] == 0x00) && (p_buffer[i + 2] == 0x00)) { 552 553 *p_bytes_used = i + 4; 554 sav_eav = p_buffer[i + 3]; 555 return sav_eav; 556 } 557 } 558 559 *p_bytes_used = buffer_size; 560 return 0; 561 } 562 563 u32 cx231xx_get_video_line(struct cx231xx *dev, 564 struct cx231xx_dmaqueue *dma_q, u8 sav_eav, 565 u8 *p_buffer, u32 buffer_size) 566 { 567 u32 bytes_copied = 0; 568 int current_field = -1; 569 570 switch (sav_eav) { 571 case SAV_ACTIVE_VIDEO_FIELD1: 572 /* looking for skipped line which occurred in PAL 720x480 mode. 573 In this case, there will be no active data contained 574 between the SAV and EAV */ 575 if ((buffer_size > 3) && (p_buffer[0] == 0xFF) && 576 (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) && 577 ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) || 578 (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) || 579 (p_buffer[3] == EAV_VBLANK_FIELD1) || 580 (p_buffer[3] == EAV_VBLANK_FIELD2))) 581 return bytes_copied; 582 current_field = 1; 583 break; 584 585 case SAV_ACTIVE_VIDEO_FIELD2: 586 /* looking for skipped line which occurred in PAL 720x480 mode. 587 In this case, there will be no active data contained between 588 the SAV and EAV */ 589 if ((buffer_size > 3) && (p_buffer[0] == 0xFF) && 590 (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) && 591 ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) || 592 (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) || 593 (p_buffer[3] == EAV_VBLANK_FIELD1) || 594 (p_buffer[3] == EAV_VBLANK_FIELD2))) 595 return bytes_copied; 596 current_field = 2; 597 break; 598 } 599 600 dma_q->last_sav = sav_eav; 601 602 bytes_copied = cx231xx_copy_video_line(dev, dma_q, p_buffer, 603 buffer_size, current_field); 604 605 return bytes_copied; 606 } 607 608 u32 cx231xx_copy_video_line(struct cx231xx *dev, 609 struct cx231xx_dmaqueue *dma_q, u8 *p_line, 610 u32 length, int field_number) 611 { 612 u32 bytes_to_copy; 613 struct cx231xx_buffer *buf; 614 u32 _line_size = dev->width * 2; 615 616 if (dma_q->current_field != field_number) 617 cx231xx_reset_video_buffer(dev, dma_q); 618 619 /* get the buffer pointer */ 620 if (dev->USE_ISO) 621 buf = dev->video_mode.isoc_ctl.buf; 622 else 623 buf = dev->video_mode.bulk_ctl.buf; 624 625 /* Remember the field number for next time */ 626 dma_q->current_field = field_number; 627 628 bytes_to_copy = dma_q->bytes_left_in_line; 629 if (bytes_to_copy > length) 630 bytes_to_copy = length; 631 632 if (dma_q->lines_completed >= dma_q->lines_per_field) { 633 dma_q->bytes_left_in_line -= bytes_to_copy; 634 dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0) ? 635 0 : 1; 636 return 0; 637 } 638 639 dma_q->is_partial_line = 1; 640 641 /* If we don't have a buffer, just return the number of bytes we would 642 have copied if we had a buffer. */ 643 if (!buf) { 644 dma_q->bytes_left_in_line -= bytes_to_copy; 645 dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0) 646 ? 0 : 1; 647 return bytes_to_copy; 648 } 649 650 /* copy the data to video buffer */ 651 cx231xx_do_copy(dev, dma_q, p_line, bytes_to_copy); 652 653 dma_q->pos += bytes_to_copy; 654 dma_q->bytes_left_in_line -= bytes_to_copy; 655 656 if (dma_q->bytes_left_in_line == 0) { 657 dma_q->bytes_left_in_line = _line_size; 658 dma_q->lines_completed++; 659 dma_q->is_partial_line = 0; 660 661 if (cx231xx_is_buffer_done(dev, dma_q) && buf) { 662 buffer_filled(dev, dma_q, buf); 663 664 dma_q->pos = 0; 665 buf = NULL; 666 dma_q->lines_completed = 0; 667 } 668 } 669 670 return bytes_to_copy; 671 } 672 673 void cx231xx_reset_video_buffer(struct cx231xx *dev, 674 struct cx231xx_dmaqueue *dma_q) 675 { 676 struct cx231xx_buffer *buf; 677 678 /* handle the switch from field 1 to field 2 */ 679 if (dma_q->current_field == 1) { 680 if (dma_q->lines_completed >= dma_q->lines_per_field) 681 dma_q->field1_done = 1; 682 else 683 dma_q->field1_done = 0; 684 } 685 686 if (dev->USE_ISO) 687 buf = dev->video_mode.isoc_ctl.buf; 688 else 689 buf = dev->video_mode.bulk_ctl.buf; 690 691 if (buf == NULL) { 692 /* first try to get the buffer */ 693 get_next_buf(dma_q, &buf); 694 695 dma_q->pos = 0; 696 dma_q->field1_done = 0; 697 dma_q->current_field = -1; 698 } 699 700 /* reset the counters */ 701 dma_q->bytes_left_in_line = dev->width << 1; 702 dma_q->lines_completed = 0; 703 } 704 705 int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q, 706 u8 *p_buffer, u32 bytes_to_copy) 707 { 708 u8 *p_out_buffer = NULL; 709 u32 current_line_bytes_copied = 0; 710 struct cx231xx_buffer *buf; 711 u32 _line_size = dev->width << 1; 712 void *startwrite; 713 int offset, lencopy; 714 715 if (dev->USE_ISO) 716 buf = dev->video_mode.isoc_ctl.buf; 717 else 718 buf = dev->video_mode.bulk_ctl.buf; 719 720 if (buf == NULL) 721 return -1; 722 723 p_out_buffer = videobuf_to_vmalloc(&buf->vb); 724 725 current_line_bytes_copied = _line_size - dma_q->bytes_left_in_line; 726 727 /* Offset field 2 one line from the top of the buffer */ 728 offset = (dma_q->current_field == 1) ? 0 : _line_size; 729 730 /* Offset for field 2 */ 731 startwrite = p_out_buffer + offset; 732 733 /* lines already completed in the current field */ 734 startwrite += (dma_q->lines_completed * _line_size * 2); 735 736 /* bytes already completed in the current line */ 737 startwrite += current_line_bytes_copied; 738 739 lencopy = dma_q->bytes_left_in_line > bytes_to_copy ? 740 bytes_to_copy : dma_q->bytes_left_in_line; 741 742 if ((u8 *)(startwrite + lencopy) > (u8 *)(p_out_buffer + buf->vb.size)) 743 return 0; 744 745 /* The below copies the UYVY data straight into video buffer */ 746 cx231xx_swab((u16 *) p_buffer, (u16 *) startwrite, (u16) lencopy); 747 748 return 0; 749 } 750 751 void cx231xx_swab(u16 *from, u16 *to, u16 len) 752 { 753 u16 i; 754 755 if (len <= 0) 756 return; 757 758 for (i = 0; i < len / 2; i++) 759 to[i] = (from[i] << 8) | (from[i] >> 8); 760 } 761 762 u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q) 763 { 764 u8 buffer_complete = 0; 765 766 /* Dual field stream */ 767 buffer_complete = ((dma_q->current_field == 2) && 768 (dma_q->lines_completed >= dma_q->lines_per_field) && 769 dma_q->field1_done); 770 771 return buffer_complete; 772 } 773 774 /* ------------------------------------------------------------------ 775 Videobuf operations 776 ------------------------------------------------------------------*/ 777 778 static int 779 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size) 780 { 781 struct cx231xx_fh *fh = vq->priv_data; 782 struct cx231xx *dev = fh->dev; 783 784 *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)>>3; 785 if (0 == *count) 786 *count = CX231XX_DEF_BUF; 787 788 if (*count < CX231XX_MIN_BUF) 789 *count = CX231XX_MIN_BUF; 790 791 return 0; 792 } 793 794 /* This is called *without* dev->slock held; please keep it that way */ 795 static void free_buffer(struct videobuf_queue *vq, struct cx231xx_buffer *buf) 796 { 797 struct cx231xx_fh *fh = vq->priv_data; 798 struct cx231xx *dev = fh->dev; 799 unsigned long flags = 0; 800 801 if (in_interrupt()) 802 BUG(); 803 804 /* We used to wait for the buffer to finish here, but this didn't work 805 because, as we were keeping the state as VIDEOBUF_QUEUED, 806 videobuf_queue_cancel marked it as finished for us. 807 (Also, it could wedge forever if the hardware was misconfigured.) 808 809 This should be safe; by the time we get here, the buffer isn't 810 queued anymore. If we ever start marking the buffers as 811 VIDEOBUF_ACTIVE, it won't be, though. 812 */ 813 spin_lock_irqsave(&dev->video_mode.slock, flags); 814 if (dev->USE_ISO) { 815 if (dev->video_mode.isoc_ctl.buf == buf) 816 dev->video_mode.isoc_ctl.buf = NULL; 817 } else { 818 if (dev->video_mode.bulk_ctl.buf == buf) 819 dev->video_mode.bulk_ctl.buf = NULL; 820 } 821 spin_unlock_irqrestore(&dev->video_mode.slock, flags); 822 823 videobuf_vmalloc_free(&buf->vb); 824 buf->vb.state = VIDEOBUF_NEEDS_INIT; 825 } 826 827 static int 828 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, 829 enum v4l2_field field) 830 { 831 struct cx231xx_fh *fh = vq->priv_data; 832 struct cx231xx_buffer *buf = 833 container_of(vb, struct cx231xx_buffer, vb); 834 struct cx231xx *dev = fh->dev; 835 int rc = 0, urb_init = 0; 836 837 /* The only currently supported format is 16 bits/pixel */ 838 buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth 839 + 7) >> 3; 840 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 841 return -EINVAL; 842 843 buf->vb.width = dev->width; 844 buf->vb.height = dev->height; 845 buf->vb.field = field; 846 847 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 848 rc = videobuf_iolock(vq, &buf->vb, NULL); 849 if (rc < 0) 850 goto fail; 851 } 852 853 if (dev->USE_ISO) { 854 if (!dev->video_mode.isoc_ctl.num_bufs) 855 urb_init = 1; 856 } else { 857 if (!dev->video_mode.bulk_ctl.num_bufs) 858 urb_init = 1; 859 } 860 /*cx231xx_info("urb_init=%d dev->video_mode.max_pkt_size=%d\n", 861 urb_init, dev->video_mode.max_pkt_size);*/ 862 if (urb_init) { 863 dev->mode_tv = 0; 864 if (dev->USE_ISO) 865 rc = cx231xx_init_isoc(dev, CX231XX_NUM_PACKETS, 866 CX231XX_NUM_BUFS, 867 dev->video_mode.max_pkt_size, 868 cx231xx_isoc_copy); 869 else 870 rc = cx231xx_init_bulk(dev, CX231XX_NUM_PACKETS, 871 CX231XX_NUM_BUFS, 872 dev->video_mode.max_pkt_size, 873 cx231xx_bulk_copy); 874 if (rc < 0) 875 goto fail; 876 } 877 878 buf->vb.state = VIDEOBUF_PREPARED; 879 return 0; 880 881 fail: 882 free_buffer(vq, buf); 883 return rc; 884 } 885 886 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) 887 { 888 struct cx231xx_buffer *buf = 889 container_of(vb, struct cx231xx_buffer, vb); 890 struct cx231xx_fh *fh = vq->priv_data; 891 struct cx231xx *dev = fh->dev; 892 struct cx231xx_dmaqueue *vidq = &dev->video_mode.vidq; 893 894 buf->vb.state = VIDEOBUF_QUEUED; 895 list_add_tail(&buf->vb.queue, &vidq->active); 896 897 } 898 899 static void buffer_release(struct videobuf_queue *vq, 900 struct videobuf_buffer *vb) 901 { 902 struct cx231xx_buffer *buf = 903 container_of(vb, struct cx231xx_buffer, vb); 904 struct cx231xx_fh *fh = vq->priv_data; 905 struct cx231xx *dev = (struct cx231xx *)fh->dev; 906 907 cx231xx_isocdbg("cx231xx: called buffer_release\n"); 908 909 free_buffer(vq, buf); 910 } 911 912 static struct videobuf_queue_ops cx231xx_video_qops = { 913 .buf_setup = buffer_setup, 914 .buf_prepare = buffer_prepare, 915 .buf_queue = buffer_queue, 916 .buf_release = buffer_release, 917 }; 918 919 /********************* v4l2 interface **************************************/ 920 921 void video_mux(struct cx231xx *dev, int index) 922 { 923 dev->video_input = index; 924 dev->ctl_ainput = INPUT(index)->amux; 925 926 cx231xx_set_video_input_mux(dev, index); 927 928 cx25840_call(dev, video, s_routing, INPUT(index)->vmux, 0, 0); 929 930 cx231xx_set_audio_input(dev, dev->ctl_ainput); 931 932 cx231xx_info("video_mux : %d\n", index); 933 934 /* do mode control overrides if required */ 935 cx231xx_do_mode_ctrl_overrides(dev); 936 } 937 938 /* Usage lock check functions */ 939 static int res_get(struct cx231xx_fh *fh) 940 { 941 struct cx231xx *dev = fh->dev; 942 int rc = 0; 943 944 /* This instance already has stream_on */ 945 if (fh->stream_on) 946 return rc; 947 948 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 949 if (dev->stream_on) 950 return -EBUSY; 951 dev->stream_on = 1; 952 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 953 if (dev->vbi_stream_on) 954 return -EBUSY; 955 dev->vbi_stream_on = 1; 956 } else 957 return -EINVAL; 958 959 fh->stream_on = 1; 960 961 return rc; 962 } 963 964 static int res_check(struct cx231xx_fh *fh) 965 { 966 return fh->stream_on; 967 } 968 969 static void res_free(struct cx231xx_fh *fh) 970 { 971 struct cx231xx *dev = fh->dev; 972 973 fh->stream_on = 0; 974 975 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 976 dev->stream_on = 0; 977 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) 978 dev->vbi_stream_on = 0; 979 } 980 981 static int check_dev(struct cx231xx *dev) 982 { 983 if (dev->state & DEV_DISCONNECTED) { 984 cx231xx_errdev("v4l2 ioctl: device not present\n"); 985 return -ENODEV; 986 } 987 return 0; 988 } 989 990 /* ------------------------------------------------------------------ 991 IOCTL vidioc handling 992 ------------------------------------------------------------------*/ 993 994 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 995 struct v4l2_format *f) 996 { 997 struct cx231xx_fh *fh = priv; 998 struct cx231xx *dev = fh->dev; 999 1000 f->fmt.pix.width = dev->width; 1001 f->fmt.pix.height = dev->height; 1002 f->fmt.pix.pixelformat = dev->format->fourcc; 1003 f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3; 1004 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height; 1005 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1006 1007 f->fmt.pix.field = V4L2_FIELD_INTERLACED; 1008 1009 return 0; 1010 } 1011 1012 static struct cx231xx_fmt *format_by_fourcc(unsigned int fourcc) 1013 { 1014 unsigned int i; 1015 1016 for (i = 0; i < ARRAY_SIZE(format); i++) 1017 if (format[i].fourcc == fourcc) 1018 return &format[i]; 1019 1020 return NULL; 1021 } 1022 1023 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 1024 struct v4l2_format *f) 1025 { 1026 struct cx231xx_fh *fh = priv; 1027 struct cx231xx *dev = fh->dev; 1028 unsigned int width = f->fmt.pix.width; 1029 unsigned int height = f->fmt.pix.height; 1030 unsigned int maxw = norm_maxw(dev); 1031 unsigned int maxh = norm_maxh(dev); 1032 struct cx231xx_fmt *fmt; 1033 1034 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1035 if (!fmt) { 1036 cx231xx_videodbg("Fourcc format (%08x) invalid.\n", 1037 f->fmt.pix.pixelformat); 1038 return -EINVAL; 1039 } 1040 1041 /* width must even because of the YUYV format 1042 height must be even because of interlacing */ 1043 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1, 0); 1044 1045 f->fmt.pix.width = width; 1046 f->fmt.pix.height = height; 1047 f->fmt.pix.pixelformat = fmt->fourcc; 1048 f->fmt.pix.bytesperline = (dev->width * fmt->depth + 7) >> 3; 1049 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height; 1050 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1051 f->fmt.pix.field = V4L2_FIELD_INTERLACED; 1052 1053 return 0; 1054 } 1055 1056 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1057 struct v4l2_format *f) 1058 { 1059 struct cx231xx_fh *fh = priv; 1060 struct cx231xx *dev = fh->dev; 1061 int rc; 1062 struct cx231xx_fmt *fmt; 1063 struct v4l2_mbus_framefmt mbus_fmt; 1064 1065 rc = check_dev(dev); 1066 if (rc < 0) 1067 return rc; 1068 1069 vidioc_try_fmt_vid_cap(file, priv, f); 1070 1071 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1072 if (!fmt) 1073 return -EINVAL; 1074 1075 if (videobuf_queue_is_busy(&fh->vb_vidq)) { 1076 cx231xx_errdev("%s queue busy\n", __func__); 1077 return -EBUSY; 1078 } 1079 1080 if (dev->stream_on && !fh->stream_on) { 1081 cx231xx_errdev("%s device in use by another fh\n", __func__); 1082 return -EBUSY; 1083 } 1084 1085 /* set new image size */ 1086 dev->width = f->fmt.pix.width; 1087 dev->height = f->fmt.pix.height; 1088 dev->format = fmt; 1089 1090 v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED); 1091 call_all(dev, video, s_mbus_fmt, &mbus_fmt); 1092 v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt); 1093 1094 return rc; 1095 } 1096 1097 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id) 1098 { 1099 struct cx231xx_fh *fh = priv; 1100 struct cx231xx *dev = fh->dev; 1101 1102 *id = dev->norm; 1103 return 0; 1104 } 1105 1106 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm) 1107 { 1108 struct cx231xx_fh *fh = priv; 1109 struct cx231xx *dev = fh->dev; 1110 struct v4l2_mbus_framefmt mbus_fmt; 1111 struct v4l2_format f; 1112 int rc; 1113 1114 rc = check_dev(dev); 1115 if (rc < 0) 1116 return rc; 1117 1118 cx231xx_info("vidioc_s_std : 0x%x\n", (unsigned int)*norm); 1119 1120 dev->norm = *norm; 1121 1122 /* Adjusts width/height, if needed */ 1123 f.fmt.pix.width = dev->width; 1124 f.fmt.pix.height = dev->height; 1125 vidioc_try_fmt_vid_cap(file, priv, &f); 1126 1127 call_all(dev, core, s_std, dev->norm); 1128 1129 /* We need to reset basic properties in the decoder related to 1130 resolution (since a standard change effects things like the number 1131 of lines in VACT, etc) */ 1132 v4l2_fill_mbus_format(&mbus_fmt, &f.fmt.pix, V4L2_MBUS_FMT_FIXED); 1133 call_all(dev, video, s_mbus_fmt, &mbus_fmt); 1134 v4l2_fill_pix_format(&f.fmt.pix, &mbus_fmt); 1135 1136 /* set new image size */ 1137 dev->width = f.fmt.pix.width; 1138 dev->height = f.fmt.pix.height; 1139 1140 /* do mode control overrides */ 1141 cx231xx_do_mode_ctrl_overrides(dev); 1142 1143 return 0; 1144 } 1145 1146 static const char *iname[] = { 1147 [CX231XX_VMUX_COMPOSITE1] = "Composite1", 1148 [CX231XX_VMUX_SVIDEO] = "S-Video", 1149 [CX231XX_VMUX_TELEVISION] = "Television", 1150 [CX231XX_VMUX_CABLE] = "Cable TV", 1151 [CX231XX_VMUX_DVB] = "DVB", 1152 [CX231XX_VMUX_DEBUG] = "for debug only", 1153 }; 1154 1155 static int vidioc_enum_input(struct file *file, void *priv, 1156 struct v4l2_input *i) 1157 { 1158 struct cx231xx_fh *fh = priv; 1159 struct cx231xx *dev = fh->dev; 1160 u32 gen_stat; 1161 unsigned int ret, n; 1162 1163 n = i->index; 1164 if (n >= MAX_CX231XX_INPUT) 1165 return -EINVAL; 1166 if (0 == INPUT(n)->type) 1167 return -EINVAL; 1168 1169 i->index = n; 1170 i->type = V4L2_INPUT_TYPE_CAMERA; 1171 1172 strcpy(i->name, iname[INPUT(n)->type]); 1173 1174 if ((CX231XX_VMUX_TELEVISION == INPUT(n)->type) || 1175 (CX231XX_VMUX_CABLE == INPUT(n)->type)) 1176 i->type = V4L2_INPUT_TYPE_TUNER; 1177 1178 i->std = dev->vdev->tvnorms; 1179 1180 /* If they are asking about the active input, read signal status */ 1181 if (n == dev->video_input) { 1182 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS, 1183 GEN_STAT, 2, &gen_stat, 4); 1184 if (ret > 0) { 1185 if ((gen_stat & FLD_VPRES) == 0x00) 1186 i->status |= V4L2_IN_ST_NO_SIGNAL; 1187 if ((gen_stat & FLD_HLOCK) == 0x00) 1188 i->status |= V4L2_IN_ST_NO_H_LOCK; 1189 } 1190 } 1191 1192 return 0; 1193 } 1194 1195 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1196 { 1197 struct cx231xx_fh *fh = priv; 1198 struct cx231xx *dev = fh->dev; 1199 1200 *i = dev->video_input; 1201 1202 return 0; 1203 } 1204 1205 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1206 { 1207 struct cx231xx_fh *fh = priv; 1208 struct cx231xx *dev = fh->dev; 1209 int rc; 1210 1211 dev->mode_tv = 0; 1212 rc = check_dev(dev); 1213 if (rc < 0) 1214 return rc; 1215 1216 if (i >= MAX_CX231XX_INPUT) 1217 return -EINVAL; 1218 if (0 == INPUT(i)->type) 1219 return -EINVAL; 1220 1221 video_mux(dev, i); 1222 1223 if (INPUT(i)->type == CX231XX_VMUX_TELEVISION || 1224 INPUT(i)->type == CX231XX_VMUX_CABLE) { 1225 /* There's a tuner, so reset the standard and put it on the 1226 last known frequency (since it was probably powered down 1227 until now */ 1228 call_all(dev, core, s_std, dev->norm); 1229 } 1230 1231 return 0; 1232 } 1233 1234 static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 1235 { 1236 struct cx231xx_fh *fh = priv; 1237 struct cx231xx *dev = fh->dev; 1238 1239 switch (a->index) { 1240 case CX231XX_AMUX_VIDEO: 1241 strcpy(a->name, "Television"); 1242 break; 1243 case CX231XX_AMUX_LINE_IN: 1244 strcpy(a->name, "Line In"); 1245 break; 1246 default: 1247 return -EINVAL; 1248 } 1249 1250 a->index = dev->ctl_ainput; 1251 a->capability = V4L2_AUDCAP_STEREO; 1252 1253 return 0; 1254 } 1255 1256 static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio *a) 1257 { 1258 struct cx231xx_fh *fh = priv; 1259 struct cx231xx *dev = fh->dev; 1260 int status = 0; 1261 1262 /* Doesn't allow manual routing */ 1263 if (a->index != dev->ctl_ainput) 1264 return -EINVAL; 1265 1266 dev->ctl_ainput = INPUT(a->index)->amux; 1267 status = cx231xx_set_audio_input(dev, dev->ctl_ainput); 1268 1269 return status; 1270 } 1271 1272 static int vidioc_queryctrl(struct file *file, void *priv, 1273 struct v4l2_queryctrl *qc) 1274 { 1275 struct cx231xx_fh *fh = priv; 1276 struct cx231xx *dev = fh->dev; 1277 int id = qc->id; 1278 int i; 1279 int rc; 1280 1281 rc = check_dev(dev); 1282 if (rc < 0) 1283 return rc; 1284 1285 qc->id = v4l2_ctrl_next(ctrl_classes, qc->id); 1286 if (unlikely(qc->id == 0)) 1287 return -EINVAL; 1288 1289 memset(qc, 0, sizeof(*qc)); 1290 1291 qc->id = id; 1292 1293 if (qc->id < V4L2_CID_BASE || qc->id >= V4L2_CID_LASTP1) 1294 return -EINVAL; 1295 1296 for (i = 0; i < CX231XX_CTLS; i++) 1297 if (cx231xx_ctls[i].v.id == qc->id) 1298 break; 1299 1300 if (i == CX231XX_CTLS) { 1301 *qc = no_ctl; 1302 return 0; 1303 } 1304 *qc = cx231xx_ctls[i].v; 1305 1306 call_all(dev, core, queryctrl, qc); 1307 1308 if (qc->type) 1309 return 0; 1310 else 1311 return -EINVAL; 1312 } 1313 1314 static int vidioc_g_ctrl(struct file *file, void *priv, 1315 struct v4l2_control *ctrl) 1316 { 1317 struct cx231xx_fh *fh = priv; 1318 struct cx231xx *dev = fh->dev; 1319 int rc; 1320 1321 rc = check_dev(dev); 1322 if (rc < 0) 1323 return rc; 1324 1325 call_all(dev, core, g_ctrl, ctrl); 1326 return rc; 1327 } 1328 1329 static int vidioc_s_ctrl(struct file *file, void *priv, 1330 struct v4l2_control *ctrl) 1331 { 1332 struct cx231xx_fh *fh = priv; 1333 struct cx231xx *dev = fh->dev; 1334 int rc; 1335 1336 rc = check_dev(dev); 1337 if (rc < 0) 1338 return rc; 1339 1340 call_all(dev, core, s_ctrl, ctrl); 1341 return rc; 1342 } 1343 1344 static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 1345 { 1346 struct cx231xx_fh *fh = priv; 1347 struct cx231xx *dev = fh->dev; 1348 int rc; 1349 1350 rc = check_dev(dev); 1351 if (rc < 0) 1352 return rc; 1353 1354 if (0 != t->index) 1355 return -EINVAL; 1356 1357 strcpy(t->name, "Tuner"); 1358 1359 t->type = V4L2_TUNER_ANALOG_TV; 1360 t->capability = V4L2_TUNER_CAP_NORM; 1361 t->rangehigh = 0xffffffffUL; 1362 t->signal = 0xffff; /* LOCKED */ 1363 1364 return 0; 1365 } 1366 1367 static int vidioc_s_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 1368 { 1369 struct cx231xx_fh *fh = priv; 1370 struct cx231xx *dev = fh->dev; 1371 int rc; 1372 1373 rc = check_dev(dev); 1374 if (rc < 0) 1375 return rc; 1376 1377 if (0 != t->index) 1378 return -EINVAL; 1379 #if 0 1380 call_all(dev, tuner, s_tuner, t); 1381 #endif 1382 return 0; 1383 } 1384 1385 static int vidioc_g_frequency(struct file *file, void *priv, 1386 struct v4l2_frequency *f) 1387 { 1388 struct cx231xx_fh *fh = priv; 1389 struct cx231xx *dev = fh->dev; 1390 1391 f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; 1392 f->frequency = dev->ctl_freq; 1393 1394 call_all(dev, tuner, g_frequency, f); 1395 1396 return 0; 1397 } 1398 1399 static int vidioc_s_frequency(struct file *file, void *priv, 1400 struct v4l2_frequency *f) 1401 { 1402 struct cx231xx_fh *fh = priv; 1403 struct cx231xx *dev = fh->dev; 1404 int rc; 1405 u32 if_frequency = 5400000; 1406 1407 cx231xx_info("Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n", 1408 f->frequency, f->type); 1409 /*cx231xx_info("f->type: 1-radio 2-analogTV 3-digitalTV\n");*/ 1410 1411 rc = check_dev(dev); 1412 if (rc < 0) 1413 return rc; 1414 1415 if (0 != f->tuner) 1416 return -EINVAL; 1417 1418 if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV)) 1419 return -EINVAL; 1420 if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO)) 1421 return -EINVAL; 1422 1423 /* set pre channel change settings in DIF first */ 1424 rc = cx231xx_tuner_pre_channel_change(dev); 1425 1426 dev->ctl_freq = f->frequency; 1427 call_all(dev, tuner, s_frequency, f); 1428 1429 /* set post channel change settings in DIF first */ 1430 rc = cx231xx_tuner_post_channel_change(dev); 1431 1432 if (dev->tuner_type == TUNER_NXP_TDA18271) { 1433 if (dev->norm & (V4L2_STD_MN | V4L2_STD_NTSC_443)) 1434 if_frequency = 5400000; /*5.4MHz */ 1435 else if (dev->norm & V4L2_STD_B) 1436 if_frequency = 6000000; /*6.0MHz */ 1437 else if (dev->norm & (V4L2_STD_PAL_DK | V4L2_STD_SECAM_DK)) 1438 if_frequency = 6900000; /*6.9MHz */ 1439 else if (dev->norm & V4L2_STD_GH) 1440 if_frequency = 7100000; /*7.1MHz */ 1441 else if (dev->norm & V4L2_STD_PAL_I) 1442 if_frequency = 7250000; /*7.25MHz */ 1443 else if (dev->norm & V4L2_STD_SECAM_L) 1444 if_frequency = 6900000; /*6.9MHz */ 1445 else if (dev->norm & V4L2_STD_SECAM_LC) 1446 if_frequency = 1250000; /*1.25MHz */ 1447 1448 cx231xx_info("if_frequency is set to %d\n", if_frequency); 1449 cx231xx_set_Colibri_For_LowIF(dev, if_frequency, 1, 1); 1450 1451 update_HH_register_after_set_DIF(dev); 1452 } 1453 1454 cx231xx_info("Set New FREQUENCY to %d\n", f->frequency); 1455 1456 return rc; 1457 } 1458 1459 #ifdef CONFIG_VIDEO_ADV_DEBUG 1460 1461 /* 1462 -R, --list-registers=type=<host/i2cdrv/i2caddr>, 1463 chip=<chip>[,min=<addr>,max=<addr>] 1464 dump registers from <min> to <max> [VIDIOC_DBG_G_REGISTER] 1465 -r, --set-register=type=<host/i2cdrv/i2caddr>, 1466 chip=<chip>,reg=<addr>,val=<val> 1467 set the register [VIDIOC_DBG_S_REGISTER] 1468 1469 if type == host, then <chip> is the hosts chip ID (default 0) 1470 if type == i2cdrv (default), then <chip> is the I2C driver name or ID 1471 if type == i2caddr, then <chip> is the 7-bit I2C address 1472 */ 1473 1474 static int vidioc_g_register(struct file *file, void *priv, 1475 struct v4l2_dbg_register *reg) 1476 { 1477 struct cx231xx_fh *fh = priv; 1478 struct cx231xx *dev = fh->dev; 1479 int ret = 0; 1480 u8 value[4] = { 0, 0, 0, 0 }; 1481 u32 data = 0; 1482 1483 switch (reg->match.type) { 1484 case V4L2_CHIP_MATCH_HOST: 1485 switch (reg->match.addr) { 1486 case 0: /* Cx231xx - internal registers */ 1487 ret = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, 1488 (u16)reg->reg, value, 4); 1489 reg->val = value[0] | value[1] << 8 | 1490 value[2] << 16 | value[3] << 24; 1491 break; 1492 case 1: /* AFE - read byte */ 1493 ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS, 1494 (u16)reg->reg, 2, &data, 1); 1495 reg->val = le32_to_cpu(data & 0xff); 1496 break; 1497 case 14: /* AFE - read dword */ 1498 ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS, 1499 (u16)reg->reg, 2, &data, 4); 1500 reg->val = le32_to_cpu(data); 1501 break; 1502 case 2: /* Video Block - read byte */ 1503 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS, 1504 (u16)reg->reg, 2, &data, 1); 1505 reg->val = le32_to_cpu(data & 0xff); 1506 break; 1507 case 24: /* Video Block - read dword */ 1508 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS, 1509 (u16)reg->reg, 2, &data, 4); 1510 reg->val = le32_to_cpu(data); 1511 break; 1512 case 3: /* I2S block - read byte */ 1513 ret = cx231xx_read_i2c_data(dev, 1514 I2S_BLK_DEVICE_ADDRESS, 1515 (u16)reg->reg, 1, 1516 &data, 1); 1517 reg->val = le32_to_cpu(data & 0xff); 1518 break; 1519 case 34: /* I2S Block - read dword */ 1520 ret = 1521 cx231xx_read_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS, 1522 (u16)reg->reg, 1, &data, 4); 1523 reg->val = le32_to_cpu(data); 1524 break; 1525 } 1526 return ret < 0 ? ret : 0; 1527 1528 case V4L2_CHIP_MATCH_I2C_DRIVER: 1529 call_all(dev, core, g_register, reg); 1530 return 0; 1531 case V4L2_CHIP_MATCH_I2C_ADDR:/*for register debug*/ 1532 switch (reg->match.addr) { 1533 case 0: /* Cx231xx - internal registers */ 1534 ret = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, 1535 (u16)reg->reg, value, 4); 1536 reg->val = value[0] | value[1] << 8 | 1537 value[2] << 16 | value[3] << 24; 1538 1539 break; 1540 case 0x600:/* AFE - read byte */ 1541 ret = cx231xx_read_i2c_master(dev, AFE_DEVICE_ADDRESS, 1542 (u16)reg->reg, 2, 1543 &data, 1 , 0); 1544 reg->val = le32_to_cpu(data & 0xff); 1545 break; 1546 1547 case 0x880:/* Video Block - read byte */ 1548 if (reg->reg < 0x0b) { 1549 ret = cx231xx_read_i2c_master(dev, 1550 VID_BLK_I2C_ADDRESS, 1551 (u16)reg->reg, 2, 1552 &data, 1 , 0); 1553 reg->val = le32_to_cpu(data & 0xff); 1554 } else { 1555 ret = cx231xx_read_i2c_master(dev, 1556 VID_BLK_I2C_ADDRESS, 1557 (u16)reg->reg, 2, 1558 &data, 4 , 0); 1559 reg->val = le32_to_cpu(data); 1560 } 1561 break; 1562 case 0x980: 1563 ret = cx231xx_read_i2c_master(dev, 1564 I2S_BLK_DEVICE_ADDRESS, 1565 (u16)reg->reg, 1, 1566 &data, 1 , 0); 1567 reg->val = le32_to_cpu(data & 0xff); 1568 break; 1569 case 0x400: 1570 ret = 1571 cx231xx_read_i2c_master(dev, 0x40, 1572 (u16)reg->reg, 1, 1573 &data, 1 , 0); 1574 reg->val = le32_to_cpu(data & 0xff); 1575 break; 1576 case 0xc01: 1577 ret = 1578 cx231xx_read_i2c_master(dev, 0xc0, 1579 (u16)reg->reg, 2, 1580 &data, 38, 1); 1581 reg->val = le32_to_cpu(data); 1582 break; 1583 case 0x022: 1584 ret = 1585 cx231xx_read_i2c_master(dev, 0x02, 1586 (u16)reg->reg, 1, 1587 &data, 1, 2); 1588 reg->val = le32_to_cpu(data & 0xff); 1589 break; 1590 case 0x322: 1591 ret = cx231xx_read_i2c_master(dev, 1592 0x32, 1593 (u16)reg->reg, 1, 1594 &data, 4 , 2); 1595 reg->val = le32_to_cpu(data); 1596 break; 1597 case 0x342: 1598 ret = cx231xx_read_i2c_master(dev, 1599 0x34, 1600 (u16)reg->reg, 1, 1601 &data, 4 , 2); 1602 reg->val = le32_to_cpu(data); 1603 break; 1604 1605 default: 1606 cx231xx_info("no match device address!!\n"); 1607 break; 1608 } 1609 return ret < 0 ? ret : 0; 1610 /*return -EINVAL;*/ 1611 default: 1612 if (!v4l2_chip_match_host(®->match)) 1613 return -EINVAL; 1614 } 1615 1616 call_all(dev, core, g_register, reg); 1617 1618 return ret; 1619 } 1620 1621 static int vidioc_s_register(struct file *file, void *priv, 1622 struct v4l2_dbg_register *reg) 1623 { 1624 struct cx231xx_fh *fh = priv; 1625 struct cx231xx *dev = fh->dev; 1626 int ret = 0; 1627 __le64 buf; 1628 u32 value; 1629 u8 data[4] = { 0, 0, 0, 0 }; 1630 1631 buf = cpu_to_le64(reg->val); 1632 1633 switch (reg->match.type) { 1634 case V4L2_CHIP_MATCH_HOST: 1635 { 1636 value = (u32) buf & 0xffffffff; 1637 1638 switch (reg->match.addr) { 1639 case 0: /* cx231xx internal registers */ 1640 data[0] = (u8) value; 1641 data[1] = (u8) (value >> 8); 1642 data[2] = (u8) (value >> 16); 1643 data[3] = (u8) (value >> 24); 1644 ret = cx231xx_write_ctrl_reg(dev, 1645 VRT_SET_REGISTER, 1646 (u16)reg->reg, data, 1647 4); 1648 break; 1649 case 1: /* AFE - read byte */ 1650 ret = cx231xx_write_i2c_data(dev, 1651 AFE_DEVICE_ADDRESS, 1652 (u16)reg->reg, 2, 1653 value, 1); 1654 break; 1655 case 14: /* AFE - read dword */ 1656 ret = cx231xx_write_i2c_data(dev, 1657 AFE_DEVICE_ADDRESS, 1658 (u16)reg->reg, 2, 1659 value, 4); 1660 break; 1661 case 2: /* Video Block - read byte */ 1662 ret = 1663 cx231xx_write_i2c_data(dev, 1664 VID_BLK_I2C_ADDRESS, 1665 (u16)reg->reg, 2, 1666 value, 1); 1667 break; 1668 case 24: /* Video Block - read dword */ 1669 ret = 1670 cx231xx_write_i2c_data(dev, 1671 VID_BLK_I2C_ADDRESS, 1672 (u16)reg->reg, 2, 1673 value, 4); 1674 break; 1675 case 3: /* I2S block - read byte */ 1676 ret = 1677 cx231xx_write_i2c_data(dev, 1678 I2S_BLK_DEVICE_ADDRESS, 1679 (u16)reg->reg, 1, 1680 value, 1); 1681 break; 1682 case 34: /* I2S block - read dword */ 1683 ret = 1684 cx231xx_write_i2c_data(dev, 1685 I2S_BLK_DEVICE_ADDRESS, 1686 (u16)reg->reg, 1, 1687 value, 4); 1688 break; 1689 } 1690 } 1691 return ret < 0 ? ret : 0; 1692 case V4L2_CHIP_MATCH_I2C_ADDR: 1693 { 1694 value = (u32) buf & 0xffffffff; 1695 1696 switch (reg->match.addr) { 1697 case 0:/*cx231xx internal registers*/ 1698 data[0] = (u8) value; 1699 data[1] = (u8) (value >> 8); 1700 data[2] = (u8) (value >> 16); 1701 data[3] = (u8) (value >> 24); 1702 ret = cx231xx_write_ctrl_reg(dev, 1703 VRT_SET_REGISTER, 1704 (u16)reg->reg, data, 1705 4); 1706 break; 1707 case 0x600:/* AFE - read byte */ 1708 ret = cx231xx_write_i2c_master(dev, 1709 AFE_DEVICE_ADDRESS, 1710 (u16)reg->reg, 2, 1711 value, 1 , 0); 1712 break; 1713 1714 case 0x880:/* Video Block - read byte */ 1715 if (reg->reg < 0x0b) 1716 cx231xx_write_i2c_master(dev, 1717 VID_BLK_I2C_ADDRESS, 1718 (u16)reg->reg, 2, 1719 value, 1, 0); 1720 else 1721 cx231xx_write_i2c_master(dev, 1722 VID_BLK_I2C_ADDRESS, 1723 (u16)reg->reg, 2, 1724 value, 4, 0); 1725 break; 1726 case 0x980: 1727 ret = 1728 cx231xx_write_i2c_master(dev, 1729 I2S_BLK_DEVICE_ADDRESS, 1730 (u16)reg->reg, 1, 1731 value, 1, 0); 1732 break; 1733 case 0x400: 1734 ret = 1735 cx231xx_write_i2c_master(dev, 1736 0x40, 1737 (u16)reg->reg, 1, 1738 value, 1, 0); 1739 break; 1740 case 0xc01: 1741 ret = 1742 cx231xx_write_i2c_master(dev, 1743 0xc0, 1744 (u16)reg->reg, 1, 1745 value, 1, 1); 1746 break; 1747 1748 case 0x022: 1749 ret = 1750 cx231xx_write_i2c_master(dev, 1751 0x02, 1752 (u16)reg->reg, 1, 1753 value, 1, 2); 1754 case 0x322: 1755 ret = 1756 cx231xx_write_i2c_master(dev, 1757 0x32, 1758 (u16)reg->reg, 1, 1759 value, 4, 2); 1760 break; 1761 1762 case 0x342: 1763 ret = 1764 cx231xx_write_i2c_master(dev, 1765 0x34, 1766 (u16)reg->reg, 1, 1767 value, 4, 2); 1768 break; 1769 default: 1770 cx231xx_info("no match device address, " 1771 "the value is %x\n", reg->match.addr); 1772 break; 1773 1774 } 1775 1776 } 1777 default: 1778 break; 1779 } 1780 1781 call_all(dev, core, s_register, reg); 1782 1783 return ret; 1784 } 1785 #endif 1786 1787 static int vidioc_cropcap(struct file *file, void *priv, 1788 struct v4l2_cropcap *cc) 1789 { 1790 struct cx231xx_fh *fh = priv; 1791 struct cx231xx *dev = fh->dev; 1792 1793 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1794 return -EINVAL; 1795 1796 cc->bounds.left = 0; 1797 cc->bounds.top = 0; 1798 cc->bounds.width = dev->width; 1799 cc->bounds.height = dev->height; 1800 cc->defrect = cc->bounds; 1801 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */ 1802 cc->pixelaspect.denominator = 59; 1803 1804 return 0; 1805 } 1806 1807 static int vidioc_streamon(struct file *file, void *priv, 1808 enum v4l2_buf_type type) 1809 { 1810 struct cx231xx_fh *fh = priv; 1811 struct cx231xx *dev = fh->dev; 1812 int rc; 1813 1814 rc = check_dev(dev); 1815 if (rc < 0) 1816 return rc; 1817 1818 rc = res_get(fh); 1819 1820 if (likely(rc >= 0)) 1821 rc = videobuf_streamon(&fh->vb_vidq); 1822 1823 call_all(dev, video, s_stream, 1); 1824 1825 return rc; 1826 } 1827 1828 static int vidioc_streamoff(struct file *file, void *priv, 1829 enum v4l2_buf_type type) 1830 { 1831 struct cx231xx_fh *fh = priv; 1832 struct cx231xx *dev = fh->dev; 1833 int rc; 1834 1835 rc = check_dev(dev); 1836 if (rc < 0) 1837 return rc; 1838 1839 if ((fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 1840 (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)) 1841 return -EINVAL; 1842 if (type != fh->type) 1843 return -EINVAL; 1844 1845 cx25840_call(dev, video, s_stream, 0); 1846 1847 videobuf_streamoff(&fh->vb_vidq); 1848 res_free(fh); 1849 1850 return 0; 1851 } 1852 1853 static int vidioc_querycap(struct file *file, void *priv, 1854 struct v4l2_capability *cap) 1855 { 1856 struct cx231xx_fh *fh = priv; 1857 struct cx231xx *dev = fh->dev; 1858 1859 strlcpy(cap->driver, "cx231xx", sizeof(cap->driver)); 1860 strlcpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card)); 1861 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1862 1863 cap->capabilities = V4L2_CAP_VBI_CAPTURE | 1864 #if 0 1865 V4L2_CAP_SLICED_VBI_CAPTURE | 1866 #endif 1867 V4L2_CAP_VIDEO_CAPTURE | 1868 V4L2_CAP_AUDIO | 1869 V4L2_CAP_READWRITE | 1870 V4L2_CAP_STREAMING; 1871 1872 if (dev->tuner_type != TUNER_ABSENT) 1873 cap->capabilities |= V4L2_CAP_TUNER; 1874 1875 return 0; 1876 } 1877 1878 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1879 struct v4l2_fmtdesc *f) 1880 { 1881 if (unlikely(f->index >= ARRAY_SIZE(format))) 1882 return -EINVAL; 1883 1884 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1885 f->pixelformat = format[f->index].fourcc; 1886 1887 return 0; 1888 } 1889 1890 /* Sliced VBI ioctls */ 1891 static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv, 1892 struct v4l2_format *f) 1893 { 1894 struct cx231xx_fh *fh = priv; 1895 struct cx231xx *dev = fh->dev; 1896 int rc; 1897 1898 rc = check_dev(dev); 1899 if (rc < 0) 1900 return rc; 1901 1902 f->fmt.sliced.service_set = 0; 1903 1904 call_all(dev, vbi, g_sliced_fmt, &f->fmt.sliced); 1905 1906 if (f->fmt.sliced.service_set == 0) 1907 rc = -EINVAL; 1908 1909 return rc; 1910 } 1911 1912 static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv, 1913 struct v4l2_format *f) 1914 { 1915 struct cx231xx_fh *fh = priv; 1916 struct cx231xx *dev = fh->dev; 1917 int rc; 1918 1919 rc = check_dev(dev); 1920 if (rc < 0) 1921 return rc; 1922 1923 call_all(dev, vbi, g_sliced_fmt, &f->fmt.sliced); 1924 1925 if (f->fmt.sliced.service_set == 0) 1926 return -EINVAL; 1927 1928 return 0; 1929 } 1930 1931 /* RAW VBI ioctls */ 1932 1933 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1934 struct v4l2_format *f) 1935 { 1936 struct cx231xx_fh *fh = priv; 1937 struct cx231xx *dev = fh->dev; 1938 f->fmt.vbi.sampling_rate = 6750000 * 4; 1939 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH; 1940 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1941 f->fmt.vbi.offset = 0; 1942 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ? 1943 PAL_VBI_START_LINE : NTSC_VBI_START_LINE; 1944 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ? 1945 PAL_VBI_LINES : NTSC_VBI_LINES; 1946 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ? 1947 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263; 1948 f->fmt.vbi.count[1] = f->fmt.vbi.count[0]; 1949 1950 return 0; 1951 1952 } 1953 1954 static int vidioc_try_fmt_vbi_cap(struct file *file, void *priv, 1955 struct v4l2_format *f) 1956 { 1957 struct cx231xx_fh *fh = priv; 1958 struct cx231xx *dev = fh->dev; 1959 1960 if (dev->vbi_stream_on && !fh->stream_on) { 1961 cx231xx_errdev("%s device in use by another fh\n", __func__); 1962 return -EBUSY; 1963 } 1964 1965 f->type = V4L2_BUF_TYPE_VBI_CAPTURE; 1966 f->fmt.vbi.sampling_rate = 6750000 * 4; 1967 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH; 1968 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1969 f->fmt.vbi.offset = 0; 1970 f->fmt.vbi.flags = 0; 1971 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ? 1972 PAL_VBI_START_LINE : NTSC_VBI_START_LINE; 1973 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ? 1974 PAL_VBI_LINES : NTSC_VBI_LINES; 1975 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ? 1976 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263; 1977 f->fmt.vbi.count[1] = f->fmt.vbi.count[0]; 1978 1979 return 0; 1980 1981 } 1982 1983 static int vidioc_reqbufs(struct file *file, void *priv, 1984 struct v4l2_requestbuffers *rb) 1985 { 1986 struct cx231xx_fh *fh = priv; 1987 struct cx231xx *dev = fh->dev; 1988 int rc; 1989 1990 rc = check_dev(dev); 1991 if (rc < 0) 1992 return rc; 1993 1994 return videobuf_reqbufs(&fh->vb_vidq, rb); 1995 } 1996 1997 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *b) 1998 { 1999 struct cx231xx_fh *fh = priv; 2000 struct cx231xx *dev = fh->dev; 2001 int rc; 2002 2003 rc = check_dev(dev); 2004 if (rc < 0) 2005 return rc; 2006 2007 return videobuf_querybuf(&fh->vb_vidq, b); 2008 } 2009 2010 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2011 { 2012 struct cx231xx_fh *fh = priv; 2013 struct cx231xx *dev = fh->dev; 2014 int rc; 2015 2016 rc = check_dev(dev); 2017 if (rc < 0) 2018 return rc; 2019 2020 return videobuf_qbuf(&fh->vb_vidq, b); 2021 } 2022 2023 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2024 { 2025 struct cx231xx_fh *fh = priv; 2026 struct cx231xx *dev = fh->dev; 2027 int rc; 2028 2029 rc = check_dev(dev); 2030 if (rc < 0) 2031 return rc; 2032 2033 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK); 2034 } 2035 2036 /* ----------------------------------------------------------- */ 2037 /* RADIO ESPECIFIC IOCTLS */ 2038 /* ----------------------------------------------------------- */ 2039 2040 static int radio_querycap(struct file *file, void *priv, 2041 struct v4l2_capability *cap) 2042 { 2043 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2044 2045 strlcpy(cap->driver, "cx231xx", sizeof(cap->driver)); 2046 strlcpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card)); 2047 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 2048 2049 cap->capabilities = V4L2_CAP_TUNER; 2050 return 0; 2051 } 2052 2053 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2054 { 2055 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2056 2057 if (unlikely(t->index > 0)) 2058 return -EINVAL; 2059 2060 strcpy(t->name, "Radio"); 2061 t->type = V4L2_TUNER_RADIO; 2062 2063 call_all(dev, tuner, s_tuner, t); 2064 2065 return 0; 2066 } 2067 2068 static int radio_enum_input(struct file *file, void *priv, struct v4l2_input *i) 2069 { 2070 if (i->index != 0) 2071 return -EINVAL; 2072 strcpy(i->name, "Radio"); 2073 i->type = V4L2_INPUT_TYPE_TUNER; 2074 2075 return 0; 2076 } 2077 2078 static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 2079 { 2080 if (unlikely(a->index)) 2081 return -EINVAL; 2082 2083 strcpy(a->name, "Radio"); 2084 return 0; 2085 } 2086 2087 static int radio_s_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2088 { 2089 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2090 2091 if (0 != t->index) 2092 return -EINVAL; 2093 2094 call_all(dev, tuner, s_tuner, t); 2095 2096 return 0; 2097 } 2098 2099 static int radio_s_audio(struct file *file, void *fh, const struct v4l2_audio *a) 2100 { 2101 return 0; 2102 } 2103 2104 static int radio_s_input(struct file *file, void *fh, unsigned int i) 2105 { 2106 return 0; 2107 } 2108 2109 static int radio_queryctrl(struct file *file, void *priv, 2110 struct v4l2_queryctrl *c) 2111 { 2112 int i; 2113 2114 if (c->id < V4L2_CID_BASE || c->id >= V4L2_CID_LASTP1) 2115 return -EINVAL; 2116 if (c->id == V4L2_CID_AUDIO_MUTE) { 2117 for (i = 0; i < CX231XX_CTLS; i++) { 2118 if (cx231xx_ctls[i].v.id == c->id) 2119 break; 2120 } 2121 if (i == CX231XX_CTLS) 2122 return -EINVAL; 2123 *c = cx231xx_ctls[i].v; 2124 } else 2125 *c = no_ctl; 2126 return 0; 2127 } 2128 2129 /* 2130 * cx231xx_v4l2_open() 2131 * inits the device and starts isoc transfer 2132 */ 2133 static int cx231xx_v4l2_open(struct file *filp) 2134 { 2135 int errCode = 0, radio = 0; 2136 struct video_device *vdev = video_devdata(filp); 2137 struct cx231xx *dev = video_drvdata(filp); 2138 struct cx231xx_fh *fh; 2139 enum v4l2_buf_type fh_type = 0; 2140 2141 switch (vdev->vfl_type) { 2142 case VFL_TYPE_GRABBER: 2143 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2144 break; 2145 case VFL_TYPE_VBI: 2146 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 2147 break; 2148 case VFL_TYPE_RADIO: 2149 radio = 1; 2150 break; 2151 } 2152 2153 cx231xx_videodbg("open dev=%s type=%s users=%d\n", 2154 video_device_node_name(vdev), v4l2_type_names[fh_type], 2155 dev->users); 2156 2157 #if 0 2158 errCode = cx231xx_set_mode(dev, CX231XX_ANALOG_MODE); 2159 if (errCode < 0) { 2160 cx231xx_errdev 2161 ("Device locked on digital mode. Can't open analog\n"); 2162 return -EBUSY; 2163 } 2164 #endif 2165 2166 fh = kzalloc(sizeof(struct cx231xx_fh), GFP_KERNEL); 2167 if (!fh) { 2168 cx231xx_errdev("cx231xx-video.c: Out of memory?!\n"); 2169 return -ENOMEM; 2170 } 2171 if (mutex_lock_interruptible(&dev->lock)) { 2172 kfree(fh); 2173 return -ERESTARTSYS; 2174 } 2175 fh->dev = dev; 2176 fh->radio = radio; 2177 fh->type = fh_type; 2178 filp->private_data = fh; 2179 2180 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) { 2181 dev->width = norm_maxw(dev); 2182 dev->height = norm_maxh(dev); 2183 2184 /* Power up in Analog TV mode */ 2185 if (dev->board.external_av) 2186 cx231xx_set_power_mode(dev, 2187 POLARIS_AVMODE_ENXTERNAL_AV); 2188 else 2189 cx231xx_set_power_mode(dev, POLARIS_AVMODE_ANALOGT_TV); 2190 2191 #if 0 2192 cx231xx_set_mode(dev, CX231XX_ANALOG_MODE); 2193 #endif 2194 2195 /* set video alternate setting */ 2196 cx231xx_set_video_alternate(dev); 2197 2198 /* Needed, since GPIO might have disabled power of 2199 some i2c device */ 2200 cx231xx_config_i2c(dev); 2201 2202 /* device needs to be initialized before isoc transfer */ 2203 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input; 2204 2205 } 2206 if (fh->radio) { 2207 cx231xx_videodbg("video_open: setting radio device\n"); 2208 2209 /* cx231xx_start_radio(dev); */ 2210 2211 call_all(dev, tuner, s_radio); 2212 } 2213 2214 dev->users++; 2215 2216 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2217 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_video_qops, 2218 NULL, &dev->video_mode.slock, 2219 fh->type, V4L2_FIELD_INTERLACED, 2220 sizeof(struct cx231xx_buffer), 2221 fh, &dev->lock); 2222 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2223 /* Set the required alternate setting VBI interface works in 2224 Bulk mode only */ 2225 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 2226 2227 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_vbi_qops, 2228 NULL, &dev->vbi_mode.slock, 2229 fh->type, V4L2_FIELD_SEQ_TB, 2230 sizeof(struct cx231xx_buffer), 2231 fh, &dev->lock); 2232 } 2233 mutex_unlock(&dev->lock); 2234 2235 return errCode; 2236 } 2237 2238 /* 2239 * cx231xx_realease_resources() 2240 * unregisters the v4l2,i2c and usb devices 2241 * called when the device gets disconected or at module unload 2242 */ 2243 void cx231xx_release_analog_resources(struct cx231xx *dev) 2244 { 2245 2246 /*FIXME: I2C IR should be disconnected */ 2247 2248 if (dev->radio_dev) { 2249 if (video_is_registered(dev->radio_dev)) 2250 video_unregister_device(dev->radio_dev); 2251 else 2252 video_device_release(dev->radio_dev); 2253 dev->radio_dev = NULL; 2254 } 2255 if (dev->vbi_dev) { 2256 cx231xx_info("V4L2 device %s deregistered\n", 2257 video_device_node_name(dev->vbi_dev)); 2258 if (video_is_registered(dev->vbi_dev)) 2259 video_unregister_device(dev->vbi_dev); 2260 else 2261 video_device_release(dev->vbi_dev); 2262 dev->vbi_dev = NULL; 2263 } 2264 if (dev->vdev) { 2265 cx231xx_info("V4L2 device %s deregistered\n", 2266 video_device_node_name(dev->vdev)); 2267 2268 if (dev->board.has_417) 2269 cx231xx_417_unregister(dev); 2270 2271 if (video_is_registered(dev->vdev)) 2272 video_unregister_device(dev->vdev); 2273 else 2274 video_device_release(dev->vdev); 2275 dev->vdev = NULL; 2276 } 2277 } 2278 2279 /* 2280 * cx231xx_close() 2281 * stops streaming and deallocates all resources allocated by the v4l2 2282 * calls and ioctls 2283 */ 2284 static int cx231xx_close(struct file *filp) 2285 { 2286 struct cx231xx_fh *fh = filp->private_data; 2287 struct cx231xx *dev = fh->dev; 2288 2289 cx231xx_videodbg("users=%d\n", dev->users); 2290 2291 cx231xx_videodbg("users=%d\n", dev->users); 2292 if (res_check(fh)) 2293 res_free(fh); 2294 2295 /* 2296 * To workaround error number=-71 on EP0 for VideoGrabber, 2297 * need exclude following. 2298 * FIXME: It is probably safe to remove most of these, as we're 2299 * now avoiding the alternate setting for INDEX_VANC 2300 */ 2301 if (!dev->board.no_alt_vanc) 2302 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2303 videobuf_stop(&fh->vb_vidq); 2304 videobuf_mmap_free(&fh->vb_vidq); 2305 2306 /* the device is already disconnect, 2307 free the remaining resources */ 2308 if (dev->state & DEV_DISCONNECTED) { 2309 if (atomic_read(&dev->devlist_count) > 0) { 2310 cx231xx_release_resources(dev); 2311 fh->dev = NULL; 2312 return 0; 2313 } 2314 return 0; 2315 } 2316 2317 /* do this before setting alternate! */ 2318 cx231xx_uninit_vbi_isoc(dev); 2319 2320 /* set alternate 0 */ 2321 if (!dev->vbi_or_sliced_cc_mode) 2322 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 2323 else 2324 cx231xx_set_alt_setting(dev, INDEX_HANC, 0); 2325 2326 kfree(fh); 2327 dev->users--; 2328 wake_up_interruptible_nr(&dev->open, 1); 2329 return 0; 2330 } 2331 2332 dev->users--; 2333 if (!dev->users) { 2334 videobuf_stop(&fh->vb_vidq); 2335 videobuf_mmap_free(&fh->vb_vidq); 2336 2337 /* the device is already disconnect, 2338 free the remaining resources */ 2339 if (dev->state & DEV_DISCONNECTED) { 2340 cx231xx_release_resources(dev); 2341 fh->dev = NULL; 2342 return 0; 2343 } 2344 2345 /* Save some power by putting tuner to sleep */ 2346 call_all(dev, core, s_power, 0); 2347 2348 /* do this before setting alternate! */ 2349 if (dev->USE_ISO) 2350 cx231xx_uninit_isoc(dev); 2351 else 2352 cx231xx_uninit_bulk(dev); 2353 cx231xx_set_mode(dev, CX231XX_SUSPEND); 2354 2355 /* set alternate 0 */ 2356 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0); 2357 } 2358 kfree(fh); 2359 wake_up_interruptible_nr(&dev->open, 1); 2360 return 0; 2361 } 2362 2363 static int cx231xx_v4l2_close(struct file *filp) 2364 { 2365 struct cx231xx_fh *fh = filp->private_data; 2366 struct cx231xx *dev = fh->dev; 2367 int rc; 2368 2369 mutex_lock(&dev->lock); 2370 rc = cx231xx_close(filp); 2371 mutex_unlock(&dev->lock); 2372 return rc; 2373 } 2374 2375 /* 2376 * cx231xx_v4l2_read() 2377 * will allocate buffers when called for the first time 2378 */ 2379 static ssize_t 2380 cx231xx_v4l2_read(struct file *filp, char __user *buf, size_t count, 2381 loff_t *pos) 2382 { 2383 struct cx231xx_fh *fh = filp->private_data; 2384 struct cx231xx *dev = fh->dev; 2385 int rc; 2386 2387 rc = check_dev(dev); 2388 if (rc < 0) 2389 return rc; 2390 2391 if ((fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) || 2392 (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)) { 2393 rc = res_get(fh); 2394 2395 if (unlikely(rc < 0)) 2396 return rc; 2397 2398 if (mutex_lock_interruptible(&dev->lock)) 2399 return -ERESTARTSYS; 2400 rc = videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0, 2401 filp->f_flags & O_NONBLOCK); 2402 mutex_unlock(&dev->lock); 2403 return rc; 2404 } 2405 return 0; 2406 } 2407 2408 /* 2409 * cx231xx_v4l2_poll() 2410 * will allocate buffers when called for the first time 2411 */ 2412 static unsigned int cx231xx_v4l2_poll(struct file *filp, poll_table *wait) 2413 { 2414 struct cx231xx_fh *fh = filp->private_data; 2415 struct cx231xx *dev = fh->dev; 2416 int rc; 2417 2418 rc = check_dev(dev); 2419 if (rc < 0) 2420 return rc; 2421 2422 rc = res_get(fh); 2423 2424 if (unlikely(rc < 0)) 2425 return POLLERR; 2426 2427 if ((V4L2_BUF_TYPE_VIDEO_CAPTURE == fh->type) || 2428 (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)) { 2429 unsigned int res; 2430 2431 mutex_lock(&dev->lock); 2432 res = videobuf_poll_stream(filp, &fh->vb_vidq, wait); 2433 mutex_unlock(&dev->lock); 2434 return res; 2435 } 2436 return POLLERR; 2437 } 2438 2439 /* 2440 * cx231xx_v4l2_mmap() 2441 */ 2442 static int cx231xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma) 2443 { 2444 struct cx231xx_fh *fh = filp->private_data; 2445 struct cx231xx *dev = fh->dev; 2446 int rc; 2447 2448 rc = check_dev(dev); 2449 if (rc < 0) 2450 return rc; 2451 2452 rc = res_get(fh); 2453 2454 if (unlikely(rc < 0)) 2455 return rc; 2456 2457 if (mutex_lock_interruptible(&dev->lock)) 2458 return -ERESTARTSYS; 2459 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma); 2460 mutex_unlock(&dev->lock); 2461 2462 cx231xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n", 2463 (unsigned long)vma->vm_start, 2464 (unsigned long)vma->vm_end - 2465 (unsigned long)vma->vm_start, rc); 2466 2467 return rc; 2468 } 2469 2470 static const struct v4l2_file_operations cx231xx_v4l_fops = { 2471 .owner = THIS_MODULE, 2472 .open = cx231xx_v4l2_open, 2473 .release = cx231xx_v4l2_close, 2474 .read = cx231xx_v4l2_read, 2475 .poll = cx231xx_v4l2_poll, 2476 .mmap = cx231xx_v4l2_mmap, 2477 .unlocked_ioctl = video_ioctl2, 2478 }; 2479 2480 static const struct v4l2_ioctl_ops video_ioctl_ops = { 2481 .vidioc_querycap = vidioc_querycap, 2482 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2483 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2484 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2485 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2486 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2487 .vidioc_try_fmt_vbi_cap = vidioc_try_fmt_vbi_cap, 2488 .vidioc_s_fmt_vbi_cap = vidioc_try_fmt_vbi_cap, 2489 .vidioc_g_audio = vidioc_g_audio, 2490 .vidioc_s_audio = vidioc_s_audio, 2491 .vidioc_cropcap = vidioc_cropcap, 2492 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap, 2493 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap, 2494 .vidioc_reqbufs = vidioc_reqbufs, 2495 .vidioc_querybuf = vidioc_querybuf, 2496 .vidioc_qbuf = vidioc_qbuf, 2497 .vidioc_dqbuf = vidioc_dqbuf, 2498 .vidioc_s_std = vidioc_s_std, 2499 .vidioc_g_std = vidioc_g_std, 2500 .vidioc_enum_input = vidioc_enum_input, 2501 .vidioc_g_input = vidioc_g_input, 2502 .vidioc_s_input = vidioc_s_input, 2503 .vidioc_queryctrl = vidioc_queryctrl, 2504 .vidioc_g_ctrl = vidioc_g_ctrl, 2505 .vidioc_s_ctrl = vidioc_s_ctrl, 2506 .vidioc_streamon = vidioc_streamon, 2507 .vidioc_streamoff = vidioc_streamoff, 2508 .vidioc_g_tuner = vidioc_g_tuner, 2509 .vidioc_s_tuner = vidioc_s_tuner, 2510 .vidioc_g_frequency = vidioc_g_frequency, 2511 .vidioc_s_frequency = vidioc_s_frequency, 2512 #ifdef CONFIG_VIDEO_ADV_DEBUG 2513 .vidioc_g_register = vidioc_g_register, 2514 .vidioc_s_register = vidioc_s_register, 2515 #endif 2516 }; 2517 2518 static struct video_device cx231xx_vbi_template; 2519 2520 static const struct video_device cx231xx_video_template = { 2521 .fops = &cx231xx_v4l_fops, 2522 .release = video_device_release, 2523 .ioctl_ops = &video_ioctl_ops, 2524 .tvnorms = V4L2_STD_ALL, 2525 .current_norm = V4L2_STD_PAL, 2526 }; 2527 2528 static const struct v4l2_file_operations radio_fops = { 2529 .owner = THIS_MODULE, 2530 .open = cx231xx_v4l2_open, 2531 .release = cx231xx_v4l2_close, 2532 .ioctl = video_ioctl2, 2533 }; 2534 2535 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2536 .vidioc_querycap = radio_querycap, 2537 .vidioc_g_tuner = radio_g_tuner, 2538 .vidioc_enum_input = radio_enum_input, 2539 .vidioc_g_audio = radio_g_audio, 2540 .vidioc_s_tuner = radio_s_tuner, 2541 .vidioc_s_audio = radio_s_audio, 2542 .vidioc_s_input = radio_s_input, 2543 .vidioc_queryctrl = radio_queryctrl, 2544 .vidioc_g_ctrl = vidioc_g_ctrl, 2545 .vidioc_s_ctrl = vidioc_s_ctrl, 2546 .vidioc_g_frequency = vidioc_g_frequency, 2547 .vidioc_s_frequency = vidioc_s_frequency, 2548 #ifdef CONFIG_VIDEO_ADV_DEBUG 2549 .vidioc_g_register = vidioc_g_register, 2550 .vidioc_s_register = vidioc_s_register, 2551 #endif 2552 }; 2553 2554 static struct video_device cx231xx_radio_template = { 2555 .name = "cx231xx-radio", 2556 .fops = &radio_fops, 2557 .ioctl_ops = &radio_ioctl_ops, 2558 }; 2559 2560 /******************************** usb interface ******************************/ 2561 2562 static struct video_device *cx231xx_vdev_init(struct cx231xx *dev, 2563 const struct video_device 2564 *template, const char *type_name) 2565 { 2566 struct video_device *vfd; 2567 2568 vfd = video_device_alloc(); 2569 if (NULL == vfd) 2570 return NULL; 2571 2572 *vfd = *template; 2573 vfd->v4l2_dev = &dev->v4l2_dev; 2574 vfd->release = video_device_release; 2575 vfd->debug = video_debug; 2576 vfd->lock = &dev->lock; 2577 2578 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name); 2579 2580 video_set_drvdata(vfd, dev); 2581 return vfd; 2582 } 2583 2584 int cx231xx_register_analog_devices(struct cx231xx *dev) 2585 { 2586 int ret; 2587 2588 cx231xx_info("%s: v4l2 driver version %s\n", 2589 dev->name, CX231XX_VERSION); 2590 2591 /* set default norm */ 2592 /*dev->norm = cx231xx_video_template.current_norm; */ 2593 dev->width = norm_maxw(dev); 2594 dev->height = norm_maxh(dev); 2595 dev->interlaced = 0; 2596 2597 /* Analog specific initialization */ 2598 dev->format = &format[0]; 2599 2600 /* Set the initial input */ 2601 video_mux(dev, dev->video_input); 2602 2603 /* Audio defaults */ 2604 dev->mute = 1; 2605 dev->volume = 0x1f; 2606 2607 /* enable vbi capturing */ 2608 /* write code here... */ 2609 2610 /* allocate and fill video video_device struct */ 2611 dev->vdev = cx231xx_vdev_init(dev, &cx231xx_video_template, "video"); 2612 if (!dev->vdev) { 2613 cx231xx_errdev("cannot allocate video_device.\n"); 2614 return -ENODEV; 2615 } 2616 2617 /* register v4l2 video video_device */ 2618 ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER, 2619 video_nr[dev->devno]); 2620 if (ret) { 2621 cx231xx_errdev("unable to register video device (error=%i).\n", 2622 ret); 2623 return ret; 2624 } 2625 2626 cx231xx_info("%s/0: registered device %s [v4l2]\n", 2627 dev->name, video_device_node_name(dev->vdev)); 2628 2629 /* Initialize VBI template */ 2630 memcpy(&cx231xx_vbi_template, &cx231xx_video_template, 2631 sizeof(cx231xx_vbi_template)); 2632 strcpy(cx231xx_vbi_template.name, "cx231xx-vbi"); 2633 2634 /* Allocate and fill vbi video_device struct */ 2635 dev->vbi_dev = cx231xx_vdev_init(dev, &cx231xx_vbi_template, "vbi"); 2636 2637 /* register v4l2 vbi video_device */ 2638 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI, 2639 vbi_nr[dev->devno]); 2640 if (ret < 0) { 2641 cx231xx_errdev("unable to register vbi device\n"); 2642 return ret; 2643 } 2644 2645 cx231xx_info("%s/0: registered device %s\n", 2646 dev->name, video_device_node_name(dev->vbi_dev)); 2647 2648 if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) { 2649 dev->radio_dev = cx231xx_vdev_init(dev, &cx231xx_radio_template, 2650 "radio"); 2651 if (!dev->radio_dev) { 2652 cx231xx_errdev("cannot allocate video_device.\n"); 2653 return -ENODEV; 2654 } 2655 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO, 2656 radio_nr[dev->devno]); 2657 if (ret < 0) { 2658 cx231xx_errdev("can't register radio device\n"); 2659 return ret; 2660 } 2661 cx231xx_info("Registered radio device as %s\n", 2662 video_device_node_name(dev->radio_dev)); 2663 } 2664 2665 cx231xx_info("V4L2 device registered as %s and %s\n", 2666 video_device_node_name(dev->vdev), 2667 video_device_node_name(dev->vbi_dev)); 2668 2669 return 0; 2670 } 2671