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