drivers/media/video/ivtv/ivtv-i2c.c

   1 /*
   2     I2C functions
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /*
  22     This file includes an i2c implementation that was reverse engineered
  23     from the Hauppauge windows driver.  Older ivtv versions used i2c-algo-bit,
  24     which whilst fine under most circumstances, had trouble with the Zilog
  25     CPU on the PVR-150 which handles IR functions (occasional inability to
  26     communicate with the chip until it was reset) and also with the i2c
  27     bus being completely unreachable when multiple PVR cards were present.
  28
  29     The implementation is very similar to i2c-algo-bit, but there are enough
  30     subtle differences that the two are hard to merge.  The general strategy
  31     employed by i2c-algo-bit is to use udelay() to implement the timing
  32     when putting out bits on the scl/sda lines.  The general strategy taken
  33     here is to poll the lines for state changes (see ivtv_waitscl and
  34     ivtv_waitsda).  In addition there are small delays at various locations
  35     which poll the SCL line 5 times (ivtv_scldelay).  I would guess that
  36     since this is memory mapped I/O that the length of those delays is tied
  37     to the PCI bus clock.  There is some extra code to do with recovery
  38     and retries.  Since it is not known what causes the actual i2c problems
  39     in the first place, the only goal if one was to attempt to use
  40     i2c-algo-bit would be to try to make it follow the same code path.
  41     This would be a lot of work, and I'm also not convinced that it would
  42     provide a generic benefit to i2c-algo-bit.  Therefore consider this
  43     an engineering solution -- not pretty, but it works.
  44
  45     Some more general comments about what we are doing:
  46
  47     The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA)
  48     lines.  To communicate on the bus (as a master, we don't act as a slave),
  49     we first initiate a start condition (ivtv_start).  We then write the
  50     address of the device that we want to communicate with, along with a flag
  51     that indicates whether this is a read or a write.  The slave then issues
  52     an ACK signal (ivtv_ack), which tells us that it is ready for reading /
  53     writing.  We then proceed with reading or writing (ivtv_read/ivtv_write),
  54     and finally issue a stop condition (ivtv_stop) to make the bus available
  55     to other masters.
  56
  57     There is an additional form of transaction where a write may be
  58     immediately followed by a read.  In this case, there is no intervening
  59     stop condition.  (Only the msp3400 chip uses this method of data transfer).
  60  */
  61
  62 #include "ivtv-driver.h"
  63 #include "ivtv-cards.h"
  64 #include "ivtv-gpio.h"
  65 #include "ivtv-i2c.h"
  66
  67 /* i2c implementation for cx23415/6 chip, ivtv project.
  68  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  69  */
  70 /* i2c stuff */
  71 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
  72 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
  73 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
  74 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
  75
  76 #define IVTV_CS53L32A_I2C_ADDR          0x11
  77 #define IVTV_M52790_I2C_ADDR            0x48
  78 #define IVTV_CX25840_I2C_ADDR           0x44
  79 #define IVTV_SAA7115_I2C_ADDR           0x21
  80 #define IVTV_SAA7127_I2C_ADDR           0x44
  81 #define IVTV_SAA717x_I2C_ADDR           0x21
  82 #define IVTV_MSP3400_I2C_ADDR           0x40
  83 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
  84 #define IVTV_WM8739_I2C_ADDR            0x1a
  85 #define IVTV_WM8775_I2C_ADDR            0x1b
  86 #define IVTV_TEA5767_I2C_ADDR           0x60
  87 #define IVTV_UPD64031A_I2C_ADDR         0x12
  88 #define IVTV_UPD64083_I2C_ADDR          0x5c
  89 #define IVTV_VP27SMPX_I2C_ADDR          0x5b
  90 #define IVTV_M52790_I2C_ADDR            0x48
  91 #define IVTV_AVERMEDIA_IR_RX_I2C_ADDR   0x40
  92 #define IVTV_HAUP_EXT_IR_RX_I2C_ADDR    0x1a
  93 #define IVTV_HAUP_INT_IR_RX_I2C_ADDR    0x18
  94 #define IVTV_Z8F0811_IR_TX_I2C_ADDR     0x70
  95 #define IVTV_Z8F0811_IR_RX_I2C_ADDR     0x71
  96
  97 /* This array should match the IVTV_HW_ defines */
  98 static const u8 hw_addrs[] = {
  99         IVTV_CX25840_I2C_ADDR,
 100         IVTV_SAA7115_I2C_ADDR,
 101         IVTV_SAA7127_I2C_ADDR,
 102         IVTV_MSP3400_I2C_ADDR,
 103         0,
 104         IVTV_WM8775_I2C_ADDR,
 105         IVTV_CS53L32A_I2C_ADDR,
 106         0,
 107         IVTV_SAA7115_I2C_ADDR,
 108         IVTV_UPD64031A_I2C_ADDR,
 109         IVTV_UPD64083_I2C_ADDR,
 110         IVTV_SAA717x_I2C_ADDR,
 111         IVTV_WM8739_I2C_ADDR,
 112         IVTV_VP27SMPX_I2C_ADDR,
 113         IVTV_M52790_I2C_ADDR,
 114         0,                              /* IVTV_HW_GPIO dummy driver ID */
 115         IVTV_AVERMEDIA_IR_RX_I2C_ADDR,  /* IVTV_HW_I2C_IR_RX_AVER */
 116         IVTV_HAUP_EXT_IR_RX_I2C_ADDR,   /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 117         IVTV_HAUP_INT_IR_RX_I2C_ADDR,   /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 118         IVTV_Z8F0811_IR_TX_I2C_ADDR,    /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 119         IVTV_Z8F0811_IR_RX_I2C_ADDR,    /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 120 };
 121
 122 /* This array should match the IVTV_HW_ defines */
 123 static const char *hw_modules[] = {
 124         "cx25840",
 125         "saa7115",
 126         "saa7127",
 127         "msp3400",
 128         "tuner",
 129         "wm8775",
 130         "cs53l32a",
 131         NULL,
 132         "saa7115",
 133         "upd64031a",
 134         "upd64083",
 135         "saa717x",
 136         "wm8739",
 137         "vp27smpx",
 138         "m52790",
 139         NULL,
 140         NULL,           /* IVTV_HW_I2C_IR_RX_AVER */
 141         NULL,           /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 142         NULL,           /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 143         NULL,           /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 144         NULL,           /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 145 };
 146
 147 /* This array should match the IVTV_HW_ defines */
 148 static const char * const hw_devicenames[] = {
 149         "cx25840",
 150         "saa7115",
 151         "saa7127_auto", /* saa7127 or saa7129 */
 152         "msp3400",
 153         "tuner",
 154         "wm8775",
 155         "cs53l32a",
 156         "tveeprom",
 157         "saa7114",
 158         "upd64031a",
 159         "upd64083",
 160         "saa717x",
 161         "wm8739",
 162         "vp27smpx",
 163         "m52790",
 164         "gpio",
 165         "ir_video",             /* IVTV_HW_I2C_IR_RX_AVER */
 166         "ir_video",             /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
 167         "ir_video",             /* IVTV_HW_I2C_IR_RX_HAUP_INT */
 168         "ir_tx_z8f0811_haup",   /* IVTV_HW_Z8F0811_IR_TX_HAUP */
 169         "ir_rx_z8f0811_haup",   /* IVTV_HW_Z8F0811_IR_RX_HAUP */
 170 };
 171
 172 static int ivtv_i2c_new_ir(struct ivtv *itv, u32 hw, const char *type, u8 addr)
 173 {
 174         struct i2c_board_info info;
 175         struct i2c_adapter *adap = &itv->i2c_adap;
 176         struct IR_i2c_init_data *init_data = &itv->ir_i2c_init_data;
 177         unsigned short addr_list[2] = { addr, I2C_CLIENT_END };
 178
 179         /* Only allow one IR transmitter to be registered per board */
 180         if (hw & IVTV_HW_IR_TX_ANY) {
 181                 if (itv->hw_flags & IVTV_HW_IR_TX_ANY)
 182                         return -1;
 183                 memset(&info, 0, sizeof(struct i2c_board_info));
 184                 strlcpy(info.type, type, I2C_NAME_SIZE);
 185                 return i2c_new_probed_device(adap, &info, addr_list) == NULL
 186                                                                      ? -1 : 0;
 187         }
 188
 189         /* Only allow one IR receiver to be registered per board */
 190         if (itv->hw_flags & IVTV_HW_IR_RX_ANY)
 191                 return -1;
 192
 193         /* Our default information for ir-kbd-i2c.c to use */
 194         switch (hw) {
 195         case IVTV_HW_I2C_IR_RX_AVER:
 196                 init_data->ir_codes = RC_MAP_AVERMEDIA_CARDBUS;
 197                 init_data->internal_get_key_func =
 198                                         IR_KBD_GET_KEY_AVERMEDIA_CARDBUS;
 199                 init_data->type = IR_TYPE_OTHER;
 200                 init_data->name = "AVerMedia AVerTV card";
 201                 break;
 202         case IVTV_HW_I2C_IR_RX_HAUP_EXT:
 203         case IVTV_HW_I2C_IR_RX_HAUP_INT:
 204                 /* Default to old black remote */
 205                 init_data->ir_codes = RC_MAP_RC5_TV;
 206                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
 207                 init_data->type = IR_TYPE_RC5;
 208                 init_data->name = itv->card_name;
 209                 break;
 210         case IVTV_HW_Z8F0811_IR_RX_HAUP:
 211                 /* Default to grey remote */
 212                 init_data->ir_codes = RC_MAP_HAUPPAUGE_NEW;
 213                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
 214                 init_data->type = IR_TYPE_RC5;
 215                 init_data->name = itv->card_name;
 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 ? -1 : 0;
 224 }
 225
 226 /* Instantiate the IR receiver device using probing -- undesirable */
 227 struct i2c_client *ivtv_i2c_new_ir_legacy(struct ivtv *itv)
 228 {
 229         struct i2c_board_info info;
 230         /*
 231          * The external IR receiver is at i2c address 0x34.
 232          * The internal IR receiver is at i2c address 0x30.
 233          *
 234          * In theory, both can be fitted, and Hauppauge suggests an external
 235          * overrides an internal.  That's why we probe 0x1a (~0x34) first. CB
 236          *
 237          * Some of these addresses we probe may collide with other i2c address
 238          * allocations, so this function must be called after all other i2c
 239          * devices we care about are registered.
 240          */
 241         const unsigned short addr_list[] = {
 242                 0x1a,   /* Hauppauge IR external - collides with WM8739 */
 243                 0x18,   /* Hauppauge IR internal */
 244                 0x71,   /* Hauppauge IR (PVR150) */
 245                 0x6b,   /* Adaptec IR */
 246                 I2C_CLIENT_END
 247         };
 248
 249         memset(&info, 0, sizeof(struct i2c_board_info));
 250         strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
 251         return i2c_new_probed_device(&itv->i2c_adap, &info, addr_list);
 252 }
 253
 254 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
 255 {
 256         struct v4l2_subdev *sd;
 257         struct i2c_adapter *adap = &itv->i2c_adap;
 258         const char *mod = hw_modules[idx];
 259         const char *type = hw_devicenames[idx];
 260         u32 hw = 1 << idx;
 261
 262         if (idx >= ARRAY_SIZE(hw_addrs))
 263                 return -1;
 264         if (hw == IVTV_HW_TUNER) {
 265                 /* special tuner handling */
 266                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 267                                 adap, mod, type,
 268                                 0, itv->card_i2c->radio);
 269                 if (sd)
 270                         sd->grp_id = 1 << idx;
 271                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 272                                 adap, mod, type,
 273                                 0, itv->card_i2c->demod);
 274                 if (sd)
 275                         sd->grp_id = 1 << idx;
 276                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 277                                 adap, mod, type,
 278                                 0, itv->card_i2c->tv);
 279                 if (sd)
 280                         sd->grp_id = 1 << idx;
 281                 return sd ? 0 : -1;
 282         }
 283
 284         if (hw & IVTV_HW_IR_ANY)
 285                 return ivtv_i2c_new_ir(itv, hw, type, hw_addrs[idx]);
 286
 287         /* Is it not an I2C device or one we do not wish to register? */
 288         if (!hw_addrs[idx])
 289                 return -1;
 290
 291         /* It's an I2C device other than an analog tuner or IR chip */
 292         if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
 293                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 294                                 adap, mod, type, 0, I2C_ADDRS(hw_addrs[idx]));
 295         } else {
 296                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
 297                                 adap, mod, type, hw_addrs[idx], NULL);
 298         }
 299         if (sd)
 300                 sd->grp_id = 1 << idx;
 301         return sd ? 0 : -1;
 302 }
 303
 304 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
 305 {
 306         struct v4l2_subdev *result = NULL;
 307         struct v4l2_subdev *sd;
 308
 309         spin_lock(&itv->v4l2_dev.lock);
 310         v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
 311                 if (sd->grp_id == hw) {
 312                         result = sd;
 313                         break;
 314                 }
 315         }
 316         spin_unlock(&itv->v4l2_dev.lock);
 317         return result;
 318 }
 319
 320 /* Set the serial clock line to the desired state */
 321 static void ivtv_setscl(struct ivtv *itv, int state)
 322 {
 323         /* write them out */
 324         /* write bits are inverted */
 325         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
 326 }
 327
 328 /* Set the serial data line to the desired state */
 329 static void ivtv_setsda(struct ivtv *itv, int state)
 330 {
 331         /* write them out */
 332         /* write bits are inverted */
 333         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
 334 }
 335
 336 /* Read the serial clock line */
 337 static int ivtv_getscl(struct ivtv *itv)
 338 {
 339         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 340 }
 341
 342 /* Read the serial data line */
 343 static int ivtv_getsda(struct ivtv *itv)
 344 {
 345         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 346 }
 347
 348 /* Implement a short delay by polling the serial clock line */
 349 static void ivtv_scldelay(struct ivtv *itv)
 350 {
 351         int i;
 352
 353         for (i = 0; i < 5; ++i)
 354                 ivtv_getscl(itv);
 355 }
 356
 357 /* Wait for the serial clock line to become set to a specific value */
 358 static int ivtv_waitscl(struct ivtv *itv, int val)
 359 {
 360         int i;
 361
 362         ivtv_scldelay(itv);
 363         for (i = 0; i < 1000; ++i) {
 364                 if (ivtv_getscl(itv) == val)
 365                         return 1;
 366         }
 367         return 0;
 368 }
 369
 370 /* Wait for the serial data line to become set to a specific value */
 371 static int ivtv_waitsda(struct ivtv *itv, int val)
 372 {
 373         int i;
 374
 375         ivtv_scldelay(itv);
 376         for (i = 0; i < 1000; ++i) {
 377                 if (ivtv_getsda(itv) == val)
 378                         return 1;
 379         }
 380         return 0;
 381 }
 382
 383 /* Wait for the slave to issue an ACK */
 384 static int ivtv_ack(struct ivtv *itv)
 385 {
 386         int ret = 0;
 387
 388         if (ivtv_getscl(itv) == 1) {
 389                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
 390                 ivtv_setscl(itv, 0);
 391                 if (!ivtv_waitscl(itv, 0)) {
 392                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
 393                         return -EREMOTEIO;
 394                 }
 395         }
 396         ivtv_setsda(itv, 1);
 397         ivtv_scldelay(itv);
 398         ivtv_setscl(itv, 1);
 399         if (!ivtv_waitsda(itv, 0)) {
 400                 IVTV_DEBUG_I2C("Slave did not ack\n");
 401                 ret = -EREMOTEIO;
 402         }
 403         ivtv_setscl(itv, 0);
 404         if (!ivtv_waitscl(itv, 0)) {
 405                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
 406                 ret = -EREMOTEIO;
 407         }
 408         return ret;
 409 }
 410
 411 /* Write a single byte to the i2c bus and wait for the slave to ACK */
 412 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
 413 {
 414         int i, bit;
 415
 416         IVTV_DEBUG_HI_I2C("write %x\n",byte);
 417         for (i = 0; i < 8; ++i, byte<<=1) {
 418                 ivtv_setscl(itv, 0);
 419                 if (!ivtv_waitscl(itv, 0)) {
 420                         IVTV_DEBUG_I2C("Error setting SCL low\n");
 421                         return -EREMOTEIO;
 422                 }
 423                 bit = (byte>>7)&1;
 424                 ivtv_setsda(itv, bit);
 425                 if (!ivtv_waitsda(itv, bit)) {
 426                         IVTV_DEBUG_I2C("Error setting SDA\n");
 427                         return -EREMOTEIO;
 428                 }
 429                 ivtv_setscl(itv, 1);
 430                 if (!ivtv_waitscl(itv, 1)) {
 431                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
 432                         return -EREMOTEIO;
 433                 }
 434         }
 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         return ivtv_ack(itv);
 441 }
 442
 443 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
 444    final byte) */
 445 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
 446 {
 447         int i;
 448
 449         *byte = 0;
 450
 451         ivtv_setsda(itv, 1);
 452         ivtv_scldelay(itv);
 453         for (i = 0; i < 8; ++i) {
 454                 ivtv_setscl(itv, 0);
 455                 ivtv_scldelay(itv);
 456                 ivtv_setscl(itv, 1);
 457                 if (!ivtv_waitscl(itv, 1)) {
 458                         IVTV_DEBUG_I2C("Error setting SCL high\n");
 459                         return -EREMOTEIO;
 460                 }
 461                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
 462         }
 463         ivtv_setscl(itv, 0);
 464         ivtv_scldelay(itv);
 465         ivtv_setsda(itv, nack);
 466         ivtv_scldelay(itv);
 467         ivtv_setscl(itv, 1);
 468         ivtv_scldelay(itv);
 469         ivtv_setscl(itv, 0);
 470         ivtv_scldelay(itv);
 471         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
 472         return 0;
 473 }
 474
 475 /* Issue a start condition on the i2c bus to alert slaves to prepare for
 476    an address write */
 477 static int ivtv_start(struct ivtv *itv)
 478 {
 479         int sda;
 480
 481         sda = ivtv_getsda(itv);
 482         if (sda != 1) {
 483                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
 484                 ivtv_setsda(itv, 1);
 485                 if (!ivtv_waitsda(itv, 1)) {
 486                         IVTV_DEBUG_I2C("SDA stuck low\n");
 487                         return -EREMOTEIO;
 488                 }
 489         }
 490         if (ivtv_getscl(itv) != 1) {
 491                 ivtv_setscl(itv, 1);
 492                 if (!ivtv_waitscl(itv, 1)) {
 493                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
 494                         return -EREMOTEIO;
 495                 }
 496         }
 497         ivtv_setsda(itv, 0);
 498         ivtv_scldelay(itv);
 499         return 0;
 500 }
 501
 502 /* Issue a stop condition on the i2c bus to release it */
 503 static int ivtv_stop(struct ivtv *itv)
 504 {
 505         int i;
 506
 507         if (ivtv_getscl(itv) != 0) {
 508                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
 509                 ivtv_setscl(itv, 0);
 510                 if (!ivtv_waitscl(itv, 0)) {
 511                         IVTV_DEBUG_I2C("SCL could not be set low\n");
 512                 }
 513         }
 514         ivtv_setsda(itv, 0);
 515         ivtv_scldelay(itv);
 516         ivtv_setscl(itv, 1);
 517         if (!ivtv_waitscl(itv, 1)) {
 518                 IVTV_DEBUG_I2C("SCL could not be set high\n");
 519                 return -EREMOTEIO;
 520         }
 521         ivtv_scldelay(itv);
 522         ivtv_setsda(itv, 1);
 523         if (!ivtv_waitsda(itv, 1)) {
 524                 IVTV_DEBUG_I2C("resetting I2C\n");
 525                 for (i = 0; i < 16; ++i) {
 526                         ivtv_setscl(itv, 0);
 527                         ivtv_scldelay(itv);
 528                         ivtv_setscl(itv, 1);
 529                         ivtv_scldelay(itv);
 530                         ivtv_setsda(itv, 1);
 531                 }
 532                 ivtv_waitsda(itv, 1);
 533                 return -EREMOTEIO;
 534         }
 535         return 0;
 536 }
 537
 538 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
 539    issuing the i2c stop condition (when following with a read) */
 540 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
 541 {
 542         int retry, ret = -EREMOTEIO;
 543         u32 i;
 544
 545         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 546                 ret = ivtv_start(itv);
 547
 548                 if (ret == 0) {
 549                         ret = ivtv_sendbyte(itv, addr<<1);
 550                         for (i = 0; ret == 0 && i < len; ++i)
 551                                 ret = ivtv_sendbyte(itv, data[i]);
 552                 }
 553                 if (ret != 0 || do_stop) {
 554                         ivtv_stop(itv);
 555                 }
 556         }
 557         if (ret)
 558                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
 559         return ret;
 560 }
 561
 562 /* Read data from the given i2c slave.  A stop condition is always issued. */
 563 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
 564 {
 565         int retry, ret = -EREMOTEIO;
 566         u32 i;
 567
 568         for (retry = 0; ret != 0 && retry < 8; ++retry) {
 569                 ret = ivtv_start(itv);
 570                 if (ret == 0)
 571                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
 572                 for (i = 0; ret == 0 && i < len; ++i) {
 573                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
 574                 }
 575                 ivtv_stop(itv);
 576         }
 577         if (ret)
 578                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
 579         return ret;
 580 }
 581
 582 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
 583    or written.  If a read follows a write, this will occur without an
 584    intervening stop condition */
 585 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 586 {
 587         struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
 588         struct ivtv *itv = to_ivtv(v4l2_dev);
 589         int retval;
 590         int i;
 591
 592         mutex_lock(&itv->i2c_bus_lock);
 593         for (i = retval = 0; retval == 0 && i < num; i++) {
 594                 if (msgs[i].flags & I2C_M_RD)
 595                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
 596                 else {
 597                         /* if followed by a read, don't stop */
 598                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
 599
 600                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
 601                 }
 602         }
 603         mutex_unlock(&itv->i2c_bus_lock);
 604         return retval ? retval : num;
 605 }
 606
 607 /* Kernel i2c capabilities */
 608 static u32 ivtv_functionality(struct i2c_adapter *adap)
 609 {
 610         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 611 }
 612
 613 static struct i2c_algorithm ivtv_algo = {
 614         .master_xfer   = ivtv_xfer,
 615         .functionality = ivtv_functionality,
 616 };
 617
 618 /* template for our-bit banger */
 619 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
 620         .name = "ivtv i2c driver",
 621         .algo = &ivtv_algo,
 622         .algo_data = NULL,                      /* filled from template */
 623         .owner = THIS_MODULE,
 624 };
 625
 626 static void ivtv_setscl_old(void *data, int state)
 627 {
 628         struct ivtv *itv = (struct ivtv *)data;
 629
 630         if (state)
 631                 itv->i2c_state |= 0x01;
 632         else
 633                 itv->i2c_state &= ~0x01;
 634
 635         /* write them out */
 636         /* write bits are inverted */
 637         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
 638 }
 639
 640 static void ivtv_setsda_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_SETSDA_OFFSET);
 652 }
 653
 654 static int ivtv_getscl_old(void *data)
 655 {
 656         struct ivtv *itv = (struct ivtv *)data;
 657
 658         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
 659 }
 660
 661 static int ivtv_getsda_old(void *data)
 662 {
 663         struct ivtv *itv = (struct ivtv *)data;
 664
 665         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
 666 }
 667
 668 /* template for i2c-bit-algo */
 669 static struct i2c_adapter ivtv_i2c_adap_template = {
 670         .name = "ivtv i2c driver",
 671         .algo = NULL,                   /* set by i2c-algo-bit */
 672         .algo_data = NULL,              /* filled from template */
 673         .owner = THIS_MODULE,
 674 };
 675
 676 #define IVTV_ALGO_BIT_TIMEOUT   (2)     /* seconds */
 677
 678 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
 679         .setsda         = ivtv_setsda_old,
 680         .setscl         = ivtv_setscl_old,
 681         .getsda         = ivtv_getsda_old,
 682         .getscl         = ivtv_getscl_old,
 683         .udelay         = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2,  /* microseconds */
 684         .timeout        = IVTV_ALGO_BIT_TIMEOUT * HZ,         /* jiffies */
 685 };
 686
 687 static struct i2c_client ivtv_i2c_client_template = {
 688         .name = "ivtv internal",
 689 };
 690
 691 /* init + register i2c adapter */
 692 int init_ivtv_i2c(struct ivtv *itv)
 693 {
 694         int retval;
 695
 696         IVTV_DEBUG_I2C("i2c init\n");
 697
 698         /* Sanity checks for the I2C hardware arrays. They must be the
 699          * same size.
 700          */
 701         if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) ||
 702             ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_modules)) {
 703                 IVTV_ERR("Mismatched I2C hardware arrays\n");
 704                 return -ENODEV;
 705         }
 706         if (itv->options.newi2c > 0) {
 707                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
 708                        sizeof(struct i2c_adapter));
 709         } else {
 710                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
 711                        sizeof(struct i2c_adapter));
 712                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
 713                        sizeof(struct i2c_algo_bit_data));
 714         }
 715         itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2;
 716         itv->i2c_algo.data = itv;
 717         itv->i2c_adap.algo_data = &itv->i2c_algo;
 718
 719         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
 720                 itv->instance);
 721         i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
 722
 723         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
 724                sizeof(struct i2c_client));
 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 }