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