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

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