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