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 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx: 730 errCode = cx231xx_set_power_mode(dev, 731 POLARIS_AVMODE_DIGITAL); 732 break; 733 default: 734 break; 735 } 736 } else/* Set Analog Power mode */ { 737 /* set AGC mode to Analog */ 738 switch (dev->model) { 739 case CX231XX_BOARD_CNXT_CARRAERA: 740 case CX231XX_BOARD_CNXT_RDE_250: 741 case CX231XX_BOARD_CNXT_SHELBY: 742 case CX231XX_BOARD_CNXT_RDU_250: 743 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1); 744 break; 745 case CX231XX_BOARD_CNXT_RDE_253S: 746 case CX231XX_BOARD_CNXT_RDU_253S: 747 case CX231XX_BOARD_HAUPPAUGE_EXETER: 748 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx: 749 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID: 750 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL: 751 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC: 752 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0); 753 break; 754 default: 755 break; 756 } 757 } 758 759 return errCode ? -EINVAL : 0; 760 } 761 EXPORT_SYMBOL_GPL(cx231xx_set_mode); 762 763 int cx231xx_ep5_bulkout(struct cx231xx *dev, u8 *firmware, u16 size) 764 { 765 int errCode = 0; 766 int actlen, ret = -ENOMEM; 767 u32 *buffer; 768 769 buffer = kzalloc(4096, GFP_KERNEL); 770 if (buffer == NULL) { 771 cx231xx_info("out of mem\n"); 772 return -ENOMEM; 773 } 774 memcpy(&buffer[0], firmware, 4096); 775 776 ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 5), 777 buffer, 4096, &actlen, 2000); 778 779 if (ret) 780 cx231xx_info("bulk message failed: %d (%d/%d)", ret, 781 size, actlen); 782 else { 783 errCode = actlen != size ? -1 : 0; 784 } 785 kfree(buffer); 786 return errCode; 787 } 788 789 /***************************************************************** 790 * URB Streaming functions * 791 ******************************************************************/ 792 793 /* 794 * IRQ callback, called by URB callback 795 */ 796 static void cx231xx_isoc_irq_callback(struct urb *urb) 797 { 798 struct cx231xx_dmaqueue *dma_q = urb->context; 799 struct cx231xx_video_mode *vmode = 800 container_of(dma_q, struct cx231xx_video_mode, vidq); 801 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode); 802 int i; 803 804 switch (urb->status) { 805 case 0: /* success */ 806 case -ETIMEDOUT: /* NAK */ 807 break; 808 case -ECONNRESET: /* kill */ 809 case -ENOENT: 810 case -ESHUTDOWN: 811 return; 812 default: /* error */ 813 cx231xx_isocdbg("urb completition error %d.\n", urb->status); 814 break; 815 } 816 817 /* Copy data from URB */ 818 spin_lock(&dev->video_mode.slock); 819 dev->video_mode.isoc_ctl.isoc_copy(dev, urb); 820 spin_unlock(&dev->video_mode.slock); 821 822 /* Reset urb buffers */ 823 for (i = 0; i < urb->number_of_packets; i++) { 824 urb->iso_frame_desc[i].status = 0; 825 urb->iso_frame_desc[i].actual_length = 0; 826 } 827 828 urb->status = usb_submit_urb(urb, GFP_ATOMIC); 829 if (urb->status) { 830 cx231xx_isocdbg("urb resubmit failed (error=%i)\n", 831 urb->status); 832 } 833 } 834 /***************************************************************** 835 * URB Streaming functions * 836 ******************************************************************/ 837 838 /* 839 * IRQ callback, called by URB callback 840 */ 841 static void cx231xx_bulk_irq_callback(struct urb *urb) 842 { 843 struct cx231xx_dmaqueue *dma_q = urb->context; 844 struct cx231xx_video_mode *vmode = 845 container_of(dma_q, struct cx231xx_video_mode, vidq); 846 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode); 847 848 switch (urb->status) { 849 case 0: /* success */ 850 case -ETIMEDOUT: /* NAK */ 851 break; 852 case -ECONNRESET: /* kill */ 853 case -ENOENT: 854 case -ESHUTDOWN: 855 return; 856 default: /* error */ 857 cx231xx_isocdbg("urb completition error %d.\n", urb->status); 858 break; 859 } 860 861 /* Copy data from URB */ 862 spin_lock(&dev->video_mode.slock); 863 dev->video_mode.bulk_ctl.bulk_copy(dev, urb); 864 spin_unlock(&dev->video_mode.slock); 865 866 /* Reset urb buffers */ 867 urb->status = usb_submit_urb(urb, GFP_ATOMIC); 868 if (urb->status) { 869 cx231xx_isocdbg("urb resubmit failed (error=%i)\n", 870 urb->status); 871 } 872 } 873 /* 874 * Stop and Deallocate URBs 875 */ 876 void cx231xx_uninit_isoc(struct cx231xx *dev) 877 { 878 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 879 struct urb *urb; 880 int i; 881 882 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_isoc\n"); 883 884 dev->video_mode.isoc_ctl.nfields = -1; 885 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 886 urb = dev->video_mode.isoc_ctl.urb[i]; 887 if (urb) { 888 if (!irqs_disabled()) 889 usb_kill_urb(urb); 890 else 891 usb_unlink_urb(urb); 892 893 if (dev->video_mode.isoc_ctl.transfer_buffer[i]) { 894 usb_free_coherent(dev->udev, 895 urb->transfer_buffer_length, 896 dev->video_mode.isoc_ctl. 897 transfer_buffer[i], 898 urb->transfer_dma); 899 } 900 usb_free_urb(urb); 901 dev->video_mode.isoc_ctl.urb[i] = NULL; 902 } 903 dev->video_mode.isoc_ctl.transfer_buffer[i] = NULL; 904 } 905 906 kfree(dev->video_mode.isoc_ctl.urb); 907 kfree(dev->video_mode.isoc_ctl.transfer_buffer); 908 kfree(dma_q->p_left_data); 909 910 dev->video_mode.isoc_ctl.urb = NULL; 911 dev->video_mode.isoc_ctl.transfer_buffer = NULL; 912 dev->video_mode.isoc_ctl.num_bufs = 0; 913 dma_q->p_left_data = NULL; 914 915 if (dev->mode_tv == 0) 916 cx231xx_capture_start(dev, 0, Raw_Video); 917 else 918 cx231xx_capture_start(dev, 0, TS1_serial_mode); 919 920 921 } 922 EXPORT_SYMBOL_GPL(cx231xx_uninit_isoc); 923 924 /* 925 * Stop and Deallocate URBs 926 */ 927 void cx231xx_uninit_bulk(struct cx231xx *dev) 928 { 929 struct urb *urb; 930 int i; 931 932 cx231xx_isocdbg("cx231xx: called cx231xx_uninit_bulk\n"); 933 934 dev->video_mode.bulk_ctl.nfields = -1; 935 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 936 urb = dev->video_mode.bulk_ctl.urb[i]; 937 if (urb) { 938 if (!irqs_disabled()) 939 usb_kill_urb(urb); 940 else 941 usb_unlink_urb(urb); 942 943 if (dev->video_mode.bulk_ctl.transfer_buffer[i]) { 944 usb_free_coherent(dev->udev, 945 urb->transfer_buffer_length, 946 dev->video_mode.isoc_ctl. 947 transfer_buffer[i], 948 urb->transfer_dma); 949 } 950 usb_free_urb(urb); 951 dev->video_mode.bulk_ctl.urb[i] = NULL; 952 } 953 dev->video_mode.bulk_ctl.transfer_buffer[i] = NULL; 954 } 955 956 kfree(dev->video_mode.bulk_ctl.urb); 957 kfree(dev->video_mode.bulk_ctl.transfer_buffer); 958 959 dev->video_mode.bulk_ctl.urb = NULL; 960 dev->video_mode.bulk_ctl.transfer_buffer = NULL; 961 dev->video_mode.bulk_ctl.num_bufs = 0; 962 963 if (dev->mode_tv == 0) 964 cx231xx_capture_start(dev, 0, Raw_Video); 965 else 966 cx231xx_capture_start(dev, 0, TS1_serial_mode); 967 968 969 } 970 EXPORT_SYMBOL_GPL(cx231xx_uninit_bulk); 971 972 /* 973 * Allocate URBs and start IRQ 974 */ 975 int cx231xx_init_isoc(struct cx231xx *dev, int max_packets, 976 int num_bufs, int max_pkt_size, 977 int (*isoc_copy) (struct cx231xx *dev, struct urb *urb)) 978 { 979 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 980 int i; 981 int sb_size, pipe; 982 struct urb *urb; 983 int j, k; 984 int rc; 985 986 /* De-allocates all pending stuff */ 987 cx231xx_uninit_isoc(dev); 988 989 dma_q->p_left_data = kzalloc(4096, GFP_KERNEL); 990 if (dma_q->p_left_data == NULL) { 991 cx231xx_info("out of mem\n"); 992 return -ENOMEM; 993 } 994 995 996 997 dev->video_mode.isoc_ctl.isoc_copy = isoc_copy; 998 dev->video_mode.isoc_ctl.num_bufs = num_bufs; 999 dma_q->pos = 0; 1000 dma_q->is_partial_line = 0; 1001 dma_q->last_sav = 0; 1002 dma_q->current_field = -1; 1003 dma_q->field1_done = 0; 1004 dma_q->lines_per_field = dev->height / 2; 1005 dma_q->bytes_left_in_line = dev->width << 1; 1006 dma_q->lines_completed = 0; 1007 dma_q->mpeg_buffer_done = 0; 1008 dma_q->left_data_count = 0; 1009 dma_q->mpeg_buffer_completed = 0; 1010 dma_q->add_ps_package_head = CX231XX_NEED_ADD_PS_PACKAGE_HEAD; 1011 dma_q->ps_head[0] = 0x00; 1012 dma_q->ps_head[1] = 0x00; 1013 dma_q->ps_head[2] = 0x01; 1014 dma_q->ps_head[3] = 0xBA; 1015 for (i = 0; i < 8; i++) 1016 dma_q->partial_buf[i] = 0; 1017 1018 dev->video_mode.isoc_ctl.urb = 1019 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1020 if (!dev->video_mode.isoc_ctl.urb) { 1021 cx231xx_errdev("cannot alloc memory for usb buffers\n"); 1022 return -ENOMEM; 1023 } 1024 1025 dev->video_mode.isoc_ctl.transfer_buffer = 1026 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1027 if (!dev->video_mode.isoc_ctl.transfer_buffer) { 1028 cx231xx_errdev("cannot allocate memory for usbtransfer\n"); 1029 kfree(dev->video_mode.isoc_ctl.urb); 1030 return -ENOMEM; 1031 } 1032 1033 dev->video_mode.isoc_ctl.max_pkt_size = max_pkt_size; 1034 dev->video_mode.isoc_ctl.buf = NULL; 1035 1036 sb_size = max_packets * dev->video_mode.isoc_ctl.max_pkt_size; 1037 1038 if (dev->mode_tv == 1) 1039 dev->video_mode.end_point_addr = 0x81; 1040 else 1041 dev->video_mode.end_point_addr = 0x84; 1042 1043 1044 /* allocate urbs and transfer buffers */ 1045 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 1046 urb = usb_alloc_urb(max_packets, GFP_KERNEL); 1047 if (!urb) { 1048 cx231xx_err("cannot alloc isoc_ctl.urb %i\n", i); 1049 cx231xx_uninit_isoc(dev); 1050 return -ENOMEM; 1051 } 1052 dev->video_mode.isoc_ctl.urb[i] = urb; 1053 1054 dev->video_mode.isoc_ctl.transfer_buffer[i] = 1055 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL, 1056 &urb->transfer_dma); 1057 if (!dev->video_mode.isoc_ctl.transfer_buffer[i]) { 1058 cx231xx_err("unable to allocate %i bytes for transfer" 1059 " buffer %i%s\n", 1060 sb_size, i, 1061 in_interrupt() ? " while in int" : ""); 1062 cx231xx_uninit_isoc(dev); 1063 return -ENOMEM; 1064 } 1065 memset(dev->video_mode.isoc_ctl.transfer_buffer[i], 0, sb_size); 1066 1067 pipe = 1068 usb_rcvisocpipe(dev->udev, dev->video_mode.end_point_addr); 1069 1070 usb_fill_int_urb(urb, dev->udev, pipe, 1071 dev->video_mode.isoc_ctl.transfer_buffer[i], 1072 sb_size, cx231xx_isoc_irq_callback, dma_q, 1); 1073 1074 urb->number_of_packets = max_packets; 1075 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 1076 1077 k = 0; 1078 for (j = 0; j < max_packets; j++) { 1079 urb->iso_frame_desc[j].offset = k; 1080 urb->iso_frame_desc[j].length = 1081 dev->video_mode.isoc_ctl.max_pkt_size; 1082 k += dev->video_mode.isoc_ctl.max_pkt_size; 1083 } 1084 } 1085 1086 init_waitqueue_head(&dma_q->wq); 1087 1088 /* submit urbs and enables IRQ */ 1089 for (i = 0; i < dev->video_mode.isoc_ctl.num_bufs; i++) { 1090 rc = usb_submit_urb(dev->video_mode.isoc_ctl.urb[i], 1091 GFP_ATOMIC); 1092 if (rc) { 1093 cx231xx_err("submit of urb %i failed (error=%i)\n", i, 1094 rc); 1095 cx231xx_uninit_isoc(dev); 1096 return rc; 1097 } 1098 } 1099 1100 if (dev->mode_tv == 0) 1101 cx231xx_capture_start(dev, 1, Raw_Video); 1102 else 1103 cx231xx_capture_start(dev, 1, TS1_serial_mode); 1104 1105 return 0; 1106 } 1107 EXPORT_SYMBOL_GPL(cx231xx_init_isoc); 1108 1109 /* 1110 * Allocate URBs and start IRQ 1111 */ 1112 int cx231xx_init_bulk(struct cx231xx *dev, int max_packets, 1113 int num_bufs, int max_pkt_size, 1114 int (*bulk_copy) (struct cx231xx *dev, struct urb *urb)) 1115 { 1116 struct cx231xx_dmaqueue *dma_q = &dev->video_mode.vidq; 1117 int i; 1118 int sb_size, pipe; 1119 struct urb *urb; 1120 int rc; 1121 1122 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input; 1123 1124 cx231xx_coredbg("Setting Video mux to %d\n", dev->video_input); 1125 1126 video_mux(dev, dev->video_input); 1127 1128 /* De-allocates all pending stuff */ 1129 cx231xx_uninit_bulk(dev); 1130 1131 dev->video_mode.bulk_ctl.bulk_copy = bulk_copy; 1132 dev->video_mode.bulk_ctl.num_bufs = num_bufs; 1133 dma_q->pos = 0; 1134 dma_q->is_partial_line = 0; 1135 dma_q->last_sav = 0; 1136 dma_q->current_field = -1; 1137 dma_q->field1_done = 0; 1138 dma_q->lines_per_field = dev->height / 2; 1139 dma_q->bytes_left_in_line = dev->width << 1; 1140 dma_q->lines_completed = 0; 1141 dma_q->mpeg_buffer_done = 0; 1142 dma_q->left_data_count = 0; 1143 dma_q->mpeg_buffer_completed = 0; 1144 dma_q->ps_head[0] = 0x00; 1145 dma_q->ps_head[1] = 0x00; 1146 dma_q->ps_head[2] = 0x01; 1147 dma_q->ps_head[3] = 0xBA; 1148 for (i = 0; i < 8; i++) 1149 dma_q->partial_buf[i] = 0; 1150 1151 dev->video_mode.bulk_ctl.urb = 1152 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1153 if (!dev->video_mode.bulk_ctl.urb) { 1154 cx231xx_errdev("cannot alloc memory for usb buffers\n"); 1155 return -ENOMEM; 1156 } 1157 1158 dev->video_mode.bulk_ctl.transfer_buffer = 1159 kzalloc(sizeof(void *) * num_bufs, GFP_KERNEL); 1160 if (!dev->video_mode.bulk_ctl.transfer_buffer) { 1161 cx231xx_errdev("cannot allocate memory for usbtransfer\n"); 1162 kfree(dev->video_mode.bulk_ctl.urb); 1163 return -ENOMEM; 1164 } 1165 1166 dev->video_mode.bulk_ctl.max_pkt_size = max_pkt_size; 1167 dev->video_mode.bulk_ctl.buf = NULL; 1168 1169 sb_size = max_packets * dev->video_mode.bulk_ctl.max_pkt_size; 1170 1171 if (dev->mode_tv == 1) 1172 dev->video_mode.end_point_addr = 0x81; 1173 else 1174 dev->video_mode.end_point_addr = 0x84; 1175 1176 1177 /* allocate urbs and transfer buffers */ 1178 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 1179 urb = usb_alloc_urb(0, GFP_KERNEL); 1180 if (!urb) { 1181 cx231xx_err("cannot alloc bulk_ctl.urb %i\n", i); 1182 cx231xx_uninit_bulk(dev); 1183 return -ENOMEM; 1184 } 1185 dev->video_mode.bulk_ctl.urb[i] = urb; 1186 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 1187 1188 dev->video_mode.bulk_ctl.transfer_buffer[i] = 1189 usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL, 1190 &urb->transfer_dma); 1191 if (!dev->video_mode.bulk_ctl.transfer_buffer[i]) { 1192 cx231xx_err("unable to allocate %i bytes for transfer" 1193 " buffer %i%s\n", 1194 sb_size, i, 1195 in_interrupt() ? " while in int" : ""); 1196 cx231xx_uninit_bulk(dev); 1197 return -ENOMEM; 1198 } 1199 memset(dev->video_mode.bulk_ctl.transfer_buffer[i], 0, sb_size); 1200 1201 pipe = usb_rcvbulkpipe(dev->udev, 1202 dev->video_mode.end_point_addr); 1203 usb_fill_bulk_urb(urb, dev->udev, pipe, 1204 dev->video_mode.bulk_ctl.transfer_buffer[i], 1205 sb_size, cx231xx_bulk_irq_callback, dma_q); 1206 } 1207 1208 init_waitqueue_head(&dma_q->wq); 1209 1210 /* submit urbs and enables IRQ */ 1211 for (i = 0; i < dev->video_mode.bulk_ctl.num_bufs; i++) { 1212 rc = usb_submit_urb(dev->video_mode.bulk_ctl.urb[i], 1213 GFP_ATOMIC); 1214 if (rc) { 1215 cx231xx_err("submit of urb %i failed (error=%i)\n", i, 1216 rc); 1217 cx231xx_uninit_bulk(dev); 1218 return rc; 1219 } 1220 } 1221 1222 if (dev->mode_tv == 0) 1223 cx231xx_capture_start(dev, 1, Raw_Video); 1224 else 1225 cx231xx_capture_start(dev, 1, TS1_serial_mode); 1226 1227 return 0; 1228 } 1229 EXPORT_SYMBOL_GPL(cx231xx_init_bulk); 1230 void cx231xx_stop_TS1(struct cx231xx *dev) 1231 { 1232 u8 val[4] = { 0, 0, 0, 0 }; 1233 1234 val[0] = 0x00; 1235 val[1] = 0x03; 1236 val[2] = 0x00; 1237 val[3] = 0x00; 1238 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1239 TS_MODE_REG, val, 4); 1240 1241 val[0] = 0x00; 1242 val[1] = 0x70; 1243 val[2] = 0x04; 1244 val[3] = 0x00; 1245 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1246 TS1_CFG_REG, val, 4); 1247 } 1248 /* EXPORT_SYMBOL_GPL(cx231xx_stop_TS1); */ 1249 void cx231xx_start_TS1(struct cx231xx *dev) 1250 { 1251 u8 val[4] = { 0, 0, 0, 0 }; 1252 1253 val[0] = 0x03; 1254 val[1] = 0x03; 1255 val[2] = 0x00; 1256 val[3] = 0x00; 1257 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1258 TS_MODE_REG, val, 4); 1259 1260 val[0] = 0x04; 1261 val[1] = 0xA3; 1262 val[2] = 0x3B; 1263 val[3] = 0x00; 1264 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, 1265 TS1_CFG_REG, val, 4); 1266 } 1267 /* EXPORT_SYMBOL_GPL(cx231xx_start_TS1); */ 1268 /***************************************************************** 1269 * Device Init/UnInit functions * 1270 ******************************************************************/ 1271 int cx231xx_dev_init(struct cx231xx *dev) 1272 { 1273 int errCode = 0; 1274 1275 /* Initialize I2C bus */ 1276 1277 /* External Master 1 Bus */ 1278 dev->i2c_bus[0].nr = 0; 1279 dev->i2c_bus[0].dev = dev; 1280 dev->i2c_bus[0].i2c_period = I2C_SPEED_100K; /* 100 KHz */ 1281 dev->i2c_bus[0].i2c_nostop = 0; 1282 dev->i2c_bus[0].i2c_reserve = 0; 1283 1284 /* External Master 2 Bus */ 1285 dev->i2c_bus[1].nr = 1; 1286 dev->i2c_bus[1].dev = dev; 1287 dev->i2c_bus[1].i2c_period = I2C_SPEED_100K; /* 100 KHz */ 1288 dev->i2c_bus[1].i2c_nostop = 0; 1289 dev->i2c_bus[1].i2c_reserve = 0; 1290 1291 /* Internal Master 3 Bus */ 1292 dev->i2c_bus[2].nr = 2; 1293 dev->i2c_bus[2].dev = dev; 1294 dev->i2c_bus[2].i2c_period = I2C_SPEED_100K; /* 100kHz */ 1295 dev->i2c_bus[2].i2c_nostop = 0; 1296 dev->i2c_bus[2].i2c_reserve = 0; 1297 1298 /* register I2C buses */ 1299 cx231xx_i2c_register(&dev->i2c_bus[0]); 1300 cx231xx_i2c_register(&dev->i2c_bus[1]); 1301 cx231xx_i2c_register(&dev->i2c_bus[2]); 1302 1303 /* init hardware */ 1304 /* Note : with out calling set power mode function, 1305 afe can not be set up correctly */ 1306 if (dev->board.external_av) { 1307 errCode = cx231xx_set_power_mode(dev, 1308 POLARIS_AVMODE_ENXTERNAL_AV); 1309 if (errCode < 0) { 1310 cx231xx_errdev 1311 ("%s: Failed to set Power - errCode [%d]!\n", 1312 __func__, errCode); 1313 return errCode; 1314 } 1315 } else { 1316 errCode = cx231xx_set_power_mode(dev, 1317 POLARIS_AVMODE_ANALOGT_TV); 1318 if (errCode < 0) { 1319 cx231xx_errdev 1320 ("%s: Failed to set Power - errCode [%d]!\n", 1321 __func__, errCode); 1322 return errCode; 1323 } 1324 } 1325 1326 /* reset the Tuner, if it is a Xceive tuner */ 1327 if ((dev->board.tuner_type == TUNER_XC5000) || 1328 (dev->board.tuner_type == TUNER_XC2028)) 1329 cx231xx_gpio_set(dev, dev->board.tuner_gpio); 1330 1331 /* initialize Colibri block */ 1332 errCode = cx231xx_afe_init_super_block(dev, 0x23c); 1333 if (errCode < 0) { 1334 cx231xx_errdev 1335 ("%s: cx231xx_afe init super block - errCode [%d]!\n", 1336 __func__, errCode); 1337 return errCode; 1338 } 1339 errCode = cx231xx_afe_init_channels(dev); 1340 if (errCode < 0) { 1341 cx231xx_errdev 1342 ("%s: cx231xx_afe init channels - errCode [%d]!\n", 1343 __func__, errCode); 1344 return errCode; 1345 } 1346 1347 /* Set DIF in By pass mode */ 1348 errCode = cx231xx_dif_set_standard(dev, DIF_USE_BASEBAND); 1349 if (errCode < 0) { 1350 cx231xx_errdev 1351 ("%s: cx231xx_dif set to By pass mode - errCode [%d]!\n", 1352 __func__, errCode); 1353 return errCode; 1354 } 1355 1356 /* I2S block related functions */ 1357 errCode = cx231xx_i2s_blk_initialize(dev); 1358 if (errCode < 0) { 1359 cx231xx_errdev 1360 ("%s: cx231xx_i2s block initialize - errCode [%d]!\n", 1361 __func__, errCode); 1362 return errCode; 1363 } 1364 1365 /* init control pins */ 1366 errCode = cx231xx_init_ctrl_pin_status(dev); 1367 if (errCode < 0) { 1368 cx231xx_errdev("%s: cx231xx_init ctrl pins - errCode [%d]!\n", 1369 __func__, errCode); 1370 return errCode; 1371 } 1372 1373 /* set AGC mode to Analog */ 1374 switch (dev->model) { 1375 case CX231XX_BOARD_CNXT_CARRAERA: 1376 case CX231XX_BOARD_CNXT_RDE_250: 1377 case CX231XX_BOARD_CNXT_SHELBY: 1378 case CX231XX_BOARD_CNXT_RDU_250: 1379 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 1); 1380 break; 1381 case CX231XX_BOARD_CNXT_RDE_253S: 1382 case CX231XX_BOARD_CNXT_RDU_253S: 1383 case CX231XX_BOARD_HAUPPAUGE_EXETER: 1384 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx: 1385 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID: 1386 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL: 1387 case CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC: 1388 errCode = cx231xx_set_agc_analog_digital_mux_select(dev, 0); 1389 break; 1390 default: 1391 break; 1392 } 1393 if (errCode < 0) { 1394 cx231xx_errdev 1395 ("%s: cx231xx_AGC mode to Analog - errCode [%d]!\n", 1396 __func__, errCode); 1397 return errCode; 1398 } 1399 1400 /* set all alternate settings to zero initially */ 1401 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0); 1402 cx231xx_set_alt_setting(dev, INDEX_VANC, 0); 1403 cx231xx_set_alt_setting(dev, INDEX_HANC, 0); 1404 if (dev->board.has_dvb) 1405 cx231xx_set_alt_setting(dev, INDEX_TS1, 0); 1406 1407 /* set the I2C master port to 3 on channel 1 */ 1408 errCode = cx231xx_enable_i2c_port_3(dev, true); 1409 1410 return errCode; 1411 } 1412 EXPORT_SYMBOL_GPL(cx231xx_dev_init); 1413 1414 void cx231xx_dev_uninit(struct cx231xx *dev) 1415 { 1416 /* Un Initialize I2C bus */ 1417 cx231xx_i2c_unregister(&dev->i2c_bus[2]); 1418 cx231xx_i2c_unregister(&dev->i2c_bus[1]); 1419 cx231xx_i2c_unregister(&dev->i2c_bus[0]); 1420 } 1421 EXPORT_SYMBOL_GPL(cx231xx_dev_uninit); 1422 1423 /***************************************************************** 1424 * G P I O related functions * 1425 ******************************************************************/ 1426 int cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val, 1427 u8 len, u8 request, u8 direction) 1428 { 1429 int status = 0; 1430 struct VENDOR_REQUEST_IN ven_req; 1431 1432 /* Set wValue */ 1433 ven_req.wValue = (u16) (gpio_bit >> 16 & 0xffff); 1434 1435 /* set request */ 1436 if (!request) { 1437 if (direction) 1438 ven_req.bRequest = VRT_GET_GPIO; /* 0x8 gpio */ 1439 else 1440 ven_req.bRequest = VRT_SET_GPIO; /* 0x9 gpio */ 1441 } else { 1442 if (direction) 1443 ven_req.bRequest = VRT_GET_GPIE; /* 0xa gpie */ 1444 else 1445 ven_req.bRequest = VRT_SET_GPIE; /* 0xb gpie */ 1446 } 1447 1448 /* set index value */ 1449 ven_req.wIndex = (u16) (gpio_bit & 0xffff); 1450 1451 /* set wLength value */ 1452 ven_req.wLength = len; 1453 1454 /* set bData value */ 1455 ven_req.bData = 0; 1456 1457 /* set the buffer for read / write */ 1458 ven_req.pBuff = gpio_val; 1459 1460 /* set the direction */ 1461 if (direction) { 1462 ven_req.direction = USB_DIR_IN; 1463 memset(ven_req.pBuff, 0x00, ven_req.wLength); 1464 } else 1465 ven_req.direction = USB_DIR_OUT; 1466 1467 1468 /* call common vendor command request */ 1469 status = cx231xx_send_vendor_cmd(dev, &ven_req); 1470 if (status < 0) { 1471 cx231xx_info 1472 ("UsbInterface::sendCommand, failed with status -%d\n", 1473 status); 1474 } 1475 1476 return status; 1477 } 1478 EXPORT_SYMBOL_GPL(cx231xx_send_gpio_cmd); 1479 1480 /***************************************************************** 1481 * C O N T R O L - Register R E A D / W R I T E functions * 1482 *****************************************************************/ 1483 int cx231xx_mode_register(struct cx231xx *dev, u16 address, u32 mode) 1484 { 1485 u8 value[4] = { 0x0, 0x0, 0x0, 0x0 }; 1486 u32 tmp = 0; 1487 int status = 0; 1488 1489 status = 1490 cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER, address, value, 4); 1491 if (status < 0) 1492 return status; 1493 1494 tmp = le32_to_cpu(*((u32 *) value)); 1495 tmp |= mode; 1496 1497 value[0] = (u8) tmp; 1498 value[1] = (u8) (tmp >> 8); 1499 value[2] = (u8) (tmp >> 16); 1500 value[3] = (u8) (tmp >> 24); 1501 1502 status = 1503 cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER, address, value, 4); 1504 1505 return status; 1506 } 1507 1508 /***************************************************************** 1509 * I 2 C Internal C O N T R O L functions * 1510 *****************************************************************/ 1511 int cx231xx_read_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1512 u8 saddr_len, u32 *data, u8 data_len, int master) 1513 { 1514 int status = 0; 1515 struct cx231xx_i2c_xfer_data req_data; 1516 u8 value[64] = "0"; 1517 1518 if (saddr_len == 0) 1519 saddr = 0; 1520 else if (saddr_len == 1) 1521 saddr &= 0xff; 1522 1523 /* prepare xfer_data struct */ 1524 req_data.dev_addr = dev_addr >> 1; 1525 req_data.direction = I2C_M_RD; 1526 req_data.saddr_len = saddr_len; 1527 req_data.saddr_dat = saddr; 1528 req_data.buf_size = data_len; 1529 req_data.p_buffer = (u8 *) value; 1530 1531 /* usb send command */ 1532 if (master == 0) 1533 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], 1534 &req_data); 1535 else if (master == 1) 1536 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1], 1537 &req_data); 1538 else if (master == 2) 1539 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2], 1540 &req_data); 1541 1542 if (status >= 0) { 1543 /* Copy the data read back to main buffer */ 1544 if (data_len == 1) 1545 *data = value[0]; 1546 else if (data_len == 4) 1547 *data = 1548 value[0] | value[1] << 8 | value[2] << 16 | value[3] 1549 << 24; 1550 else if (data_len > 4) 1551 *data = value[saddr]; 1552 } 1553 1554 return status; 1555 } 1556 1557 int cx231xx_write_i2c_master(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1558 u8 saddr_len, u32 data, u8 data_len, int master) 1559 { 1560 int status = 0; 1561 u8 value[4] = { 0, 0, 0, 0 }; 1562 struct cx231xx_i2c_xfer_data req_data; 1563 1564 value[0] = (u8) data; 1565 value[1] = (u8) (data >> 8); 1566 value[2] = (u8) (data >> 16); 1567 value[3] = (u8) (data >> 24); 1568 1569 if (saddr_len == 0) 1570 saddr = 0; 1571 else if (saddr_len == 1) 1572 saddr &= 0xff; 1573 1574 /* prepare xfer_data struct */ 1575 req_data.dev_addr = dev_addr >> 1; 1576 req_data.direction = 0; 1577 req_data.saddr_len = saddr_len; 1578 req_data.saddr_dat = saddr; 1579 req_data.buf_size = data_len; 1580 req_data.p_buffer = value; 1581 1582 /* usb send command */ 1583 if (master == 0) 1584 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], 1585 &req_data); 1586 else if (master == 1) 1587 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[1], 1588 &req_data); 1589 else if (master == 2) 1590 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[2], 1591 &req_data); 1592 1593 return status; 1594 } 1595 1596 int cx231xx_read_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1597 u8 saddr_len, u32 *data, u8 data_len) 1598 { 1599 int status = 0; 1600 struct cx231xx_i2c_xfer_data req_data; 1601 u8 value[4] = { 0, 0, 0, 0 }; 1602 1603 if (saddr_len == 0) 1604 saddr = 0; 1605 else if (saddr_len == 1) 1606 saddr &= 0xff; 1607 1608 /* prepare xfer_data struct */ 1609 req_data.dev_addr = dev_addr >> 1; 1610 req_data.direction = I2C_M_RD; 1611 req_data.saddr_len = saddr_len; 1612 req_data.saddr_dat = saddr; 1613 req_data.buf_size = data_len; 1614 req_data.p_buffer = (u8 *) value; 1615 1616 /* usb send command */ 1617 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data); 1618 1619 if (status >= 0) { 1620 /* Copy the data read back to main buffer */ 1621 if (data_len == 1) 1622 *data = value[0]; 1623 else 1624 *data = 1625 value[0] | value[1] << 8 | value[2] << 16 | value[3] 1626 << 24; 1627 } 1628 1629 return status; 1630 } 1631 1632 int cx231xx_write_i2c_data(struct cx231xx *dev, u8 dev_addr, u16 saddr, 1633 u8 saddr_len, u32 data, u8 data_len) 1634 { 1635 int status = 0; 1636 u8 value[4] = { 0, 0, 0, 0 }; 1637 struct cx231xx_i2c_xfer_data req_data; 1638 1639 value[0] = (u8) data; 1640 value[1] = (u8) (data >> 8); 1641 value[2] = (u8) (data >> 16); 1642 value[3] = (u8) (data >> 24); 1643 1644 if (saddr_len == 0) 1645 saddr = 0; 1646 else if (saddr_len == 1) 1647 saddr &= 0xff; 1648 1649 /* prepare xfer_data struct */ 1650 req_data.dev_addr = dev_addr >> 1; 1651 req_data.direction = 0; 1652 req_data.saddr_len = saddr_len; 1653 req_data.saddr_dat = saddr; 1654 req_data.buf_size = data_len; 1655 req_data.p_buffer = value; 1656 1657 /* usb send command */ 1658 status = dev->cx231xx_send_usb_command(&dev->i2c_bus[0], &req_data); 1659 1660 return status; 1661 } 1662 1663 int cx231xx_reg_mask_write(struct cx231xx *dev, u8 dev_addr, u8 size, 1664 u16 register_address, u8 bit_start, u8 bit_end, 1665 u32 value) 1666 { 1667 int status = 0; 1668 u32 tmp; 1669 u32 mask = 0; 1670 int i; 1671 1672 if (bit_start > (size - 1) || bit_end > (size - 1)) 1673 return -1; 1674 1675 if (size == 8) { 1676 status = 1677 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2, 1678 &tmp, 1); 1679 } else { 1680 status = 1681 cx231xx_read_i2c_data(dev, dev_addr, register_address, 2, 1682 &tmp, 4); 1683 } 1684 1685 if (status < 0) 1686 return status; 1687 1688 mask = 1 << bit_end; 1689 for (i = bit_end; i > bit_start && i > 0; i--) 1690 mask = mask + (1 << (i - 1)); 1691 1692 value <<= bit_start; 1693 1694 if (size == 8) { 1695 tmp &= ~mask; 1696 tmp |= value; 1697 tmp &= 0xff; 1698 status = 1699 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2, 1700 tmp, 1); 1701 } else { 1702 tmp &= ~mask; 1703 tmp |= value; 1704 status = 1705 cx231xx_write_i2c_data(dev, dev_addr, register_address, 2, 1706 tmp, 4); 1707 } 1708 1709 return status; 1710 } 1711 1712 int cx231xx_read_modify_write_i2c_dword(struct cx231xx *dev, u8 dev_addr, 1713 u16 saddr, u32 mask, u32 value) 1714 { 1715 u32 temp; 1716 int status = 0; 1717 1718 status = cx231xx_read_i2c_data(dev, dev_addr, saddr, 2, &temp, 4); 1719 1720 if (status < 0) 1721 return status; 1722 1723 temp &= ~mask; 1724 temp |= value; 1725 1726 status = cx231xx_write_i2c_data(dev, dev_addr, saddr, 2, temp, 4); 1727 1728 return status; 1729 } 1730 1731 u32 cx231xx_set_field(u32 field_mask, u32 data) 1732 { 1733 u32 temp; 1734 1735 for (temp = field_mask; (temp & 1) == 0; temp >>= 1) 1736 data <<= 1; 1737 1738 return data; 1739 } 1740