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