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

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