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