Quelle  mxl111sf-i2c.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  mxl111sf-i2c.c - driver for the MaxLinear MXL111SF
 *
 *  Copyright (C) 2010-2014 Michael Krufky <mkrufky@linuxtv.org>
 */

#include "mxl111sf-i2c.h"
#include "mxl111sf.h"

/* SW-I2C ----------------------------------------------------------------- */

#define SW_I2C_ADDR  0x1a
#define SW_I2C_EN  0x02
#define SW_SCL_OUT  0x04
#define SW_SDA_OUT  0x08
#define SW_SDA_IN  0x04

#define SW_I2C_BUSY_ADDR 0x2f
#define SW_I2C_BUSY  0x02

static int mxl111sf_i2c_bitbang_sendbyte(struct mxl111sf_state *state,
      u8 byte)
{
 int i, ret;
 u8 data = 0;

 mxl_i2c("(0x%02x)", byte);

 ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
 if (mxl_fail(ret))
  goto fail;

 for (i = 0; i < 8; i++) {

  data = (byte & (0x80 >> i)) ? SW_SDA_OUT : 0;

  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN | data);
  if (mxl_fail(ret))
   goto fail;

  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN | data | SW_SCL_OUT);
  if (mxl_fail(ret))
   goto fail;

  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN | data);
  if (mxl_fail(ret))
   goto fail;
 }

 /* last bit was 0 so we need to release SDA */
 if (!(byte & 1)) {
  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN | SW_SDA_OUT);
  if (mxl_fail(ret))
   goto fail;
 }

 /* CLK high for ACK readback */
 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
 if (mxl_fail(ret))
  goto fail;

 /* drop the CLK after getting ACK, SDA will go high right away */
 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 if (data & SW_SDA_IN)
  ret = -EIO;
fail:
 return ret;
}

static int mxl111sf_i2c_bitbang_recvbyte(struct mxl111sf_state *state,
      u8 *pbyte)
{
 int i, ret;
 u8 byte = 0;
 u8 data = 0;

 mxl_i2c("()");

 *pbyte = 0;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 for (i = 0; i < 8; i++) {
  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN |
      SW_SCL_OUT | SW_SDA_OUT);
  if (mxl_fail(ret))
   goto fail;

  ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &data);
  if (mxl_fail(ret))
   goto fail;

  if (data & SW_SDA_IN)
   byte |= (0x80 >> i);

  ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
      0x10 | SW_I2C_EN | SW_SDA_OUT);
  if (mxl_fail(ret))
   goto fail;
 }
 *pbyte = byte;
fail:
 return ret;
}

static int mxl111sf_i2c_start(struct mxl111sf_state *state)
{
 int ret;

 mxl_i2c("()");

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN); /* start */
 mxl_fail(ret);
fail:
 return ret;
}

static int mxl111sf_i2c_stop(struct mxl111sf_state *state)
{
 int ret;

 mxl_i2c("()");

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN); /* stop */
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_SCL_OUT | SW_SDA_OUT);
 mxl_fail(ret);
fail:
 return ret;
}

static int mxl111sf_i2c_ack(struct mxl111sf_state *state)
{
 int ret;
 u8 b = 0;

 mxl_i2c("()");

 ret = mxl111sf_read_reg(state, SW_I2C_BUSY_ADDR, &b);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN);
 if (mxl_fail(ret))
  goto fail;

 /* pull SDA low */
 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SDA_OUT);
 mxl_fail(ret);
fail:
 return ret;
}

static int mxl111sf_i2c_nack(struct mxl111sf_state *state)
{
 int ret;

 mxl_i2c("()");

 /* SDA high to signal last byte read from slave */
 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SCL_OUT | SW_SDA_OUT);
 if (mxl_fail(ret))
  goto fail;

 ret = mxl111sf_write_reg(state, SW_I2C_ADDR,
     0x10 | SW_I2C_EN | SW_SDA_OUT);
 mxl_fail(ret);
