LXR linux/drivers/media/usb/dvb-usb-v2/mxl111sf-i2c.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  mxl111sf-i2c.c - driver for the MaxLinear MXL111SF
   4 *
   5 *  Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
   6 */
   7
   8#include "mxl111sf-i2c.h"
   9#include "mxl111sf.h"
  10
  11/* SW-I2C ----------------------------------------------------------------- */
  12
  13#define SW_I2C_ADDR             0x1a
  14#define SW_I2C_EN               0x02
  15#define SW_SCL_OUT              0x04
  16#define SW_SDA_OUT              0x08
  17#define SW_SDA_IN               0x04
  18
  19#define SW_I2C_BUSY_ADDR        0x2f
  20#define SW_I2C_BUSY             0x02
  21
  22static int mxl111sf_i2c_bitbang_sendbyte(struct mxl111sf_state *state,
  23                                         u8 byte)
  24{
  25        int i, ret;
  26        u8 data = 0;
  27
  28        mxl_i2c("(0x%02x)", byte);
  29
  30        ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
  31        if (mxl_fail(ret))
  32                goto fail;
  33
  34        for (i = 0; i < 8; i++) {
  35
  36                data = (byte & (0x80 >> i)) ? SW_SDA_OUT : 0;
  37
  38                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  39                                         0x10 | SW_I2C_EN | data);
  40                if (mxl_fail(ret))
  41                        goto fail;
  42
  43                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  44                                         0x10 | SW_I2C_EN | data | SW_SCL_OUT);
  45                if (mxl_fail(ret))
  46                        goto fail;
  47
  48                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  49                                         0x10 | SW_I2C_EN | data);
  50                if (mxl_fail(ret))
  51                        goto fail;
  52        }
  53
  54        /* last bit was 0 so we need to release SDA */
  55        if (!(byte & 1)) {
  56                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  57                                         0x10 | SW_I2C_EN | SW_SDA_OUT);
  58                if (mxl_fail(ret))
  59                        goto fail;
  60        }
  61
  62        /* CLK high for ACK readback */
  63        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  64                                 0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
  65        if (mxl_fail(ret))
  66                goto fail;
  67
  68        ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
  69        if (mxl_fail(ret))
  70                goto fail;
  71
  72        /* drop the CLK after getting ACK, SDA will go high right away */
  73        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  74                                 0x10 | SW_I2C_EN | SW_SDA_OUT);
  75        if (mxl_fail(ret))
  76                goto fail;
  77
  78        if (data & SW_SDA_IN)
  79                ret = -EIO;
  80fail:
  81        return ret;
  82}
  83
  84static int mxl111sf_i2c_bitbang_recvbyte(struct mxl111sf_state *state,
  85                                         u8 *pbyte)
  86{
  87        int i, ret;
  88        u8 byte = 0;
  89        u8 data = 0;
  90
  91        mxl_i2c("()");
  92
  93        *pbyte = 0;
  94
  95        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
  96                                 0x10 | SW_I2C_EN | SW_SDA_OUT);
  97        if (mxl_fail(ret))
  98                goto fail;
  99
 100        for (i = 0; i < 8; i++) {
 101                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 102                                         0x10 | SW_I2C_EN |
 103                                         SW_SCL_OUT | SW_SDA_OUT);
 104                if (mxl_fail(ret))
 105                        goto fail;
 106
 107                ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
 108                if (mxl_fail(ret))
 109                        goto fail;
 110
 111                if (data & SW_SDA_IN)
 112                        byte |= (0x80 >> i);
 113
 114                ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 115                                         0x10 | SW_I2C_EN | SW_SDA_OUT);
 116                if (mxl_fail(ret))
 117                        goto fail;
 118        }
 119        *pbyte = byte;
 120fail:
 121        return ret;
 122}
 123
 124static int mxl111sf_i2c_start(struct mxl111sf_state *state)
 125{
 126        int ret;
 127
 128        mxl_i2c("()");
 129
 130        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 131                                 0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 132        if (mxl_fail(ret))
 133                goto fail;
 134
 135        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 136                                 0x10 | SW_I2C_EN | SW_SCL_OUT);
 137        if (mxl_fail(ret))
 138                goto fail;
 139
 140        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 141                                 0x10 | SW_I2C_EN); /* start */
 142        mxl_fail(ret);
 143fail:
 144        return ret;
 145}
 146
 147static int mxl111sf_i2c_stop(struct mxl111sf_state *state)
 148{
 149        int ret;
 150
 151        mxl_i2c("()");
 152
 153        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 154                                 0x10 | SW_I2C_EN); /* stop */
 155        if (mxl_fail(ret))
 156                goto fail;
 157
 158        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 159                                 0x10 | SW_I2C_EN | SW_SCL_OUT);
 160        if (mxl_fail(ret))
 161                goto fail;
 162
 163        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 164                                 0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 165        if (mxl_fail(ret))
 166                goto fail;
 167
 168        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 169                                 0x10 | SW_SCL_OUT | SW_SDA_OUT);
 170        mxl_fail(ret);
 171fail:
 172        return ret;
 173}
 174
 175static int mxl111sf_i2c_ack(struct mxl111sf_state *state)
 176{
 177        int ret;
 178        u8 b = 0;
 179
 180        mxl_i2c("()");
 181
 182        ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &b);
 183        if (mxl_fail(ret))
 184                goto fail;
 185
 186        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 187                                 0x10 | SW_I2C_EN);
 188        if (mxl_fail(ret))
 189                goto fail;
 190
 191        /* pull SDA low */
 192        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 193                                 0x10 | SW_I2C_EN | SW_SCL_OUT);
 194        if (mxl_fail(ret))
 195                goto fail;
 196
 197        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 198                                 0x10 | SW_I2C_EN | SW_SDA_OUT);
 199        mxl_fail(ret);
 200fail:
 201        return ret;
 202}
 203
 204static int mxl111sf_i2c_nack(struct mxl111sf_state *state)
 205{
 206        int ret;
 207
 208        mxl_i2c("()");
 209
 210        /* SDA high to signal last byte read from slave */
 211        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 212                                 0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 213        if (mxl_fail(ret))
 214                goto fail;
 215
 216        ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
 217                                 0x10 | SW_I2C_EN | SW_SDA_OUT);
 218        mxl_fail(ret);
 219fail:
 220        return ret;
 221}
 222
 223/* ------------------------------------------------------------------------ */
 224
 225static int mxl111sf_i2c_sw_xfer_msg(struct mxl111sf_state *state,
 226                                    struct i2c_msg *msg)
 227{
 228        int i, ret;
 229
 230        mxl_i2c("()");
 231
 232        if (msg->flags & I2C_M_RD) {
 233
 234                ret = mxl111sf_i2c_start(state);
 235                if (mxl_fail(ret))
 236                        goto fail;
 237
 238                ret = mxl111sf_i2c_bitbang_sendbyte(state,
 239                                                    (msg->addr << 1) | 0x01);
 240                if (mxl_fail(ret)) {
 241                        mxl111sf_i2c_stop(state);
 242                        goto fail;
 243                }
 244
 245                for (i = 0; i < msg->len; i++) {
 246                        ret = mxl111sf_i2c_bitbang_recvbyte(state,
 247                                                            &msg->buf[i]);
 248                        if (mxl_fail(ret)) {
 249                                mxl111sf_i2c_stop(state);
 250                                goto fail;
 251                        }
 252
 253                        if (i < msg->len - 1)
 254                                mxl111sf_i2c_ack(state);
 255                }
 256
 257                mxl111sf_i2c_nack(state);
 258
 259                ret = mxl111sf_i2c_stop(state);
 260                if (mxl_fail(ret))
 261                        goto fail;
 262
 263        } else {
 264
 265                ret = mxl111sf_i2c_start(state);
 266                if (mxl_fail(ret))
 267                        goto fail;
 268
 269                ret = mxl111sf_i2c_bitbang_sendbyte(state,
 270                                                    (msg->addr << 1) & 0xfe);
 271                if (mxl_fail(ret)) {
 272                        mxl111sf_i2c_stop(state);
 273                        goto fail;
 274                }
 275
 276                for (i = 0; i < msg->len; i++) {
 277                        ret = mxl111sf_i2c_bitbang_sendbyte(state,
 278                                                            msg->buf[i]);
 279                        if (mxl_fail(ret)) {
 280                                mxl111sf_i2c_stop(state);
 281                                goto fail;
 282                        }
 283                }
 284
 285                /* FIXME: we only want to do this on the last transaction */
 286                mxl111sf_i2c_stop(state);
 287        }
 288fail:
 289        return ret;
 290}
 291
 292/* HW-I2C ----------------------------------------------------------------- */
 293
 294#define USB_WRITE_I2C_CMD     0x99
 295#define USB_READ_I2C_CMD      0xdd
 296#define USB_END_I2C_CMD       0xfe
 297
 298#define USB_WRITE_I2C_CMD_LEN   26
 299#define USB_READ_I2C_CMD_LEN    24
 300
 301#define I2C_MUX_REG           0x30
 302#define I2C_CONTROL_REG       0x00
 303#define I2C_SLAVE_ADDR_REG    0x08
 304#define I2C_DATA_REG          0x0c
 305#define I2C_INT_STATUS_REG    0x10
 306
 307static int mxl111sf_i2c_send_data(struct mxl111sf_state *state,
 308                                  u8 index, u8 *wdata)
 309{
 310        int ret = mxl111sf_ctrl_msg(state, wdata[0],
 311                                    &wdata[1], 25, NULL, 0);
 312        mxl_fail(ret);
 313
 314        return ret;
 315}
 316
 317static int mxl111sf_i2c_get_data(struct mxl111sf_state *state,
 318                                 u8 index, u8 *wdata, u8 *rdata)
 319{
 320        int ret = mxl111sf_ctrl_msg(state, wdata[0],
 321                                    &wdata[1], 25, rdata, 24);
 322        mxl_fail(ret);
 323
 324        return ret;
 325}
 326
 327static u8 mxl111sf_i2c_check_status(struct mxl111sf_state *state)
 328{
 329        u8 status = 0;
 330        u8 buf[26];
 331
 332        mxl_i2c_adv("()");
 333
 334        buf[0] = USB_READ_I2C_CMD;
 335        buf[1] = 0x00;
 336
 337        buf[2] = I2C_INT_STATUS_REG;
 338        buf[3] = 0x00;
 339        buf[4] = 0x00;
 340
 341        buf[5] = USB_END_I2C_CMD;
 342
 343        mxl111sf_i2c_get_data(state, 0, buf, buf);
 344
 345        if (buf[1] & 0x04)
 346                status = 1;
 347
 348        return status;
 349}
 350
 351static u8 mxl111sf_i2c_check_fifo(struct mxl111sf_state *state)
 352{
 353        u8 status = 0;
 354        u8 buf[26];
 355
 356        mxl_i2c("()");
 357
 358        buf[0] = USB_READ_I2C_CMD;
 359        buf[1] = 0x00;
 360
 361        buf[2] = I2C_MUX_REG;
 362        buf[3] = 0x00;
 363        buf[4] = 0x00;
 364
 365        buf[5] = I2C_INT_STATUS_REG;
 366        buf[6] = 0x00;
 367        buf[7] = 0x00;
 368        buf[8] = USB_END_I2C_CMD;
 369
 370        mxl111sf_i2c_get_data(state, 0, buf, buf);
 371
 372        if (0x08 == (buf[1] & 0x08))
 373                status = 1;
 374
 375        if ((buf[5] & 0x02) == 0x02)
 376                mxl_i2c("(buf[5] & 0x02) == 0x02"); /* FIXME */
 377
 378        return status;
 379}
 380
 381static int mxl111sf_i2c_readagain(struct mxl111sf_state *state,
 382                                  u8 count, u8 *rbuf)
 383{
 384        u8 i2c_w_data[26];
 385        u8 i2c_r_data[24];
 386        u8 i = 0;
 387        u8 fifo_status = 0;
 388        int status = 0;
 389
 390        mxl_i2c("read %d bytes", count);
 391
 392        while ((fifo_status == 0) && (i++ < 5))
 393                fifo_status = mxl111sf_i2c_check_fifo(state);
 394
 395        i2c_w_data[0] = 0xDD;
 396        i2c_w_data[1] = 0x00;
 397
 398        for (i = 2; i < 26; i++)
 399                i2c_w_data[i] = 0xFE;
 400
 401        for (i = 0; i < count; i++) {
 402                i2c_w_data[2+(i*3)] = 0x0C;
 403                i2c_w_data[3+(i*3)] = 0x00;
 404                i2c_w_data[4+(i*3)] = 0x00;
 405        }
 406
 407        mxl111sf_i2c_get_data(state, 0, i2c_w_data, i2c_r_data);
 408
 409        /* Check for I2C NACK status */
 410        if (mxl111sf_i2c_check_status(state) == 1) {
 411                mxl_i2c("error!");
 412        } else {
 413                for (i = 0; i < count; i++) {
 414                        rbuf[i] = i2c_r_data[(i*3)+1];
 415                        mxl_i2c("%02x\t %02x",
 416                                i2c_r_data[(i*3)+1],
 417                                i2c_r_data[(i*3)+2]);
 418                }
 419
 420                status = 1;
 421        }
 422
 423        return status;
 424}
 425
 426#define HWI2C400 1
 427static int mxl111sf_i2c_hw_xfer_msg(struct mxl111sf_state *state,
 428                                    struct i2c_msg *msg)
 429{
 430        int i, k, ret = 0;
 431        u16 index = 0;
 432        u8 buf[26];
 433        u8 i2c_r_data[24];
 434        u16 block_len;
 435        u16 left_over_len;
 436        u8 rd_status[8];
 437        u8 ret_status;
 438        u8 readbuff[26];
 439
 440        mxl_i2c("addr: 0x%02x, read buff len: %d, write buff len: %d",
 441                msg->addr, (msg->flags & I2C_M_RD) ? msg->len : 0,
 442                (!(msg->flags & I2C_M_RD)) ? msg->len : 0);
 443
 444        for (index = 0; index < 26; index++)
 445                buf[index] = USB_END_I2C_CMD;
 446
 447        /* command to indicate data payload is destined for I2C interface */
 448        buf[0] = USB_WRITE_I2C_CMD;
 449        buf[1] = 0x00;
 450
 451        /* enable I2C interface */
 452        buf[2] = I2C_MUX_REG;
 453        buf[3] = 0x80;
 454        buf[4] = 0x00;
 455
 456        /* enable I2C interface */
 457        buf[5] = I2C_MUX_REG;
 458        buf[6] = 0x81;
 459        buf[7] = 0x00;
 460
 461        /* set Timeout register on I2C interface */
 462        buf[8] = 0x14;
 463        buf[9] = 0xff;
 464        buf[10] = 0x00;
 465#if 0
 466        /* enable Interrupts on I2C interface */
 467        buf[8] = 0x24;
 468        buf[9] = 0xF7;
 469        buf[10] = 0x00;
 470#endif
 471        buf[11] = 0x24;
 472        buf[12] = 0xF7;
 473        buf[13] = 0x00;
 474
 475        ret = mxl111sf_i2c_send_data(state, 0, buf);
 476
 477        /* write data on I2C bus */
 478        if (!(msg->flags & I2C_M_RD) && (msg->len > 0)) {
 479                mxl_i2c("%d\t%02x", msg->len, msg->buf[0]);
 480
 481                /* control register on I2C interface to initialize I2C bus */
 482                buf[2] = I2C_CONTROL_REG;
 483                buf[3] = 0x5E;
 484                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 485
 486                /* I2C Slave device Address */
 487                buf[5] = I2C_SLAVE_ADDR_REG;
 488                buf[6] = (msg->addr);
 489                buf[7] = 0x00;
 490                buf[8] = USB_END_I2C_CMD;
 491                ret = mxl111sf_i2c_send_data(state, 0, buf);
 492
 493                /* check for slave device status */
 494                if (mxl111sf_i2c_check_status(state) == 1) {
 495                        mxl_i2c("NACK writing slave address %02x",
 496                                msg->addr);
 497                        /* if NACK, stop I2C bus and exit */
 498                        buf[2] = I2C_CONTROL_REG;
 499                        buf[3] = 0x4E;
 500                        buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 501                        ret = -EIO;
 502                        goto exit;
 503                }
 504
 505                /* I2C interface can do I2C operations in block of 8 bytes of
 506                   I2C data. calculation to figure out number of blocks of i2c
 507                   data required to program */
 508                block_len = (msg->len / 8);
 509                left_over_len = (msg->len % 8);
 510
 511                mxl_i2c("block_len %d, left_over_len %d",
 512                        block_len, left_over_len);
 513
 514                for (index = 0; index < block_len; index++) {
 515                        for (i = 0; i < 8; i++) {
 516                                /* write data on I2C interface */
 517                                buf[2+(i*3)] = I2C_DATA_REG;
 518                                buf[3+(i*3)] = msg->buf[(index*8)+i];
 519                                buf[4+(i*3)] = 0x00;
 520                        }
 521
 522                        ret = mxl111sf_i2c_send_data(state, 0, buf);
 523
 524                        /* check for I2C NACK status */
 525                        if (mxl111sf_i2c_check_status(state) == 1) {
 526                                mxl_i2c("NACK writing slave address %02x",
 527                                        msg->addr);
 528
 529                                /* if NACK, stop I2C bus and exit */
 530                                buf[2] = I2C_CONTROL_REG;
 531                                buf[3] = 0x4E;
 532                                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 533                                ret = -EIO;
 534                                goto exit;
 535                        }
 536
 537                }
 538
 539                if (left_over_len) {
 540                        for (k = 0; k < 26; k++)
 541                                buf[k] = USB_END_I2C_CMD;
 542
 543                        buf[0] = 0x99;
 544                        buf[1] = 0x00;
 545
 546                        for (i = 0; i < left_over_len; i++) {
 547                                buf[2+(i*3)] = I2C_DATA_REG;
 548                                buf[3+(i*3)] = msg->buf[(index*8)+i];
 549                                mxl_i2c("index = %d %d data %d",
 550                                        index, i, msg->buf[(index*8)+i]);
 551                                buf[4+(i*3)] = 0x00;
 552                        }
 553                        ret = mxl111sf_i2c_send_data(state, 0, buf);
 554
 555                        /* check for I2C NACK status */
 556                        if (mxl111sf_i2c_check_status(state) == 1) {
 557                                mxl_i2c("NACK writing slave address %02x",
 558                                        msg->addr);
 559
 560                                /* if NACK, stop I2C bus and exit */
 561                                buf[2] = I2C_CONTROL_REG;
 562                                buf[3] = 0x4E;
 563                                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 564                                ret = -EIO;
 565                                goto exit;
 566                        }
 567
 568                }
 569
 570                /* issue I2C STOP after write */
 571                buf[2] = I2C_CONTROL_REG;
 572                buf[3] = 0x4E;
 573                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 574
 575        }
 576
 577        /* read data from I2C bus */
 578        if ((msg->flags & I2C_M_RD) && (msg->len > 0)) {
 579                mxl_i2c("read buf len %d", msg->len);
 580
 581                /* command to indicate data payload is
 582                   destined for I2C interface */
 583                buf[2] = I2C_CONTROL_REG;
 584                buf[3] = 0xDF;
 585                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 586
 587                /* I2C xfer length */
 588                buf[5] = 0x14;
 589                buf[6] = (msg->len & 0xFF);
 590                buf[7] = 0;
 591
 592                /* I2C slave device Address */
 593                buf[8] = I2C_SLAVE_ADDR_REG;
 594                buf[9] = msg->addr;
 595                buf[10] = 0x00;
 596                buf[11] = USB_END_I2C_CMD;
 597                ret = mxl111sf_i2c_send_data(state, 0, buf);
 598
 599                /* check for I2C NACK status */
 600                if (mxl111sf_i2c_check_status(state) == 1) {
 601                        mxl_i2c("NACK reading slave address %02x",
 602                                msg->addr);
 603
 604                        /* if NACK, stop I2C bus and exit */
 605                        buf[2] = I2C_CONTROL_REG;
 606                        buf[3] = 0xC7;
 607                        buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 608                        ret = -EIO;
 609                        goto exit;
 610                }
 611
 612                /* I2C interface can do I2C operations in block of 8 bytes of
 613                   I2C data. calculation to figure out number of blocks of
 614                   i2c data required to program */
 615                block_len = ((msg->len) / 8);
 616                left_over_len = ((msg->len) % 8);
 617                index = 0;
 618
 619                mxl_i2c("block_len %d, left_over_len %d",
 620                        block_len, left_over_len);
 621
 622                /* command to read data from I2C interface */
 623                buf[0] = USB_READ_I2C_CMD;
 624                buf[1] = 0x00;
 625
 626                for (index = 0; index < block_len; index++) {
 627                        /* setup I2C read request packet on I2C interface */
 628                        for (i = 0; i < 8; i++) {
 629                                buf[2+(i*3)] = I2C_DATA_REG;
 630                                buf[3+(i*3)] = 0x00;
 631                                buf[4+(i*3)] = 0x00;
 632                        }
 633
 634                        ret = mxl111sf_i2c_get_data(state, 0, buf, i2c_r_data);
 635
 636                        /* check for I2C NACK status */
 637                        if (mxl111sf_i2c_check_status(state) == 1) {
 638                                mxl_i2c("NACK reading slave address %02x",
 639                                        msg->addr);
 640
 641                                /* if NACK, stop I2C bus and exit */
 642                                buf[2] = I2C_CONTROL_REG;
 643                                buf[3] = 0xC7;
 644                                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 645                                ret = -EIO;
 646                                goto exit;
 647                        }
 648
 649                        /* copy data from i2c data payload to read buffer */
 650                        for (i = 0; i < 8; i++) {
 651                                rd_status[i] = i2c_r_data[(i*3)+2];
 652
 653                                if (rd_status[i] == 0x04) {
 654                                        if (i < 7) {
 655                                                mxl_i2c("i2c fifo empty! @ %d",
 656                                                        i);
 657                                                msg->buf[(index*8)+i] =
 658                                                        i2c_r_data[(i*3)+1];
 659                                                /* read again */
 660                                                ret_status =
 661                                                        mxl111sf_i2c_readagain(
 662                                                                state, 8-(i+1),
 663                                                                readbuff);
 664                                                if (ret_status == 1) {
 665                                                        for (k = 0;
 666                                                             k < 8-(i+1);
 667                                                             k++) {
 668
 669                                        msg->buf[(index*8)+(k+i+1)] =
 670                                                readbuff[k];
 671                                        mxl_i2c("read data: %02x\t %02x",
 672                                                msg->buf[(index*8)+(k+i)],
 673                                                (index*8)+(k+i));
 674                                        mxl_i2c("read data: %02x\t %02x",
 675                                                msg->buf[(index*8)+(k+i+1)],
 676                                                readbuff[k]);
 677
 678                                                        }
 679                                                        goto stop_copy;
 680                                                } else {
 681                                                        mxl_i2c("readagain ERROR!");
 682                                                }
 683                                        } else {
 684                                                msg->buf[(index*8)+i] =
 685                                                        i2c_r_data[(i*3)+1];
 686                                        }
 687                                } else {
 688                                        msg->buf[(index*8)+i] =
 689                                                i2c_r_data[(i*3)+1];
 690                                }
 691                        }
 692stop_copy:
 693                        ;
 694
 695                }
 696
 697                if (left_over_len) {
 698                        for (k = 0; k < 26; k++)
 699                                buf[k] = USB_END_I2C_CMD;
 700
 701                        buf[0] = 0xDD;
 702                        buf[1] = 0x00;
 703
 704                        for (i = 0; i < left_over_len; i++) {
 705                                buf[2+(i*3)] = I2C_DATA_REG;
 706                                buf[3+(i*3)] = 0x00;
 707                                buf[4+(i*3)] = 0x00;
 708                        }
 709                        ret = mxl111sf_i2c_get_data(state, 0, buf,
 710                                                    i2c_r_data);
 711
 712                        /* check for I2C NACK status */
 713                        if (mxl111sf_i2c_check_status(state) == 1) {
 714                                mxl_i2c("NACK reading slave address %02x",
 715                                        msg->addr);
 716
 717                                /* if NACK, stop I2C bus and exit */
 718                                buf[2] = I2C_CONTROL_REG;
 719                                buf[3] = 0xC7;
 720                                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 721                                ret = -EIO;
 722                                goto exit;
 723                        }
 724
 725                        for (i = 0; i < left_over_len; i++) {
 726                                msg->buf[(block_len*8)+i] =
 727                                        i2c_r_data[(i*3)+1];
 728                                mxl_i2c("read data: %02x\t %02x",
 729                                        i2c_r_data[(i*3)+1],
 730                                        i2c_r_data[(i*3)+2]);
 731                        }
 732                }
 733
 734                /* indicate I2C interface to issue NACK
 735                   after next I2C read op */
 736                buf[0] = USB_WRITE_I2C_CMD;
 737                buf[1] = 0x00;
 738
 739                /* control register */
 740                buf[2] = I2C_CONTROL_REG;
 741                buf[3] = 0x17;
 742                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 743
 744                buf[5] = USB_END_I2C_CMD;
 745                ret = mxl111sf_i2c_send_data(state, 0, buf);
 746
 747                /* control register */
 748                buf[2] = I2C_CONTROL_REG;
 749                buf[3] = 0xC7;
 750                buf[4] = (HWI2C400) ? 0x03 : 0x0D;
 751
 752        }
 753exit:
 754        /* STOP and disable I2C MUX */
 755        buf[0] = USB_WRITE_I2C_CMD;
 756        buf[1] = 0x00;
 757
 758        /* de-initilize I2C BUS */
 759        buf[5] = USB_END_I2C_CMD;
 760        mxl111sf_i2c_send_data(state, 0, buf);
 761
 762        /* Control Register */
 763        buf[2] = I2C_CONTROL_REG;
 764        buf[3] = 0xDF;
 765        buf[4] = 0x03;
 766
 767        /* disable I2C interface */
 768        buf[5] = I2C_MUX_REG;
 769        buf[6] = 0x00;
 770        buf[7] = 0x00;
 771
 772        /* de-initilize I2C BUS */
 773        buf[8] = USB_END_I2C_CMD;
 774        mxl111sf_i2c_send_data(state, 0, buf);
 775
 776        /* disable I2C interface */
 777        buf[2] = I2C_MUX_REG;
 778        buf[3] = 0x81;
 779        buf[4] = 0x00;
 780
 781        /* disable I2C interface */
 782        buf[5] = I2C_MUX_REG;
 783        buf[6] = 0x00;
 784        buf[7] = 0x00;
 785
 786        /* disable I2C interface */
 787        buf[8] = I2C_MUX_REG;
 788        buf[9] = 0x00;
 789        buf[10] = 0x00;
 790
 791        buf[11] = USB_END_I2C_CMD;
 792        mxl111sf_i2c_send_data(state, 0, buf);
 793
 794        return ret;
 795}
 796
 797/* ------------------------------------------------------------------------ */
 798
 799int mxl111sf_i2c_xfer(struct i2c_adapter *adap,
 800                      struct i2c_msg msg[], int num)
 801{
 802        struct dvb_usb_device *d = i2c_get_adapdata(adap);
 803        struct mxl111sf_state *state = d->priv;
 804        int hwi2c = (state->chip_rev > MXL111SF_V6);
 805        int i, ret;
 806
 807        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 808                return -EAGAIN;
 809
 810        for (i = 0; i < num; i++) {
 811                ret = (hwi2c) ?
 812                        mxl111sf_i2c_hw_xfer_msg(state, &msg[i]) :
 813                        mxl111sf_i2c_sw_xfer_msg(state, &msg[i]);
 814                if (mxl_fail(ret)) {
 815                        mxl_debug_adv("failed with error %d on i2c transaction %d of %d, %sing %d bytes to/from 0x%02x",
 816                                      ret, i+1, num,
 817                                      (msg[i].flags & I2C_M_RD) ?
 818                                      "read" : "writ",
 819                                      msg[i].len, msg[i].addr);
 820
 821                        break;
 822                }
 823        }
 824
 825        mutex_unlock(&d->i2c_mutex);
 826
 827        return i == num ? num : -EREMOTEIO;
 828}
 829