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 /* i2c implementation for cx23415/6 chip, ivtv project.
  68  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  69  */
  70 /* i2c stuff */
  71 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
  72 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
  73 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
  74 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
  75
  76 #define IVTV_CS53L32A_I2C_ADDR          0x11
  77 #define IVTV_M52790_I2C_ADDR            0x48
  78 #define IVTV_CX25840_I2C_ADDR           0x44
  79 #define IVTV_SAA7115_I2C_ADDR           0x21
  80 #define IVTV_SAA7127_I2C_ADDR           0x44
  81 #define IVTV_SAA717x_I2C_ADDR           0x21
  82 #define IVTV_MSP3400_I2C_ADDR           0x40
  83 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
  84 #define IVTV_WM8739_I2C_ADDR            0x1a
  85 #define IVTV_WM8775_I2C_ADDR            0x1b
  86 #define IVTV_TEA5767_I2C_ADDR           0x60
  87 #define IVTV_UPD64031A_I2C_ADDR         0x12
  88 #define IVTV_UPD64083_I2C_ADDR          0x5c
  89 #define IVTV_VP27SMPX_I2C_ADDR          0x5b
  90 #define IVTV_M52790_I2C_ADDR            0x48
  91
  92 /* This array should match the IVTV_HW_ defines */
  93 static const u8 hw_addrs[] = {
  94         IVTV_CX25840_I2C_ADDR,
  95         IVTV_SAA7115_I2C_ADDR,
  96         IVTV_SAA7127_I2C_ADDR,
  97         IVTV_MSP3400_I2C_ADDR,
  98         0,
  99         IVTV_WM8775_I2C_ADDR,
 100         IVTV_CS53L32A_I2C_ADDR,
 101         0,
 102         IVTV_SAA7115_I2C_ADDR,
 103         IVTV_UPD64031A_I2C_ADDR,
 104         IVTV_UPD64083_I2C_ADDR,
 105         IVTV_SAA717x_I2C_ADDR,
 106         IVTV_WM8739_I2C_ADDR,
 107         IVTV_VP27SMPX_I2C_ADDR,
 108         IVTV_M52790_I2C_ADDR,
 109         0               /* IVTV_HW_GPIO dummy driver ID */
 110 };
 111
 112 /* This array should match the IVTV_HW_ defines */
 113 static const char *hw_modules[] = {
 114         "cx25840",
 115         "saa7115",
 116         "saa7127",
 117         "msp3400",
 118         "tuner",
 119         "wm8775",
 120         "cs53l32a",
 121         NULL,
 122         "saa7115",
 123         "upd64031a",
 124         "upd64083",
 125         "saa717x",
 126         "wm8739",
 127         "vp27smpx",
 128         "m52790",
 129         NULL
 130 };
 131
 132 /* This array should match the IVTV_HW_ defines */
 133 static const char * const hw_devicenames[] = {
 134         "cx25840",
 135         "saa7115",
 136         "saa7127_auto", /* saa7127 or saa7129 */
 137         "msp3400",
 138         "tuner",
 139         "wm8775",
 140         "cs53l32a",
 141         "tveeprom",
 142         "saa7114",
 143         "upd64031a",
 144         "upd64083",
 145         "saa717x",
 146         "wm8739",
 147         "vp27smpx",
 148         "m52790",
 149         "gpio",
 150 };
 151
 152 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
 153 {
 154         struct v4l2_subdev *sd;
 155         struct i2c_adapter *adap = &itv->i2c_adap;
 156         const char *mod = hw_modules[idx];
 157         const char *type = hw_devicenames[idx];
 158         u32 hw = 1 << idx;
 159
 160         if (idx >= ARRAY_SIZE(hw_addrs))
 161                 return -1;
 162         if (hw == IVTV_HW_TUNER) {
 163                 /* special tuner handling */
 164                 sd = v4l2_i2c_new_probed_subdev(adap, mod, type,
 165                                 itv->card_i2c->radio);
 166                 if (sd)
 167                         sd->grp_id = 1 << idx;
 168                 sd = v4l2_i2c_new_probed_subdev(adap, mod, type,
 169                                 itv->card_i2c->demod);
 170                 if (sd)
 171                         sd->grp_id = 1 << idx;
 172                 sd = v4l2_i2c_new_probed_subdev(adap, mod, type,
 173                                 itv->card_i2c->tv);
 174                 if (sd)
 175                         sd->grp_id = 1 << idx;
 176                 return sd ? 0 : -1;
 177         }
 178         if (!hw_addrs[idx])
 179                 return -1;
 180         if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
 181                 unsigned short addrs[2] = { hw_addrs[idx], I2C_CLIENT_END };
 182
 183                 sd = v4l2_i2c_new_probed_subdev(adap, mod, type, addrs);
 184         } else {
 185                 sd = v4l2_i2c_new_subdev(adap, mod, type, hw_addrs[idx]);
 186         }
 187         if (sd)
 188                 sd->grp_id = 1 << idx;
 189         return sd ? 0 : -1;
 190 }
 191
 192 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
 193 {
 194         struct v4l2_subdev *result = NULL;
 195         struct v4l2_subdev *sd;
 196
 197         spin_lock(&itv->device.lock);
 198         v4l2_device_for_each_subdev(sd, &itv->device) {
 199                 if (sd->grp_id == hw) {
 200                         result = sd;
 201                         break;
 202                 }
 203         }
 204         spin_unlock(&itv->device.lock);
 205         return result;
 206 }
 207
 208 /* Set the serial clock line to the desired state */
 209 static void ivtv_setscl(struct ivtv *itv, int state)
 210 {
 211         /* write them out */
 212         /* write bits are inverted */
 213         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
 214 }
 215
 216 /* Set the serial data line to the desired state */
 217 static void ivtv_setsda(struct ivtv *itv, int state)
 218 {
 219         /* write them out */
 220         /* write bits are inverted */
 221         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
 222 }
 223
 224 /* Read the serial clock line */
 225 static int ivtv_getscl(struct ivtv *itv)
 226 {
 227         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 228 }
 229
 230 /* Read the serial data line */
 231 static int ivtv_getsda(struct ivtv *itv)
 232 {
 233         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 234 }
 235
 236 /* Implement a short delay by polling the serial clock line */
 237 static void ivtv_scldelay(struct ivtv *itv)
 238 {
 239         int i;
 240
 241         for (i = 0; i < 5; ++i)
 242                 ivtv_getscl(itv);
 243 }
 244
 245 /* Wait for the serial clock line to become set to a specific value */
 246 static int ivtv_waitscl(struct ivtv *itv, int val)
 247 {
 248         int i;
 249
 250         ivtv_scldelay(itv);
 251         for (i = 0; i < 1000; ++i) {
 252                 if (ivtv_getscl(itv) == val)
 253                         return 1;
 254         }
 255         return 0;
 256 }
 257
 258 /* Wait for the serial data line to become set to a specific value */
 259 static int ivtv_waitsda(struct ivtv *itv, int val)
 260 {
 261         int i;
 262
 263         ivtv_scldelay(itv);
 264         for (i = 0; i < 1000; ++i) {
 265                 if (ivtv_getsda(itv) == val)
 266                         return 1;
 267         }
 268         return 0;
 269 }
 270
 271 /* Wait for the slave to issue an ACK */
 272 static int ivtv_ack(struct ivtv *itv)
 273 {
 274         int ret = 0;
 275
 276         if (ivtv_getscl(itv) == 1) {
 277                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
 278                 ivtv_setscl(itv, 0);
 279                 if (!ivtv_waitscl(itv, 0)) {
 280                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
 281                         return -EREMOTEIO;
 282                 }
 283         }
 284         ivtv_setsda(itv, 1);
 285         ivtv_scldelay(itv);
 286         ivtv_setscl(itv, 1);
 287         if (!ivtv_waitsda(itv, 0)) {
 288                 IVTV_DEBUG_I2C("Slave did not ack\n");
 289                 ret = -EREMOTEIO;
 290         }
 291         ivtv_setscl(itv, 0);
 292         if (!ivtv_waitscl(itv, 0)) {
 293                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
 294                 ret = -EREMOTEIO;
 295         }
 296         return ret;
 297 }
 298
 299 /* Write a single byte to the i2c bus and wait for the slave to ACK */
 300 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
 301 {
 302         int i, bit;
 303
 304         IVTV_DEBUG_HI_I2C("write %x\n",byte);
 305         for (i = 0; i < 8; ++i, byte<<=1) {
 306                 ivtv_setscl(itv, 0);
 307                 if (!ivtv_waitscl(itv, 0)) {
 308                         IVTV_DEBUG_I2C("Error setting SCL low\n");
 309                         return -EREMOTEIO;
 310                 }
 311                 bit = (byte>>7)&1;
 312                 ivtv_setsda(itv, bit);
 313                 if (!ivtv_waitsda(itv, bit)) {
 314                         IVTV_DEBUG_I2C("Error setting SDA\n");
 315                         return -EREMOTEIO;
 316                 }
 317                 ivtv_setscl(itv, 1);
 318                 if (!ivtv_waitscl(itv, 1)) {
 319                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
 320                         return -EREMOTEIO;
 321                 }
 322         }
 323         ivtv_setscl(itv, 0);
 324         if (!ivtv_waitscl(itv, 0)) {
 325                 IVTV_DEBUG_I2C("Error setting SCL low\n");
 326                 return -EREMOTEIO;
 327         }
 328         return ivtv_ack(itv);
 329 }
 330
 331 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
 332    final byte) */
 333 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
 334 {
 335         int i;
 336
 337         *byte = 0;
 338
 339         ivtv_setsda(itv, 1);
 340         ivtv_scldelay(itv);
 341         for (i = 0; i < 8; ++i) {
 342                 ivtv_setscl(itv, 0);
 343                 ivtv_scldelay(itv);
 344                 ivtv_setscl(itv, 1);
 345                 if (!ivtv_waitscl(itv, 1)) {
 346                         IVTV_DEBUG_I2C("Error setting SCL high\n");
 347                         return -EREMOTEIO;
 348                 }
 349                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
 350         }
 351         ivtv_setscl(itv, 0);
 352         ivtv_scldelay(itv);
 353         ivtv_setsda(itv, nack);
 354         ivtv_scldelay(itv);
 355         ivtv_setscl(itv, 1);
 356         ivtv_scldelay(itv);
 357         ivtv_setscl(itv, 0);
 358         ivtv_scldelay(itv);
 359         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
 360         return 0;
 361 }
 362
 363 /* Issue a start condition on the i2c bus to alert slaves to prepare for
 364    an address write */
 365 static int ivtv_start(struct ivtv *itv)
 366 {
 367         int sda;
 368
 369         sda = ivtv_getsda(itv);
 370         if (sda != 1) {
 371                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
 372                 ivtv_setsda(itv, 1);
 373                 if (!ivtv_waitsda(itv, 1)) {
 374                         IVTV_DEBUG_I2C("SDA stuck low\n");
 375                         return -EREMOTEIO;
 376                 }
 377         }
 378         if (ivtv_getscl(itv) != 1) {
 379                 ivtv_setscl(itv, 1);
 380                 if (!ivtv_waitscl(itv, 1)) {
 381                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
 382                         return -EREMOTEIO;
 383                 }
 384         }
 385         ivtv_setsda(itv, 0);
 386         ivtv_scldelay(itv);
 387         return 0;
 388 }
 389
 390 /* Issue a stop condition on the i2c bus to release it */
 391 static int ivtv_stop(struct ivtv *itv)
 392 {
 393         int i;
 394
 395         if (ivtv_getscl(itv) != 0) {
 396                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
 397                 ivtv_setscl(itv, 0);
 398                 if (!ivtv_waitscl(itv, 0)) {
 399                         IVTV_DEBUG_I2C("SCL could not be set low\n");
 400                 }
 401         }
 402         ivtv_setsda(itv, 0);
 403         ivtv_scldelay(itv);
 404         ivtv_setscl(itv, 1);
 405         if (!ivtv_waitscl(itv, 1)) {
 406                 IVTV_DEBUG_I2C("SCL could not be set high\n");
 407                 return -EREMOTEIO;
 408         }
 409         ivtv_scldelay(itv);
 410         ivtv_setsda(itv, 1);
 411         if (!ivtv_waitsda(itv, 1)) {
 412                 IVTV_DEBUG_I2C("resetting I2C\n");
 413                 for (i = 0; i < 16; ++i) {
 414                         ivtv_setscl(itv, 0);
 415                         ivtv_scldelay(itv);
 416                         ivtv_setscl(itv, 1);
 417                         ivtv_scldelay(itv);
 418                         ivtv_setsda(itv, 1);
 419                 }
 420                 ivtv_waitsda(itv, 1);
 421                 return -EREMOTEIO;
 422         }
 423         return 0;
 424 }
 425
 426 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
 427    issuing the i2c stop condition (when following with a read) */
 428 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
 429 {
 430         int retry, ret = -EREMOTEIO;
 431         u32 i;
 432
 433         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 434                 ret = ivtv_start(itv);
 435
 436                 if (ret == 0) {
 437                         ret = ivtv_sendbyte(itv, addr<<1);
 438                         for (i = 0; ret == 0 && i < len; ++i)
 439                                 ret = ivtv_sendbyte(itv, data[i]);
 440                 }
 441                 if (ret != 0 || do_stop) {
 442                         ivtv_stop(itv);
 443                 }
 444         }
 445         if (ret)
 446                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
 447         return ret;
 448 }
 449
 450 /* Read data from the given i2c slave.  A stop condition is always issued. */
 451 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
 452 {
 453         int retry, ret = -EREMOTEIO;
 454         u32 i;
 455
 456         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 457                 ret = ivtv_start(itv);
 458                 if (ret == 0)
 459                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
 460                 for (i = 0; ret == 0 && i < len; ++i) {
 461                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
 462                 }
 463                 ivtv_stop(itv);
 464         }
 465         if (ret)
 466                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
 467         return ret;
 468 }
 469
 470 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
 471    or written.  If a read follows a write, this will occur without an
 472    intervening stop condition */
 473 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 474 {
 475         struct v4l2_device *drv = i2c_get_adapdata(i2c_adap);
 476         struct ivtv *itv = to_ivtv(drv);
 477         int retval;
 478         int i;
 479
 480         mutex_lock(&itv->i2c_bus_lock);
 481         for (i = retval = 0; retval == 0 && i < num; i++) {
 482                 if (msgs[i].flags & I2C_M_RD)
 483                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
 484                 else {
 485                         /* if followed by a read, don't stop */
 486                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
 487
 488                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
 489                 }
 490         }
 491         mutex_unlock(&itv->i2c_bus_lock);
 492         return retval ? retval : num;
 493 }
 494
 495 /* Kernel i2c capabilities */
 496 static u32 ivtv_functionality(struct i2c_adapter *adap)
 497 {
 498         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 499 }
 500
 501 static struct i2c_algorithm ivtv_algo = {
 502         .master_xfer   = ivtv_xfer,
 503         .functionality = ivtv_functionality,
 504 };
 505
 506 /* template for our-bit banger */
 507 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
 508         .name = "ivtv i2c driver",
 509         .id = I2C_HW_B_CX2341X,
 510         .algo = &ivtv_algo,
 511         .algo_data = NULL,                      /* filled from template */
 512         .owner = THIS_MODULE,
 513 };
 514
 515 static void ivtv_setscl_old(void *data, int state)
 516 {
 517         struct ivtv *itv = (struct ivtv *)data;
 518
 519         if (state)
 520                 itv->i2c_state |= 0x01;
 521         else
 522                 itv->i2c_state &= ~0x01;
 523
 524         /* write them out */
 525         /* write bits are inverted */
 526         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
 527 }
 528
 529 static void ivtv_setsda_old(void *data, int state)
 530 {
 531         struct ivtv *itv = (struct ivtv *)data;
 532
 533         if (state)
 534                 itv->i2c_state |= 0x01;
 535         else
 536                 itv->i2c_state &= ~0x01;
 537
 538         /* write them out */
 539         /* write bits are inverted */
 540         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
 541 }
 542
 543 static int ivtv_getscl_old(void *data)
 544 {
 545         struct ivtv *itv = (struct ivtv *)data;
 546
 547         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 548 }
 549
 550 static int ivtv_getsda_old(void *data)
 551 {
 552         struct ivtv *itv = (struct ivtv *)data;
 553
 554         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 555 }
 556
 557 /* template for i2c-bit-algo */
 558 static struct i2c_adapter ivtv_i2c_adap_template = {
 559         .name = "ivtv i2c driver",
 560         .id = I2C_HW_B_CX2341X,
 561         .algo = NULL,                   /* set by i2c-algo-bit */
 562         .algo_data = NULL,              /* filled from template */
 563         .owner = THIS_MODULE,
 564 };
 565
 566 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
 567         .setsda         = ivtv_setsda_old,
 568         .setscl         = ivtv_setscl_old,
 569         .getsda         = ivtv_getsda_old,
 570         .getscl         = ivtv_getscl_old,
 571         .udelay         = 10,
 572         .timeout        = 200,
 573 };
 574
 575 static struct i2c_client ivtv_i2c_client_template = {
 576         .name = "ivtv internal",
 577 };
 578
 579 /* init + register i2c algo-bit adapter */
 580 int init_ivtv_i2c(struct ivtv *itv)
 581 {
 582         IVTV_DEBUG_I2C("i2c init\n");
 583
 584         /* Sanity checks for the I2C hardware arrays. They must be the
 585          * same size and GPIO must be the last entry.
 586          */
 587         if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) ||
 588             ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_modules) ||
 589             IVTV_HW_GPIO != (1 << (ARRAY_SIZE(hw_addrs) - 1))) {
 590                 IVTV_ERR("Mismatched I2C hardware arrays\n");
 591                 return -ENODEV;
 592         }
 593         if (itv->options.newi2c > 0) {
 594                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
 595                        sizeof(struct i2c_adapter));
 596         } else {
 597                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
 598                        sizeof(struct i2c_adapter));
 599                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
 600                        sizeof(struct i2c_algo_bit_data));
 601         }
 602         itv->i2c_algo.data = itv;
 603         itv->i2c_adap.algo_data = &itv->i2c_algo;
 604
 605         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
 606                 itv->instance);
 607         i2c_set_adapdata(&itv->i2c_adap, &itv->device);
 608
 609         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
 610                sizeof(struct i2c_client));
 611         itv->i2c_client.adapter = &itv->i2c_adap;
 612         itv->i2c_adap.dev.parent = &itv->dev->dev;
 613
 614         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
 615         ivtv_setscl(itv, 1);
 616         ivtv_setsda(itv, 1);
 617
 618         if (itv->options.newi2c > 0)
 619                 return i2c_add_adapter(&itv->i2c_adap);
 620         else
 621                 return i2c_bit_add_bus(&itv->i2c_adap);
 622 }
 623
 624 void exit_ivtv_i2c(struct ivtv *itv)
 625 {
 626         IVTV_DEBUG_I2C("i2c exit\n");
 627
 628         i2c_del_adapter(&itv->i2c_adap);
 629 }