1 /* 2 cx231xx-core.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 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/init.h> 24 #include <linux/list.h> 25 #include <linux/module.h> 26 #include <linux/slab.h> 27 #include <linux/usb.h> 28 #include <linux/vmalloc.h> 29 #include <media/v4l2-common.h> 30 #include <media/tuner.h> 31 32 #include "cx231xx.h" 33 #include "cx231xx-reg.h" 34 35 /* #define ENABLE_DEBUG_ISOC_FRAMES */ 36 37 static unsigned int core_debug; 38 module_param(core_debug, int, 0644); 39 MODULE_PARM_DESC(core_debug, "enable debug messages [core]"); 40 41 #define cx231xx_coredbg(fmt, arg...) do {\ 42 if (core_debug) \ 43 printk(KERN_INFO "%s %s :"fmt, \ 44 dev->name, __func__ , ##arg); } while (0) 45 46 static unsigned int reg_debug; 47 module_param(reg_debug, int, 0644); 48 MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]"); 49 50 static int alt = CX231XX_PINOUT; 51 module_param(alt, int, 0644); 52 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint"); 53 54 #define cx231xx_isocdbg(fmt, arg...) do {\ 55 if (core_debug) \ 56 printk(KERN_INFO "%s %s :"fmt, \ 57 dev->name, __func__ , ##arg); } while (0) 58 59 /***************************************************************** 60 * Device control list functions * 61 ******************************************************************/ 62 63 LIST_HEAD(cx231xx_devlist); 64 static DEFINE_MUTEX(cx231xx_devlist_mutex); 65 66 /* 67 * cx231xx_realease_resources() 68 * unregisters the v4l2,i2c and usb devices 69 * called when the device gets disconected or at module unload 70 */ 71 void cx231xx_remove_from_devlist(struct cx231xx *dev) 72 { 73 if (dev == NULL) 74 return; 75 if (dev->udev == NULL) 76 return; 77 78 if (atomic_read(&dev->devlist_count) > 0) { 79 mutex_lock(&cx231xx_devlist_mutex); 80 list_del(&dev->devlist); 81 atomic_dec(&dev->devlist_count); 82 mutex_unlock(&cx231xx_devlist_mutex); 83 } 84 }; 85 86 void cx231xx_add_into_devlist(struct cx231xx *dev) 87 { 88 mutex_lock(&cx231xx_devlist_mutex); 89 list_add_tail(&dev->devlist, &cx231xx_devlist); 90 atomic_inc(&dev->devlist_count); 91 mutex_unlock(&cx231xx_devlist_mutex); 92 }; 93 94 static LIST_HEAD(cx231xx_extension_devlist); 95 96 int cx231xx_register_extension(struct cx231xx_ops *ops) 97 { 98 struct cx231xx *dev = NULL; 99 100 mutex_lock(&cx231xx_devlist_mutex); 101 list_add_tail(&ops->next, &cx231xx_extension_devlist); 102 list_for_each_entry(dev, &cx231xx_devlist, devlist) 103 ops->init(dev); 104 105 printk(KERN_INFO DRIVER_NAME ": %s initialized\n", ops->name); 106 mutex_unlock(&cx231xx_devlist_mutex); 107 return 0; 108 } 109 EXPORT_SYMBOL(cx231xx_register_extension); 110 111 void cx231xx_unregister_extension(struct cx231xx_ops *ops) 112 { 113 struct cx231xx *dev = NULL; 114 115 mutex_lock(&cx231xx_devlist_mutex); 116 list_for_each_entry(dev, &cx231xx_devlist, devlist) 117 ops->fini(dev); 118 119 120 printk(KERN_INFO DRIVER_NAME ": %s removed\n", ops->name); 121 list_del(&ops->next); 122 mutex_unlock(&cx231xx_devlist_mutex); 123 } 124 EXPORT_SYMBOL(cx231xx_unregister_extension); 125 126 void cx231xx_init_extension(struct cx231xx *dev) 127 { 128 struct cx231xx_ops *ops = NULL; 129 130 mutex_lock(&cx231xx_devlist_mutex); 131 if (!list_empty(&cx231xx_extension_devlist)) { 132 list_for_each_entry(ops, &cx231xx_extension_devlist, next) { 133 if (ops->init) 134 ops->init(dev); 135 } 136 } 137 mutex_unlock(&cx231xx_devlist_mutex); 138 } 139 140 void cx231xx_close_extension(struct cx231xx *dev) 141 { 142 struct cx231xx_ops *ops = NULL; 143 144 mutex_lock(&cx231xx_devlist_mutex); 145 if (!list_empty(&cx231xx_extension_devlist)) { 146 list_for_each_entry(ops, &cx231xx_extension_devlist, next) { 147 if (ops->fini) 148 ops->fini(dev); 149 } 150 } 151 mutex_unlock(&cx231xx_devlist_mutex); 152 } 153 154 /**************************************************************** 155 * U S B related functions * 156 *****************************************************************/ 157 int cx231xx_send_usb_command(struct cx231xx_i2c *i2c_bus, 158 struct cx231xx_i2c_xfer_data *req_data) 159 { 160 int status = 0; 161 struct cx231xx *dev = i2c_bus->dev; 162 struct VENDOR_REQUEST_IN ven_req; 163 164 u8 saddr_len = 0; 165 u8 _i2c_period = 0; 166 u8 _i2c_nostop = 0; 167 u8 _i2c_reserve = 0; 168 169 if (dev->state & DEV_DISCONNECTED) 170 return -ENODEV; 171 172 /* Get the I2C period, nostop and reserve parameters */ 173 _i2c_period = i2c_bus->i2c_period; 174 _i2c_nostop = i2c_bus->i2c_nostop; 175 _i2c_reserve = i2c_bus->i2c_reserve; 176 177 saddr_len = req_data->saddr_len; 178 179 /* Set wValue */ 180 if (saddr_len == 1) /* need check saddr_len == 0 */ 181 ven_req.wValue = 182 req_data-> 183 dev_addr << 9 | _i2c_period << 4 | saddr_len << 2 | 184 _i2c_nostop << 1 | I2C_SYNC | _i2c_reserve << 6; 185 else 186 ven_req.wValue = 187 req_data-> 188 dev_addr << 9 | _i2c_period << 4 | saddr_len << 2 | 189 _i2c_nostop << 1 | I2C_SYNC | _i2c_reserve << 6; 190 191 /* set channel number */ 192 if (req_data->direction & I2C_M_RD) { 193 /* channel number, for read,spec required channel_num +4 */ 194 ven_req.bRequest = i2c_bus->nr + 4; 195 } else 196 ven_req.bRequest = i2c_bus->nr; /* channel number, */ 197 198 /* set index value */ 199 switch (saddr_len) { 200 case 0: 201 ven_req.wIndex = 0; /* need check */ 202 break; 203 case 1: 204 ven_req.wIndex = (req_data->saddr_dat & 0xff); 205 break; 206 case 2: 207 ven_req.wIndex = req_data->saddr_dat; 208 break; 209 } 210 211 /* set wLength value */ 212 ven_req.wLength = req_data->buf_size; 213 214 /* set bData value */ 215 ven_req.bData = 0; 216 217 /* set the direction */ 218 if (req_data->direction) { 219 ven_req.direction = USB_DIR_IN; 220 memset(req_data->p_buffer, 0x00, ven_req.wLength); 221 } else 222 ven_req.direction = USB_DIR_OUT; 223 224 /* set the buffer for read / write */ 225 ven_req.pBuff = req_data->p_buffer; 226 227 228 /* call common vendor command request */ 229 status = cx231xx_send_vendor_cmd(dev, &ven_req); 230 if (status < 0) { 231 cx231xx_info 232 ("UsbInterface::sendCommand, failed with status -%d\n", 233 status); 234 } 235 236 return status; 237 } 238 EXPORT_SYMBOL_GPL(cx231xx_send_usb_command); 239 240 /* 241 * Sends/Receives URB control messages, assuring to use a kalloced buffer 242 * for all operations (dev->urb_buf), to avoid using stacked buffers, as 243 * they aren't safe for usage with USB, due to DMA restrictions. 244 * Also implements the debug code for control URB's. 245 */ 246 static int __usb_control_msg(struct cx231xx *dev, unsigned int pipe, 247 __u8 request, __u8 requesttype, __u16 value, __u16 index, 248 void *data, __u16 size, int timeout) 249 { 250 int rc, i; 251 252 if (reg_debug) { 253 printk(KERN_DEBUG "%s: (pipe 0x%08x): " 254 "%s: %02x %02x %02x %02x %02x %02x %02x %02x ", 255 dev->name, 256 pipe, 257 (requesttype & USB_DIR_IN) ? "IN" : "OUT", 258 requesttype, 259 request, 260 value & 0xff, value >> 8, 261 index & 0xff, index >> 8, 262 size & 0xff, size >> 8); 263 if (!(requesttype & USB_DIR_IN)) { 264 printk(KERN_CONT ">>>"); 265 for (i = 0; i < size; i++) 266 printk(KERN_CONT " %02x", 267 ((unsigned char *)data)[i]); 268 } 269 } 270 271 /* Do the real call to usb_control_msg */ 272 mutex_lock(&dev->ctrl_urb_lock); 273 if (!(requesttype & USB_DIR_IN) && size) 274 memcpy(dev->urb_buf, data, size); 275 rc = usb_control_msg(dev->udev, pipe, request, requesttype, value, 276 index, dev->urb_buf, size, timeout); 277 if ((requesttype & USB_DIR_IN) && size) 278 memcpy(data, dev->urb_buf, size); 279 mutex_unlock(&dev->ctrl_urb_lock); 280 281 if (reg_debug) { 282 if (unlikely(rc < 0)) { 283 printk(KERN_CONT "FAILED!\n"); 284 return rc; 285 } 286 287 if ((requesttype & USB_DIR_IN)) { 288 printk(KERN_CONT "<<<"); 289 for (i = 0; i < size; i++) 290 printk(KERN_CONT " %02x", 291 ((unsigned char *)data)[i]); 292 } 293 printk(KERN_CONT "\n"); 294 } 295 296 return rc; 297 } 298 299 300 /* 301 * cx231xx_read_ctrl_reg() 302 * reads data from the usb device specifying bRequest and wValue 303 */ 304 int cx231xx_read_ctrl_reg(struct cx231xx *dev, u8 req, u16 reg, 305 char *buf, int len) 306 { 307 u8 val = 0; 308 int ret; 309 int pipe = usb_rcvctrlpipe(dev->udev, 0); 310 311 if (dev->state & DEV_DISCONNECTED) 312 return -ENODEV; 313 314 if (len > URB_MAX_CTRL_SIZE) 315 return -EINVAL; 316 317 switch (len) { 318 case 1: 319 val = ENABLE_ONE_BYTE; 320 break; 321 case 2: 322 val = ENABLE_TWE_BYTE; 323 break; 324 case 3: 325 val = ENABLE_THREE_BYTE; 326 break; 327 case 4: 328 val = ENABLE_FOUR_BYTE; 329 break; 330 default: 331 val = 0xFF; /* invalid option */ 332 } 333 334 if (val == 0xFF) 335 return -EINVAL; 336 337 ret = __usb_control_msg(dev, pipe, req, 338 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 339 val, reg, buf, len, HZ); 340 return ret; 341 } 342 343 int cx231xx_send_vendor_cmd(struct cx231xx *dev, 344 struct VENDOR_REQUEST_IN *ven_req) 345 { 346 int ret; 347 int pipe = 0; 348 int unsend_size = 0; 349 u8 *pdata; 350 351 if (dev->state & DEV_DISCONNECTED) 352 return -ENODEV; 353 354 if ((ven_req->wLength > URB_MAX_CTRL_SIZE)) 355 return -EINVAL; 356 357 if (ven_req->direction) 358 pipe = usb_rcvctrlpipe(dev->udev, 0); 359 else 360 pipe = usb_sndctrlpipe(dev->udev, 0); 361 362 /* 363 * If the cx23102 read more than 4 bytes with i2c bus, 364 * need chop to 4 byte per request 365 */ 366 if ((ven_req->wLength > 4) && ((ven_req->bRequest == 0x4) || 367 (ven_req->bRequest == 0x5) || 368 (ven_req->bRequest == 0x6))) { 369 unsend_size = 0; 370 pdata = ven_req->pBuff; 371 372 373 unsend_size = ven_req->wLength; 374 375 /* the first package */ 376 ven_req->wValue = ven_req->wValue & 0xFFFB; 377 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x2; 378 ret = __usb_control_msg(dev, pipe, ven_req->bRequest, 379 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 380 ven_req->wValue, ven_req->wIndex, pdata, 381 0x0004, HZ); 382 unsend_size = unsend_size - 4; 383 384 /* the middle package */ 385 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x42; 386 while (unsend_size - 4 > 0) { 387 pdata = pdata + 4; 388 ret = __usb_control_msg(dev, pipe, 389 ven_req->bRequest, 390 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 391 ven_req->wValue, ven_req->wIndex, pdata, 392 0x0004, HZ); 393 unsend_size = unsend_size - 4; 394 } 395 396 /* the last package */ 397 ven_req->wValue = (ven_req->wValue & 0xFFBD) | 0x40; 398 pdata = pdata + 4; 399 ret = __usb_control_msg(dev, pipe, ven_req->bRequest, 400 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 401 ven_req->wValue, ven_req->wIndex, pdata, 402 unsend_size, HZ); 403 } else { 404 ret = __usb_control_msg(dev, pipe, ven_req->bRequest, 405 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 406 ven_req->wValue, ven_req->wIndex, 407 ven_req->pBuff, ven_req->wLength, HZ); 408 } 409 410 return ret; 411 } 412 413 /* 414 * cx231xx_write_ctrl_reg() 415 * sends data to the usb device, specifying bRequest 416 */ 417 int cx231xx_write_ctrl_reg(struct cx231xx *dev, u8 req, u16 reg, char *buf, 418 int len) 419 { 420 u8 val = 0; 421 int ret; 422 int pipe = usb_sndctrlpipe(dev->udev, 0); 423 424 if (dev->state & DEV_DISCONNECTED) 425 return -ENODEV; 426 427 if ((len < 1) || (len > URB_MAX_CTRL_SIZE)) 428 return -EINVAL; 429 430 switch (len) { 431 case 1: 432 val = ENABLE_ONE_BYTE; 433 break; 434 case 2: 435 val = ENABLE_TWE_BYTE; 436 break; 437 case 3: 438 val = ENABLE_THREE_BYTE; 439 break; 440 case 4: 441 val = ENABLE_FOUR_BYTE; 442 break; 443 default: 444 val = 0xFF; /* invalid option */ 445 } 446 447 if (val == 0xFF) 448 return -EINVAL; 449 450 if (reg_debug) { 451 int byte; 452 453 cx231xx_isocdbg("(pipe 0x%08x): " 454 "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>", 455 pipe, 456 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 457 req, 0, val, reg & 0xff, 458 reg >> 8, len & 0xff, len >> 8); 459 460 for (byte = 0; byte < len; byte++) 461 cx231xx_isocdbg(" %02x", (unsigned char)buf[byte]); 462 cx231xx_isocdbg("\n"); 463 } 464 465 ret = __usb_control_msg(dev, pipe, req, 466 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 467 val, reg, buf, len, HZ); 468 469 return ret; 470 } 471 472 /**************************************************************** 473 * USB Alternate Setting functions * 474 *****************************************************************/ 475 476 int cx231xx_set_video_alternate(struct cx231xx *dev) 477 { 478 int errCode, prev_alt = dev->video_mode.alt; 479 unsigned int min_pkt_size = dev->width * 2 + 4; 480 u32 usb_interface_index = 0; 481 482 /* When image size is bigger than a certain value, 483 the frame size should be increased, otherwise, only 484 green screen will be received. 485 */ 486 if (dev->width * 2 * dev->height > 720 * 240 * 2) 487 min_pkt_size *= 2; 488 489 if (dev->width > 360) { 490 /* resolutions: 720,704,640 */ 491 dev->video_mode.alt = 3; 492 } else if (dev->width > 180) { 493 /* resolutions: 360,352,320,240 */ 494 dev->video_mode.alt = 2; 495 } else if (dev->width > 0) { 496 /* resolutions: 180,176,160,128,88 */ 497 dev->video_mode.alt = 1; 498 } else { 499 /* Change to alt0 BULK to release USB bandwidth */ 500 dev->video_mode.alt = 0; 501 } 502 503 if (dev->USE_ISO == 0) 504 dev->video_mode.alt = 0; 505 506 cx231xx_coredbg("dev->video_mode.alt= %d\n", dev->video_mode.alt); 507 508 /* Get the correct video interface Index */ 509 usb_interface_index = 510 dev->current_pcb_config.hs_config_info[0].interface_info. 511 video_index + 1; 512 513 if (dev->video_mode.alt != prev_alt) { 514 cx231xx_coredbg("minimum isoc packet size: %u (alt=%d)\n", 515 min_pkt_size, dev->video_mode.alt); 516 517 if (dev->video_mode.alt_max_pkt_size != NULL) 518 dev->video_mode.max_pkt_size = 519 dev->video_mode.alt_max_pkt_size[dev->video_mode.alt]; 520 cx231xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n", 521 dev->video_mode.alt, 522 dev->video_mode.max_pkt_size); 523 errCode = 524 usb_set_interface(dev->udev, usb_interface_index, 525 dev->video_mode.alt); 526 if (errCode < 0) { 527 cx231xx_errdev 528 ("cannot change alt number to %d (error=%i)\n", 529 dev->video_mode.alt, errCode); 530 return errCode; 531 } 532 } 533 return 0; 534 } 535 536 int cx231xx_set_alt_setting(struct cx231xx *dev, u8 index, u8 alt) 537 { 538 int status = 0; 539 u32 usb_interface_index = 0; 540 u32 max_pkt_size = 0; 541 542 switch (index) { 543 case INDEX_TS1: 544 usb_interface_index = 545 dev->current_pcb_config.hs_config_info[0].interface_info. 546 ts1_index + 1; 547 dev->ts1_mode.alt = alt; 548 if (dev->ts1_mode.alt_max_pkt_size != NULL) 549 max_pkt_size = dev->ts1_mode.max_pkt_size = 550 dev->ts1_mode.alt_max_pkt_size[dev->ts1_mode.alt]; 551 break; 552 case INDEX_TS2: 553 usb_interface_index = 554 dev->current_pcb_config.hs_config_info[0].interface_info. 555 ts2_index + 1; 556 break; 557 case INDEX_AUDIO: 558 usb_interface_index = 559 dev->current_pcb_config.hs_config_info[0].interface_info. 560 audio_index + 1; 561 dev->adev.alt = alt; 562 if (dev->adev.alt_max_pkt_size != NULL) 563 max_pkt_size = dev->adev.max_pkt_size = 564 dev->adev.alt_max_pkt_size[dev->adev.alt]; 565 break; 566 case INDEX_VIDEO: 567 usb_interface_index = 568 dev->current_pcb_config.hs_config_info[0].interface_info. 569 video_index + 1; 570 dev->video_mode.alt = alt; 571 if (dev->video_mode.alt_max_pkt_size != NULL) 572 max_pkt_size = dev->video_mode.max_pkt_size = 573 dev->video_mode.alt_max_pkt_size[dev->video_mode. 574 alt]; 575 break; 576 case INDEX_VANC: 577 if (dev->board.no_alt_vanc) 578 return 0; 579 usb_interface_index = 580 dev->current_pcb_config.hs_config_info[0].interface_info. 581 vanc_index + 1; 582 dev->vbi_mode.alt = alt; 583 if (dev->vbi_mode.alt_max_pkt_size != NULL) 584 max_pkt_size = dev->vbi_mode.max_pkt_size = 585 dev->vbi_mode.alt_max_pkt_size[dev->vbi_mode.alt]; 586 break; 587 case INDEX_HANC: 588 usb_interface_index = 589 dev->current_pcb_config.hs_config_info[0].interface_info. 590 hanc_index + 1; 591 dev->sliced_cc_mode.alt = alt; 592 if (dev->sliced_cc_mode.alt_max_pkt_size != NULL) 593 max_pkt_size = dev->sliced_cc_mode.max_pkt_size = 594 dev->sliced_cc_mode.alt_max_pkt_size[dev-> 595 sliced_cc_mode. 596 alt]; 597 break; 598 default: 599 break; 600 } 601 602 if (alt > 0 && max_pkt_size == 0) { 603 cx231xx_errdev 604 ("can't change interface %d alt no. to %d: Max. Pkt size = 0\n", 605 usb_interface_index, alt); 606 /*To workaround error number=-71 on EP0 for videograbber, 607 need add following codes.*/ 608 if (dev->board.no_alt_vanc) 609 return -1; 610 } 611 612 cx231xx_coredbg("setting alternate %d with wMaxPacketSize=%u," 613 "Interface = %d\n", alt, max_pkt_size, 614 usb_interface_index); 615 616 if (usb_interface_index > 0) { 617 status = usb_set_interface(dev->udev, usb_interface_index, alt); 618 if (status < 0) { 619 cx231xx_errdev 620 ("can't change interface %d alt no. to %d (err=%i)\n", 621 usb_interface_index, alt, status); 622 return status; 623 } 624 } 625 626 return status; 627 } 628 EXPORT_SYMBOL_GPL(cx231xx_set_alt_setting); 629 630 int cx231xx_gpio_set(struct cx231xx *dev, struct cx231xx_reg_seq *gpio) 631 { 632 int rc = 0; 633 634 if (!gpio) 635 return rc; 636 637 /* Send GPIO reset sequences specified at board entry */ 638 while (gpio->sleep >= 0) { 639 rc = cx231xx_set_gpio_value(dev, gpio->bit, gpio->val); 640 if (rc < 0) 641 return rc; 642 643 if (gpio->sleep > 0) 644 msleep(gpio->sleep); 645 646 gpio++; 647 } 648 return rc; 649 } 650 651 int cx231xx_demod_reset(struct cx231xx *dev) 652 { 653 654 u8 status = 0; 655 u8 value[4] = { 0, 0, 0, 0 }; 656 657 status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, 658 value, 4); 659 660 cx231xx_coredbg("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN, 661 value[0], value[1], value[2], value[3]); 662 663 cx231xx_coredbg("Enter cx231xx_demod_reset()\n"); 664 665 value[1] = (u8) 0x3; 666 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 667 PWR_CTL_EN, value, 4); 668 msleep(10); 669 670 value[1] = (u8) 0x0; 671 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 672 PWR_CTL_EN, value, 4); 673 msleep(10); 674 675 value[1] = (u8) 0x3; 676 status = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 677 PWR_CTL_EN, value, 4); 678 msleep(10); 679 680 681 682 status = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, PWR_CTL_EN, 683 value, 4); 684 685 cx231xx_coredbg("reg0x%x=0x%x 0x%x 0x%x 0x%x\n", PWR_CTL_EN, 686 value[0], value[1], value[2], value[3]); 687 688 return status; 689 } 690 EXPORT_SYMBOL_GPL(cx231xx_demod_reset); 691 int is_fw_load(struct cx231xx *dev) 692 { 693 return cx231xx_check_fw(dev); 694 } 695 EXPORT_SYMBOL_GPL(is_fw_load); 696 697 int cx231xx_set_mode(struct cx231xx *dev, enum cx231xx_mode set_mode) 698 { 699 int errCode = 0; 700 701 if (dev->mode == set_mode) 702 return 0; 703 704 if (set_mode == CX231XX_SUSPEND) { 705 /* Set the chip in power saving mode */ 706 dev->mode = set_mode; 707 } 708 709 /* Resource is locked */ 710 if (dev->mode != CX231XX_SUSPEND) 711 return -EINVAL; 712 713 dev->mode = set_mode; 714 715 if (dev->mode == CX231XX_DIGITAL_MODE)/* Set Digital power mode */ { 716 /* set AGC mode to Digital */ 717 switch (dev->model) { 718 case CX231XX_BOARD_CNXT_CARRAERA: 719 case CX231XX_BOARD_CNXT_RDE_250: 720 case CX231XX_BOARD_CNXT_SHELBY: 721 case CX231XX_BOARD_CNXT_RDU_250: 722 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0); 723 break; 724 case CX231XX_BOARD_CNXT_RDE_253S: 725 case CX231XX_BOARD_CNXT_RDU_253S: 726 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1); 727 break; 728 case CX231XX_BOARD_HAUPPAUGE_EXETER: 729 errCode = cx231xx_set_power_mode(dev, 730 POLARIS_AVMODE_DIGITAL); 731 break; 732 default: 733 break; 734 } 735 } else/* Set Analog Power mode */ { 736 /* set AGC mode to Analog */ 737 switch (dev->model) { 738 case CX231XX_BOARD_CNXT_CARRAERA: 739 case CX231XX_BOARD_CNXT_RDE_250: 740 case CX231XX_BOARD_CNXT_SHELBY: 741 case CX231XX_BOARD_CNXT_RDU_250: 742 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1); 743 break; 744 case CX231XX_BOARD_CNXT_RDE_253S: 745 case CX231XX_BOARD_CNXT_RDU_253S: 746 case CX231XX_BOARD_HAUPPAUGE_EXETER: 747 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID: 748 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL: 749 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC: 750 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0); 751 break; 752 default: 753 break; 754 } 755 } 756 757 return errCode ? -EINVAL : 0; 758 } 759 EXPORT_SYMBOL_GPL(cx231xx_set_mode); 760 761 int cx231xx_ep5_bulkout(struct cx231xx *dev, u8 *firmware, u16 size) 762 { 763 int errCode = 0; 764 int actlen, ret = -ENOMEM; 765 u32 *buffer; 766 767 buffer = kzalloc(4096, GFP_KERNEL); 768 if (buffer == NULL) { 769 cx231xx_info("out of mem\n"); 770 return -ENOMEM; 771 } 772 memcpy(&buffer[0], firmware, 4096); 773 774 ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 5), 775 buffer, 4096, &actlen, 2000); 776 777 if (ret) 778 cx231xx_info("bulk message failed: %d (%d/%d)", ret, 779 size, actlen); 780 else { 781 errCode = actlen != size ? -1 : 0; 782 } 783 kfree(buffer); 784 return errCode; 785 } 786 787 /***************************************************************** 788 * URB Streaming functions * 789 ******************************************************************/ 790 791 /* 792 * IRQ callback, called by URB callback 793 */ 794 static void cx231xx_isoc_irq_callback(struct urb *urb) 795 { 796 struct cx231xx_dmaqueue *dma_q = urb->context; 797 struct cx231xx_video_mode *vmode = 798 container_of(dma_q, struct cx231xx_video_mode, vidq); 799 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode); 800 int i; 801 802 switch (urb->status) { 803 case 0: /* success */ 804 case -ETIMEDOUT: /* NAK */ 805 break; 806 case -ECONNRESET: /* kill */ 807 case -ENOENT: 808 case -ESHUTDOWN: 809 return; 810 default: /* error */ 811 cx231xx_isocdbg("urb completition error %d.\n", urb->status); 812 break; 813 } 814 815 /* Copy data from URB */ 816 spin_lock(&dev->video_mode.slock); 817 dev->video_mode.isoc_ctl.isoc_copy(dev, urb); 818 spin_unlock(&dev->video_mode.slock); 819 820 /* Reset urb buffers */ 821 for (i = 0; i < urb->number_of_packets; i++) { 822 urb->iso_frame_desc[i].status = 0; 823 urb->iso_frame_desc[i].actual_length = 0; 824 } 825 826 urb->status = usb_submit_urb(urb, GFP_ATOMIC); 827 if (urb->status) { 828 cx231xx_isocdbg("urb resubmit failed (error=%i)\n", 829 urb->status); 830 } 831 } 832 /***************************************************************** 833 * URB Streaming functions * 834 ******************************************************************/ 835 836 /* 837 * IRQ callback, called by URB callback 838 */ 839 static void cx231xx_bulk_irq_callback(struct urb *urb) 840 { 841 struct cx231xx_dmaqueue *dma_q = urb->context; 842 struct cx231xx_video_mode *vmode = 843 container_of(dma_q, struct cx231xx_video_mode, vidq); 844 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode); 845 846 switch (urb->status) { 847 case 0: /* success */ 848 case -ETIMEDOUT: /* NAK */ 849 break; 850 case -ECONNRESET: /* kill */ 851 case -ENOENT: 852 case -ESHUTDOWN: 853 return; 854 default: /* error */ 855 cx231xx_isocdbg("urb completition error %d.\n", urb->status); 856 break; 857 } 858 859 /* Copy data from URB */ 860 spin_lock(&dev->video_mode.slock); 861 dev->video_mode.bulk_ctl.bulk_copy(dev, urb); 862 spin_unlock(&dev->video_mode.slock); 863 864 /* Reset urb buffers */ 865 urb->status = usb_submit_urb(urb, GFP_ATOMIC); 866 if (urb->status) { 867 cx231xx_isocdbg("urb resubmit failed (error=%i)\n", 868 urb->status); 869 } 870 } 871 /* 872 * Stop and Deallocate URBs 873 */ 874 void cx231xx_uninit_isoc(struct cx231xx *dev) 875 { 876 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 877 struct urb *urb; 878 int i; 879 880 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_isoc\n"); 881 882 dev->video_mode.isoc_ctl.nfields = -1; 883 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 884 urb = dev->video_mode.isoc_ctl.urb[i]; 885 if (urb) { 886 if (!irqs_disabled()) 887 usb_kill_urb(urb); 888 else 889 usb_unlink_urb(urb); 890 891 if (dev->video_mode.isoc_ctl.transfer_buffer[i]) { 892 usb_free_coherent(dev->udev, 893 urb->transfer_buffer_length, 894 dev->video_mode.isoc_ctl. 895 transfer_buffer[i], 896 urb->transfer_dma); 897 } 898 usb_free_urb(urb); 899 dev->video_mode.isoc_ctl.urb[i] = NULL; 900 } 901 dev->video_mode.isoc_ctl.transfer_buffer[i] = NULL; 902 } 903 904 kfree(dev->video_mode.isoc_ctl.urb); 905 kfree(dev->video_mode.isoc_ctl.transfer_buffer); 906 kfree(dma_q->p_left_data); 907 908 dev->video_mode.isoc_ctl.urb = NULL; 909 dev->video_mode.isoc_ctl.transfer_buffer = NULL; 910 dev->video_mode.isoc_ctl.num_bufs = 0; 911 dma_q->p_left_data = NULL; 912 913 if (dev->mode_tv == 0) 914 cx231xx_capture_start(dev, 0, Raw_Video); 915 else 916 cx231xx_capture_start(dev, 0, TS1_serial_mode); 917 918 919 } 920 EXPORT_SYMBOL_GPL(cx231xx_uninit_isoc); 921 922 /* 923 * Stop and Deallocate URBs 924 */ 925 void cx231xx_uninit_bulk(struct cx231xx *dev) 926 { 927 struct urb *urb; 928 int i; 929 930 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_bulk\n"); 931 932 dev->video_mode.bulk_ctl.nfields = -1; 933 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 934 urb = dev->video_mode.bulk_ctl.urb[i]; 935 if (urb) { 936 if (!irqs_disabled()) 937 usb_kill_urb(urb); 938 else 939 usb_unlink_urb(urb); 940 941 if (dev->video_mode.bulk_ctl.transfer_buffer[i]) { 942 usb_free_coherent(dev->udev, 943 urb->transfer_buffer_length, 944 dev->video_mode.isoc_ctl. 945 transfer_buffer[i], 946 urb->transfer_dma); 947 } 948 usb_free_urb(urb); 949 dev->video_mode.bulk_ctl.urb[i] = NULL; 950 } 951 dev->video_mode.bulk_ctl.transfer_buffer[i] = NULL; 952 } 953 954 kfree(dev->video_mode.bulk_ctl.urb); 955 kfree(dev->video_mode.bulk_ctl.transfer_buffer); 956 957 dev->video_mode.bulk_ctl.urb = NULL; 958 dev->video_mode.bulk_ctl.transfer_buffer = NULL; 959 dev->video_mode.bulk_ctl.num_bufs = 0; 960 961 if (dev->mode_tv == 0) 962 cx231xx_capture_start(dev, 0, Raw_Video); 963 else 964 cx231xx_capture_start(dev, 0, TS1_serial_mode); 965 966 967 } 968 EXPORT_SYMBOL_GPL(cx231xx_uninit_bulk); 969 970 /* 971 * Allocate URBs and start IRQ 972 */ 973 int cx231xx_init_isoc(struct cx231xx *dev, int max_packets, 974 int num_bufs, int max_pkt_size, 975 int (*isoc_copy) (struct cx231xx *dev, struct urb *urb)) 976 { 977 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 978 int i; 979 int sb_size, pipe; 980 struct urb *urb; 981 int j, k; 982 int rc; 983 984 /* De-allocates all pending stuff */ 985 cx231xx_uninit_isoc(dev); 986 987 dma_q->p_left_data = kzalloc(4096, GFP_KERNEL); 988 if (dma_q->p_left_data == NULL) { 989 cx231xx_info("out of mem\n"); 990 return -ENOMEM; 991 } 992 993 994 995 dev->video_mode.isoc_ctl.isoc_copy = isoc_copy; 996 dev->video_mode.isoc_ctl.num_bufs = num_bufs; 997 dma_q->pos = 0; 998 dma_q->is_partial_line = 0; 999 dma_q->last_sav = 0; 1000 dma_q->current_field = -1; 1001 dma_q->field1_done = 0; 1002 dma_q->lines_per_field = dev->height / 2; 1003 dma_q->bytes_left_in_line = dev->width << 1; 1004 dma_q->lines_completed = 0; 1005 dma_q->mpeg_buffer_done = 0; 1006 dma_q->left_data_count = 0; 1007 dma_q->mpeg_buffer_completed = 0; 1008 dma_q->add_ps_package_head = CX231XX_NEED_ADD_PS_PACKAGE_HEAD; 1009 dma_q->ps_head[0] = 0x00; 1010 dma_q->ps_head[1] = 0x00; 1011 dma_q->ps_head[2] = 0x01; 1012 dma_q->ps_head[3] = 0xBA; 1013 for (i = 0; i < 8; i++) 1014 dma_q->partial_buf[i] = 0; 1015 1016 dev->video_mode.isoc_ctl.urb = 1017 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1018 if (!dev->video_mode.isoc_ctl.urb) { 1019 cx231xx_errdev("cannot alloc memory for usb buffers\n"); 1020 return -ENOMEM; 1021 } 1022 1023 dev->video_mode.isoc_ctl.transfer_buffer = 1024 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1025 if (!dev->video_mode.isoc_ctl.transfer_buffer) { 1026 cx231xx_errdev("cannot allocate memory for usbtransfer\n"); 1027 kfree(dev->video_mode.isoc_ctl.urb); 1028 return -ENOMEM; 1029 } 1030 1031 dev->video_mode.isoc_ctl.max_pkt_size = max_pkt_size; 1032 dev->video_mode.isoc_ctl.buf = NULL; 1033 1034 sb_size = max_packets * dev->video_mode.isoc_ctl.max_pkt_size; 1035 1036 if (dev->mode_tv == 1) 1037 dev->video_mode.end_point_addr = 0x81; 1038 else 1039 dev->video_mode.end_point_addr = 0x84; 1040 1041 1042 /* allocate urbs and transfer buffers */ 1043 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 1044 urb = usb_alloc_urb(max_packets, GFP_KERNEL); 1045 if (!urb) { 1046 cx231xx_err("cannot alloc isoc_ctl.urb %i\n", i); 1047 cx231xx_uninit_isoc(dev); 1048 return -ENOMEM; 1049 } 1050 dev->video_mode.isoc_ctl.urb[i] = urb; 1051 1052 dev->video_mode.isoc_ctl.transfer_buffer[i] = 1053 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL, 1054 &urb->transfer_dma); 1055 if (!dev->video_mode.isoc_ctl.transfer_buffer[i]) { 1056 cx231xx_err("unable to allocate %i bytes for transfer" 1057 " buffer %i%s\n", 1058 sb_size, i, 1059 in_interrupt() ? " while in int" : ""); 1060 cx231xx_uninit_isoc(dev); 1061 return -ENOMEM; 1062 } 1063 memset(dev->video_mode.isoc_ctl.transfer_buffer[i], 0, sb_size); 1064 1065 pipe = 1066 usb_rcvisocpipe(dev->udev, dev->video_mode.end_point_addr); 1067 1068 usb_fill_int_urb(urb, dev->udev, pipe, 1069 dev->video_mode.isoc_ctl.transfer_buffer[i], 1070 sb_size, cx231xx_isoc_irq_callback, dma_q, 1); 1071 1072 urb->number_of_packets = max_packets; 1073 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 1074 1075 k = 0; 1076 for (j = 0; j < max_packets; j++) { 1077 urb->iso_frame_desc[j].offset = k; 1078 urb->iso_frame_desc[j].length = 1079 dev->video_mode.isoc_ctl.max_pkt_size; 1080 k += dev->video_mode.isoc_ctl.max_pkt_size; 1081 } 1082 } 1083 1084 init_waitqueue_head(&dma_q->wq); 1085 1086 /* submit urbs and enables IRQ */ 1087 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 1088 rc = usb_submit_urb(dev->video_mode.isoc_ctl.urb[i], 1089 GFP_ATOMIC); 1090 if (rc) { 1091 cx231xx_err("submit of urb %i failed (error=%i)\n", i, 1092 rc); 1093 cx231xx_uninit_isoc(dev); 1094 return rc; 1095 } 1096 } 1097 1098 if (dev->mode_tv == 0) 1099 cx231xx_capture_start(dev, 1, Raw_Video); 1100 else 1101 cx231xx_capture_start(dev, 1, TS1_serial_mode); 1102 1103 return 0; 1104 } 1105 EXPORT_SYMBOL_GPL(cx231xx_init_isoc); 1106 1107 /* 1108 * Allocate URBs and start IRQ 1109 */ 1110 int cx231xx_init_bulk(struct cx231xx *dev, int max_packets, 1111 int num_bufs, int max_pkt_size, 1112 int (*bulk_copy) (struct cx231xx *dev, struct urb *urb)) 1113 { 1114 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 1115 int i; 1116 int sb_size, pipe; 1117 struct urb *urb; 1118 int rc; 1119 1120 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input; 1121 1122 cx231xx_coredbg("Setting Video mux to %d\n", dev->video_input); 1123 1124 video_mux(dev, dev->video_input); 1125 1126 /* De-allocates all pending stuff */ 1127 cx231xx_uninit_bulk(dev); 1128 1129 dev->video_mode.bulk_ctl.bulk_copy = bulk_copy; 1130 dev->video_mode.bulk_ctl.num_bufs = num_bufs; 1131 dma_q->pos = 0; 1132 dma_q->is_partial_line = 0; 1133 dma_q->last_sav = 0; 1134 dma_q->current_field = -1; 1135 dma_q->field1_done = 0; 1136 dma_q->lines_per_field = dev->height / 2; 1137 dma_q->bytes_left_in_line = dev->width << 1; 1138 dma_q->lines_completed = 0; 1139 dma_q->mpeg_buffer_done = 0; 1140 dma_q->left_data_count = 0; 1141 dma_q->mpeg_buffer_completed = 0; 1142 dma_q->ps_head[0] = 0x00; 1143 dma_q->ps_head[1] = 0x00; 1144 dma_q->ps_head[2] = 0x01; 1145 dma_q->ps_head[3] = 0xBA; 1146 for (i = 0; i < 8; i++) 1147 dma_q->partial_buf[i] = 0; 1148 1149 dev->video_mode.bulk_ctl.urb = 1150 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1151 if (!dev->video_mode.bulk_ctl.urb) { 1152 cx231xx_errdev("cannot alloc memory for usb buffers\n"); 1153 return -ENOMEM; 1154 } 1155 1156 dev->video_mode.bulk_ctl.transfer_buffer = 1157 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1158 if (!dev->video_mode.bulk_ctl.transfer_buffer) { 1159 cx231xx_errdev("cannot allocate memory for usbtransfer\n"); 1160 kfree(dev->video_mode.bulk_ctl.urb); 1161 return -ENOMEM; 1162 } 1163 1164 dev->video_mode.bulk_ctl.max_pkt_size = max_pkt_size; 1165 dev->video_mode.bulk_ctl.buf = NULL; 1166 1167 sb_size = max_packets * dev->video_mode.bulk_ctl.max_pkt_size; 1168 1169 if (dev->mode_tv == 1) 1170 dev->video_mode.end_point_addr = 0x81; 1171 else 1172 dev->video_mode.end_point_addr = 0x84; 1173 1174 1175 /* allocate urbs and transfer buffers */ 1176 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 1177 urb = usb_alloc_urb(0, GFP_KERNEL); 1178 if (!urb) { 1179 cx231xx_err("cannot alloc bulk_ctl.urb %i\n", i); 1180 cx231xx_uninit_bulk(dev); 1181 return -ENOMEM; 1182 } 1183 dev->video_mode.bulk_ctl.urb[i] = urb; 1184 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 1185 1186 dev->video_mode.bulk_ctl.transfer_buffer[i] = 1187 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL, 1188 &urb->transfer_dma); 1189 if (!dev->video_mode.bulk_ctl.transfer_buffer[i]) { 1190 cx231xx_err("unable to allocate %i bytes for transfer" 1191 " buffer %i%s\n", 1192 sb_size, i, 1193 in_interrupt() ? " while in int" : ""); 1194 cx231xx_uninit_bulk(dev); 1195 return -ENOMEM; 1196 } 1197 memset(dev->video_mode.bulk_ctl.transfer_buffer[i], 0, sb_size); 1198 1199 pipe = usb_rcvbulkpipe(dev->udev, 1200 dev->video_mode.end_point_addr); 1201 usb_fill_bulk_urb(urb, dev->udev, pipe, 1202 dev->video_mode.bulk_ctl.transfer_buffer[i], 1203 sb_size, cx231xx_bulk_irq_callback, dma_q); 1204 } 1205 1206 init_waitqueue_head(&dma_q->wq); 1207 1208 /* submit urbs and enables IRQ */ 1209 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 1210 rc = usb_submit_urb(dev->video_mode.bulk_ctl.urb[i], 1211 GFP_ATOMIC); 1212 if (rc) { 1213 cx231xx_err("submit of urb %i failed (error=%i)\n", i, 1214 rc); 1215 cx231xx_uninit_bulk(dev); 1216 return rc; 1217 } 1218 } 1219 1220 if (dev->mode_tv == 0) 1221 cx231xx_capture_start(dev, 1, Raw_Video); 1222 else 1223 cx231xx_capture_start(dev, 1, TS1_serial_mode); 1224 1225 return 0; 1226 } 1227 EXPORT_SYMBOL_GPL(cx231xx_init_bulk); 1228 void cx231xx_stop_TS1(struct cx231xx *dev) 1229 { 1230 u8 val[4] = { 0, 0, 0, 0 }; 1231 1232 val[0] = 0x00; 1233 val[1] = 0x03; 1234 val[2] = 0x00; 1235 val[3] = 0x00; 1236 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1237 TS_MODE_REG, val, 4); 1238 1239 val[0] = 0x00; 1240 val[1] = 0x70; 1241 val[2] = 0x04; 1242 val[3] = 0x00; 1243 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1244 TS1_CFG_REG, val, 4); 1245 } 1246 /* EXPORT_SYMBOL_GPL(cx231xx_stop_TS1); */ 1247 void cx231xx_start_TS1(struct cx231xx *dev) 1248 { 1249 u8 val[4] = { 0, 0, 0, 0 }; 1250 1251 val[0] = 0x03; 1252 val[1] = 0x03; 1253 val[2] = 0x00; 1254 val[3] = 0x00; 1255 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1256 TS_MODE_REG, val, 4); 1257 1258 val[0] = 0x04; 1259 val[1] = 0xA3; 1260 val[2] = 0x3B; 1261 val[3] = 0x00; 1262 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1263 TS1_CFG_REG, val, 4); 1264 } 1265 /* EXPORT_SYMBOL_GPL(cx231xx_start_TS1); */ 1266 /***************************************************************** 1267 * Device Init/UnInit functions * 1268 ******************************************************************/ 1269 int cx231xx_dev_init(struct cx231xx *dev) 1270 { 1271 int errCode = 0; 1272 1273 /* Initialize I2C bus */ 1274 1275 /* External Master 1 Bus */ 1276 dev->i2c_bus[0].nr = 0; 1277 dev->i2c_bus[0].dev = dev; 1278 dev->i2c_bus[0].i2c_period = I2C_SPEED_100K; /* 100 KHz */ 1279 dev->i2c_bus[0].i2c_nostop = 0; 1280 dev->i2c_bus[0].i2c_reserve = 0; 1281 1282 /* External Master 2 Bus */ 1283 dev->i2c_bus[1].nr = 1; 1284 dev->i2c_bus[1].dev = dev; 1285 dev->i2c_bus[1].i2c_period = I2C_SPEED_100K; /* 100 KHz */ 1286 dev->i2c_bus[1].i2c_nostop = 0; 1287 dev->i2c_bus[1].i2c_reserve = 0; 1288 1289 /* Internal Master 3 Bus */ 1290 dev->i2c_bus[2].nr = 2; 1291 dev->i2c_bus[2].dev = dev; 1292 dev->i2c_bus[2].i2c_period = I2C_SPEED_100K; /* 100kHz */ 1293 dev->i2c_bus[2].i2c_nostop = 0; 1294 dev->i2c_bus[2].i2c_reserve = 0; 1295 1296 /* register I2C buses */ 1297 cx231xx_i2c_register(&dev->i2c_bus[0]); 1298 cx231xx_i2c_register(&dev->i2c_bus[1]); 1299 cx231xx_i2c_register(&dev->i2c_bus[2]); 1300 1301 /* init hardware */ 1302 /* Note : with out calling set power mode function, 1303 afe can not be set up correctly */ 1304 if (dev->board.external_av) { 1305 errCode = cx231xx_set_power_mode(dev, 1306 POLARIS_AVMODE_ENXTERNAL_AV); 1307 if (errCode < 0) { 1308 cx231xx_errdev 1309 ("%s: Failed to set Power - errCode [%d]!\n", 1310 __func__, errCode); 1311 return errCode; 1312 } 1313 } else { 1314 errCode = cx231xx_set_power_mode(dev, 1315 POLARIS_AVMODE_ANALOGT_TV); 1316 if (errCode < 0) { 1317 cx231xx_errdev 1318 ("%s: Failed to set Power - errCode [%d]!\n", 1319 __func__, errCode); 1320 return errCode; 1321 } 1322 } 1323 1324 /* reset the Tuner, if it is a Xceive tuner */ 1325 if ((dev->board.tuner_type == TUNER_XC5000) || 1326 (dev->board.tuner_type == TUNER_XC2028)) 1327 cx231xx_gpio_set(dev, dev->board.tuner_gpio); 1328 1329 /* initialize Colibri block */ 1330 errCode = cx231xx_afe_init_super_block(dev, 0x23c); 1331 if (errCode < 0) { 1332 cx231xx_errdev 1333 ("%s: cx231xx_afe init super block - errCode [%d]!\n", 1334 __func__, errCode); 1335 return errCode; 1336 } 1337 errCode = cx231xx_afe_init_channels(dev); 1338 if (errCode < 0) { 1339 cx231xx_errdev 1340 ("%s: cx231xx_afe init channels - errCode [%d]!\n", 1341 __func__, errCode); 1342 return errCode; 1343 } 1344 1345 /* Set DIF in By pass mode */ 1346 errCode = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND); 1347 if (errCode < 0) { 1348 cx231xx_errdev 1349 ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n", 1350 __func__, errCode); 1351 return errCode; 1352 } 1353 1354 /* I2S block related functions */ 1355 errCode = cx231xx_i2s_blk_initialize(dev); 1356 if (errCode < 0) { 1357 cx231xx_errdev 1358 ("%s: cx231xx_i2s block initialize - errCode [%d]!\n", 1359 __func__, errCode); 1360 return errCode; 1361 } 1362 1363 /* init control pins */ 1364 errCode = cx231xx_init_ctrl_pin_status(dev); 1365 if (errCode < 0) { 1366 cx231xx_errdev("%s: cx231xx_init ctrl pins - errCode [%d]!\n", 1367 __func__, errCode); 1368 return errCode; 1369 } 1370 1371 /* set AGC mode to Analog */ 1372 switch (dev->model) { 1373 case CX231XX_BOARD_CNXT_CARRAERA: 1374 case CX231XX_BOARD_CNXT_RDE_250: 1375 case CX231XX_BOARD_CNXT_SHELBY: 1376 case CX231XX_BOARD_CNXT_RDU_250: 1377 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1); 1378 break; 1379 case CX231XX_BOARD_CNXT_RDE_253S: 1380 case CX231XX_BOARD_CNXT_RDU_253S: 1381 case CX231XX_BOARD_HAUPPAUGE_EXETER: 1382 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID: 1383 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL: 1384 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC: 1385 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0); 1386 break; 1387 default: 1388 break; 1389 } 1390 if (errCode < 0) { 1391 cx231xx_errdev 1392 ("%s: cx231xx_AGC mode to Analog - errCode [%d]!\n", 1393 __func__, errCode); 1394 return errCode; 1395 } 1396 1397 /* set all alternate settings to zero initially */ 1398 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0); 1399 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 1400 cx231xx_set_alt_setting(dev, INDEX_HANC, 0); 1401 if (dev->board.has_dvb) 1402 cx231xx_set_alt_setting(dev, INDEX_TS1, 0); 1403 1404 /* set the I2C master port to 3 on channel 1 */ 1405 errCode = cx231xx_enable_i2c_port_3(dev, true); 1406 1407 return errCode; 1408 } 1409 EXPORT_SYMBOL_GPL(cx231xx_dev_init); 1410 1411 void cx231xx_dev_uninit(struct cx231xx *dev) 1412 { 1413 /* Un Initialize I2C bus */ 1414 cx231xx_i2c_unregister(&dev->i2c_bus[2]); 1415 cx231xx_i2c_unregister(&dev->i2c_bus[1]); 1416 cx231xx_i2c_unregister(&dev->i2c_bus[0]); 1417 } 1418 EXPORT_SYMBOL_GPL(cx231xx_dev_uninit); 1419 1420 /***************************************************************** 1421 * G P I O related functions * 1422 ******************************************************************/ 1423 int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val, 1424 u8 len, u8 request, u8 direction) 1425 { 1426 int status = 0; 1427 struct VENDOR_REQUEST_IN ven_req; 1428 1429 /* Set wValue */ 1430 ven_req.wValue = (u16) (gpio_bit >> 16 & 0xffff); 1431 1432 /* set request */ 1433 if (!request) { 1434 if (direction) 1435 ven_req.bRequest = VRT_GET_GPIO; /* 0x8 gpio */ 1436 else 1437 ven_req.bRequest = VRT_SET_GPIO; /* 0x9 gpio */ 1438 } else { 1439 if (direction) 1440 ven_req.bRequest = VRT_GET_GPIE; /* 0xa gpie */ 1441 else 1442 ven_req.bRequest = VRT_SET_GPIE; /* 0xb gpie */ 1443 } 1444 1445 /* set index value */ 1446 ven_req.wIndex = (u16) (gpio_bit & 0xffff); 1447 1448 /* set wLength value */ 1449 ven_req.wLength = len; 1450 1451 /* set bData value */ 1452 ven_req.bData = 0; 1453 1454 /* set the buffer for read / write */ 1455 ven_req.pBuff = gpio_val; 1456 1457 /* set the direction */ 1458 if (direction) { 1459 ven_req.direction = USB_DIR_IN; 1460 memset(ven_req.pBuff, 0x00, ven_req.wLength); 1461 } else 1462 ven_req.direction = USB_DIR_OUT; 1463 1464 1465 /* call common vendor command request */ 1466 status = cx231xx_send_vendor_cmd(dev, &ven_req); 1467 if (status < 0) { 1468 cx231xx_info 1469 ("UsbInterface::sendCommand, failed with status -%d\n", 1470 status); 1471 } 1472 1473 return status; 1474 } 1475 EXPORT_SYMBOL_GPL(cx231xx_send_gpio_cmd); 1476 1477 /***************************************************************** 1478 * C O N T R O L - Register R E A D / W R I T E functions * 1479 *****************************************************************/ 1480 int cx231xx_mode_register(struct cx231xx *dev, u16 address, u32 mode) 1481 { 1482 u8 value[4] = { 0x0, 0x0, 0x0, 0x0 }; 1483 u32 tmp = 0; 1484 int status = 0; 1485 1486 status = 1487 cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, address, value, 4); 1488 if (status < 0) 1489 return status; 1490 1491 tmp = *((u32 *) value); 1492 tmp |= mode; 1493 1494 value[0] = (u8) tmp; 1495 value[1] = (u8) (tmp >> 8); 1496 value[2] = (u8) (tmp >> 16); 1497 value[3] = (u8) (tmp >> 24); 1498 1499 status = 1500 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, address, value, 4); 1501 1502 return status; 1503 } 1504 1505 /***************************************************************** 1506 * I 2 C Internal C O N T R O L functions * 1507 *****************************************************************/ 1508 int cx231xx_read_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1509 u8 saddr_len, u32 *data, u8 data_len, int master) 1510 { 1511 int status = 0; 1512 struct cx231xx_i2c_xfer_data req_data; 1513 u8 value[64] = "0"; 1514 1515 if (saddr_len == 0) 1516 saddr = 0; 1517 else if (saddr_len == 1) 1518 saddr &= 0xff; 1519 1520 /* prepare xfer_data struct */ 1521 req_data.dev_addr = dev_addr >> 1; 1522 req_data.direction = I2C_M_RD; 1523 req_data.saddr_len = saddr_len; 1524 req_data.saddr_dat = saddr; 1525 req_data.buf_size = data_len; 1526 req_data.p_buffer = (u8 *) value; 1527 1528 /* usb send command */ 1529 if (master == 0) 1530 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], 1531 &req_data); 1532 else if (master == 1) 1533 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1], 1534 &req_data); 1535 else if (master == 2) 1536 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2], 1537 &req_data); 1538 1539 if (status >= 0) { 1540 /* Copy the data read back to main buffer */ 1541 if (data_len == 1) 1542 *data = value[0]; 1543 else if (data_len == 4) 1544 *data = 1545 value[0] | value[1] << 8 | value[2] << 16 | value[3] 1546 << 24; 1547 else if (data_len > 4) 1548 *data = value[saddr]; 1549 } 1550 1551 return status; 1552 } 1553 1554 int cx231xx_write_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1555 u8 saddr_len, u32 data, u8 data_len, int master) 1556 { 1557 int status = 0; 1558 u8 value[4] = { 0, 0, 0, 0 }; 1559 struct cx231xx_i2c_xfer_data req_data; 1560 1561 value[0] = (u8) data; 1562 value[1] = (u8) (data >> 8); 1563 value[2] = (u8) (data >> 16); 1564 value[3] = (u8) (data >> 24); 1565 1566 if (saddr_len == 0) 1567 saddr = 0; 1568 else if (saddr_len == 1) 1569 saddr &= 0xff; 1570 1571 /* prepare xfer_data struct */ 1572 req_data.dev_addr = dev_addr >> 1; 1573 req_data.direction = 0; 1574 req_data.saddr_len = saddr_len; 1575 req_data.saddr_dat = saddr; 1576 req_data.buf_size = data_len; 1577 req_data.p_buffer = value; 1578 1579 /* usb send command */ 1580 if (master == 0) 1581 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], 1582 &req_data); 1583 else if (master == 1) 1584 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1], 1585 &req_data); 1586 else if (master == 2) 1587 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2], 1588 &req_data); 1589 1590 return status; 1591 } 1592 1593 int cx231xx_read_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1594 u8 saddr_len, u32 *data, u8 data_len) 1595 { 1596 int status = 0; 1597 struct cx231xx_i2c_xfer_data req_data; 1598 u8 value[4] = { 0, 0, 0, 0 }; 1599 1600 if (saddr_len == 0) 1601 saddr = 0; 1602 else if (saddr_len == 1) 1603 saddr &= 0xff; 1604 1605 /* prepare xfer_data struct */ 1606 req_data.dev_addr = dev_addr >> 1; 1607 req_data.direction = I2C_M_RD; 1608 req_data.saddr_len = saddr_len; 1609 req_data.saddr_dat = saddr; 1610 req_data.buf_size = data_len; 1611 req_data.p_buffer = (u8 *) value; 1612 1613 /* usb send command */ 1614 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data); 1615 1616 if (status >= 0) { 1617 /* Copy the data read back to main buffer */ 1618 if (data_len == 1) 1619 *data = value[0]; 1620 else 1621 *data = 1622 value[0] | value[1] << 8 | value[2] << 16 | value[3] 1623 << 24; 1624 } 1625 1626 return status; 1627 } 1628 1629 int cx231xx_write_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1630 u8 saddr_len, u32 data, u8 data_len) 1631 { 1632 int status = 0; 1633 u8 value[4] = { 0, 0, 0, 0 }; 1634 struct cx231xx_i2c_xfer_data req_data; 1635 1636 value[0] = (u8) data; 1637 value[1] = (u8) (data >> 8); 1638 value[2] = (u8) (data >> 16); 1639 value[3] = (u8) (data >> 24); 1640 1641 if (saddr_len == 0) 1642 saddr = 0; 1643 else if (saddr_len == 1) 1644 saddr &= 0xff; 1645 1646 /* prepare xfer_data struct */ 1647 req_data.dev_addr = dev_addr >> 1; 1648 req_data.direction = 0; 1649 req_data.saddr_len = saddr_len; 1650 req_data.saddr_dat = saddr; 1651 req_data.buf_size = data_len; 1652 req_data.p_buffer = value; 1653 1654 /* usb send command */ 1655 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data); 1656 1657 return status; 1658 } 1659 1660 int cx231xx_reg_mask_write(struct cx231xx *dev, u8 dev_addr, u8 size, 1661 u16 register_address, u8 bit_start, u8 bit_end, 1662 u32 value) 1663 { 1664 int status = 0; 1665 u32 tmp; 1666 u32 mask = 0; 1667 int i; 1668 1669 if (bit_start > (size - 1) || bit_end > (size - 1)) 1670 return -1; 1671 1672 if (size == 8) { 1673 status = 1674 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2, 1675 &tmp, 1); 1676 } else { 1677 status = 1678 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2, 1679 &tmp, 4); 1680 } 1681 1682 if (status < 0) 1683 return status; 1684 1685 mask = 1 << bit_end; 1686 for (i = bit_end; i > bit_start && i > 0; i--) 1687 mask = mask + (1 << (i - 1)); 1688 1689 value <<= bit_start; 1690 1691 if (size == 8) { 1692 tmp &= ~mask; 1693 tmp |= value; 1694 tmp &= 0xff; 1695 status = 1696 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2, 1697 tmp, 1); 1698 } else { 1699 tmp &= ~mask; 1700 tmp |= value; 1701 status = 1702 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2, 1703 tmp, 4); 1704 } 1705 1706 return status; 1707 } 1708 1709 int cx231xx_read_modify_write_i2c_dword(struct cx231xx *dev, u8 dev_addr, 1710 u16 saddr, u32 mask, u32 value) 1711 { 1712 u32 temp; 1713 int status = 0; 1714 1715 status = cx231xx_read_i2c_data(dev, dev_addr, saddr, 2, &temp, 4); 1716 1717 if (status < 0) 1718 return status; 1719 1720 temp &= ~mask; 1721 temp |= value; 1722 1723 status = cx231xx_write_i2c_data(dev, dev_addr, saddr, 2, temp, 4); 1724 1725 return status; 1726 } 1727 1728 u32 cx231xx_set_field(u32 field_mask, u32 data) 1729 { 1730 u32 temp; 1731 1732 for (temp = field_mask; (temp & 1) == 0; temp >>= 1) 1733 data <<= 1; 1734 1735 return data; 1736 } 1737