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