SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 #include "ivtv-i2c.h"
  66
  67 #include <media/ir-kbd-i2c.h>
  68
  69 /* i2c implementation for cx23415/6 chip, ivtv project.
  70  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  71  */
  72 /* i2c stuff */
  73 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
  74 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
  75 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
  76 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
  77
  78 #ifndef I2C_ADAP_CLASS_TV_ANALOG
  79 #define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
  80 #endif /* I2C_ADAP_CLASS_TV_ANALOG */
  81
  82 #define IVTV_CS53L32A_I2C_ADDR          0x11
  83 #define IVTV_CX25840_I2C_ADDR           0x44
  84 #define IVTV_SAA7115_I2C_ADDR           0x21
  85 #define IVTV_SAA7127_I2C_ADDR           0x44
  86 #define IVTV_SAA717x_I2C_ADDR           0x21
  87 #define IVTV_MSP3400_I2C_ADDR           0x40
  88 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
  89 #define IVTV_WM8739_I2C_ADDR            0x1a
  90 #define IVTV_WM8775_I2C_ADDR            0x1b
  91 #define IVTV_TEA5767_I2C_ADDR           0x60
  92 #define IVTV_UPD64031A_I2C_ADDR         0x12
  93 #define IVTV_UPD64083_I2C_ADDR          0x5c
  94 #define IVTV_TDA985X_I2C_ADDR           0x5b
  95
  96 /* This array should match the IVTV_HW_ defines */
  97 static const u8 hw_driverids[] = {
  98         I2C_DRIVERID_CX25840,
  99         I2C_DRIVERID_SAA711X,
 100         I2C_DRIVERID_SAA7127,
 101         I2C_DRIVERID_MSP3400,
 102         I2C_DRIVERID_TUNER,
 103         I2C_DRIVERID_WM8775,
 104         I2C_DRIVERID_CS53L32A,
 105         I2C_DRIVERID_TVEEPROM,
 106         I2C_DRIVERID_SAA711X,
 107         I2C_DRIVERID_TVAUDIO,
 108         I2C_DRIVERID_UPD64031A,
 109         I2C_DRIVERID_UPD64083,
 110         I2C_DRIVERID_SAA717X,
 111         I2C_DRIVERID_WM8739,
 112         0               /* IVTV_HW_GPIO dummy driver ID */
 113 };
 114
 115 /* This array should match the IVTV_HW_ defines */
 116 static const char * const hw_drivernames[] = {
 117         "cx2584x",
 118         "saa7115",
 119         "saa7127",
 120         "msp3400",
 121         "tuner",
 122         "wm8775",
 123         "cs53l32a",
 124         "tveeprom",
 125         "saa7114",
 126         "tvaudio",
 127         "upd64031a",
 128         "upd64083",
 129         "saa717x",
 130         "wm8739",
 131         "gpio",
 132 };
 133
 134 static int attach_inform(struct i2c_client *client)
 135 {
 136         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
 137         int i;
 138
 139         IVTV_DEBUG_I2C("i2c client attach\n");
 140         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 141                 if (itv->i2c_clients[i] == NULL) {
 142                         itv->i2c_clients[i] = client;
 143                         break;
 144                 }
 145         }
 146         if (i == I2C_CLIENTS_MAX) {
 147                 IVTV_ERR("Insufficient room for new I2C client\n");
 148         }
 149         return 0;
 150 }
 151
 152 static int detach_inform(struct i2c_client *client)
 153 {
 154         int i;
 155         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
 156
 157         IVTV_DEBUG_I2C("i2c client detach\n");
 158         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 159                 if (itv->i2c_clients[i] == client) {
 160                         itv->i2c_clients[i] = NULL;
 161                         break;
 162                 }
 163         }
 164         IVTV_DEBUG_I2C("i2c detach [client=%s,%s]\n",
 165                    client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
 166
 167         return 0;
 168 }
 169
 170 /* Set the serial clock line to the desired state */
 171 static void ivtv_setscl(struct ivtv *itv, int state)
 172 {
 173         /* write them out */
 174         /* write bits are inverted */
 175         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
 176 }
 177
 178 /* Set the serial data line to the desired state */
 179 static void ivtv_setsda(struct ivtv *itv, int state)
 180 {
 181         /* write them out */
 182         /* write bits are inverted */
 183         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
 184 }
 185
 186 /* Read the serial clock line */
 187 static int ivtv_getscl(struct ivtv *itv)
 188 {
 189         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 190 }
 191
 192 /* Read the serial data line */
 193 static int ivtv_getsda(struct ivtv *itv)
 194 {
 195         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 196 }
 197
 198 /* Implement a short delay by polling the serial clock line */
 199 static void ivtv_scldelay(struct ivtv *itv)
 200 {
 201         int i;
 202
 203         for (i = 0; i < 5; ++i)
 204                 ivtv_getscl(itv);
 205 }
 206
 207 /* Wait for the serial clock line to become set to a specific value */
 208 static int ivtv_waitscl(struct ivtv *itv, int val)
 209 {
 210         int i;
 211
 212         ivtv_scldelay(itv);
 213         for (i = 0; i < 1000; ++i) {
 214                 if (ivtv_getscl(itv) == val)
 215                         return 1;
 216         }
 217         return 0;
 218 }
 219
 220 /* Wait for the serial data line to become set to a specific value */
 221 static int ivtv_waitsda(struct ivtv *itv, int val)
 222 {
 223         int i;
 224
 225         ivtv_scldelay(itv);
 226         for (i = 0; i < 1000; ++i) {
 227                 if (ivtv_getsda(itv) == val)
 228                         return 1;
 229         }
 230         return 0;
 231 }
 232
 233 /* Wait for the slave to issue an ACK */
 234 static int ivtv_ack(struct ivtv *itv)
 235 {
 236         int ret = 0;
 237
 238         if (ivtv_getscl(itv) == 1) {
 239                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
 240                 ivtv_setscl(itv, 0);
 241                 if (!ivtv_waitscl(itv, 0)) {
 242                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
 243                         return -EREMOTEIO;
 244                 }
 245         }
 246         ivtv_setsda(itv, 1);
 247         ivtv_scldelay(itv);
 248         ivtv_setscl(itv, 1);
 249         if (!ivtv_waitsda(itv, 0)) {
 250                 IVTV_DEBUG_I2C("Slave did not ack\n");
 251                 ret = -EREMOTEIO;
 252         }
 253         ivtv_setscl(itv, 0);
 254         if (!ivtv_waitscl(itv, 0)) {
 255                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
 256                 ret = -EREMOTEIO;
 257         }
 258         return ret;
 259 }
 260
 261 /* Write a single byte to the i2c bus and wait for the slave to ACK */
 262 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
 263 {
 264         int i, bit;
 265
 266         IVTV_DEBUG_HI_I2C("write %x\n",byte);
 267         for (i = 0; i < 8; ++i, byte<<=1) {
 268                 ivtv_setscl(itv, 0);
 269                 if (!ivtv_waitscl(itv, 0)) {
 270                         IVTV_DEBUG_I2C("Error setting SCL low\n");
 271                         return -EREMOTEIO;
 272                 }
 273                 bit = (byte>>7)&1;
 274                 ivtv_setsda(itv, bit);
 275                 if (!ivtv_waitsda(itv, bit)) {
 276                         IVTV_DEBUG_I2C("Error setting SDA\n");
 277                         return -EREMOTEIO;
 278                 }
 279                 ivtv_setscl(itv, 1);
 280                 if (!ivtv_waitscl(itv, 1)) {
 281                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
 282                         return -EREMOTEIO;
 283                 }
 284         }
 285         ivtv_setscl(itv, 0);
 286         if (!ivtv_waitscl(itv, 0)) {
 287                 IVTV_DEBUG_I2C("Error setting SCL low\n");
 288                 return -EREMOTEIO;
 289         }
 290         return ivtv_ack(itv);
 291 }
 292
 293 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
 294    final byte) */
 295 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
 296 {
 297         int i;
 298
 299         *byte = 0;
 300
 301         ivtv_setsda(itv, 1);
 302         ivtv_scldelay(itv);
 303         for (i = 0; i < 8; ++i) {
 304                 ivtv_setscl(itv, 0);
 305                 ivtv_scldelay(itv);
 306                 ivtv_setscl(itv, 1);
 307                 if (!ivtv_waitscl(itv, 1)) {
 308                         IVTV_DEBUG_I2C("Error setting SCL high\n");
 309                         return -EREMOTEIO;
 310                 }
 311                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
 312         }
 313         ivtv_setscl(itv, 0);
 314         ivtv_scldelay(itv);
 315         ivtv_setsda(itv, nack);
 316         ivtv_scldelay(itv);
 317         ivtv_setscl(itv, 1);
 318         ivtv_scldelay(itv);
 319         ivtv_setscl(itv, 0);
 320         ivtv_scldelay(itv);
 321         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
 322         return 0;
 323 }
 324
 325 /* Issue a start condition on the i2c bus to alert slaves to prepare for
 326    an address write */
 327 static int ivtv_start(struct ivtv *itv)
 328 {
 329         int sda;
 330
 331         sda = ivtv_getsda(itv);
 332         if (sda != 1) {
 333                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
 334                 ivtv_setsda(itv, 1);
 335                 if (!ivtv_waitsda(itv, 1)) {
 336                         IVTV_DEBUG_I2C("SDA stuck low\n");
 337                         return -EREMOTEIO;
 338                 }
 339         }
 340         if (ivtv_getscl(itv) != 1) {
 341                 ivtv_setscl(itv, 1);
 342                 if (!ivtv_waitscl(itv, 1)) {
 343                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
 344                         return -EREMOTEIO;
 345                 }
 346         }
 347         ivtv_setsda(itv, 0);
 348         ivtv_scldelay(itv);
 349         return 0;
 350 }
 351
 352 /* Issue a stop condition on the i2c bus to release it */
 353 static int ivtv_stop(struct ivtv *itv)
 354 {
 355         int i;
 356
 357         if (ivtv_getscl(itv) != 0) {
 358                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
 359                 ivtv_setscl(itv, 0);
 360                 if (!ivtv_waitscl(itv, 0)) {
 361                         IVTV_DEBUG_I2C("SCL could not be set low\n");
 362                 }
 363         }
 364         ivtv_setsda(itv, 0);
 365         ivtv_scldelay(itv);
 366         ivtv_setscl(itv, 1);
 367         if (!ivtv_waitscl(itv, 1)) {
 368                 IVTV_DEBUG_I2C("SCL could not be set high\n");
 369                 return -EREMOTEIO;
 370         }
 371         ivtv_scldelay(itv);
 372         ivtv_setsda(itv, 1);
 373         if (!ivtv_waitsda(itv, 1)) {
 374                 IVTV_DEBUG_I2C("resetting I2C\n");
 375                 for (i = 0; i < 16; ++i) {
 376                         ivtv_setscl(itv, 0);
 377                         ivtv_scldelay(itv);
 378                         ivtv_setscl(itv, 1);
 379                         ivtv_scldelay(itv);
 380                         ivtv_setsda(itv, 1);
 381                 }
 382                 ivtv_waitsda(itv, 1);
 383                 return -EREMOTEIO;
 384         }
 385         return 0;
 386 }
 387
 388 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
 389    issuing the i2c stop condition (when following with a read) */
 390 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
 391 {
 392         int retry, ret = -EREMOTEIO;
 393         u32 i;
 394
 395         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 396                 ret = ivtv_start(itv);
 397
 398                 if (ret == 0) {
 399                         ret = ivtv_sendbyte(itv, addr<<1);
 400                         for (i = 0; ret == 0 && i < len; ++i)
 401                                 ret = ivtv_sendbyte(itv, data[i]);
 402                 }
 403                 if (ret != 0 || do_stop) {
 404                         ivtv_stop(itv);
 405                 }
 406         }
 407         if (ret)
 408                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
 409         return ret;
 410 }
 411
 412 /* Read data from the given i2c slave.  A stop condition is always issued. */
 413 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
 414 {
 415         int retry, ret = -EREMOTEIO;
 416         u32 i;
 417
 418         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 419                 ret = ivtv_start(itv);
 420                 if (ret == 0)
 421                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
 422                 for (i = 0; ret == 0 && i < len; ++i) {
 423                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
 424                 }
 425                 ivtv_stop(itv);
 426         }
 427         if (ret)
 428                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
 429         return ret;
 430 }
 431
 432 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
 433    or written.  If a read follows a write, this will occur without an
 434    intervening stop condition */
 435 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 436 {
 437         struct ivtv *itv = i2c_get_adapdata(i2c_adap);
 438         int retval;
 439         int i;
 440
 441         mutex_lock(&itv->i2c_bus_lock);
 442         for (i = retval = 0; retval == 0 && i < num; i++) {
 443                 if (msgs[i].flags & I2C_M_RD)
 444                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
 445                 else {
 446                         /* if followed by a read, don't stop */
 447                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
 448
 449                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
 450                 }
 451         }
 452         mutex_unlock(&itv->i2c_bus_lock);
 453         return retval ? retval : num;
 454 }
 455
 456 /* Kernel i2c capabilities */
 457 static u32 ivtv_functionality(struct i2c_adapter *adap)
 458 {
 459         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 460 }
 461
 462 static struct i2c_algorithm ivtv_algo = {
 463         .master_xfer   = ivtv_xfer,
 464         .functionality = ivtv_functionality,
 465 };
 466
 467 /* template for our-bit banger */
 468 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
 469         .name = "ivtv i2c driver",
 470         .id = I2C_HW_B_CX2341X,
 471         .algo = &ivtv_algo,
 472         .algo_data = NULL,                      /* filled from template */
 473         .client_register = attach_inform,
 474         .client_unregister = detach_inform,
 475         .owner = THIS_MODULE,
 476 #ifdef I2C_ADAP_CLASS_TV_ANALOG
 477         .class = I2C_ADAP_CLASS_TV_ANALOG,
 478 #endif
 479 };
 480
 481 static void ivtv_setscl_old(void *data, int state)
 482 {
 483         struct ivtv *itv = (struct ivtv *)data;
 484
 485         if (state)
 486                 itv->i2c_state |= 0x01;
 487         else
 488                 itv->i2c_state &= ~0x01;
 489
 490         /* write them out */
 491         /* write bits are inverted */
 492         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
 493 }
 494
 495 static void ivtv_setsda_old(void *data, int state)
 496 {
 497         struct ivtv *itv = (struct ivtv *)data;
 498
 499         if (state)
 500                 itv->i2c_state |= 0x01;
 501         else
 502                 itv->i2c_state &= ~0x01;
 503
 504         /* write them out */
 505         /* write bits are inverted */
 506         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
 507 }
 508
 509 static int ivtv_getscl_old(void *data)
 510 {
 511         struct ivtv *itv = (struct ivtv *)data;
 512
 513         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 514 }
 515
 516 static int ivtv_getsda_old(void *data)
 517 {
 518         struct ivtv *itv = (struct ivtv *)data;
 519
 520         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 521 }
 522
 523 /* template for i2c-bit-algo */
 524 static struct i2c_adapter ivtv_i2c_adap_template = {
 525         .name = "ivtv i2c driver",
 526         .id = I2C_HW_B_CX2341X,         /* algo-bit is OR'd with this */
 527         .algo = NULL,                   /* set by i2c-algo-bit */
 528         .algo_data = NULL,              /* filled from template */
 529         .client_register = attach_inform,
 530         .client_unregister = detach_inform,
 531         .owner = THIS_MODULE,
 532 #ifdef I2C_ADAP_CLASS_TV_ANALOG
 533         .class = I2C_ADAP_CLASS_TV_ANALOG,
 534 #endif
 535 };
 536
 537 static struct i2c_algo_bit_data ivtv_i2c_algo_template = {
 538         NULL,                   /* ?? */
 539         ivtv_setsda_old,        /* setsda function */
 540         ivtv_setscl_old,        /* " */
 541         ivtv_getsda_old,        /* " */
 542         ivtv_getscl_old,        /* " */
 543         10,                     /* udelay */
 544         200                     /* timeout */
 545 };
 546
 547 static struct i2c_client ivtv_i2c_client_template = {
 548         .name = "ivtv internal",
 549 };
 550
 551 int ivtv_call_i2c_client(struct ivtv *itv, int addr, unsigned int cmd, void *arg)
 552 {
 553         struct i2c_client *client;
 554         int retval;
 555         int i;
 556
 557         IVTV_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
 558         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 559                 client = itv->i2c_clients[i];
 560                 if (client == NULL) {
 561                         continue;
 562                 }
 563                 if (client->driver->command == NULL) {
 564                         continue;
 565                 }
 566                 if (addr == client->addr) {
 567                         retval = client->driver->command(client, cmd, arg);
 568                         return retval;
 569                 }
 570         }
 571         if (cmd != VIDIOC_G_CHIP_IDENT)
 572                 IVTV_ERR("i2c addr 0x%02x not found for command 0x%x\n", addr, cmd);
 573         return -ENODEV;
 574 }
 575
 576 /* Find the i2c device based on the driver ID and return
 577    its i2c address or -ENODEV if no matching device was found. */
 578 static int ivtv_i2c_id_addr(struct ivtv *itv, u32 id)
 579 {
 580         struct i2c_client *client;
 581         int retval = -ENODEV;
 582         int i;
 583
 584         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
 585                 client = itv->i2c_clients[i];
 586                 if (client == NULL)
 587                         continue;
 588                 if (id == client->driver->id) {
 589                         retval = client->addr;
 590                         break;
 591                 }
 592         }
 593         return retval;
 594 }
 595
 596 /* Find the i2c device name matching the DRIVERID */
 597 static const char *ivtv_i2c_id_name(u32 id)
 598 {
 599         int i;
 600
 601         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 602                 if (hw_driverids[i] == id)
 603                         return hw_drivernames[i];
 604         return "unknown device";
 605 }
 606
 607 /* Find the i2c device name matching the IVTV_HW_ flag */
 608 static const char *ivtv_i2c_hw_name(u32 hw)
 609 {
 610         int i;
 611
 612         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 613                 if (1 << i == hw)
 614                         return hw_drivernames[i];
 615         return "unknown device";
 616 }
 617
 618 /* Find the i2c device matching the IVTV_HW_ flag and return
 619    its i2c address or -ENODEV if no matching device was found. */
 620 int ivtv_i2c_hw_addr(struct ivtv *itv, u32 hw)
 621 {
 622         int i;
 623
 624         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
 625                 if (1 << i == hw)
 626                         return ivtv_i2c_id_addr(itv, hw_driverids[i]);
 627         return -ENODEV;
 628 }
 629
 630 /* Calls i2c device based on IVTV_HW_ flag. If hw == 0, then do nothing.
 631    If hw == IVTV_HW_GPIO then call the gpio handler. */
 632 int ivtv_i2c_hw(struct ivtv *itv, u32 hw, unsigned int cmd, void *arg)
 633 {
 634         int addr;
 635
 636         if (hw == IVTV_HW_GPIO)
 637                 return ivtv_gpio(itv, cmd, arg);
 638         if (hw == 0)
 639                 return 0;
 640
 641         addr = ivtv_i2c_hw_addr(itv, hw);
 642         if (addr < 0) {
 643                 IVTV_ERR("i2c hardware 0x%08x (%s) not found for command 0x%x\n",
 644                                hw, ivtv_i2c_hw_name(hw), cmd);
 645                 return addr;
 646         }
 647         return ivtv_call_i2c_client(itv, addr, cmd, arg);
 648 }
 649
 650 /* Calls i2c device based on I2C driver ID. */
 651 int ivtv_i2c_id(struct ivtv *itv, u32 id, unsigned int cmd, void *arg)
 652 {
 653         int addr;
 654
 655         addr = ivtv_i2c_id_addr(itv, id);
 656         if (addr < 0) {
 657                 if (cmd != VIDIOC_G_CHIP_IDENT)
 658                         IVTV_ERR("i2c ID 0x%08x (%s) not found for command 0x%x\n",
 659                                 id, ivtv_i2c_id_name(id), cmd);
 660                 return addr;
 661         }
 662         return ivtv_call_i2c_client(itv, addr, cmd, arg);
 663 }
 664
 665 int ivtv_cx25840(struct ivtv *itv, unsigned int cmd, void *arg)
 666 {
 667         return ivtv_call_i2c_client(itv, IVTV_CX25840_I2C_ADDR, cmd, arg);
 668 }
 669
 670 int ivtv_saa7115(struct ivtv *itv, unsigned int cmd, void *arg)
 671 {
 672         return ivtv_call_i2c_client(itv, IVTV_SAA7115_I2C_ADDR, cmd, arg);
 673 }
 674
 675 int ivtv_saa7127(struct ivtv *itv, unsigned int cmd, void *arg)
 676 {
 677         return ivtv_call_i2c_client(itv, IVTV_SAA7127_I2C_ADDR, cmd, arg);
 678 }
 679
 680 int ivtv_saa717x(struct ivtv *itv, unsigned int cmd, void *arg)
 681 {
 682         return ivtv_call_i2c_client(itv, IVTV_SAA717x_I2C_ADDR, cmd, arg);
 683 }
 684
 685 int ivtv_upd64031a(struct ivtv *itv, unsigned int cmd, void *arg)
 686 {
 687         return ivtv_call_i2c_client(itv, IVTV_UPD64031A_I2C_ADDR, cmd, arg);
 688 }
 689
 690 int ivtv_upd64083(struct ivtv *itv, unsigned int cmd, void *arg)
 691 {
 692         return ivtv_call_i2c_client(itv, IVTV_UPD64083_I2C_ADDR, cmd, arg);
 693 }
 694
 695 /* broadcast cmd for all I2C clients and for the gpio subsystem */
 696 void ivtv_call_i2c_clients(struct ivtv *itv, unsigned int cmd, void *arg)
 697 {
 698         if (itv->i2c_adap.algo == NULL) {
 699                 IVTV_ERR("Adapter is not set");
 700                 return;
 701         }
 702         i2c_clients_command(&itv->i2c_adap, cmd, arg);
 703         if (itv->hw_flags & IVTV_HW_GPIO)
 704                 ivtv_gpio(itv, cmd, arg);
 705 }
 706
 707 /* init + register i2c algo-bit adapter */
 708 int __devinit init_ivtv_i2c(struct ivtv *itv)
 709 {
 710         IVTV_DEBUG_I2C("i2c init\n");
 711
 712         if (itv->options.newi2c > 0) {
 713                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
 714                        sizeof(struct i2c_adapter));
 715         } else {
 716                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
 717                        sizeof(struct i2c_adapter));
 718                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
 719                        sizeof(struct i2c_algo_bit_data));
 720                 itv->i2c_algo.data = itv;
 721                 itv->i2c_adap.algo_data = &itv->i2c_algo;
 722         }
 723
 724         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
 725                 itv->num);
 726         i2c_set_adapdata(&itv->i2c_adap, itv);
 727
 728         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
 729                sizeof(struct i2c_client));
 730         itv->i2c_client.adapter = &itv->i2c_adap;
 731         itv->i2c_adap.dev.parent = &itv->dev->dev;
 732
 733         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
 734         ivtv_setscl(itv, 1);
 735         ivtv_setsda(itv, 1);
 736
 737         if (itv->options.newi2c > 0)
 738                 return i2c_add_adapter(&itv->i2c_adap);
 739         else
 740                 return i2c_bit_add_bus(&itv->i2c_adap);
 741 }
 742
 743 void __devexit exit_ivtv_i2c(struct ivtv *itv)
 744 {
 745         IVTV_DEBUG_I2C("i2c exit\n");
 746
 747         i2c_del_adapter(&itv->i2c_adap);
 748 }