fail:
 return ret;
}

/* ------------------------------------------------------------------------ */

static int mxl111sf_i2c_sw_xfer_msg(struct mxl111sf_state *state,
        struct i2c_msg *msg)
{
 int i, ret;

 mxl_i2c("()");

 if (msg->flags & I2C_M_RD) {

  ret = mxl111sf_i2c_start(state);
  if (mxl_fail(ret))
   goto fail;

  ret = mxl111sf_i2c_bitbang_sendbyte(state,
          (msg->addr << 1) | 0x01);
  if (mxl_fail(ret)) {
   mxl111sf_i2c_stop(state);
   goto fail;
  }

  for (i = 0; i < msg->len; i++) {
   ret = mxl111sf_i2c_bitbang_recvbyte(state,
           &msg->buf[i]);
   if (mxl_fail(ret)) {
    mxl111sf_i2c_stop(state);
    goto fail;
   }

   if (i < msg->len - 1)
    mxl111sf_i2c_ack(state);
  }

  mxl111sf_i2c_nack(state);

  ret = mxl111sf_i2c_stop(state);
  if (mxl_fail(ret))
   goto fail;

 } else {

  ret = mxl111sf_i2c_start(state);
  if (mxl_fail(ret))
   goto fail;

  ret = mxl111sf_i2c_bitbang_sendbyte(state,
          (msg->addr << 1) & 0xfe);
  if (mxl_fail(ret)) {
   mxl111sf_i2c_stop(state);
   goto fail;
  }

  for (i = 0; i < msg->len; i++) {
   ret = mxl111sf_i2c_bitbang_sendbyte(state,
           msg->buf[i]);
   if (mxl_fail(ret)) {
    mxl111sf_i2c_stop(state);
    goto fail;
   }
  }

  /* FIXME: we only want to do this on the last transaction */
  mxl111sf_i2c_stop(state);
 }
fail:
 return ret;
}

/* HW-I2C ----------------------------------------------------------------- */

#define USB_WRITE_I2C_CMD     0x99
#define USB_READ_I2C_CMD      0xdd
#define USB_END_I2C_CMD       0xfe

#define USB_WRITE_I2C_CMD_LEN   26
#define USB_READ_I2C_CMD_LEN    24

#define I2C_MUX_REG           0x30
#define I2C_CONTROL_REG       0x00
#define I2C_SLAVE_ADDR_REG    0x08
#define I2C_DATA_REG          0x0c
#define I2C_INT_STATUS_REG    0x10

static int mxl111sf_i2c_send_data(struct mxl111sf_state *state,
      u8 index, u8 *wdata)
{
 int ret = mxl111sf_ctrl_msg(state, wdata[0],
        &wdata[1], 25, NULL, 0);
 mxl_fail(ret);

 return ret;
}

static int mxl111sf_i2c_get_data(struct mxl111sf_state *state,
     u8 index, u8 *wdata, u8 *rdata)
{
 int ret = mxl111sf_ctrl_msg(state, wdata[0],
        &wdata[1], 25, rdata, 24);
 mxl_fail(ret);

 return ret;
}

static u8 mxl111sf_i2c_check_status(struct mxl111sf_state *state)
{
 u8 status = 0;
 u8 buf[26];

 mxl_i2c_adv("()");

 buf[0] = USB_READ_I2C_CMD;
 buf[1] = 0x00;

 buf[2] = I2C_INT_STATUS_REG;
 buf[3] = 0x00;
 buf[4] = 0x00;

 buf[5] = USB_END_I2C_CMD;

 mxl111sf_i2c_get_data(state, 0, buf, buf);

 if (buf[1] & 0x04)
  status = 1;

 return status;
}

