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