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