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 #include <media/cx25840.h>
  67
  68 /* i2c implementation for cx23415/6 chip, ivtv project.
  69  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  70  */
  71 /* i2c stuff */
  72 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
  73 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
  74 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
  75 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
  76
  77 #define IVTV_CS53L32A_I2C_ADDR          0x11
  78 #define IVTV_M52790_I2C_ADDR            0x48
  79 #define IVTV_CX25840_I2C_ADDR           0x44
  80 #define IVTV_SAA7115_I2C_ADDR           0x21
  81 #define IVTV_SAA7127_I2C_ADDR           0x44
  82 #define IVTV_SAA717x_I2C_ADDR           0x21
  83 #define IVTV_MSP3400_I2C_ADDR           0x40
  84 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
  85 #define IVTV_WM8739_I2C_ADDR            0x1a
  86 #define IVTV_WM8775_I2C_ADDR            0x1b
  87 #define IVTV_TEA5767_I2C_ADDR           0x60
  88 #define IVTV_UPD64031A_I2C_ADDR         0x12
  89 #define IVTV_UPD64083_I2C_ADDR          0x5c
  90 #define IVTV_VP27SMPX_I2C_ADDR          0x5b
  91 #define IVTV_M52790_I2C_ADDR            0x48
  92 #define IVTV_AVERMEDIA_IR_RX_I2C_ADDR   0x40
  93 #define IVTV_HAUP_EXT_IR_RX_I2C_ADDR    0x1a
  94 #define IVTV_HAUP_INT_IR_RX_I2C_ADDR    0x18
  95 #define IVTV_Z8F0811_IR_TX_I2C_ADDR     0x70
  96 #define IVTV_Z8F0811_IR_RX_I2C_ADDR     0x71
  97
  98 /* This array should match the IVTV_HW_ defines */
  99 static const u8 hw_addrs[] = {
 100         IVTV_CX25840_I2C_ADDR,
 101         IVTV_SAA7115_I2C_ADDR,
 102         IVTV_SAA7127_I2C_ADDR,
 103         IVTV_MSP3400_I2C_ADDR,
 104         0,
 105         IVTV_WM8775_I2C_ADDR,
 106         IVTV_CS53L32A_I2C_ADDR,
 107         0,
 108         IVTV_SAA7115_I2C_ADDR,
 109         IVTV_UPD64031A_I2C_ADDR,
 110         IVTV_UPD64083_I2C_ADDR,
 111         IVTV_SAA717x_I2C_ADDR,
 112         IVTV_WM8739_I2C_ADDR,
 113         IVTV_VP27SMPX_I2C_ADDR,
 114         IVTV_M52790_I2C_ADDR,
 115         0,                              /* IVTV_HW_GPIO dummy driver ID */
 116         IVTV_AVERMEDIA_IR_RX_I2C_ADDR,  /* IVTV_HW_I2C_IR_RX_AVER */
 117         IVTV_HAUP_EXT_IR_RX_I2C_ADDR,   /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 118         IVTV_HAUP_INT_IR_RX_I2C_ADDR,   /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 119         IVTV_Z8F0811_IR_TX_I2C_ADDR,    /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 120         IVTV_Z8F0811_IR_RX_I2C_ADDR,    /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 121 };
 122
 123 /* This array should match the IVTV_HW_ defines */
 124 static const char *hw_modules[] = {
 125         "cx25840",
 126         "saa7115",
 127         "saa7127",
 128         "msp3400",
 129         "tuner",
 130         "wm8775",
 131         "cs53l32a",
 132         NULL,
 133         "saa7115",
 134         "upd64031a",
 135         "upd64083",
 136         "saa717x",
 137         "wm8739",
 138         "vp27smpx",
 139         "m52790",
 140         NULL,
 141         NULL,           /* IVTV_HW_I2C_IR_RX_AVER */
 142         NULL,           /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 143         NULL,           /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 144         NULL,           /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 145         NULL,           /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 146 };
 147
 148 /* This array should match the IVTV_HW_ defines */
 149 static const char * const hw_devicenames[] = {
 150         "cx25840",
 151         "saa7115",
 152         "saa7127_auto", /* saa7127 or saa7129 */
 153         "msp3400",
 154         "tuner",
 155         "wm8775",
 156         "cs53l32a",
 157         "tveeprom",
 158         "saa7114",
 159         "upd64031a",
 160         "upd64083",
 161         "saa717x",
 162         "wm8739",
 163         "vp27smpx",
 164         "m52790",
 165         "gpio",
 166         "ir_video",             /* IVTV_HW_I2C_IR_RX_AVER */
 167         "ir_video",             /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 168         "ir_video",             /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 169         "ir_tx_z8f0811_haup",   /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 170         "ir_rx_z8f0811_haup",   /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 171 };
 172
 173 static int ivtv_i2c_new_ir(struct ivtv *itv, u32 hw, const char *type, u8 addr)
 174 {
 175         struct i2c_board_info info;
 176         struct i2c_adapter *adap = &itv->i2c_adap;
 177         struct IR_i2c_init_data *init_data = &itv->ir_i2c_init_data;
 178         unsigned short addr_list[2] = { addr, I2C_CLIENT_END };
 179
 180         /* Only allow one IR transmitter to be registered per board */
 181         if (hw & IVTV_HW_IR_TX_ANY) {
 182                 if (itv->hw_flags & IVTV_HW_IR_TX_ANY)
 183                         return -1;
 184                 memset(&info, 0, sizeof(struct i2c_board_info));
 185                 strlcpy(info.type, type, I2C_NAME_SIZE);
 186                 return i2c_new_probed_device(adap, &info, addr_list, NULL)
 187                                                            == NULL ? -1 : 0;
 188         }
 189
 190         /* Only allow one IR receiver to be registered per board */
 191         if (itv->hw_flags & IVTV_HW_IR_RX_ANY)
 192                 return -1;
 193
 194         /* Our default information for ir-kbd-i2c.c to use */
 195         switch (hw) {
 196         case IVTV_HW_I2C_IR_RX_AVER:
 197                 init_data->ir_codes = RC_MAP_AVERMEDIA_CARDBUS;
 198                 init_data->internal_get_key_func =
 199                                         IR_KBD_GET_KEY_AVERMEDIA_CARDBUS;
 200                 init_data->type = IR_TYPE_OTHER;
 201                 init_data->name = "AVerMedia AVerTV card";
 202                 break;
 203         case IVTV_HW_I2C_IR_RX_HAUP_EXT:
 204         case IVTV_HW_I2C_IR_RX_HAUP_INT:
 205                 /* Default to old black remote */
 206                 init_data->ir_codes = RC_MAP_RC5_TV;
 207                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
 208                 init_data->type = IR_TYPE_RC5;
 209                 init_data->name = itv->card_name;
 210                 break;
 211         case IVTV_HW_Z8F0811_IR_RX_HAUP:
 212                 /* Default to grey remote */
 213                 init_data->ir_codes = RC_MAP_HAUPPAUGE_NEW;
 214                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
 215                 init_data->type = IR_TYPE_RC5;
 216                 init_data->name = itv->card_name;
 217                 break;
 218         }
 219
 220         memset(&info, 0, sizeof(struct i2c_board_info));
 221         info.platform_data = init_data;
 222         strlcpy(info.type, type, I2C_NAME_SIZE);
 223
 224         return i2c_new_probed_device(adap, &info, addr_list, NULL) == NULL ?
 225                -1 : 0;
 226 }
 227
 228 /* Instantiate the IR receiver device using probing -- undesirable */
 229 struct i2c_client *ivtv_i2c_new_ir_legacy(struct ivtv *itv)
 230 {
 231         struct i2c_board_info info;
 232         /*
 233          * The external IR receiver is at i2c address 0x34.
 234          * The internal IR receiver is at i2c address 0x30.
 235          *
 236          * In theory, both can be fitted, and Hauppauge suggests an external
 237          * overrides an internal.  That's why we probe 0x1a (~0x34) first. CB
 238          *
 239          * Some of these addresses we probe may collide with other i2c address
 240          * allocations, so this function must be called after all other i2c
 241          * devices we care about are registered.
 242          */
 243         const unsigned short addr_list[] = {
 244                 0x1a,   /* Hauppauge IR external - collides with WM8739 */
 245                 0x18,   /* Hauppauge IR internal */
 246                 0x71,   /* Hauppauge IR (PVR150) */
 247                 0x6b,   /* Adaptec IR */
 248                 I2C_CLIENT_END
 249         };
 250
 251         memset(&info, 0, sizeof(struct i2c_board_info));
 252         strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
 253         return i2c_new_probed_device(&itv->i2c_adap, &info, addr_list, NULL);
 254 }
 255
 256 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
 257 {
 258         struct v4l2_subdev *sd;
 259         struct i2c_adapter *adap = &itv->i2c_adap;
 260         const char *mod = hw_modules[idx];
 261         const char *type = hw_devicenames[idx];
 262         u32 hw = 1 << idx;
 263
 264         if (idx >= ARRAY_SIZE(hw_addrs))
 265                 return -1;
 266         if (hw == IVTV_HW_TUNER) {
 267                 /* special tuner handling */
 268                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 269                                 adap, mod, type,
 270                                 0, itv->card_i2c->radio);
 271                 if (sd)
 272                         sd->grp_id = 1 << idx;
 273                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 274                                 adap, mod, type,
 275                                 0, itv->card_i2c->demod);
 276                 if (sd)
 277                         sd->grp_id = 1 << idx;
 278                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 279                                 adap, mod, type,
 280                                 0, itv->card_i2c->tv);
 281                 if (sd)
 282                         sd->grp_id = 1 << idx;
 283                 return sd ? 0 : -1;
 284         }
 285
 286         if (hw & IVTV_HW_IR_ANY)
 287                 return ivtv_i2c_new_ir(itv, hw, type, hw_addrs[idx]);
 288
 289         /* Is it not an I2C device or one we do not wish to register? */
 290         if (!hw_addrs[idx])
 291                 return -1;
 292
 293         /* It's an I2C device other than an analog tuner or IR chip */
 294         if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
 295                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 296                                 adap, mod, type, 0, I2C_ADDRS(hw_addrs[idx]));
 297         } else if (hw == IVTV_HW_CX25840) {
 298                 struct cx25840_platform_data pdata;
 299
 300                 pdata.pvr150_workaround = itv->pvr150_workaround;
 301                 sd = v4l2_i2c_new_subdev_cfg(&itv->v4l2_dev,
 302                                 adap, mod, type, 0, &pdata, hw_addrs[idx], NULL);
 303         } else {
 304                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 305                                 adap, mod, type, hw_addrs[idx], NULL);
 306         }
 307         if (sd)
 308                 sd->grp_id = 1 << idx;
 309         return sd ? 0 : -1;
 310 }
 311
 312 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
 313 {
 314         struct v4l2_subdev *result = NULL;
 315         struct v4l2_subdev *sd;
 316
 317         spin_lock(&itv->v4l2_dev.lock);
 318         v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
 319                 if (sd->grp_id == hw) {
 320                         result = sd;
 321                         break;
 322                 }
 323         }
 324         spin_unlock(&itv->v4l2_dev.lock);
 325         return result;
 326 }
 327
 328 /* Set the serial clock line to the desired state */
 329 static void ivtv_setscl(struct ivtv *itv, int state)
 330 {
 331         /* write them out */
 332         /* write bits are inverted */
 333         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
 334 }
 335
 336 /* Set the serial data line to the desired state */
 337 static void ivtv_setsda(struct ivtv *itv, int state)
 338 {
 339         /* write them out */
 340         /* write bits are inverted */
 341         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
 342 }
 343
 344 /* Read the serial clock line */
 345 static int ivtv_getscl(struct ivtv *itv)
 346 {
 347         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 348 }
 349
 350 /* Read the serial data line */
 351 static int ivtv_getsda(struct ivtv *itv)
 352 {
 353         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 354 }
 355
 356 /* Implement a short delay by polling the serial clock line */
 357 static void ivtv_scldelay(struct ivtv *itv)
 358 {
 359         int i;
 360
 361         for (i = 0; i < 5; ++i)
 362                 ivtv_getscl(itv);
 363 }
 364
 365 /* Wait for the serial clock line to become set to a specific value */
 366 static int ivtv_waitscl(struct ivtv *itv, int val)
 367 {
 368         int i;
 369
 370         ivtv_scldelay(itv);
 371         for (i = 0; i < 1000; ++i) {
 372                 if (ivtv_getscl(itv) == val)
 373                         return 1;
 374         }
 375         return 0;
 376 }
 377
 378 /* Wait for the serial data line to become set to a specific value */
 379 static int ivtv_waitsda(struct ivtv *itv, int val)
 380 {
 381         int i;
 382
 383         ivtv_scldelay(itv);
 384         for (i = 0; i < 1000; ++i) {
 385                 if (ivtv_getsda(itv) == val)
 386                         return 1;
 387         }
 388         return 0;
 389 }
 390
 391 /* Wait for the slave to issue an ACK */
 392 static int ivtv_ack(struct ivtv *itv)
 393 {
 394         int ret = 0;
 395
 396         if (ivtv_getscl(itv) == 1) {
 397                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
 398                 ivtv_setscl(itv, 0);
 399                 if (!ivtv_waitscl(itv, 0)) {
 400                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
 401                         return -EREMOTEIO;
 402                 }
 403         }
 404         ivtv_setsda(itv, 1);
 405         ivtv_scldelay(itv);
 406         ivtv_setscl(itv, 1);
 407         if (!ivtv_waitsda(itv, 0)) {
 408                 IVTV_DEBUG_I2C("Slave did not ack\n");
 409                 ret = -EREMOTEIO;
 410         }
 411         ivtv_setscl(itv, 0);
 412         if (!ivtv_waitscl(itv, 0)) {
 413                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
 414                 ret = -EREMOTEIO;
 415         }
 416         return ret;
 417 }
 418
 419 /* Write a single byte to the i2c bus and wait for the slave to ACK */
 420 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
 421 {
 422         int i, bit;
 423
 424         IVTV_DEBUG_HI_I2C("write %x\n",byte);
 425         for (i = 0; i < 8; ++i, byte<<=1) {
 426                 ivtv_setscl(itv, 0);
 427                 if (!ivtv_waitscl(itv, 0)) {
 428                         IVTV_DEBUG_I2C("Error setting SCL low\n");
 429                         return -EREMOTEIO;
 430                 }
 431                 bit = (byte>>7)&1;
 432                 ivtv_setsda(itv, bit);
 433                 if (!ivtv_waitsda(itv, bit)) {
 434                         IVTV_DEBUG_I2C("Error setting SDA\n");
 435                         return -EREMOTEIO;
 436                 }
 437                 ivtv_setscl(itv, 1);
 438                 if (!ivtv_waitscl(itv, 1)) {
 439                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
 440                         return -EREMOTEIO;
 441                 }
 442         }
 443         ivtv_setscl(itv, 0);
 444         if (!ivtv_waitscl(itv, 0)) {
 445                 IVTV_DEBUG_I2C("Error setting SCL low\n");
 446                 return -EREMOTEIO;
 447         }
 448         return ivtv_ack(itv);
 449 }
 450
 451 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
 452    final byte) */
 453 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
 454 {
 455         int i;
 456
 457         *byte = 0;
 458
 459         ivtv_setsda(itv, 1);
 460         ivtv_scldelay(itv);
 461         for (i = 0; i < 8; ++i) {
 462                 ivtv_setscl(itv, 0);
 463                 ivtv_scldelay(itv);
 464                 ivtv_setscl(itv, 1);
 465                 if (!ivtv_waitscl(itv, 1)) {
 466                         IVTV_DEBUG_I2C("Error setting SCL high\n");
 467                         return -EREMOTEIO;
 468                 }
 469                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
 470         }
 471         ivtv_setscl(itv, 0);
 472         ivtv_scldelay(itv);
 473         ivtv_setsda(itv, nack);
 474         ivtv_scldelay(itv);
 475         ivtv_setscl(itv, 1);
 476         ivtv_scldelay(itv);
 477         ivtv_setscl(itv, 0);
 478         ivtv_scldelay(itv);
 479         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
 480         return 0;
 481 }
 482
 483 /* Issue a start condition on the i2c bus to alert slaves to prepare for
 484    an address write */
 485 static int ivtv_start(struct ivtv *itv)
 486 {
 487         int sda;
 488
 489         sda = ivtv_getsda(itv);
 490         if (sda != 1) {
 491                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
 492                 ivtv_setsda(itv, 1);
 493                 if (!ivtv_waitsda(itv, 1)) {
 494                         IVTV_DEBUG_I2C("SDA stuck low\n");
 495                         return -EREMOTEIO;
 496                 }
 497         }
 498         if (ivtv_getscl(itv) != 1) {
 499                 ivtv_setscl(itv, 1);
 500                 if (!ivtv_waitscl(itv, 1)) {
 501                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
 502                         return -EREMOTEIO;
 503                 }
 504         }
 505         ivtv_setsda(itv, 0);
 506         ivtv_scldelay(itv);
 507         return 0;
 508 }
 509
 510 /* Issue a stop condition on the i2c bus to release it */
 511 static int ivtv_stop(struct ivtv *itv)
 512 {
 513         int i;
 514
 515         if (ivtv_getscl(itv) != 0) {
 516                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
 517                 ivtv_setscl(itv, 0);
 518                 if (!ivtv_waitscl(itv, 0)) {
 519                         IVTV_DEBUG_I2C("SCL could not be set low\n");
 520                 }
 521         }
 522         ivtv_setsda(itv, 0);
 523         ivtv_scldelay(itv);
 524         ivtv_setscl(itv, 1);
 525         if (!ivtv_waitscl(itv, 1)) {
 526                 IVTV_DEBUG_I2C("SCL could not be set high\n");
 527                 return -EREMOTEIO;
 528         }
 529         ivtv_scldelay(itv);
 530         ivtv_setsda(itv, 1);
 531         if (!ivtv_waitsda(itv, 1)) {
 532                 IVTV_DEBUG_I2C("resetting I2C\n");
 533                 for (i = 0; i < 16; ++i) {
 534                         ivtv_setscl(itv, 0);
 535                         ivtv_scldelay(itv);
 536                         ivtv_setscl(itv, 1);
 537                         ivtv_scldelay(itv);
 538                         ivtv_setsda(itv, 1);
 539                 }
 540                 ivtv_waitsda(itv, 1);
 541                 return -EREMOTEIO;
 542         }
 543         return 0;
 544 }
 545
 546 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
 547    issuing the i2c stop condition (when following with a read) */
 548 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
 549 {
 550         int retry, ret = -EREMOTEIO;
 551         u32 i;
 552
 553         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 554                 ret = ivtv_start(itv);
 555
 556                 if (ret == 0) {
 557                         ret = ivtv_sendbyte(itv, addr<<1);
 558                         for (i = 0; ret == 0 && i < len; ++i)
 559                                 ret = ivtv_sendbyte(itv, data[i]);
 560                 }
 561                 if (ret != 0 || do_stop) {
 562                         ivtv_stop(itv);
 563                 }
 564         }
 565         if (ret)
 566                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
 567         return ret;
 568 }
 569
 570 /* Read data from the given i2c slave.  A stop condition is always issued. */
 571 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
 572 {
 573         int retry, ret = -EREMOTEIO;
 574         u32 i;
 575
 576         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 577                 ret = ivtv_start(itv);
 578                 if (ret == 0)
 579                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
 580                 for (i = 0; ret == 0 && i < len; ++i) {
 581                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
 582                 }
 583                 ivtv_stop(itv);
 584         }
 585         if (ret)
 586                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
 587         return ret;
 588 }
 589
 590 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
 591    or written.  If a read follows a write, this will occur without an
 592    intervening stop condition */
 593 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 594 {
 595         struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
 596         struct ivtv *itv = to_ivtv(v4l2_dev);
 597         int retval;
 598         int i;
 599
 600         mutex_lock(&itv->i2c_bus_lock);
 601         for (i = retval = 0; retval == 0 && i < num; i++) {
 602                 if (msgs[i].flags & I2C_M_RD)
 603                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
 604                 else {
 605                         /* if followed by a read, don't stop */
 606                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
 607
 608                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
 609                 }
 610         }
 611         mutex_unlock(&itv->i2c_bus_lock);
 612         return retval ? retval : num;
 613 }
 614
 615 /* Kernel i2c capabilities */
 616 static u32 ivtv_functionality(struct i2c_adapter *adap)
 617 {
 618         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 619 }
 620
 621 static struct i2c_algorithm ivtv_algo = {
 622         .master_xfer   = ivtv_xfer,
 623         .functionality = ivtv_functionality,
 624 };
 625
 626 /* template for our-bit banger */
 627 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
 628         .name = "ivtv i2c driver",
 629         .algo = &ivtv_algo,
 630         .algo_data = NULL,                      /* filled from template */
 631         .owner = THIS_MODULE,
 632 };
 633
 634 static void ivtv_setscl_old(void *data, int state)
 635 {
 636         struct ivtv *itv = (struct ivtv *)data;
 637
 638         if (state)
 639                 itv->i2c_state |= 0x01;
 640         else
 641                 itv->i2c_state &= ~0x01;
 642
 643         /* write them out */
 644         /* write bits are inverted */
 645         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
 646 }
 647
 648 static void ivtv_setsda_old(void *data, int state)
 649 {
 650         struct ivtv *itv = (struct ivtv *)data;
 651
 652         if (state)
 653                 itv->i2c_state |= 0x01;
 654         else
 655                 itv->i2c_state &= ~0x01;
 656
 657         /* write them out */
 658         /* write bits are inverted */
 659         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
 660 }
 661
 662 static int ivtv_getscl_old(void *data)
 663 {
 664         struct ivtv *itv = (struct ivtv *)data;
 665
 666         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 667 }
 668
 669 static int ivtv_getsda_old(void *data)
 670 {
 671         struct ivtv *itv = (struct ivtv *)data;
 672
 673         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 674 }
 675
 676 /* template for i2c-bit-algo */
 677 static struct i2c_adapter ivtv_i2c_adap_template = {
 678         .name = "ivtv i2c driver",
 679         .algo = NULL,                   /* set by i2c-algo-bit */
 680         .algo_data = NULL,              /* filled from template */
 681         .owner = THIS_MODULE,
 682 };
 683
 684 #define IVTV_ALGO_BIT_TIMEOUT   (2)     /* seconds */
 685
 686 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
 687         .setsda         = ivtv_setsda_old,
 688         .setscl         = ivtv_setscl_old,
 689         .getsda         = ivtv_getsda_old,
 690         .getscl         = ivtv_getscl_old,
 691         .udelay         = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2,  /* microseconds */
 692         .timeout        = IVTV_ALGO_BIT_TIMEOUT * HZ,         /* jiffies */
 693 };
 694
 695 static struct i2c_client ivtv_i2c_client_template = {
 696         .name = "ivtv internal",
 697 };
 698
 699 /* init + register i2c adapter */
 700 int init_ivtv_i2c(struct ivtv *itv)
 701 {
 702         int retval;
 703
 704         IVTV_DEBUG_I2C("i2c init\n");
 705
 706         /* Sanity checks for the I2C hardware arrays. They must be the
 707          * same size.
 708          */
 709         if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) ||
 710             ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_modules)) {
 711                 IVTV_ERR("Mismatched I2C hardware arrays\n");
 712                 return -ENODEV;
 713         }
 714         if (itv->options.newi2c > 0) {
 715                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
 716                        sizeof(struct i2c_adapter));
 717         } else {
 718                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
 719                        sizeof(struct i2c_adapter));
 720                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
 721                        sizeof(struct i2c_algo_bit_data));
 722         }
 723         itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2;
 724         itv->i2c_algo.data = itv;
 725         itv->i2c_adap.algo_data = &itv->i2c_algo;
 726
 727         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
 728                 itv->instance);
 729         i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
 730
 731         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
 732                sizeof(struct i2c_client));
 733         itv->i2c_client.adapter = &itv->i2c_adap;
 734         itv->i2c_adap.dev.parent = &itv->pdev->dev;
 735
 736         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
 737         ivtv_setscl(itv, 1);
 738         ivtv_setsda(itv, 1);
 739
 740         if (itv->options.newi2c > 0)
 741                 retval = i2c_add_adapter(&itv->i2c_adap);
 742         else
 743                 retval = i2c_bit_add_bus(&itv->i2c_adap);
 744
 745         return retval;
 746 }
 747
 748 void exit_ivtv_i2c(struct ivtv *itv)
 749 {
 750         IVTV_DEBUG_I2C("i2c exit\n");
 751
 752         i2c_del_adapter(&itv->i2c_adap);
 753 }