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