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

   1 /*
   2    cx231xx-i2c.c - driver for Conexant Cx23100/101/102 USB video capture devices
   3
   4    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
   5                 Based on em28xx driver
   6                 Based on Cx23885 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/module.h>
  24 #include <linux/kernel.h>
  25 #include <linux/usb.h>
  26 #include <linux/i2c.h>
  27 #include <media/v4l2-common.h>
  28 #include <media/tuner.h>
  29
  30 #include "cx231xx.h"
  31
  32 /* ----------------------------------------------------------- */
  33
  34 static unsigned int i2c_scan;
  35 module_param(i2c_scan, int, 0444);
  36 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
  37
  38 static unsigned int i2c_debug;
  39 module_param(i2c_debug, int, 0644);
  40 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
  41
  42 #define dprintk1(lvl, fmt, args...)                     \
  43 do {                                                    \
  44         if (i2c_debug >= lvl) {                         \
  45                 printk(fmt, ##args);                    \
  46                 }                                       \
  47 } while (0)
  48
  49 #define dprintk2(lvl, fmt, args...)                     \
  50 do {                                                    \
  51         if (i2c_debug >= lvl) {                         \
  52                 printk(KERN_DEBUG "%s at %s: " fmt,     \
  53                        dev->name, __func__ , ##args);   \
  54       }                                                 \
  55 } while (0)
  56
  57 static inline bool is_tuner(struct cx231xx *dev, struct cx231xx_i2c *bus,
  58                         const struct i2c_msg *msg, int tuner_type)
  59 {
  60         if (bus->nr != dev->board.tuner_i2c_master)
  61                 return false;
  62
  63         if (msg->addr != dev->board.tuner_addr)
  64                 return false;
  65
  66         if (dev->tuner_type != tuner_type)
  67                 return false;
  68
  69         return true;
  70 }
  71
  72 /*
  73  * cx231xx_i2c_send_bytes()
  74  */
  75 static int cx231xx_i2c_send_bytes(struct i2c_adapter *i2c_adap,
  76                                   const struct i2c_msg *msg)
  77 {
  78         struct cx231xx_i2c *bus = i2c_adap->algo_data;
  79         struct cx231xx *dev = bus->dev;
  80         struct cx231xx_i2c_xfer_data req_data;
  81         int status = 0;
  82         u16 size = 0;
  83         u8 loop = 0;
  84         u8 saddr_len = 1;
  85         u8 *buf_ptr = NULL;
  86         u16 saddr = 0;
  87         u8 need_gpio = 0;
  88
  89         if (is_tuner(dev, bus, msg, TUNER_XC5000)) {
  90                 size = msg->len;
  91
  92                 if (size == 2) {        /* register write sub addr */
  93                         /* Just writing sub address will cause problem
  94                         * to XC5000. So ignore the request */
  95                         return 0;
  96                 } else if (size == 4) { /* register write with sub addr */
  97                         if (msg->len >= 2)
  98                                 saddr = msg->buf[0] << 8 | msg->buf[1];
  99                         else if (msg->len == 1)
 100                                 saddr = msg->buf[0];
 101
 102                         switch (saddr) {
 103                         case 0x0000:    /* start tuner calibration mode */
 104                                 need_gpio = 1;
 105                                 /* FW Loading is done */
 106                                 dev->xc_fw_load_done = 1;
 107                                 break;
 108                         case 0x000D:    /* Set signal source */
 109                         case 0x0001:    /* Set TV standard - Video */
 110                         case 0x0002:    /* Set TV standard - Audio */
 111                         case 0x0003:    /* Set RF Frequency */
 112                                 need_gpio = 1;
 113                                 break;
 114                         default:
 115                                 if (dev->xc_fw_load_done)
 116                                         need_gpio = 1;
 117                                 break;
 118                         }
 119
 120                         if (need_gpio) {
 121                                 dprintk1(1,
 122                                 "GPIO WRITE: addr 0x%x, len %d, saddr 0x%x\n",
 123                                 msg->addr, msg->len, saddr);
 124
 125                                 return dev->cx231xx_gpio_i2c_write(dev,
 126                                                                    msg->addr,
 127                                                                    msg->buf,
 128                                                                    msg->len);
 129                         }
 130                 }
 131
 132                 /* special case for Xc5000 tuner case */
 133                 saddr_len = 1;
 134
 135                 /* adjust the length to correct length */
 136                 size -= saddr_len;
 137                 buf_ptr = (u8 *) (msg->buf + 1);
 138
 139                 do {
 140                         /* prepare xfer_data struct */
 141                         req_data.dev_addr = msg->addr;
 142                         req_data.direction = msg->flags;
 143                         req_data.saddr_len = saddr_len;
 144                         req_data.saddr_dat = msg->buf[0];
 145                         req_data.buf_size = size > 16 ? 16 : size;
 146                         req_data.p_buffer = (u8 *) (buf_ptr + loop * 16);
 147
 148                         bus->i2c_nostop = (size > 16) ? 1 : 0;
 149                         bus->i2c_reserve = (loop == 0) ? 0 : 1;
 150
 151                         /* usb send command */
 152                         status = dev->cx231xx_send_usb_command(bus, &req_data);
 153                         loop++;
 154
 155                         if (size >= 16)
 156                                 size -= 16;
 157                         else
 158                                 size = 0;
 159
 160                 } while (size > 0);
 161
 162                 bus->i2c_nostop = 0;
 163                 bus->i2c_reserve = 0;
 164
 165         } else {                /* regular case */
 166
 167                 /* prepare xfer_data struct */
 168                 req_data.dev_addr = msg->addr;
 169                 req_data.direction = msg->flags;
 170                 req_data.saddr_len = 0;
 171                 req_data.saddr_dat = 0;
 172                 req_data.buf_size = msg->len;
 173                 req_data.p_buffer = msg->buf;
 174
 175                 /* usb send command */
 176                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 177         }
 178
 179         return status < 0 ? status : 0;
 180 }
 181
 182 /*
 183  * cx231xx_i2c_recv_bytes()
 184  * read a byte from the i2c device
 185  */
 186 static int cx231xx_i2c_recv_bytes(struct i2c_adapter *i2c_adap,
 187                                   const struct i2c_msg *msg)
 188 {
 189         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 190         struct cx231xx *dev = bus->dev;
 191         struct cx231xx_i2c_xfer_data req_data;
 192         int status = 0;
 193         u16 saddr = 0;
 194         u8 need_gpio = 0;
 195
 196         if (is_tuner(dev, bus, msg, TUNER_XC5000)) {
 197                 if (msg->len == 2)
 198                         saddr = msg->buf[0] << 8 | msg->buf[1];
 199                 else if (msg->len == 1)
 200                         saddr = msg->buf[0];
 201
 202                 if (dev->xc_fw_load_done) {
 203
 204                         switch (saddr) {
 205                         case 0x0009:    /* BUSY check */
 206                                 dprintk1(1,
 207                                 "GPIO R E A D: Special case BUSY check \n");
 208                                 /*Try read BUSY register, just set it to zero*/
 209                                 msg->buf[0] = 0;
 210                                 if (msg->len == 2)
 211                                         msg->buf[1] = 0;
 212                                 return 0;
 213                         case 0x0004:    /* read Lock status */
 214                                 need_gpio = 1;
 215                                 break;
 216
 217                         }
 218
 219                         if (need_gpio) {
 220                                 /* this is a special case to handle Xceive tuner
 221                                 clock stretch issue with gpio based I2C */
 222
 223                                 dprintk1(1,
 224                                 "GPIO R E A D: addr 0x%x, len %d, saddr 0x%x\n",
 225                                 msg->addr, msg->len,
 226                                 msg->buf[0] << 8 | msg->buf[1]);
 227
 228                                 status =
 229                                     dev->cx231xx_gpio_i2c_write(dev, msg->addr,
 230                                                                 msg->buf,
 231                                                                 msg->len);
 232                                 status =
 233                                     dev->cx231xx_gpio_i2c_read(dev, msg->addr,
 234                                                                msg->buf,
 235                                                                msg->len);
 236                                 return status;
 237                         }
 238                 }
 239
 240                 /* prepare xfer_data struct */
 241                 req_data.dev_addr = msg->addr;
 242                 req_data.direction = msg->flags;
 243                 req_data.saddr_len = msg->len;
 244                 req_data.saddr_dat = msg->buf[0] << 8 | msg->buf[1];
 245                 req_data.buf_size = msg->len;
 246                 req_data.p_buffer = msg->buf;
 247
 248                 /* usb send command */
 249                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 250
 251         } else {
 252
 253                 /* prepare xfer_data struct */
 254                 req_data.dev_addr = msg->addr;
 255                 req_data.direction = msg->flags;
 256                 req_data.saddr_len = 0;
 257                 req_data.saddr_dat = 0;
 258                 req_data.buf_size = msg->len;
 259                 req_data.p_buffer = msg->buf;
 260
 261                 /* usb send command */
 262                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 263         }
 264
 265         return status < 0 ? status : 0;
 266 }
 267
 268 /*
 269  * cx231xx_i2c_recv_bytes_with_saddr()
 270  * read a byte from the i2c device
 271  */
 272 static int cx231xx_i2c_recv_bytes_with_saddr(struct i2c_adapter *i2c_adap,
 273                                              const struct i2c_msg *msg1,
 274                                              const struct i2c_msg *msg2)
 275 {
 276         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 277         struct cx231xx *dev = bus->dev;
 278         struct cx231xx_i2c_xfer_data req_data;
 279         int status = 0;
 280         u16 saddr = 0;
 281         u8 need_gpio = 0;
 282
 283         if (msg1->len == 2)
 284                 saddr = msg1->buf[0] << 8 | msg1->buf[1];
 285         else if (msg1->len == 1)
 286                 saddr = msg1->buf[0];
 287
 288         if (is_tuner(dev, bus, msg2, TUNER_XC5000)) {
 289                 if ((msg2->len < 16)) {
 290
 291                         dprintk1(1,
 292                         "i2c_read: addr 0x%x, len %d, saddr 0x%x, len %d\n",
 293                         msg2->addr, msg2->len, saddr, msg1->len);
 294
 295                         switch (saddr) {
 296                         case 0x0008:    /* read FW load status */
 297                                 need_gpio = 1;
 298                                 break;
 299                         case 0x0004:    /* read Lock status */
 300                                 need_gpio = 1;
 301                                 break;
 302                         }
 303
 304                         if (need_gpio) {
 305                                 status =
 306                                     dev->cx231xx_gpio_i2c_write(dev, msg1->addr,
 307                                                                 msg1->buf,
 308                                                                 msg1->len);
 309                                 status =
 310                                     dev->cx231xx_gpio_i2c_read(dev, msg2->addr,
 311                                                                msg2->buf,
 312                                                                msg2->len);
 313                                 return status;
 314                         }
 315                 }
 316         }
 317
 318         /* prepare xfer_data struct */
 319         req_data.dev_addr = msg2->addr;
 320         req_data.direction = msg2->flags;
 321         req_data.saddr_len = msg1->len;
 322         req_data.saddr_dat = saddr;
 323         req_data.buf_size = msg2->len;
 324         req_data.p_buffer = msg2->buf;
 325
 326         /* usb send command */
 327         status = dev->cx231xx_send_usb_command(bus, &req_data);
 328
 329         return status < 0 ? status : 0;
 330 }
 331
 332 /*
 333  * cx231xx_i2c_check_for_device()
 334  * check if there is a i2c_device at the supplied address
 335  */
 336 static int cx231xx_i2c_check_for_device(struct i2c_adapter *i2c_adap,
 337                                         const struct i2c_msg *msg)
 338 {
 339         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 340         struct cx231xx *dev = bus->dev;
 341         struct cx231xx_i2c_xfer_data req_data;
 342         int status = 0;
 343
 344         /* prepare xfer_data struct */
 345         req_data.dev_addr = msg->addr;
 346         req_data.direction = msg->flags;
 347         req_data.saddr_len = 0;
 348         req_data.saddr_dat = 0;
 349         req_data.buf_size = 0;
 350         req_data.p_buffer = NULL;
 351
 352         /* usb send command */
 353         status = dev->cx231xx_send_usb_command(bus, &req_data);
 354
 355         return status < 0 ? status : 0;
 356 }
 357
 358 /*
 359  * cx231xx_i2c_xfer()
 360  * the main i2c transfer function
 361  */
 362 static int cx231xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 363                             struct i2c_msg msgs[], int num)
 364 {
 365         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 366         struct cx231xx *dev = bus->dev;
 367         int addr, rc, i, byte;
 368
 369         if (num <= 0)
 370                 return 0;
 371         mutex_lock(&dev->i2c_lock);
 372         for (i = 0; i < num; i++) {
 373
 374                 addr = msgs[i].addr;
 375
 376                 dprintk2(2, "%s %s addr=0x%x len=%d:",
 377                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 378                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 379                 if (!msgs[i].len) {
 380                         /* no len: check only for device presence */
 381                         rc = cx231xx_i2c_check_for_device(i2c_adap, &msgs[i]);
 382                         if (rc < 0) {
 383                                 dprintk2(2, " no device\n");
 384                                 mutex_unlock(&dev->i2c_lock);
 385                                 return rc;
 386                         }
 387
 388                 } else if (msgs[i].flags & I2C_M_RD) {
 389                         /* read bytes */
 390                         rc = cx231xx_i2c_recv_bytes(i2c_adap, &msgs[i]);
 391                         if (i2c_debug >= 2) {
 392                                 for (byte = 0; byte < msgs[i].len; byte++)
 393                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 394                         }
 395                 } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
 396                            msgs[i].addr == msgs[i + 1].addr
 397                            && (msgs[i].len <= 2) && (bus->nr < 3)) {
 398                         /* write bytes */
 399                         if (i2c_debug >= 2) {
 400                                 for (byte = 0; byte < msgs[i].len; byte++)
 401                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 402                                 printk(KERN_CONT "\n");
 403                         }
 404                         /* read bytes */
 405                         dprintk2(2, "plus %s %s addr=0x%x len=%d:",
 406                                 (msgs[i+1].flags & I2C_M_RD) ? "read" : "write",
 407                                 i+1 == num - 1 ? "stop" : "nonstop", addr, msgs[i+1].len);
 408                         rc = cx231xx_i2c_recv_bytes_with_saddr(i2c_adap,
 409                                                                &msgs[i],
 410                                                                &msgs[i + 1]);
 411                         if (i2c_debug >= 2) {
 412                                 for (byte = 0; byte < msgs[i+1].len; byte++)
 413                                         printk(KERN_CONT " %02x", msgs[i+1].buf[byte]);
 414                         }
 415                         i++;
 416                 } else {
 417                         /* write bytes */
 418                         if (i2c_debug >= 2) {
 419                                 for (byte = 0; byte < msgs[i].len; byte++)
 420                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 421                         }
 422                         rc = cx231xx_i2c_send_bytes(i2c_adap, &msgs[i]);
 423                 }
 424                 if (rc < 0)
 425                         goto err;
 426                 if (i2c_debug >= 2)
 427                         printk(KERN_CONT "\n");
 428         }
 429         mutex_unlock(&dev->i2c_lock);
 430         return num;
 431 err:
 432         dprintk2(2, " ERROR: %i\n", rc);
 433         mutex_unlock(&dev->i2c_lock);
 434         return rc;
 435 }
 436
 437 /* ----------------------------------------------------------- */
 438
 439 /*
 440  * functionality()
 441  */
 442 static u32 functionality(struct i2c_adapter *adap)
 443 {
 444         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
 445 }
 446
 447 static struct i2c_algorithm cx231xx_algo = {
 448         .master_xfer = cx231xx_i2c_xfer,
 449         .functionality = functionality,
 450 };
 451
 452 static struct i2c_adapter cx231xx_adap_template = {
 453         .owner = THIS_MODULE,
 454         .name = "cx231xx",
 455         .algo = &cx231xx_algo,
 456 };
 457
 458 static struct i2c_client cx231xx_client_template = {
 459         .name = "cx231xx internal",
 460 };
 461
 462 /* ----------------------------------------------------------- */
 463
 464 /*
 465  * i2c_devs
 466  * incomplete list of known devices
 467  */
 468 static char *i2c_devs[128] = {
 469         [0x60 >> 1] = "colibri",
 470         [0x88 >> 1] = "hammerhead",
 471         [0x8e >> 1] = "CIR",
 472         [0x32 >> 1] = "GeminiIII",
 473         [0x02 >> 1] = "Aquarius",
 474         [0xa0 >> 1] = "eeprom",
 475         [0xc0 >> 1] = "tuner",
 476         [0xc2 >> 1] = "tuner",
 477 };
 478
 479 /*
 480  * cx231xx_do_i2c_scan()
 481  * check i2c address range for devices
 482  */
 483 void cx231xx_do_i2c_scan(struct cx231xx *dev, struct i2c_client *c)
 484 {
 485         unsigned char buf;
 486         int i, rc;
 487
 488         cx231xx_info(": Checking for I2C devices ..\n");
 489         for (i = 0; i < 128; i++) {
 490                 c->addr = i;
 491                 rc = i2c_master_recv(c, &buf, 0);
 492                 if (rc < 0)
 493                         continue;
 494                 cx231xx_info("%s: i2c scan: found device @ 0x%x  [%s]\n",
 495                              dev->name, i << 1,
 496                              i2c_devs[i] ? i2c_devs[i] : "???");
 497         }
 498         cx231xx_info(": Completed Checking for I2C devices.\n");
 499 }
 500
 501 /*
 502  * cx231xx_i2c_register()
 503  * register i2c bus
 504  */
 505 int cx231xx_i2c_register(struct cx231xx_i2c *bus)
 506 {
 507         struct cx231xx *dev = bus->dev;
 508
 509         BUG_ON(!dev->cx231xx_send_usb_command);
 510
 511         bus->i2c_adap = cx231xx_adap_template;
 512         bus->i2c_client = cx231xx_client_template;
 513         bus->i2c_adap.dev.parent = &dev->udev->dev;
 514
 515         strlcpy(bus->i2c_adap.name, bus->dev->name, sizeof(bus->i2c_adap.name));
 516
 517         bus->i2c_adap.algo_data = bus;
 518         i2c_set_adapdata(&bus->i2c_adap, &dev->v4l2_dev);
 519         i2c_add_adapter(&bus->i2c_adap);
 520
 521         bus->i2c_client.adapter = &bus->i2c_adap;
 522
 523         if (0 == bus->i2c_rc) {
 524                 if (i2c_scan)
 525                         cx231xx_do_i2c_scan(dev, &bus->i2c_client);
 526         } else
 527                 cx231xx_warn("%s: i2c bus %d register FAILED\n",
 528                              dev->name, bus->nr);
 529
 530         return bus->i2c_rc;
 531 }
 532
 533 /*
 534  * cx231xx_i2c_unregister()
 535  * unregister i2c_bus
 536  */
 537 int cx231xx_i2c_unregister(struct cx231xx_i2c *bus)
 538 {
 539         i2c_del_adapter(&bus->i2c_adap);
 540         return 0;
 541 }