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