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