static u8 mxl111sf_i2c_check_fifo(struct mxl111sf_state *state)
{
 u8 status = 0;
 u8 buf[26];

 mxl_i2c("()");

 buf[0] = USB_READ_I2C_CMD;
 buf[1] = 0x00;

 buf[2] = I2C_MUX_REG;
 buf[3] = 0x00;
 buf[4] = 0x00;

 buf[5] = I2C_INT_STATUS_REG;
 buf[6] = 0x00;
 buf[7] = 0x00;
 buf[8] = USB_END_I2C_CMD;

 mxl111sf_i2c_get_data(state, 0, buf, buf);

 if (0x08 == (buf[1] & 0x08))
  status = 1;

 if ((buf[5] & 0x02) == 0x02)
  mxl_i2c("(buf[5] & 0x02) == 0x02"); /* FIXME */

 return status;
}

static int mxl111sf_i2c_readagain(struct mxl111sf_state *state,
      u8 count, u8 *rbuf)
{
 u8 i2c_w_data[26];
 u8 i2c_r_data[24];
 u8 i = 0;
 u8 fifo_status = 0;
 int status = 0;

 mxl_i2c("read %d bytes", count);

 while ((fifo_status == 0) && (i++ < 5))
  fifo_status = mxl111sf_i2c_check_fifo(state);

 i2c_w_data[0] = 0xDD;
 i2c_w_data[1] = 0x00;

 for (i = 2; i < 26; i++)
  i2c_w_data[i] = 0xFE;

 for (i = 0; i < count; i++) {
  i2c_w_data[2+(i*3)] = 0x0C;
  i2c_w_data[3+(i*3)] = 0x00;
  i2c_w_data[4+(i*3)] = 0x00;
 }

 mxl111sf_i2c_get_data(state, 0, i2c_w_data, i2c_r_data);

 /* Check for I2C NACK status */
 if (mxl111sf_i2c_check_status(state) == 1) {
  mxl_i2c("error!");
 } else {
  for (i = 0; i < count; i++) {
   rbuf[i] = i2c_r_data[(i*3)+1];
   mxl_i2c("%02x\t %02x",
    i2c_r_data[(i*3)+1],
    i2c_r_data[(i*3)+2]);
  }

  status = 1;
 }

 return status;
}

#define HWI2C400 1
static int mxl111sf_i2c_hw_xfer_msg(struct mxl111sf_state *state,
        struct i2c_msg *msg)
{
 int i, k, ret = 0;
 u16 index = 0;
 u8 buf[26];
 u8 i2c_r_data[24];
 u16 block_len;
 u16 left_over_len;
 u8 rd_status[8];
 u8 ret_status;
 u8 readbuff[26];

 mxl_i2c("addr: 0x%02x, read buff len: %d, write buff len: %d",
  msg->addr, (msg->flags & I2C_M_RD) ? msg->len : 0,
  (!(msg->flags & I2C_M_RD)) ? msg->len : 0);

 for (index = 0; index < 26; index++)
  buf[index] = USB_END_I2C_CMD;

 /* command to indicate data payload is destined for I2C interface */
 buf[0] = USB_WRITE_I2C_CMD;
 buf[1] = 0x00;

 /* enable I2C interface */
 buf[2] = I2C_MUX_REG;
 buf[3] = 0x80;
 buf[4] = 0x00;

 /* enable I2C interface */
 buf[5] = I2C_MUX_REG;
 buf[6] = 0x81;
 buf[7] = 0x00;

 /* set Timeout register on I2C interface */
 buf[8] = 0x14;
 buf[9] = 0xff;
 buf[10] = 0x00;
#if 0
 /* enable Interrupts on I2C interface */
 buf[8] = 0x24;
 buf[9] = 0xF7;
 buf[10] = 0x00;
#endif
 buf[11] = 0x24;
 buf[12] = 0xF7;
 buf[13] = 0x00;

 ret = mxl111sf_i2c_send_data(state, 0, buf);

