drivers/media/video/ivtv/ivtv-i2c.c

   1 /*
   2     I2C functions
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /*
  22     This file includes an i2c implementation that was reverse engineered
  23     from the Hauppauge windows driver.  Older ivtv versions used i2c-algo-bit,
  24     which whilst fine under most circumstances, had trouble with the Zilog
  25     CPU on the PVR-150 which handles IR functions (occasional inability to
  26     communicate with the chip until it was reset) and also with the i2c
  27     bus being completely unreachable when multiple PVR cards were present.
  28
  29     The implementation is very similar to i2c-algo-bit, but there are enough
  30     subtle differences that the two are hard to merge.  The general strategy
  31     employed by i2c-algo-bit is to use udelay() to implement the timing
  32     when putting out bits on the scl/sda lines.  The general strategy taken
  33     here is to poll the lines for state changes (see ivtv_waitscl and
  34     ivtv_waitsda).  In addition there are small delays at various locations
  35     which poll the SCL line 5 times (ivtv_scldelay).  I would guess that
  36     since this is memory mapped I/O that the length of those delays is tied
  37     to the PCI bus clock.  There is some extra code to do with recovery
  38     and retries.  Since it is not known what causes the actual i2c problems
  39     in the first place, the only goal if one was to attempt to use
  40     i2c-algo-bit would be to try to make it follow the same code path.
  41     This would be a lot of work, and I'm also not convinced that it would
  42     provide a generic benefit to i2c-algo-bit.  Therefore consider this
  43     an engineering solution -- not pretty, but it works.
  44
  45     Some more general comments about what we are doing:
  46
  47     The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA)
  48     lines.  To communicate on the bus (as a master, we don't act as a slave),
  49     we first initiate a start condition (ivtv_start).  We then write the
  50     address of the device that we want to communicate with, along with a flag
  51     that indicates whether this is a read or a write.  The slave then issues
  52     an ACK signal (ivtv_ack), which tells us that it is ready for reading /
  53     writing.  We then proceed with reading or writing (ivtv_read/ivtv_write),
  54     and finally issue a stop condition (ivtv_stop) to make the bus available
  55     to other masters.
  56
  57     There is an additional form of transaction where a write may be
  58     immediately followed by a read.  In this case, there is no intervening
  59     stop condition.  (Only the msp3400 chip uses this method of data transfer).
  60  */
  61
  62 #include "ivtv-driver.h"
  63 #include "ivtv-cards.h"
  64 #include "ivtv-gpio.h"
  65
  66 #include <media/ir-kbd-i2c.h>
  67
  68 /* i2c implementation for cx23415/6 chip, ivtv project.
  69  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  70  */
  71 /* i2c stuff */
  72 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
  73 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
  74 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
  75 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
  76
  77 #ifndef I2C_ADAP_CLASS_TV_ANALOG
  78 #define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
  79 #endif /* I2C_ADAP_CLASS_TV_ANALOG */
  80
  81 #define IVTV_CS53L32A_I2C_ADDR          0x11
  82 #define IVTV_CX25840_I2C_ADDR           0x44
  83 #define IVTV_SAA7115_I2C_ADDR           0x21
  84 #define IVTV_SAA7127_I2C_ADDR           0x44
  85 #define IVTV_SAA717x_I2C_ADDR           0x21
  86 #define IVTV_MSP3400_I2C_ADDR           0x40
  87 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
  88 #define IVTV_WM8739_I2C_ADDR            0x1a
  89 #define IVTV_WM8775_I2C_ADDR            0x1b
  90 #define IVTV_TEA5767_I2C_ADDR           0x60
  91 #define IVTV_UPD64031A_I2C_ADDR         0x12
  92 #define IVTV_UPD64083_I2C_ADDR          0x5c
  93 #define IVTV_TDA985X_I2C_ADDR           0x5b
  94
  95 /* This array should match the IVTV_HW_ defines */
  96 static const u8 hw_driverids[] = {
  97         I2C_DRIVERID_CX25840,
  98         I2C_DRIVERID_SAA711X,
  99         I2C_DRIVERID_SAA7127,
 100         I2C_DRIVERID_MSP3400,
 101         I2C_DRIVERID_TUNER,
 102         I2C_DRIVERID_WM8775,
 103         I2C_DRIVERID_CS53L32A,
 104         I2C_DRIVERID_TVEEPROM,
 105         I2C_DRIVERID_SAA711X,
 106         I2C_DRIVERID_TVAUDIO,
 107         I2C_DRIVERID_UPD64031A,
 108         I2C_DRIVERID_UPD64083,
 109         I2C_DRIVERID_SAA717X,
 110         I2C_DRIVERID_WM8739,
 111         0               /* IVTV_HW_GPIO dummy driver ID */
 112 };
 113
 114 /* This array should match the IVTV_HW_ defines */
 115 static const char * const hw_drivernames[] = {
 116         "cx2584x",
 117         "saa7115",
 118         "saa7127",
 119         "msp3400",
 120         "tuner",
 121         "wm8775",
 122         "cs53l32a",
 123         "tveeprom",
 124         "saa7114",
 125         "tvaudio",
 126         "upd64031a",
 127         "upd64083",
 128         "saa717x",
 129         "wm8739",
 130         "gpio",
 131 };
 132
 133 static int attach_inform(struct i2c_client *client)
 134 {
 135         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
 136         int i;
 137
 138         IVTV_DEBUG_I2C("i2c client attach\n");
 139         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 140                 if (itv->i2c_clients[i] == NULL) {
 141                         itv->i2c_clients[i] = client;
 142                         break;
 143                 }
 144         }
 145         if (i == I2C_CLIENTS_MAX) {
 146                 IVTV_ERR("insufficient room for new I2C client!\n");
 147         }
 148         return 0;
 149 }
 150
 151 static int detach_inform(struct i2c_client *client)
 152 {
 153         int i;
 154         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
 155
 156         IVTV_DEBUG_I2C("i2c client detach\n");
 157         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 158                 if (itv->i2c_clients[i] == client) {
 159                         itv->i2c_clients[i] = NULL;
 160                         break;
 161                 }
 162         }
 163         IVTV_DEBUG_I2C("i2c detach [client=%s,%s]\n",
 164                    client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
 165
 166         return 0;
 167 }
 168
 169 /* Set the serial clock line to the desired state */
 170 static void ivtv_setscl(struct ivtv *itv, int state)
 171 {
 172         /* write them out */
 173         /* write bits are inverted */
 174         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
 175 }
 176
 177 /* Set the serial data line to the desired state */
 178 static void ivtv_setsda(struct ivtv *itv, int state)
 179 {
 180         /* write them out */
 181         /* write bits are inverted */
 182         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
 183 }
 184
 185 /* Read the serial clock line */
 186 static int ivtv_getscl(struct ivtv *itv)
 187 {
 188         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 189 }
 190
 191 /* Read the serial data line */
 192 static int ivtv_getsda(struct ivtv *itv)
 193 {
 194         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 195 }
 196
 197 /* Implement a short delay by polling the serial clock line */
 198 static void ivtv_scldelay(struct ivtv *itv)
 199 {
 200         int i;
 201
 202         for (i = 0; i < 5; ++i)
 203                 ivtv_getscl(itv);
 204 }
 205
 206 /* Wait for the serial clock line to become set to a specific value */
 207 static int ivtv_waitscl(struct ivtv *itv, int val)
 208 {
 209         int i;
 210
 211         ivtv_scldelay(itv);
 212         for (i = 0; i < 1000; ++i) {
 213                 if (ivtv_getscl(itv) == val)
 214                         return 1;
 215         }
 216         return 0;
 217 }
 218
 219 /* Wait for the serial data line to become set to a specific value */
 220 static int ivtv_waitsda(struct ivtv *itv, int val)
 221 {
 222         int i;
 223
 224         ivtv_scldelay(itv);
 225         for (i = 0; i < 1000; ++i) {
 226                 if (ivtv_getsda(itv) == val)
 227                         return 1;
 228         }
 229         return 0;
 230 }
 231
 232 /* Wait for the slave to issue an ACK */
 233 static int ivtv_ack(struct ivtv *itv)
 234 {
 235         int ret = 0;
 236
 237         if (ivtv_getscl(itv) == 1) {
 238                 IVTV_DEBUG_I2C("SCL was high starting an ack\n");
 239                 ivtv_setscl(itv, 0);
 240                 if (!ivtv_waitscl(itv, 0)) {
 241                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
 242                         return -EREMOTEIO;
 243                 }
 244         }
 245         ivtv_setsda(itv, 1);
 246         ivtv_scldelay(itv);
 247         ivtv_setscl(itv, 1);
 248         if (!ivtv_waitsda(itv, 0)) {
 249                 IVTV_DEBUG_I2C("Slave did not ack\n");
 250                 ret = -EREMOTEIO;
 251         }
 252         ivtv_setscl(itv, 0);
 253         if (!ivtv_waitscl(itv, 0)) {
 254                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
 255                 ret = -EREMOTEIO;
 256         }
 257         return ret;
 258 }
 259
 260 /* Write a single byte to the i2c bus and wait for the slave to ACK */
 261 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
 262 {
 263         int i, bit;
 264
 265         IVTV_DEBUG_I2C("write %x\n",byte);
 266         for (i = 0; i < 8; ++i, byte<<=1) {
 267                 ivtv_setscl(itv, 0);
 268                 if (!ivtv_waitscl(itv, 0)) {
 269                         IVTV_DEBUG_I2C("Error setting SCL low\n");
 270                         return -EREMOTEIO;
 271                 }
 272                 bit = (byte>>7)&1;
 273                 ivtv_setsda(itv, bit);
 274                 if (!ivtv_waitsda(itv, bit)) {
 275                         IVTV_DEBUG_I2C("Error setting SDA\n");
 276                         return -EREMOTEIO;
 277                 }
 278                 ivtv_setscl(itv, 1);
 279                 if (!ivtv_waitscl(itv, 1)) {
 280                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
 281                         return -EREMOTEIO;
 282                 }
 283         }
 284         ivtv_setscl(itv, 0);
 285         if (!ivtv_waitscl(itv, 0)) {
 286                 IVTV_DEBUG_I2C("Error setting SCL low\n");
 287                 return -EREMOTEIO;
 288         }
 289         return ivtv_ack(itv);
 290 }
 291
 292 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
 293    final byte) */
 294 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
 295 {
 296         int i;
 297
 298         *byte = 0;
 299
 300         ivtv_setsda(itv, 1);
 301         ivtv_scldelay(itv);
 302         for (i = 0; i < 8; ++i) {
 303                 ivtv_setscl(itv, 0);
 304                 ivtv_scldelay(itv);
 305                 ivtv_setscl(itv, 1);
 306                 if (!ivtv_waitscl(itv, 1)) {
 307                         IVTV_DEBUG_I2C("Error setting SCL high\n");
 308                         return -EREMOTEIO;
 309                 }
 310                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
 311         }
 312         ivtv_setscl(itv, 0);
 313         ivtv_scldelay(itv);
 314         ivtv_setsda(itv, nack);
 315         ivtv_scldelay(itv);
 316         ivtv_setscl(itv, 1);
 317         ivtv_scldelay(itv);
 318         ivtv_setscl(itv, 0);
 319         ivtv_scldelay(itv);
 320         IVTV_DEBUG_I2C("read %x\n",*byte);
 321         return 0;
 322 }
 323
 324 /* Issue a start condition on the i2c bus to alert slaves to prepare for
 325    an address write */
 326 static int ivtv_start(struct ivtv *itv)
 327 {
 328         int sda;
 329
 330         sda = ivtv_getsda(itv);
 331         if (sda != 1) {
 332                 IVTV_DEBUG_I2C("SDA was low at start\n");
 333                 ivtv_setsda(itv, 1);
 334                 if (!ivtv_waitsda(itv, 1)) {
 335                         IVTV_DEBUG_I2C("SDA stuck low\n");
 336                         return -EREMOTEIO;
 337                 }
 338         }
 339         if (ivtv_getscl(itv) != 1) {
 340                 ivtv_setscl(itv, 1);
 341                 if (!ivtv_waitscl(itv, 1)) {
 342                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
 343                         return -EREMOTEIO;
 344                 }
 345         }
 346         ivtv_setsda(itv, 0);
 347         ivtv_scldelay(itv);
 348         return 0;
 349 }
 350
 351 /* Issue a stop condition on the i2c bus to release it */
 352 static int ivtv_stop(struct ivtv *itv)
 353 {
 354         int i;
 355
 356         if (ivtv_getscl(itv) != 0) {
 357                 IVTV_DEBUG_I2C("SCL not low when stopping\n");
 358                 ivtv_setscl(itv, 0);
 359                 if (!ivtv_waitscl(itv, 0)) {
 360                         IVTV_DEBUG_I2C("SCL could not be set low\n");
 361                 }
 362         }
 363         ivtv_setsda(itv, 0);
 364         ivtv_scldelay(itv);
 365         ivtv_setscl(itv, 1);
 366         if (!ivtv_waitscl(itv, 1)) {
 367                 IVTV_DEBUG_I2C("SCL could not be set high\n");
 368                 return -EREMOTEIO;
 369         }
 370         ivtv_scldelay(itv);
 371         ivtv_setsda(itv, 1);
 372         if (!ivtv_waitsda(itv, 1)) {
 373                 IVTV_DEBUG_I2C("resetting I2C\n");
 374                 for (i = 0; i < 16; ++i) {
 375                         ivtv_setscl(itv, 0);
 376                         ivtv_scldelay(itv);
 377                         ivtv_setscl(itv, 1);
 378                         ivtv_scldelay(itv);
 379                         ivtv_setsda(itv, 1);
 380                 }
 381                 ivtv_waitsda(itv, 1);
 382                 return -EREMOTEIO;
 383         }
 384         return 0;
 385 }
 386
 387 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
 388    issuing the i2c stop condition (when following with a read) */
 389 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
 390 {
 391         int retry, ret = -EREMOTEIO;
 392         u32 i;
 393
 394         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 395                 ret = ivtv_start(itv);
 396
 397                 if (ret == 0) {
 398                         ret = ivtv_sendbyte(itv, addr<<1);
 399                         for (i = 0; ret == 0 && i < len; ++i)
 400                                 ret = ivtv_sendbyte(itv, data[i]);
 401                 }
 402                 if (ret != 0 || do_stop) {
 403                         ivtv_stop(itv);
 404                 }
 405         }
 406         if (ret)
 407                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
 408         return ret;
 409 }
 410
 411 /* Read data from the given i2c slave.  A stop condition is always issued. */
 412 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
 413 {
 414         int retry, ret = -EREMOTEIO;
 415         u32 i;
 416
 417         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 418                 ret = ivtv_start(itv);
 419                 if (ret == 0)
 420                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
 421                 for (i = 0; ret == 0 && i < len; ++i) {
 422                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
 423                 }
 424                 ivtv_stop(itv);
 425         }
 426         if (ret)
 427                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
 428         return ret;
 429 }
 430
 431 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
 432    or written.  If a read follows a write, this will occur without an
 433    intervening stop condition */
 434 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 435 {
 436         struct ivtv *itv = i2c_get_adapdata(i2c_adap);
 437         int retval;
 438         int i;
 439
 440         mutex_lock(&itv->i2c_bus_lock);
 441         for (i = retval = 0; retval == 0 && i < num; i++) {
 442                 if (msgs[i].flags & I2C_M_RD)
 443                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
 444                 else {
 445                         /* if followed by a read, don't stop */
 446                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
 447
 448                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
 449                 }
 450         }
 451         mutex_unlock(&itv->i2c_bus_lock);
 452         return retval ? retval : num;
 453 }
 454
 455 /* Kernel i2c capabilities */
 456 static u32 ivtv_functionality(struct i2c_adapter *adap)
 457 {
 458         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 459 }
 460
 461 static struct i2c_algorithm ivtv_algo = {
 462         .master_xfer   = ivtv_xfer,
 463         .functionality = ivtv_functionality,
 464 };
 465
 466 /* template for our-bit banger */
 467 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
 468         .name = "ivtv i2c driver",
 469         .id = I2C_HW_B_CX2341X,
 470         .algo = &ivtv_algo,
 471         .algo_data = NULL,                      /* filled from template */
 472         .client_register = attach_inform,
 473         .client_unregister = detach_inform,
 474         .owner = THIS_MODULE,
 475 #ifdef I2C_ADAP_CLASS_TV_ANALOG
 476         .class = I2C_ADAP_CLASS_TV_ANALOG,
 477 #endif
 478 };
 479
 480 static void ivtv_setscl_old(void *data, int state)
 481 {
 482         struct ivtv *itv = (struct ivtv *)data;
 483
 484         if (state)
 485                 itv->i2c_state |= 0x01;
 486         else
 487                 itv->i2c_state &= ~0x01;
 488
 489         /* write them out */
 490         /* write bits are inverted */
 491         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
 492 }
 493
 494 static void ivtv_setsda_old(void *data, int state)
 495 {
 496         struct ivtv *itv = (struct ivtv *)data;
 497
 498         if (state)
 499                 itv->i2c_state |= 0x01;
 500         else
 501                 itv->i2c_state &= ~0x01;
 502
 503         /* write them out */
 504         /* write bits are inverted */
 505         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
 506 }
 507
 508 static int ivtv_getscl_old(void *data)
 509 {
 510         struct ivtv *itv = (struct ivtv *)data;
 511
 512         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 513 }
 514
 515 static int ivtv_getsda_old(void *data)
 516 {
 517         struct ivtv *itv = (struct ivtv *)data;
 518
 519         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 520 }
 521
 522 /* template for i2c-bit-algo */
 523 static struct i2c_adapter ivtv_i2c_adap_template = {
 524         .name = "ivtv i2c driver",
 525         .id = I2C_HW_B_CX2341X,         /* algo-bit is OR'd with this */
 526         .algo = NULL,                   /* set by i2c-algo-bit */
 527         .algo_data = NULL,              /* filled from template */
 528         .client_register = attach_inform,
 529         .client_unregister = detach_inform,
 530         .owner = THIS_MODULE,
 531 #ifdef I2C_ADAP_CLASS_TV_ANALOG
 532         .class = I2C_ADAP_CLASS_TV_ANALOG,
 533 #endif
 534 };
 535
 536 static struct i2c_algo_bit_data ivtv_i2c_algo_template = {
 537         NULL,                   /* ?? */
 538         ivtv_setsda_old,        /* setsda function */
 539         ivtv_setscl_old,        /* " */
 540         ivtv_getsda_old,        /* " */
 541         ivtv_getscl_old,        /* " */
 542         10,                     /* udelay */
 543         200                     /* timeout */
 544 };
 545
 546 static struct i2c_client ivtv_i2c_client_template = {
 547         .name = "ivtv internal use only",
 548 };
 549
 550 int ivtv_call_i2c_client(struct ivtv *itv, int addr, unsigned int cmd, void *arg)
 551 {
 552         struct i2c_client *client;
 553         int retval;
 554         int i;
 555
 556         IVTV_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
 557         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 558                 client = itv->i2c_clients[i];
 559                 if (client == NULL) {
 560                         continue;
 561                 }
 562                 if (client->driver->command == NULL) {
 563                         continue;
 564                 }
 565                 if (addr == client->addr) {
 566                         retval = client->driver->command(client, cmd, arg);
 567                         return retval;
 568                 }
 569         }
 570         if (cmd != VIDIOC_G_CHIP_IDENT)
 571                 IVTV_ERR("i2c addr 0x%02x not found for command 0x%x!\n", addr, cmd);
 572         return -ENODEV;
 573 }
 574
 575 /* Find the i2c device based on the driver ID and return
 576    its i2c address or -ENODEV if no matching device was found. */
 577 int ivtv_i2c_id_addr(struct ivtv *itv, u32 id)
 578 {
 579         struct i2c_client *client;
 580         int retval = -ENODEV;
 581         int i;
 582
 583         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 584                 client = itv->i2c_clients[i];
 585                 if (client == NULL)
 586                         continue;
 587                 if (id == client->driver->id) {
 588                         retval = client->addr;
 589                         break;
 590                 }
 591         }
 592         return retval;
 593 }
 594
 595 /* Find the i2c device name matching the DRIVERID */
 596 static const char *ivtv_i2c_id_name(u32 id)
 597 {
 598         int i;
 599
 600         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 601                 if (hw_driverids[i] == id)
 602                         return hw_drivernames[i];
 603         return "unknown device";
 604 }
 605
 606 /* Find the i2c device name matching the IVTV_HW_ flag */
 607 static const char *ivtv_i2c_hw_name(u32 hw)
 608 {
 609         int i;
 610
 611         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 612                 if (1 << i == hw)
 613                         return hw_drivernames[i];
 614         return "unknown device";
 615 }
 616
 617 /* Find the i2c device matching the IVTV_HW_ flag and return
 618    its i2c address or -ENODEV if no matching device was found. */
 619 int ivtv_i2c_hw_addr(struct ivtv *itv, u32 hw)
 620 {
 621         int i;
 622
 623         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 624                 if (1 << i == hw)
 625                         return ivtv_i2c_id_addr(itv, hw_driverids[i]);
 626         return -ENODEV;
 627 }
 628
 629 /* Calls i2c device based on IVTV_HW_ flag. If hw == 0, then do nothing.
 630    If hw == IVTV_HW_GPIO then call the gpio handler. */
 631 int ivtv_i2c_hw(struct ivtv *itv, u32 hw, unsigned int cmd, void *arg)
 632 {
 633         int addr;
 634
 635         if (hw == IVTV_HW_GPIO)
 636                 return ivtv_gpio(itv, cmd, arg);
 637         if (hw == 0)
 638                 return 0;
 639
 640         addr = ivtv_i2c_hw_addr(itv, hw);
 641         if (addr < 0) {
 642                 IVTV_ERR("i2c hardware 0x%08x (%s) not found for command 0x%x!\n",
 643                                hw, ivtv_i2c_hw_name(hw), cmd);
 644                 return addr;
 645         }
 646         return ivtv_call_i2c_client(itv, addr, cmd, arg);
 647 }
 648
 649 /* Calls i2c device based on I2C driver ID. */
 650 int ivtv_i2c_id(struct ivtv *itv, u32 id, unsigned int cmd, void *arg)
 651 {
 652         int addr;
 653
 654         addr = ivtv_i2c_id_addr(itv, id);
 655         if (addr < 0) {
 656                 if (cmd != VIDIOC_G_CHIP_IDENT)
 657                         IVTV_ERR("i2c ID 0x%08x (%s) not found for command 0x%x!\n",
 658                                 id, ivtv_i2c_id_name(id), cmd);
 659                 return addr;
 660         }
 661         return ivtv_call_i2c_client(itv, addr, cmd, arg);
 662 }
 663
 664 int ivtv_cx25840(struct ivtv *itv, unsigned int cmd, void *arg)
 665 {
 666         return ivtv_call_i2c_client(itv, IVTV_CX25840_I2C_ADDR, cmd, arg);
 667 }
 668
 669 int ivtv_saa7115(struct ivtv *itv, unsigned int cmd, void *arg)
 670 {
 671         return ivtv_call_i2c_client(itv, IVTV_SAA7115_I2C_ADDR, cmd, arg);
 672 }
 673
 674 int ivtv_saa7127(struct ivtv *itv, unsigned int cmd, void *arg)
 675 {
 676         return ivtv_call_i2c_client(itv, IVTV_SAA7127_I2C_ADDR, cmd, arg);
 677 }
 678
 679 int ivtv_saa717x(struct ivtv *itv, unsigned int cmd, void *arg)
 680 {
 681         return ivtv_call_i2c_client(itv, IVTV_SAA717x_I2C_ADDR, cmd, arg);
 682 }
 683
 684 int ivtv_msp34xx(struct ivtv *itv, unsigned int cmd, void *arg)
 685 {
 686         return ivtv_call_i2c_client(itv, IVTV_MSP3400_I2C_ADDR, cmd, arg);
 687 }
 688
 689 int ivtv_upd64031a(struct ivtv *itv, unsigned int cmd, void *arg)
 690 {
 691         return ivtv_call_i2c_client(itv, IVTV_UPD64031A_I2C_ADDR, cmd, arg);
 692 }
 693
 694 int ivtv_upd64083(struct ivtv *itv, unsigned int cmd, void *arg)
 695 {
 696         return ivtv_call_i2c_client(itv, IVTV_UPD64083_I2C_ADDR, cmd, arg);
 697 }
 698
 699 /* broadcast cmd for all I2C clients and for the gpio subsystem */
 700 void ivtv_call_i2c_clients(struct ivtv *itv, unsigned int cmd, void *arg)
 701 {
 702         if (itv->i2c_adap.algo == NULL) {
 703                 IVTV_ERR("adapter is not set");
 704                 return;
 705         }
 706         i2c_clients_command(&itv->i2c_adap, cmd, arg);
 707         if (itv->hw_flags & IVTV_HW_GPIO)
 708                 ivtv_gpio(itv, cmd, arg);
 709 }
 710
 711 /* init + register i2c algo-bit adapter */
 712 int __devinit init_ivtv_i2c(struct ivtv *itv)
 713 {
 714         IVTV_DEBUG_I2C("i2c init\n");
 715
 716         if (itv->options.newi2c > 0) {
 717                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
 718                        sizeof(struct i2c_adapter));
 719         } else {
 720                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
 721                        sizeof(struct i2c_adapter));
 722                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
 723                        sizeof(struct i2c_algo_bit_data));
 724                 itv->i2c_algo.data = itv;
 725                 itv->i2c_adap.algo_data = &itv->i2c_algo;
 726         }
 727
 728         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
 729                 itv->num);
 730         i2c_set_adapdata(&itv->i2c_adap, itv);
 731
 732         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
 733                sizeof(struct i2c_client));
 734         itv->i2c_client.adapter = &itv->i2c_adap;
 735         itv->i2c_adap.dev.parent = &itv->dev->dev;
 736
 737         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
 738         ivtv_setscl(itv, 1);
 739         ivtv_setsda(itv, 1);
 740
 741         if (itv->options.newi2c > 0)
 742                 return i2c_add_adapter(&itv->i2c_adap);
 743         else
 744                 return i2c_bit_add_bus(&itv->i2c_adap);
 745 }
 746
 747 void __devexit exit_ivtv_i2c(struct ivtv *itv)
 748 {
 749         IVTV_DEBUG_I2C("i2c exit\n");
 750
 751         i2c_del_adapter(&itv->i2c_adap);
 752 }