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