cx231xx-video.c revision f62436a96a0678a4e8bc54e7b987be72977af9ce
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 57static unsigned int isoc_debug; 58module_param(isoc_debug, int, 0644); 59MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]"); 60 61#define cx231xx_isocdbg(fmt, arg...) \ 62do {\ 63 if (isoc_debug) { \ 64 printk(KERN_INFO "%s %s :"fmt, \ 65 dev->name, __func__ , ##arg); \ 66 } \ 67 } while (0) 68 69MODULE_AUTHOR(DRIVER_AUTHOR); 70MODULE_DESCRIPTION(DRIVER_DESC); 71MODULE_LICENSE("GPL"); 72MODULE_VERSION(CX231XX_VERSION); 73 74static unsigned int card[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 75static unsigned int video_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 76static unsigned int vbi_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 77static unsigned int radio_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET }; 78 79module_param_array(card, int, NULL, 0444); 80module_param_array(video_nr, int, NULL, 0444); 81module_param_array(vbi_nr, int, NULL, 0444); 82module_param_array(radio_nr, int, NULL, 0444); 83 84MODULE_PARM_DESC(card, "card type"); 85MODULE_PARM_DESC(video_nr, "video device numbers"); 86MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 87MODULE_PARM_DESC(radio_nr, "radio device numbers"); 88 89static unsigned int video_debug; 90module_param(video_debug, int, 0644); 91MODULE_PARM_DESC(video_debug, "enable debug messages [video]"); 92 93/* supported video standards */ 94static 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 108static const struct v4l2_queryctrl no_ctl = { 109 .name = "42", 110 .flags = V4L2_CTRL_FLAG_DISABLED, 111}; 112 113static 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}; 202static const int CX231XX_CTLS = ARRAY_SIZE(cx231xx_ctls); 203 204static 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 218static 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 */ 230static 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 v4l2_get_timestamp(&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 249static 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 */ 290static 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 */ 327static 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 424static 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 505u8 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 533u8 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 563u32 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 608u32 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 673void 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 705int 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 751void 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 762u8 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 778static int 779buffer_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 */ 795static 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 827static int 828buffer_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 881fail: 882 free_buffer(vq, buf); 883 return rc; 884} 885 886static 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 899static 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 912static 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 921void 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 */ 939static 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 964static int res_check(struct cx231xx_fh *fh) 965{ 966 return fh->stream_on; 967} 968 969static 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 981static 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 994static 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 1012static 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 1023static 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 1056static 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 1097static 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 1106static 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 1146static 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 1155static 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 1195static 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 1205static 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 1234static 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 1256static 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 1272static 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 1314static 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 1329static 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 1344static 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 1367static 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 1385static 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 1399static 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 1474static 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 1621static 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 break; 1755 case 0x322: 1756 ret = 1757 cx231xx_write_i2c_master(dev, 1758 0x32, 1759 (u16)reg->reg, 1, 1760 value, 4, 2); 1761 break; 1762 1763 case 0x342: 1764 ret = 1765 cx231xx_write_i2c_master(dev, 1766 0x34, 1767 (u16)reg->reg, 1, 1768 value, 4, 2); 1769 break; 1770 default: 1771 cx231xx_info("no match device address, " 1772 "the value is %x\n", reg->match.addr); 1773 break; 1774 1775 } 1776 1777 } 1778 default: 1779 break; 1780 } 1781 1782 call_all(dev, core, s_register, reg); 1783 1784 return ret; 1785} 1786#endif 1787 1788static int vidioc_cropcap(struct file *file, void *priv, 1789 struct v4l2_cropcap *cc) 1790{ 1791 struct cx231xx_fh *fh = priv; 1792 struct cx231xx *dev = fh->dev; 1793 1794 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1795 return -EINVAL; 1796 1797 cc->bounds.left = 0; 1798 cc->bounds.top = 0; 1799 cc->bounds.width = dev->width; 1800 cc->bounds.height = dev->height; 1801 cc->defrect = cc->bounds; 1802 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */ 1803 cc->pixelaspect.denominator = 59; 1804 1805 return 0; 1806} 1807 1808static int vidioc_streamon(struct file *file, void *priv, 1809 enum v4l2_buf_type type) 1810{ 1811 struct cx231xx_fh *fh = priv; 1812 struct cx231xx *dev = fh->dev; 1813 int rc; 1814 1815 rc = check_dev(dev); 1816 if (rc < 0) 1817 return rc; 1818 1819 rc = res_get(fh); 1820 1821 if (likely(rc >= 0)) 1822 rc = videobuf_streamon(&fh->vb_vidq); 1823 1824 call_all(dev, video, s_stream, 1); 1825 1826 return rc; 1827} 1828 1829static int vidioc_streamoff(struct file *file, void *priv, 1830 enum v4l2_buf_type type) 1831{ 1832 struct cx231xx_fh *fh = priv; 1833 struct cx231xx *dev = fh->dev; 1834 int rc; 1835 1836 rc = check_dev(dev); 1837 if (rc < 0) 1838 return rc; 1839 1840 if ((fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) && 1841 (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)) 1842 return -EINVAL; 1843 if (type != fh->type) 1844 return -EINVAL; 1845 1846 cx25840_call(dev, video, s_stream, 0); 1847 1848 videobuf_streamoff(&fh->vb_vidq); 1849 res_free(fh); 1850 1851 return 0; 1852} 1853 1854static int vidioc_querycap(struct file *file, void *priv, 1855 struct v4l2_capability *cap) 1856{ 1857 struct cx231xx_fh *fh = priv; 1858 struct cx231xx *dev = fh->dev; 1859 1860 strlcpy(cap->driver, "cx231xx", sizeof(cap->driver)); 1861 strlcpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card)); 1862 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 1863 1864 cap->capabilities = V4L2_CAP_VBI_CAPTURE | 1865#if 0 1866 V4L2_CAP_SLICED_VBI_CAPTURE | 1867#endif 1868 V4L2_CAP_VIDEO_CAPTURE | 1869 V4L2_CAP_AUDIO | 1870 V4L2_CAP_READWRITE | 1871 V4L2_CAP_STREAMING; 1872 1873 if (dev->tuner_type != TUNER_ABSENT) 1874 cap->capabilities |= V4L2_CAP_TUNER; 1875 1876 return 0; 1877} 1878 1879static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 1880 struct v4l2_fmtdesc *f) 1881{ 1882 if (unlikely(f->index >= ARRAY_SIZE(format))) 1883 return -EINVAL; 1884 1885 strlcpy(f->description, format[f->index].name, sizeof(f->description)); 1886 f->pixelformat = format[f->index].fourcc; 1887 1888 return 0; 1889} 1890 1891/* Sliced VBI ioctls */ 1892static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv, 1893 struct v4l2_format *f) 1894{ 1895 struct cx231xx_fh *fh = priv; 1896 struct cx231xx *dev = fh->dev; 1897 int rc; 1898 1899 rc = check_dev(dev); 1900 if (rc < 0) 1901 return rc; 1902 1903 f->fmt.sliced.service_set = 0; 1904 1905 call_all(dev, vbi, g_sliced_fmt, &f->fmt.sliced); 1906 1907 if (f->fmt.sliced.service_set == 0) 1908 rc = -EINVAL; 1909 1910 return rc; 1911} 1912 1913static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv, 1914 struct v4l2_format *f) 1915{ 1916 struct cx231xx_fh *fh = priv; 1917 struct cx231xx *dev = fh->dev; 1918 int rc; 1919 1920 rc = check_dev(dev); 1921 if (rc < 0) 1922 return rc; 1923 1924 call_all(dev, vbi, g_sliced_fmt, &f->fmt.sliced); 1925 1926 if (f->fmt.sliced.service_set == 0) 1927 return -EINVAL; 1928 1929 return 0; 1930} 1931 1932/* RAW VBI ioctls */ 1933 1934static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv, 1935 struct v4l2_format *f) 1936{ 1937 struct cx231xx_fh *fh = priv; 1938 struct cx231xx *dev = fh->dev; 1939 f->fmt.vbi.sampling_rate = 6750000 * 4; 1940 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH; 1941 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1942 f->fmt.vbi.offset = 0; 1943 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ? 1944 PAL_VBI_START_LINE : NTSC_VBI_START_LINE; 1945 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ? 1946 PAL_VBI_LINES : NTSC_VBI_LINES; 1947 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ? 1948 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263; 1949 f->fmt.vbi.count[1] = f->fmt.vbi.count[0]; 1950 1951 return 0; 1952 1953} 1954 1955static int vidioc_try_fmt_vbi_cap(struct file *file, void *priv, 1956 struct v4l2_format *f) 1957{ 1958 struct cx231xx_fh *fh = priv; 1959 struct cx231xx *dev = fh->dev; 1960 1961 if (dev->vbi_stream_on && !fh->stream_on) { 1962 cx231xx_errdev("%s device in use by another fh\n", __func__); 1963 return -EBUSY; 1964 } 1965 1966 f->type = V4L2_BUF_TYPE_VBI_CAPTURE; 1967 f->fmt.vbi.sampling_rate = 6750000 * 4; 1968 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH; 1969 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1970 f->fmt.vbi.offset = 0; 1971 f->fmt.vbi.flags = 0; 1972 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ? 1973 PAL_VBI_START_LINE : NTSC_VBI_START_LINE; 1974 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ? 1975 PAL_VBI_LINES : NTSC_VBI_LINES; 1976 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ? 1977 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263; 1978 f->fmt.vbi.count[1] = f->fmt.vbi.count[0]; 1979 1980 return 0; 1981 1982} 1983 1984static int vidioc_reqbufs(struct file *file, void *priv, 1985 struct v4l2_requestbuffers *rb) 1986{ 1987 struct cx231xx_fh *fh = priv; 1988 struct cx231xx *dev = fh->dev; 1989 int rc; 1990 1991 rc = check_dev(dev); 1992 if (rc < 0) 1993 return rc; 1994 1995 return videobuf_reqbufs(&fh->vb_vidq, rb); 1996} 1997 1998static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *b) 1999{ 2000 struct cx231xx_fh *fh = priv; 2001 struct cx231xx *dev = fh->dev; 2002 int rc; 2003 2004 rc = check_dev(dev); 2005 if (rc < 0) 2006 return rc; 2007 2008 return videobuf_querybuf(&fh->vb_vidq, b); 2009} 2010 2011static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2012{ 2013 struct cx231xx_fh *fh = priv; 2014 struct cx231xx *dev = fh->dev; 2015 int rc; 2016 2017 rc = check_dev(dev); 2018 if (rc < 0) 2019 return rc; 2020 2021 return videobuf_qbuf(&fh->vb_vidq, b); 2022} 2023 2024static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2025{ 2026 struct cx231xx_fh *fh = priv; 2027 struct cx231xx *dev = fh->dev; 2028 int rc; 2029 2030 rc = check_dev(dev); 2031 if (rc < 0) 2032 return rc; 2033 2034 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK); 2035} 2036 2037/* ----------------------------------------------------------- */ 2038/* RADIO ESPECIFIC IOCTLS */ 2039/* ----------------------------------------------------------- */ 2040 2041static int radio_querycap(struct file *file, void *priv, 2042 struct v4l2_capability *cap) 2043{ 2044 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2045 2046 strlcpy(cap->driver, "cx231xx", sizeof(cap->driver)); 2047 strlcpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card)); 2048 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 2049 2050 cap->capabilities = V4L2_CAP_TUNER; 2051 return 0; 2052} 2053 2054static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2055{ 2056 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2057 2058 if (unlikely(t->index > 0)) 2059 return -EINVAL; 2060 2061 strcpy(t->name, "Radio"); 2062 t->type = V4L2_TUNER_RADIO; 2063 2064 call_all(dev, tuner, s_tuner, t); 2065 2066 return 0; 2067} 2068 2069static int radio_enum_input(struct file *file, void *priv, struct v4l2_input *i) 2070{ 2071 if (i->index != 0) 2072 return -EINVAL; 2073 strcpy(i->name, "Radio"); 2074 i->type = V4L2_INPUT_TYPE_TUNER; 2075 2076 return 0; 2077} 2078 2079static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a) 2080{ 2081 if (unlikely(a->index)) 2082 return -EINVAL; 2083 2084 strcpy(a->name, "Radio"); 2085 return 0; 2086} 2087 2088static int radio_s_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2089{ 2090 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev; 2091 2092 if (0 != t->index) 2093 return -EINVAL; 2094 2095 call_all(dev, tuner, s_tuner, t); 2096 2097 return 0; 2098} 2099 2100static int radio_s_audio(struct file *file, void *fh, const struct v4l2_audio *a) 2101{ 2102 return 0; 2103} 2104 2105static int radio_s_input(struct file *file, void *fh, unsigned int i) 2106{ 2107 return 0; 2108} 2109 2110static int radio_queryctrl(struct file *file, void *priv, 2111 struct v4l2_queryctrl *c) 2112{ 2113 int i; 2114 2115 if (c->id < V4L2_CID_BASE || c->id >= V4L2_CID_LASTP1) 2116 return -EINVAL; 2117 if (c->id == V4L2_CID_AUDIO_MUTE) { 2118 for (i = 0; i < CX231XX_CTLS; i++) { 2119 if (cx231xx_ctls[i].v.id == c->id) 2120 break; 2121 } 2122 if (i == CX231XX_CTLS) 2123 return -EINVAL; 2124 *c = cx231xx_ctls[i].v; 2125 } else 2126 *c = no_ctl; 2127 return 0; 2128} 2129 2130/* 2131 * cx231xx_v4l2_open() 2132 * inits the device and starts isoc transfer 2133 */ 2134static int cx231xx_v4l2_open(struct file *filp) 2135{ 2136 int errCode = 0, radio = 0; 2137 struct video_device *vdev = video_devdata(filp); 2138 struct cx231xx *dev = video_drvdata(filp); 2139 struct cx231xx_fh *fh; 2140 enum v4l2_buf_type fh_type = 0; 2141 2142 switch (vdev->vfl_type) { 2143 case VFL_TYPE_GRABBER: 2144 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2145 break; 2146 case VFL_TYPE_VBI: 2147 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE; 2148 break; 2149 case VFL_TYPE_RADIO: 2150 radio = 1; 2151 break; 2152 } 2153 2154 cx231xx_videodbg("open dev=%s type=%s users=%d\n", 2155 video_device_node_name(vdev), v4l2_type_names[fh_type], 2156 dev->users); 2157 2158#if 0 2159 errCode = cx231xx_set_mode(dev, CX231XX_ANALOG_MODE); 2160 if (errCode < 0) { 2161 cx231xx_errdev 2162 ("Device locked on digital mode. Can't open analog\n"); 2163 return -EBUSY; 2164 } 2165#endif 2166 2167 fh = kzalloc(sizeof(struct cx231xx_fh), GFP_KERNEL); 2168 if (!fh) { 2169 cx231xx_errdev("cx231xx-video.c: Out of memory?!\n"); 2170 return -ENOMEM; 2171 } 2172 if (mutex_lock_interruptible(&dev->lock)) { 2173 kfree(fh); 2174 return -ERESTARTSYS; 2175 } 2176 fh->dev = dev; 2177 fh->radio = radio; 2178 fh->type = fh_type; 2179 filp->private_data = fh; 2180 2181 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) { 2182 dev->width = norm_maxw(dev); 2183 dev->height = norm_maxh(dev); 2184 2185 /* Power up in Analog TV mode */ 2186 if (dev->board.external_av) 2187 cx231xx_set_power_mode(dev, 2188 POLARIS_AVMODE_ENXTERNAL_AV); 2189 else 2190 cx231xx_set_power_mode(dev, POLARIS_AVMODE_ANALOGT_TV); 2191 2192#if 0 2193 cx231xx_set_mode(dev, CX231XX_ANALOG_MODE); 2194#endif 2195 2196 /* set video alternate setting */ 2197 cx231xx_set_video_alternate(dev); 2198 2199 /* Needed, since GPIO might have disabled power of 2200 some i2c device */ 2201 cx231xx_config_i2c(dev); 2202 2203 /* device needs to be initialized before isoc transfer */ 2204 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input; 2205 2206 } 2207 if (fh->radio) { 2208 cx231xx_videodbg("video_open: setting radio device\n"); 2209 2210 /* cx231xx_start_radio(dev); */ 2211 2212 call_all(dev, tuner, s_radio); 2213 } 2214 2215 dev->users++; 2216 2217 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 2218 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_video_qops, 2219 NULL, &dev->video_mode.slock, 2220 fh->type, V4L2_FIELD_INTERLACED, 2221 sizeof(struct cx231xx_buffer), 2222 fh, &dev->lock); 2223 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2224 /* Set the required alternate setting VBI interface works in 2225 Bulk mode only */ 2226 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 2227 2228 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_vbi_qops, 2229 NULL, &dev->vbi_mode.slock, 2230 fh->type, V4L2_FIELD_SEQ_TB, 2231 sizeof(struct cx231xx_buffer), 2232 fh, &dev->lock); 2233 } 2234 mutex_unlock(&dev->lock); 2235 2236 return errCode; 2237} 2238 2239/* 2240 * cx231xx_realease_resources() 2241 * unregisters the v4l2,i2c and usb devices 2242 * called when the device gets disconected or at module unload 2243*/ 2244void cx231xx_release_analog_resources(struct cx231xx *dev) 2245{ 2246 2247 /*FIXME: I2C IR should be disconnected */ 2248 2249 if (dev->radio_dev) { 2250 if (video_is_registered(dev->radio_dev)) 2251 video_unregister_device(dev->radio_dev); 2252 else 2253 video_device_release(dev->radio_dev); 2254 dev->radio_dev = NULL; 2255 } 2256 if (dev->vbi_dev) { 2257 cx231xx_info("V4L2 device %s deregistered\n", 2258 video_device_node_name(dev->vbi_dev)); 2259 if (video_is_registered(dev->vbi_dev)) 2260 video_unregister_device(dev->vbi_dev); 2261 else 2262 video_device_release(dev->vbi_dev); 2263 dev->vbi_dev = NULL; 2264 } 2265 if (dev->vdev) { 2266 cx231xx_info("V4L2 device %s deregistered\n", 2267 video_device_node_name(dev->vdev)); 2268 2269 if (dev->board.has_417) 2270 cx231xx_417_unregister(dev); 2271 2272 if (video_is_registered(dev->vdev)) 2273 video_unregister_device(dev->vdev); 2274 else 2275 video_device_release(dev->vdev); 2276 dev->vdev = NULL; 2277 } 2278} 2279 2280/* 2281 * cx231xx_close() 2282 * stops streaming and deallocates all resources allocated by the v4l2 2283 * calls and ioctls 2284 */ 2285static int cx231xx_close(struct file *filp) 2286{ 2287 struct cx231xx_fh *fh = filp->private_data; 2288 struct cx231xx *dev = fh->dev; 2289 2290 cx231xx_videodbg("users=%d\n", dev->users); 2291 2292 cx231xx_videodbg("users=%d\n", dev->users); 2293 if (res_check(fh)) 2294 res_free(fh); 2295 2296 /* 2297 * To workaround error number=-71 on EP0 for VideoGrabber, 2298 * need exclude following. 2299 * FIXME: It is probably safe to remove most of these, as we're 2300 * now avoiding the alternate setting for INDEX_VANC 2301 */ 2302 if (!dev->board.no_alt_vanc) 2303 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) { 2304 videobuf_stop(&fh->vb_vidq); 2305 videobuf_mmap_free(&fh->vb_vidq); 2306 2307 /* the device is already disconnect, 2308 free the remaining resources */ 2309 if (dev->state & DEV_DISCONNECTED) { 2310 if (atomic_read(&dev->devlist_count) > 0) { 2311 cx231xx_release_resources(dev); 2312 fh->dev = NULL; 2313 return 0; 2314 } 2315 return 0; 2316 } 2317 2318 /* do this before setting alternate! */ 2319 cx231xx_uninit_vbi_isoc(dev); 2320 2321 /* set alternate 0 */ 2322 if (!dev->vbi_or_sliced_cc_mode) 2323 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 2324 else 2325 cx231xx_set_alt_setting(dev, INDEX_HANC, 0); 2326 2327 kfree(fh); 2328 dev->users--; 2329 wake_up_interruptible_nr(&dev->open, 1); 2330 return 0; 2331 } 2332 2333 dev->users--; 2334 if (!dev->users) { 2335 videobuf_stop(&fh->vb_vidq); 2336 videobuf_mmap_free(&fh->vb_vidq); 2337 2338 /* the device is already disconnect, 2339 free the remaining resources */ 2340 if (dev->state & DEV_DISCONNECTED) { 2341 cx231xx_release_resources(dev); 2342 fh->dev = NULL; 2343 return 0; 2344 } 2345 2346 /* Save some power by putting tuner to sleep */ 2347 call_all(dev, core, s_power, 0); 2348 2349 /* do this before setting alternate! */ 2350 if (dev->USE_ISO) 2351 cx231xx_uninit_isoc(dev); 2352 else 2353 cx231xx_uninit_bulk(dev); 2354 cx231xx_set_mode(dev, CX231XX_SUSPEND); 2355 2356 /* set alternate 0 */ 2357 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0); 2358 } 2359 kfree(fh); 2360 wake_up_interruptible_nr(&dev->open, 1); 2361 return 0; 2362} 2363 2364static int cx231xx_v4l2_close(struct file *filp) 2365{ 2366 struct cx231xx_fh *fh = filp->private_data; 2367 struct cx231xx *dev = fh->dev; 2368 int rc; 2369 2370 mutex_lock(&dev->lock); 2371 rc = cx231xx_close(filp); 2372 mutex_unlock(&dev->lock); 2373 return rc; 2374} 2375 2376/* 2377 * cx231xx_v4l2_read() 2378 * will allocate buffers when called for the first time 2379 */ 2380static ssize_t 2381cx231xx_v4l2_read(struct file *filp, char __user *buf, size_t count, 2382 loff_t *pos) 2383{ 2384 struct cx231xx_fh *fh = filp->private_data; 2385 struct cx231xx *dev = fh->dev; 2386 int rc; 2387 2388 rc = check_dev(dev); 2389 if (rc < 0) 2390 return rc; 2391 2392 if ((fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) || 2393 (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)) { 2394 rc = res_get(fh); 2395 2396 if (unlikely(rc < 0)) 2397 return rc; 2398 2399 if (mutex_lock_interruptible(&dev->lock)) 2400 return -ERESTARTSYS; 2401 rc = videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0, 2402 filp->f_flags & O_NONBLOCK); 2403 mutex_unlock(&dev->lock); 2404 return rc; 2405 } 2406 return 0; 2407} 2408 2409/* 2410 * cx231xx_v4l2_poll() 2411 * will allocate buffers when called for the first time 2412 */ 2413static unsigned int cx231xx_v4l2_poll(struct file *filp, poll_table *wait) 2414{ 2415 struct cx231xx_fh *fh = filp->private_data; 2416 struct cx231xx *dev = fh->dev; 2417 int rc; 2418 2419 rc = check_dev(dev); 2420 if (rc < 0) 2421 return rc; 2422 2423 rc = res_get(fh); 2424 2425 if (unlikely(rc < 0)) 2426 return POLLERR; 2427 2428 if ((V4L2_BUF_TYPE_VIDEO_CAPTURE == fh->type) || 2429 (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)) { 2430 unsigned int res; 2431 2432 mutex_lock(&dev->lock); 2433 res = videobuf_poll_stream(filp, &fh->vb_vidq, wait); 2434 mutex_unlock(&dev->lock); 2435 return res; 2436 } 2437 return POLLERR; 2438} 2439 2440/* 2441 * cx231xx_v4l2_mmap() 2442 */ 2443static int cx231xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma) 2444{ 2445 struct cx231xx_fh *fh = filp->private_data; 2446 struct cx231xx *dev = fh->dev; 2447 int rc; 2448 2449 rc = check_dev(dev); 2450 if (rc < 0) 2451 return rc; 2452 2453 rc = res_get(fh); 2454 2455 if (unlikely(rc < 0)) 2456 return rc; 2457 2458 if (mutex_lock_interruptible(&dev->lock)) 2459 return -ERESTARTSYS; 2460 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma); 2461 mutex_unlock(&dev->lock); 2462 2463 cx231xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n", 2464 (unsigned long)vma->vm_start, 2465 (unsigned long)vma->vm_end - 2466 (unsigned long)vma->vm_start, rc); 2467 2468 return rc; 2469} 2470 2471static const struct v4l2_file_operations cx231xx_v4l_fops = { 2472 .owner = THIS_MODULE, 2473 .open = cx231xx_v4l2_open, 2474 .release = cx231xx_v4l2_close, 2475 .read = cx231xx_v4l2_read, 2476 .poll = cx231xx_v4l2_poll, 2477 .mmap = cx231xx_v4l2_mmap, 2478 .unlocked_ioctl = video_ioctl2, 2479}; 2480 2481static const struct v4l2_ioctl_ops video_ioctl_ops = { 2482 .vidioc_querycap = vidioc_querycap, 2483 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2484 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2485 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2486 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2487 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 2488 .vidioc_try_fmt_vbi_cap = vidioc_try_fmt_vbi_cap, 2489 .vidioc_s_fmt_vbi_cap = vidioc_try_fmt_vbi_cap, 2490 .vidioc_g_audio = vidioc_g_audio, 2491 .vidioc_s_audio = vidioc_s_audio, 2492 .vidioc_cropcap = vidioc_cropcap, 2493 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap, 2494 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap, 2495 .vidioc_reqbufs = vidioc_reqbufs, 2496 .vidioc_querybuf = vidioc_querybuf, 2497 .vidioc_qbuf = vidioc_qbuf, 2498 .vidioc_dqbuf = vidioc_dqbuf, 2499 .vidioc_s_std = vidioc_s_std, 2500 .vidioc_g_std = vidioc_g_std, 2501 .vidioc_enum_input = vidioc_enum_input, 2502 .vidioc_g_input = vidioc_g_input, 2503 .vidioc_s_input = vidioc_s_input, 2504 .vidioc_queryctrl = vidioc_queryctrl, 2505 .vidioc_g_ctrl = vidioc_g_ctrl, 2506 .vidioc_s_ctrl = vidioc_s_ctrl, 2507 .vidioc_streamon = vidioc_streamon, 2508 .vidioc_streamoff = vidioc_streamoff, 2509 .vidioc_g_tuner = vidioc_g_tuner, 2510 .vidioc_s_tuner = vidioc_s_tuner, 2511 .vidioc_g_frequency = vidioc_g_frequency, 2512 .vidioc_s_frequency = vidioc_s_frequency, 2513#ifdef CONFIG_VIDEO_ADV_DEBUG 2514 .vidioc_g_register = vidioc_g_register, 2515 .vidioc_s_register = vidioc_s_register, 2516#endif 2517}; 2518 2519static struct video_device cx231xx_vbi_template; 2520 2521static const struct video_device cx231xx_video_template = { 2522 .fops = &cx231xx_v4l_fops, 2523 .release = video_device_release, 2524 .ioctl_ops = &video_ioctl_ops, 2525 .tvnorms = V4L2_STD_ALL, 2526 .current_norm = V4L2_STD_PAL, 2527}; 2528 2529static const struct v4l2_file_operations radio_fops = { 2530 .owner = THIS_MODULE, 2531 .open = cx231xx_v4l2_open, 2532 .release = cx231xx_v4l2_close, 2533 .ioctl = video_ioctl2, 2534}; 2535 2536static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2537 .vidioc_querycap = radio_querycap, 2538 .vidioc_g_tuner = radio_g_tuner, 2539 .vidioc_enum_input = radio_enum_input, 2540 .vidioc_g_audio = radio_g_audio, 2541 .vidioc_s_tuner = radio_s_tuner, 2542 .vidioc_s_audio = radio_s_audio, 2543 .vidioc_s_input = radio_s_input, 2544 .vidioc_queryctrl = radio_queryctrl, 2545 .vidioc_g_ctrl = vidioc_g_ctrl, 2546 .vidioc_s_ctrl = vidioc_s_ctrl, 2547 .vidioc_g_frequency = vidioc_g_frequency, 2548 .vidioc_s_frequency = vidioc_s_frequency, 2549#ifdef CONFIG_VIDEO_ADV_DEBUG 2550 .vidioc_g_register = vidioc_g_register, 2551 .vidioc_s_register = vidioc_s_register, 2552#endif 2553}; 2554 2555static struct video_device cx231xx_radio_template = { 2556 .name = "cx231xx-radio", 2557 .fops = &radio_fops, 2558 .ioctl_ops = &radio_ioctl_ops, 2559}; 2560 2561/******************************** usb interface ******************************/ 2562 2563static struct video_device *cx231xx_vdev_init(struct cx231xx *dev, 2564 const struct video_device 2565 *template, const char *type_name) 2566{ 2567 struct video_device *vfd; 2568 2569 vfd = video_device_alloc(); 2570 if (NULL == vfd) 2571 return NULL; 2572 2573 *vfd = *template; 2574 vfd->v4l2_dev = &dev->v4l2_dev; 2575 vfd->release = video_device_release; 2576 vfd->debug = video_debug; 2577 vfd->lock = &dev->lock; 2578 2579 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name); 2580 2581 video_set_drvdata(vfd, dev); 2582 return vfd; 2583} 2584 2585int cx231xx_register_analog_devices(struct cx231xx *dev) 2586{ 2587 int ret; 2588 2589 cx231xx_info("%s: v4l2 driver version %s\n", 2590 dev->name, CX231XX_VERSION); 2591 2592 /* set default norm */ 2593 /*dev->norm = cx231xx_video_template.current_norm; */ 2594 dev->width = norm_maxw(dev); 2595 dev->height = norm_maxh(dev); 2596 dev->interlaced = 0; 2597 2598 /* Analog specific initialization */ 2599 dev->format = &format[0]; 2600 2601 /* Set the initial input */ 2602 video_mux(dev, dev->video_input); 2603 2604 /* Audio defaults */ 2605 dev->mute = 1; 2606 dev->volume = 0x1f; 2607 2608 /* enable vbi capturing */ 2609 /* write code here... */ 2610 2611 /* allocate and fill video video_device struct */ 2612 dev->vdev = cx231xx_vdev_init(dev, &cx231xx_video_template, "video"); 2613 if (!dev->vdev) { 2614 cx231xx_errdev("cannot allocate video_device.\n"); 2615 return -ENODEV; 2616 } 2617 2618 /* register v4l2 video video_device */ 2619 ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER, 2620 video_nr[dev->devno]); 2621 if (ret) { 2622 cx231xx_errdev("unable to register video device (error=%i).\n", 2623 ret); 2624 return ret; 2625 } 2626 2627 cx231xx_info("%s/0: registered device %s [v4l2]\n", 2628 dev->name, video_device_node_name(dev->vdev)); 2629 2630 /* Initialize VBI template */ 2631 cx231xx_vbi_template = cx231xx_video_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