829 lines
17 KiB
C
829 lines
17 KiB
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;
|
|
}
|