 /* write data on I2C bus */
 if (!(msg->flags & I2C_M_RD) && (msg->len > 0)) {
  mxl_i2c("%d\t%02x", msg->len, msg->buf[0]);

  /* control register on I2C interface to initialize I2C bus */
  buf[2] = I2C_CONTROL_REG;
  buf[3] = 0x5E;
  buf[4] = (HWI2C400) ? 0x03 : 0x0D;

  /* I2C Slave device Address */
  buf[5] = I2C_SLAVE_ADDR_REG;
  buf[6] = (msg->addr);
  buf[7] = 0x00;
  buf[8] = USB_END_I2C_CMD;
  ret = mxl111sf_i2c_send_data(state, 0, buf);

  /* check for slave device status */
  if (mxl111sf_i2c_check_status(state) == 1) {
   mxl_i2c("NACK writing slave address %02x",
    msg->addr);
   /* if NACK, stop I2C bus and exit */
   buf[2] = I2C_CONTROL_REG;
   buf[3] = 0x4E;
   buf[4] = (HWI2C400) ? 0x03 : 0x0D;
   ret = -EIO;
   goto exit;
  }

  /* I2C interface can do I2C operations in block of 8 bytes of
   I2C data. calculation to figure out number of blocks of i2c
   data required to program */
  block_len = (msg->len / 8);
  left_over_len = (msg->len % 8);

  mxl_i2c("block_len %d, left_over_len %d",
   block_len, left_over_len);

  for (index = 0; index < block_len; index++) {
   for (i = 0; i < 8; i++) {
    /* write data on I2C interface */
    buf[2+(i*3)] = I2C_DATA_REG;
    buf[3+(i*3)] = msg->buf[(index*8)+i];
    buf[4+(i*3)] = 0x00;
   }

   ret = mxl111sf_i2c_send_data(state, 0, buf);

   /* check for I2C NACK status */
   if (mxl111sf_i2c_check_status(state) == 1) {
    mxl_i2c("NACK writing slave address %02x",
     msg->addr);

    /* if NACK, stop I2C bus and exit */
    buf[2] = I2C_CONTROL_REG;
    buf[3] = 0x4E;
    buf[4] = (HWI2C400) ? 0x03 : 0x0D;
    ret = -EIO;
    goto exit;
   }

  }

  if (left_over_len) {
   for (k = 0; k < 26; k++)
    buf[k] = USB_END_I2C_CMD;

   buf[0] = 0x99;
   buf[1] = 0x00;

   for (i = 0; i < left_over_len; i++) {
    buf[2+(i*3)] = I2C_DATA_REG;
    buf[3+(i*3)] = msg->buf[(index*8)+i];
    mxl_i2c("index = %d %d data %d",
     index, i, msg->buf[(index*8)+i]);
    buf[4+(i*3)] = 0x00;
   }
   ret = mxl111sf_i2c_send_data(state, 0, buf);

   /* check for I2C NACK status */
   if (mxl111sf_i2c_check_status(state) == 1) {
    mxl_i2c("NACK writing slave address %02x",
     msg->addr);

    /* if NACK, stop I2C bus and exit */
    buf[2] = I2C_CONTROL_REG;
    buf[3] = 0x4E;
    buf[4] = (HWI2C400) ? 0x03 : 0x0D;
    ret = -EIO;
    goto exit;
   }

  }

  /* issue I2C STOP after write */
  buf[2] = I2C_CONTROL_REG;
  buf[3] = 0x4E;
  buf[4] = (HWI2C400) ? 0x03 : 0x0D;

 }

