drivers/media/usb/cx231xx/cx231xx-core.c

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

DEFINITIONS
