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