 /* read data from I2C bus */
 if ((msg->flags & I2C_M_RD) && (msg->len > 0)) {
  mxl_i2c("read buf len %d", msg->len);

  /* command to indicate data payload is
   destined for I2C interface */
  buf[2] = I2C_CONTROL_REG;
  buf[3] = 0xDF;
  buf[4] = (HWI2C400) ? 0x03 : 0x0D;

  /* I2C xfer length */
  buf[5] = 0x14;
  buf[6] = (msg->len & 0xFF);
  buf[7] = 0;

  /* I2C slave device Address */
  buf[8] = I2C_SLAVE_ADDR_REG;
  buf[9] = msg->addr;
  buf[10] = 0x00;
  buf[11] = USB_END_I2C_CMD;
  ret = mxl111sf_i2c_send_data(state, 0, buf);

  /* check for I2C NACK status */
  if (mxl111sf_i2c_check_status(state) == 1) {
   mxl_i2c("NACK reading slave address %02x",
    msg->addr);

   /* if NACK, stop I2C bus and exit */
   buf[2] = I2C_CONTROL_REG;
   buf[3] = 0xC7;
   buf[4] = (HWI2C400) ? 0x03 : 0x0D;
   ret = -EIO;
   goto exit;
  }

  /* I2C interface can do I2C operations in block of 8 bytes of
   I2C data. calculation to figure out number of blocks of
   i2c data required to program */
  block_len = ((msg->len) / 8);
  left_over_len = ((msg->len) % 8);
  index = 0;

  mxl_i2c("block_len %d, left_over_len %d",
   block_len, left_over_len);

  /* command to read data from I2C interface */
  buf[0] = USB_READ_I2C_CMD;
  buf[1] = 0x00;

  for (index = 0; index < block_len; index++) {
   /* setup I2C read request packet on I2C interface */
   for (i = 0; i < 8; i++) {
    buf[2+(i*3)] = I2C_DATA_REG;
    buf[3+(i*3)] = 0x00;
    buf[4+(i*3)] = 0x00;
   }

   ret = mxl111sf_i2c_get_data(state, 0, buf, i2c_r_data);

   /* check for I2C NACK status */
   if (mxl111sf_i2c_check_status(state) == 1) {
    mxl_i2c("NACK reading slave address %02x",
     msg->addr);

    /* if NACK, stop I2C bus and exit */
    buf[2] = I2C_CONTROL_REG;
    buf[3] = 0xC7;
    buf[4] = (HWI2C400) ? 0x03 : 0x0D;
    ret = -EIO;
    goto exit;
   }

   /* copy data from i2c data payload to read buffer */
   for (i = 0; i < 8; i++) {
    rd_status[i] = i2c_r_data[(i*3)+2];

    if (rd_status[i] == 0x04) {
     if (i < 7) {
      mxl_i2c("i2c fifo empty! @ %d",
       i);
      msg->buf[(index*8)+i] =
       i2c_r_data[(i*3)+1];
      /* read again */
      ret_status =
       mxl111sf_i2c_readagain(
        state, 8-(i+1),
        readbuff);
      if (ret_status == 1) {
       for (k = 0;
            k < 8-(i+1);
            k++) {

     msg->buf[(index*8)+(k+i+1)] =
      readbuff[k];
     mxl_i2c("read data: %02x\t %02x",
      msg->buf[(index*8)+(k+i)],
      (index*8)+(k+i));
     mxl_i2c("read data: %02x\t %02x",
      msg->buf[(index*8)+(k+i+1)],
      readbuff[k]);

       }
       goto stop_copy;
      } else {
       mxl_i2c("readagain ERROR!");
      }
     } else {
      msg->buf[(index*8)+i] =
       i2c_r_data[(i*3)+1];
     }
    } else {
     msg->buf[(index*8)+i] =
      i2c_r_data[(i*3)+1];
    }
   }
stop_copy:
   ;

  }

  if (left_over_len) {
   for (k = 0; k < 26; k++)
    buf[k] = USB_END_I2C_CMD;

   buf[0] = 0xDD;
   buf[1] = 0x00;

   for (i = 0; i < left_over_len; i++) {
    buf[2+(i*3)] = I2C_DATA_REG;
    buf[3+(i*3)] = 0x00;
    buf[4+(i*3)] = 0x00;
   }
   ret = mxl111sf_i2c_get_data(state, 0, buf,
          i2c_r_data);

   /* check for I2C NACK status */
   if (mxl111sf_i2c_check_status(state) == 1) {
    mxl_i2c("NACK reading slave address %02x",
     msg->addr);

    /* if NACK, stop I2C bus and exit */
    buf[2] = I2C_CONTROL_REG;
    buf[3] = 0xC7;
    buf[4] = (HWI2C400) ? 0x03 : 0x0D;
    ret = -EIO;
    goto exit;
   }

   for (i = 0; i < left_over_len; i++) {
    msg->buf[(block_len*8)+i] =
     i2c_r_data[(i*3)+1];
    mxl_i2c("read data: %02x\t %02x",
     i2c_r_data[(i*3)+1],
     i2c_r_data[(i*3)+2]);
   }
  }

  /* indicate I2C interface to issue NACK
   after next I2C read op */
  buf[0] = USB_WRITE_I2C_CMD;
  buf[1] = 0x00;

  /* control register */
  buf[2] = I2C_CONTROL_REG;
  buf[3] = 0x17;
  buf[4] = (HWI2C400) ? 0x03 : 0x0D;

  buf[5] = USB_END_I2C_CMD;
  ret = mxl111sf_i2c_send_data(state, 0, buf);

  /* control register */
  buf[2] = I2C_CONTROL_REG;
  buf[3] = 0xC7;
  buf[4] = (HWI2C400) ? 0x03 : 0x0D;

 }
exit:
 /* STOP and disable I2C MUX */
 buf[0] = USB_WRITE_I2C_CMD;
 buf[1] = 0x00;

