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