 /* de-initilize I2C BUS */
 buf[5] = USB_END_I2C_CMD;
 mxl111sf_i2c_send_data(state, 0, buf);

 /* Control Register */
 buf[2] = I2C_CONTROL_REG;
 buf[3] = 0xDF;
 buf[4] = 0x03;

 /* disable I2C interface */
 buf[5] = I2C_MUX_REG;
 buf[6] = 0x00;
 buf[7] = 0x00;

 /* de-initilize I2C BUS */
 buf[8] = USB_END_I2C_CMD;
 mxl111sf_i2c_send_data(state, 0, buf);

 /* disable I2C interface */
 buf[2] = I2C_MUX_REG;
 buf[3] = 0x81;
 buf[4] = 0x00;

 /* disable I2C interface */
 buf[5] = I2C_MUX_REG;
 buf[6] = 0x00;
 buf[7] = 0x00;

 /* disable I2C interface */
 buf[8] = I2C_MUX_REG;
 buf[9] = 0x00;
 buf[10] = 0x00;

 buf[11] = USB_END_I2C_CMD;
 mxl111sf_i2c_send_data(state, 0, buf);

 return ret;
}

/* ------------------------------------------------------------------------ */

int mxl111sf_i2c_xfer(struct i2c_adapter *adap,
        struct i2c_msg msg[], int num)
{
 struct dvb_usb_device *d = i2c_get_adapdata(adap);
 struct mxl111sf_state *state = d->priv;
 int hwi2c = (state->chip_rev > MXL111SF_V6);
 int i, ret;

 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
  return -EAGAIN;

 for (i = 0; i < num; i++) {
  ret = (hwi2c) ?
   mxl111sf_i2c_hw_xfer_msg(state, &msg[i]) :
   mxl111sf_i2c_sw_xfer_msg(state, &msg[i]);
  if (mxl_fail(ret)) {
   mxl_debug_adv("failed with error %d on i2c transaction %d of %d, %sing %d bytes to/from 0x%02x",
          ret, i+1, num,
          (msg[i].flags & I2C_M_RD) ?
          "read" : "writ",
          msg[i].len, msg[i].addr);

   break;
  }
 }

 mutex_unlock(&d->i2c_mutex);

 return i == num ? num : -EREMOTEIO;
}