summaryrefslogtreecommitdiff
path: root/common/i2c_master.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/i2c_master.c')
-rw-r--r--common/i2c_master.c274
1 files changed, 164 insertions, 110 deletions
diff --git a/common/i2c_master.c b/common/i2c_master.c
index 2efd6e9450..bfb9e01c3c 100644
--- a/common/i2c_master.c
+++ b/common/i2c_master.c
@@ -57,7 +57,7 @@ static int i2c_port_is_locked(int port)
}
-const struct i2c_port_t *get_i2c_port(int port)
+const struct i2c_port_t *get_i2c_port(const int port)
{
int i;
@@ -70,26 +70,29 @@ const struct i2c_port_t *get_i2c_port(int port)
return NULL;
}
-static int chip_i2c_xfer_with_notify(int port, int slave_addr,
+static int chip_i2c_xfer_with_notify__7bf(const int port,
+ const uint16_t slave_addr__7bf,
const uint8_t *out, int out_size,
uint8_t *in, int in_size, int flags)
{
int ret;
if (IS_ENABLED(CONFIG_I2C_DEBUG))
- i2c_trace_notify(port, slave_addr, 0, out, out_size);
+ i2c_trace_notify__7bf(port, slave_addr__7bf,
+ 0, out, out_size);
if (IS_ENABLED(CONFIG_I2C_XFER_BOARD_CALLBACK))
- i2c_start_xfer_notify(port, slave_addr);
+ i2c_start_xfer_notify__7bf(port, slave_addr__7bf);
- ret = chip_i2c_xfer(port, slave_addr, out, out_size, in, in_size,
- flags);
+ ret = chip_i2c_xfer__7bf(port, slave_addr__7bf,
+ out, out_size, in, in_size, flags);
if (IS_ENABLED(CONFIG_I2C_XFER_BOARD_CALLBACK))
- i2c_end_xfer_notify(port, slave_addr);
+ i2c_end_xfer_notify__7bf(port, slave_addr__7bf);
if (IS_ENABLED(CONFIG_I2C_DEBUG))
- i2c_trace_notify(port, slave_addr, 1, in, in_size);
+ i2c_trace_notify__7bf(port, slave_addr__7bf,
+ 1, in, in_size);
return ret;
}
@@ -99,8 +102,10 @@ static int chip_i2c_xfer_with_notify(int port, int slave_addr,
* Internal function that splits reading into multiple chip_i2c_xfer() calls
* if in_size exceeds CONFIG_I2C_CHIP_MAX_READ_SIZE.
*/
-static int i2c_xfer_no_retry(int port, int slave_addr, const uint8_t *out,
- int out_size, uint8_t *in, int in_size, int flags)
+static int i2c_xfer_no_retry__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ const uint8_t *out, int out_size,
+ uint8_t *in, int in_size, int flags)
{
int ret;
int out_flags = flags & I2C_XFER_START;
@@ -108,13 +113,15 @@ static int i2c_xfer_no_retry(int port, int slave_addr, const uint8_t *out,
in_size -= in_chunk_size;
out_flags |= !in_size ? (flags & I2C_XFER_STOP) : 0;
- ret = chip_i2c_xfer_with_notify(port, slave_addr, out, out_size, in,
+ ret = chip_i2c_xfer_with_notify__7bf(port, slave_addr__7bf,
+ out, out_size, in,
in_chunk_size, out_flags);
in += in_chunk_size;
while (in_size && ret == EC_SUCCESS) {
in_chunk_size = MIN(in_size, CONFIG_I2C_CHIP_MAX_READ_SIZE);
in_size -= in_chunk_size;
- ret = chip_i2c_xfer_with_notify(port, slave_addr, NULL, 0, in,
+ ret = chip_i2c_xfer_with_notify__7bf(port, slave_addr__7bf,
+ NULL, 0, in,
in_chunk_size, !in_size ? (flags & I2C_XFER_STOP) : 0);
in += in_chunk_size;
}
@@ -122,7 +129,8 @@ static int i2c_xfer_no_retry(int port, int slave_addr, const uint8_t *out,
}
#endif /* CONFIG_I2C_XFER_LARGE_READ */
-int i2c_xfer_unlocked(int port, int slave_addr,
+int i2c_xfer_unlocked__7bf(const int port,
+ const uint16_t slave_addr__7bf,
const uint8_t *out, int out_size,
uint8_t *in, int in_size, int flags)
{
@@ -136,11 +144,13 @@ int i2c_xfer_unlocked(int port, int slave_addr,
for (i = 0; i <= CONFIG_I2C_NACK_RETRY_COUNT; i++) {
#ifdef CONFIG_I2C_XFER_LARGE_READ
- ret = i2c_xfer_no_retry(port, slave_addr, out, out_size, in,
- in_size, flags);
+ ret = i2c_xfer_no_retry__7bf(port, slave_addr__7bf,
+ out, out_size, in,
+ in_size, flags);
#else
- ret = chip_i2c_xfer_with_notify(port, slave_addr, out, out_size,
- in, in_size, flags);
+ ret = chip_i2c_xfer_with_notify__7bf(port, slave_addr__7bf,
+ out, out_size,
+ in, in_size, flags);
#endif /* CONFIG_I2C_XFER_LARGE_READ */
if (ret != EC_ERROR_BUSY)
break;
@@ -148,14 +158,17 @@ int i2c_xfer_unlocked(int port, int slave_addr,
return ret;
}
-int i2c_xfer(int port, int slave_addr, const uint8_t *out, int out_size,
+int i2c_xfer__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ const uint8_t *out, int out_size,
uint8_t *in, int in_size)
{
int rv;
i2c_lock(port, 1);
- rv = i2c_xfer_unlocked(port, slave_addr, out, out_size, in, in_size,
- I2C_XFER_SINGLE);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ out, out_size, in, in_size,
+ I2C_XFER_SINGLE);
i2c_lock(port, 0);
return rv;
@@ -204,19 +217,22 @@ void i2c_prepare_sysjump(void)
mutex_lock(port_mutex + i);
}
-int i2c_read32(int port, int slave_addr, int offset, int *data)
+int i2c_read32__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int *data)
{
int rv;
uint8_t reg, buf[sizeof(uint32_t)];
reg = offset & 0xff;
/* I2C read 32-bit word: transmit 8-bit offset, and read 32bits */
- rv = i2c_xfer(port, slave_addr, &reg, 1, buf, sizeof(uint32_t));
+ rv = i2c_xfer__7bf(port, slave_addr__7bf,
+ &reg, 1, buf, sizeof(uint32_t));
if (rv)
return rv;
- if (slave_addr & I2C_FLAG_BIG_ENDIAN)
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf))
*data = ((int)buf[0] << 24) | ((int)buf[1] << 16) |
((int)buf[0] << 8) | buf[1];
else
@@ -226,13 +242,15 @@ int i2c_read32(int port, int slave_addr, int offset, int *data)
return EC_SUCCESS;
}
-int i2c_write32(int port, int slave_addr, int offset, int data)
+int i2c_write32__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int data)
{
uint8_t buf[1 + sizeof(uint32_t)];
buf[0] = offset & 0xff;
- if (slave_addr & I2C_FLAG_BIG_ENDIAN) {
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf)) {
buf[1] = (data >> 24) & 0xff;
buf[2] = (data >> 16) & 0xff;
buf[3] = (data >> 8) & 0xff;
@@ -244,23 +262,26 @@ int i2c_write32(int port, int slave_addr, int offset, int data)
buf[4] = (data >> 24) & 0xff;
}
- return i2c_xfer(port, slave_addr, buf, sizeof(uint32_t) + 1,
- NULL, 0);
+ return i2c_xfer__7bf(port, slave_addr__7bf,
+ buf, sizeof(uint32_t) + 1, NULL, 0);
}
-int i2c_read16(int port, int slave_addr, int offset, int *data)
+int i2c_read16__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int *data)
{
int rv;
uint8_t reg, buf[sizeof(uint16_t)];
reg = offset & 0xff;
/* I2C read 16-bit word: transmit 8-bit offset, and read 16bits */
- rv = i2c_xfer(port, slave_addr, &reg, 1, buf, sizeof(uint16_t));
+ rv = i2c_xfer__7bf(port, slave_addr__7bf,
+ &reg, 1, buf, sizeof(uint16_t));
if (rv)
return rv;
- if (slave_addr & I2C_FLAG_BIG_ENDIAN)
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf))
*data = ((int)buf[0] << 8) | buf[1];
else
*data = ((int)buf[1] << 8) | buf[0];
@@ -268,13 +289,15 @@ int i2c_read16(int port, int slave_addr, int offset, int *data)
return EC_SUCCESS;
}
-int i2c_write16(int port, int slave_addr, int offset, int data)
+int i2c_write16__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int data)
{
uint8_t buf[1 + sizeof(uint16_t)];
buf[0] = offset & 0xff;
- if (slave_addr & I2C_FLAG_BIG_ENDIAN) {
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf)) {
buf[1] = (data >> 8) & 0xff;
buf[2] = data & 0xff;
} else {
@@ -282,10 +305,13 @@ int i2c_write16(int port, int slave_addr, int offset, int data)
buf[2] = (data >> 8) & 0xff;
}
- return i2c_xfer(port, slave_addr, buf, 1 + sizeof(uint16_t), NULL, 0);
+ return i2c_xfer__7bf(port, slave_addr__7bf,
+ buf, 1 + sizeof(uint16_t), NULL, 0);
}
-int i2c_read8(int port, int slave_addr, int offset, int *data)
+int i2c_read8__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int *data)
{
int rv;
uint8_t reg = offset;
@@ -293,25 +319,28 @@ int i2c_read8(int port, int slave_addr, int offset, int *data)
reg = offset;
- rv = i2c_xfer(port, slave_addr, &reg, 1, &buf, 1);
+ rv = i2c_xfer__7bf(port, slave_addr__7bf, &reg, 1, &buf, 1);
if (!rv)
*data = buf;
return rv;
}
-int i2c_write8(int port, int slave_addr, int offset, int data)
+int i2c_write8__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, int data)
{
uint8_t buf[2];
buf[0] = offset;
buf[1] = data;
- return i2c_xfer(port, slave_addr, buf, 2, 0, 0);
+ return i2c_xfer__7bf(port, slave_addr__7bf, buf, 2, 0, 0);
}
-int i2c_read_offset16(int port, int slave_addr, uint16_t offset, int *data,
- int len)
+int i2c_read_offset16__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ uint16_t offset, int *data, int len)
{
int rv;
uint8_t buf[sizeof(uint16_t)], addr[sizeof(uint16_t)];
@@ -323,7 +352,7 @@ int i2c_read_offset16(int port, int slave_addr, uint16_t offset, int *data,
addr[1] = offset & 0xff;
/* I2C read 16-bit word: transmit 16-bit offset, and read buffer */
- rv = i2c_xfer(port, slave_addr, addr, 2, buf, len);
+ rv = i2c_xfer__7bf(port, slave_addr__7bf, addr, 2, buf, len);
if (rv)
return rv;
@@ -331,7 +360,7 @@ int i2c_read_offset16(int port, int slave_addr, uint16_t offset, int *data,
if (len == 1) {
*data = buf[0];
} else {
- if (slave_addr & I2C_FLAG_BIG_ENDIAN)
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf))
*data = ((int)buf[0] << 8) | buf[1];
else
*data = ((int)buf[1] << 8) | buf[0];
@@ -340,8 +369,9 @@ int i2c_read_offset16(int port, int slave_addr, uint16_t offset, int *data,
return EC_SUCCESS;
}
-int i2c_write_offset16(int port, int slave_addr, uint16_t offset, int data,
- int len)
+int i2c_write_offset16__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ uint16_t offset, int data, int len)
{
uint8_t buf[2 + sizeof(uint16_t)];
@@ -354,7 +384,7 @@ int i2c_write_offset16(int port, int slave_addr, uint16_t offset, int data,
if (len == 1) {
buf[2] = data & 0xff;
} else {
- if (slave_addr & I2C_FLAG_BIG_ENDIAN) {
+ if (I2C_IS_BIG_ENDIAN(slave_addr__7bf)) {
buf[2] = (data >> 8) & 0xff;
buf[3] = data & 0xff;
} else {
@@ -363,22 +393,24 @@ int i2c_write_offset16(int port, int slave_addr, uint16_t offset, int data,
}
}
- return i2c_xfer(port, slave_addr, buf, 2 + len, NULL, 0);
+ return i2c_xfer__7bf(port, slave_addr__7bf, buf, 2 + len, NULL, 0);
}
-int i2c_read_offset16_block(int port, int slave_addr, uint16_t offset,
- uint8_t *data, int len)
+int i2c_read_offset16_block__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ uint16_t offset, uint8_t *data, int len)
{
uint8_t addr[sizeof(uint16_t)];
addr[0] = (offset >> 8) & 0xff;
addr[1] = offset & 0xff;
- return i2c_xfer(port, slave_addr, addr, 2, data, len);
+ return i2c_xfer__7bf(port, slave_addr__7bf, addr, 2, data, len);
}
-int i2c_write_offset16_block(int port, int slave_addr, uint16_t offset,
- const uint8_t *data, int len)
+int i2c_write_offset16_block__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ uint16_t offset, const uint8_t *data, int len)
{
int rv;
uint8_t addr[sizeof(uint16_t)];
@@ -391,18 +423,19 @@ int i2c_write_offset16_block(int port, int slave_addr, uint16_t offset,
* appending the destination address with the data array.
*/
i2c_lock(port, 1);
- rv = i2c_xfer_unlocked(port, slave_addr, addr, 2, NULL, 0,
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf, addr, 2, NULL, 0,
I2C_XFER_START);
if (!rv)
- rv = i2c_xfer_unlocked(port, slave_addr, data, len, NULL, 0,
- I2C_XFER_STOP);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ data, len, NULL, 0, I2C_XFER_STOP);
i2c_lock(port, 0);
return rv;
}
-int i2c_read_string(int port, int slave_addr, int offset, uint8_t *data,
- int len)
+int i2c_read_string__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, uint8_t *data, int len)
{
int rv;
uint8_t reg, block_length;
@@ -414,16 +447,16 @@ int i2c_read_string(int port, int slave_addr, int offset, uint8_t *data,
* Send device reg space offset, and read back block length. Keep this
* session open without a stop.
*/
- rv = i2c_xfer_unlocked(port, slave_addr, &reg, 1, &block_length, 1,
- I2C_XFER_START);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ &reg, 1, &block_length, 1, I2C_XFER_START);
if (rv)
goto exit;
if (len && block_length > (len - 1))
block_length = len - 1;
- rv = i2c_xfer_unlocked(port, slave_addr, 0, 0, data, block_length,
- I2C_XFER_STOP);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ 0, 0, data, block_length, I2C_XFER_STOP);
data[block_length] = 0;
exit:
@@ -431,18 +464,20 @@ exit:
return rv;
}
-int i2c_read_block(int port, int slave_addr, int offset, uint8_t *data,
- int len)
+int i2c_read_block__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, uint8_t *data, int len)
{
int rv;
uint8_t reg_address = offset;
- rv = i2c_xfer(port, slave_addr, &reg_address, 1, data, len);
+ rv = i2c_xfer__7bf(port, slave_addr__7bf, &reg_address, 1, data, len);
return rv;
}
-int i2c_write_block(int port, int slave_addr, int offset, const uint8_t *data,
- int len)
+int i2c_write_block__7bf(const int port,
+ const uint16_t slave_addr__7bf,
+ int offset, const uint8_t *data, int len)
{
int rv;
uint8_t reg_address = offset;
@@ -452,11 +487,11 @@ int i2c_write_block(int port, int slave_addr, int offset, const uint8_t *data,
* appending the destination address with the data array.
*/
i2c_lock(port, 1);
- rv = i2c_xfer_unlocked(port, slave_addr, &reg_address, 1, NULL, 0,
- I2C_XFER_START);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ &reg_address, 1, NULL, 0, I2C_XFER_START);
if (!rv) {
- rv = i2c_xfer_unlocked(port, slave_addr, data, len, NULL, 0,
- I2C_XFER_STOP);
+ rv = i2c_xfer_unlocked__7bf(port, slave_addr__7bf,
+ data, len, NULL, 0, I2C_XFER_STOP);
}
i2c_lock(port, 0);
@@ -712,7 +747,7 @@ static int check_i2c_params(const struct host_cmd_handler_args *args)
/* Loop and process messages */;
for (msgnum = 0, msg = params->msg; msgnum < params->num_msgs;
msgnum++, msg++) {
- unsigned int addr_flags = msg->addr_flags;
+ unsigned int addr_flags = msg->addr_flags__7bf;
PTHRUPRINTS("port=%d, %s, addr=0x%x(7-bit), len=%d",
params->port,
@@ -769,10 +804,10 @@ static int i2c_command_passthru(struct host_cmd_handler_args *args)
if (ret)
return ret;
- if (port_protected[params->port] && i2c_port->passthru_allowed) {
+ if (port_protected[params->port] && i2c_port->passthru_allowed__7bf) {
for (i = 0; i < params->num_msgs; i++) {
- if (!i2c_port->passthru_allowed(i2c_port,
- params->msg[i].addr_flags & EC_I2C_ADDR_MASK))
+ if (!i2c_port->passthru_allowed__7bf(i2c_port,
+ params->msg[i].addr_flags__7bf))
return EC_RES_ACCESS_DENIED;
}
}
@@ -785,13 +820,15 @@ static int i2c_command_passthru(struct host_cmd_handler_args *args)
for (resp->num_msgs = 0, msg = params->msg;
resp->num_msgs < params->num_msgs;
resp->num_msgs++, msg++) {
- /* EC uses 8-bit slave address */
- unsigned int addr = (msg->addr_flags & EC_I2C_ADDR_MASK) << 1;
int xferflags = I2C_XFER_START;
int read_len = 0, write_len = 0;
int rv = 1;
- if (msg->addr_flags & EC_I2C_FLAG_READ)
+ /* Have to remove the EC flags from the address flags */
+ uint16_t addr__7bf = msg->addr_flags__7bf & EC_I2C_ADDR_MASK;
+
+
+ if (msg->addr_flags__7bf & EC_I2C_FLAG_READ)
read_len = msg->len;
else
write_len = msg->len;
@@ -800,9 +837,9 @@ static int i2c_command_passthru(struct host_cmd_handler_args *args)
if (resp->num_msgs == params->num_msgs - 1)
xferflags |= I2C_XFER_STOP;
-#if defined(VIRTUAL_BATTERY_ADDR) && defined(I2C_PORT_VIRTUAL_BATTERY)
+#if defined(VIRTUAL_BATTERY_ADDR__7bf) && defined(I2C_PORT_VIRTUAL_BATTERY)
if (params->port == I2C_PORT_VIRTUAL_BATTERY &&
- VIRTUAL_BATTERY_ADDR == addr) {
+ VIRTUAL_BATTERY_ADDR__7bf == addr__7bf) {
if (virtual_battery_handler(resp, in_len, &rv,
xferflags, read_len,
write_len, out))
@@ -811,7 +848,8 @@ static int i2c_command_passthru(struct host_cmd_handler_args *args)
#endif
/* Transfer next message */
PTHRUPRINTS("xfer port=%x addr=0x%x rlen=%d flags=0x%x",
- params->port, addr, read_len, xferflags);
+ params->port, addr__7bf,
+ read_len, xferflags);
if (write_len) {
PTHRUPRINTF(" out:");
for (i = 0; i < write_len; i++)
@@ -829,7 +867,8 @@ static int i2c_command_passthru(struct host_cmd_handler_args *args)
#endif
if (!port_is_locked)
i2c_lock(params->port, (port_is_locked = 1));
- rv = i2c_xfer_unlocked(params->port, addr,
+ rv = i2c_xfer_unlocked__7bf(params->port,
+ addr__7bf,
out, write_len,
&resp->data[in_len], read_len,
xferflags);
@@ -885,7 +924,7 @@ static void i2c_passthru_protect_tcpc_ports(void)
for (i = 0; i < CONFIG_USB_PD_PORT_COUNT; i++) {
/* TCPC tunnel not configured. No need to protect anything */
- if (!tcpc_config[i].i2c_info.addr)
+ if (!I2C_GET_ADDR__7b(tcpc_config[i].i2c_info.addr__7bf))
continue;
i2c_passthru_protect_port(tcpc_config[i].i2c_info.port);
}
@@ -976,30 +1015,31 @@ DECLARE_CONSOLE_COMMAND(i2cprotect, command_i2cprotect,
#ifdef CONFIG_CMD_I2C_SCAN
static void scan_bus(int port, const char *desc)
{
- int a;
+ int level;
uint8_t tmp;
+ uint16_t addr__7bf;
ccprintf("Scanning %d %s", port, desc);
i2c_lock(port, 1);
/* Don't scan a busy port, since reads will just fail / time out */
- a = i2c_get_line_levels(port);
- if (a != I2C_LINE_IDLE) {
+ level = i2c_get_line_levels(port);
+ if (level != I2C_LINE_IDLE) {
ccprintf(": port busy (SDA=%d, SCL=%d)",
- (a & I2C_LINE_SDA_HIGH) ? 1 : 0,
- (a & I2C_LINE_SCL_HIGH) ? 1 : 0);
+ (level & I2C_LINE_SDA_HIGH) ? 1 : 0,
+ (level & I2C_LINE_SCL_HIGH) ? 1 : 0);
goto scan_bus_exit;
}
- for (a = 0; a < 0x100; a += 2) {
+ for (addr__7bf = 0; addr__7bf <= 0xEF; ++addr__7bf) {
watchdog_reload(); /* Otherwise a full scan trips watchdog */
ccputs(".");
/* Do a single read */
- if (!i2c_xfer_unlocked(port, a, NULL, 0, &tmp, 1,
- I2C_XFER_SINGLE))
- ccprintf("\n 0x%02x", a);
+ if (!i2c_xfer_unlocked__7bf(port, addr__7bf,
+ NULL, 0, &tmp, 1, I2C_XFER_SINGLE))
+ ccprintf("\n 0x%02x", addr__7bf);
}
scan_bus_exit:
@@ -1034,7 +1074,8 @@ DECLARE_CONSOLE_COMMAND(i2cscan, command_scan,
#ifdef CONFIG_CMD_I2C_XFER
static int command_i2cxfer(int argc, char **argv)
{
- int port, slave_addr;
+ int port;
+ uint16_t addr__7bf;
uint16_t offset = 0;
uint8_t offset_size = 0;
int v = 0;
@@ -1049,7 +1090,7 @@ static int command_i2cxfer(int argc, char **argv)
if (*e)
return EC_ERROR_PARAM2;
- slave_addr = strtoi(argv[3], &e, 0);
+ addr__7bf = strtoi(argv[3], &e, 0);
if (*e)
return EC_ERROR_PARAM3;
@@ -1068,18 +1109,22 @@ static int command_i2cxfer(int argc, char **argv)
if (strcasecmp(argv[1], "r") == 0) {
/* 8-bit read */
if (offset_size == 2)
- rv = i2c_read_offset16(port, slave_addr, offset, &v, 1);
+ rv = i2c_read_offset16__7bf(port, addr__7bf,
+ offset, &v, 1);
else
- rv = i2c_read8(port, slave_addr, offset, &v);
+ rv = i2c_read8__7bf(port, addr__7bf,
+ offset, &v);
if (!rv)
ccprintf("0x%02x [%d]\n", v, v);
} else if (strcasecmp(argv[1], "r16") == 0) {
/* 16-bit read */
if (offset_size == 2)
- rv = i2c_read_offset16(port, slave_addr, offset, &v, 2);
+ rv = i2c_read_offset16__7bf(port, addr__7bf,
+ offset, &v, 2);
else
- rv = i2c_read16(port, slave_addr, offset, &v);
+ rv = i2c_read16__7bf(port, addr__7bf,
+ offset, &v);
if (!rv)
ccprintf("0x%04x [%d]\n", v, v);
@@ -1088,7 +1133,8 @@ static int command_i2cxfer(int argc, char **argv)
if (argc < 6 || v < 0 || v > sizeof(data))
return EC_ERROR_PARAM5;
- rv = i2c_xfer(port, slave_addr, (uint8_t *)&offset, 1, data, v);
+ rv = i2c_xfer__7bf(port, addr__7bf,
+ (uint8_t *)&offset, 1, data, v);
if (!rv)
ccprintf("Data: %.*h\n", v, data);
@@ -1098,18 +1144,22 @@ static int command_i2cxfer(int argc, char **argv)
if (argc < 6)
return EC_ERROR_PARAM5;
if (offset_size == 2)
- rv = i2c_write_offset16(port, slave_addr, offset, v, 1);
+ rv = i2c_write_offset16__7bf(port, addr__7bf,
+ offset, v, 1);
else
- rv = i2c_write8(port, slave_addr, offset, v);
+ rv = i2c_write8__7bf(port, addr__7bf,
+ offset, v);
} else if (strcasecmp(argv[1], "w16") == 0) {
/* 16-bit write */
if (argc < 6)
return EC_ERROR_PARAM5;
if (offset_size == 2)
- rv = i2c_write_offset16(port, slave_addr, offset, v, 2);
+ rv = i2c_write_offset16__7bf(port, addr__7bf,
+ offset, v, 2);
else
- rv = i2c_write16(port, slave_addr, offset, v);
+ rv = i2c_write16__7bf(port, addr__7bf,
+ offset, v);
} else {
return EC_ERROR_PARAM1;
@@ -1149,7 +1199,6 @@ static int command_i2ctest(int argc, char **argv)
int i, j, rv;
uint32_t rand;
int data, data_verify;
- int port, addr;
int count = 10000;
int udelay = 100;
int test_dev = i2c_test_dev_used;
@@ -1177,6 +1226,9 @@ static int command_i2ctest(int argc, char **argv)
}
for (i = 0; i < count; i++) {
+ int port;
+ uint16_t addr__7bf;
+
if (!(i % 1000))
ccprintf("running test %d\n", i);
@@ -1186,7 +1238,7 @@ static int command_i2ctest(int argc, char **argv)
}
port = i2c_stress_tests[test_dev].port;
- addr = i2c_stress_tests[test_dev].addr;
+ addr__7bf = i2c_stress_tests[test_dev].addr__7bf;
i2c_s_test = i2c_stress_tests[test_dev].i2c_test;
reg_s_info = &i2c_s_test->reg_info;
test_s_results = &i2c_s_test->test_results;
@@ -1194,8 +1246,8 @@ static int command_i2ctest(int argc, char **argv)
rand = get_time().val;
if (rand & 0x1) {
/* read */
- rv = i2c_s_test->i2c_read ?
- i2c_s_test->i2c_read(port, addr,
+ rv = i2c_s_test->i2c_read__7bf ?
+ i2c_s_test->i2c_read__7bf(port, addr__7bf,
reg_s_info->read_reg, &data) :
i2c_s_test->i2c_read_dev(
reg_s_info->read_reg, &data);
@@ -1211,8 +1263,8 @@ static int command_i2ctest(int argc, char **argv)
*/
/* Read the write register */
- rv = i2c_s_test->i2c_read ?
- i2c_s_test->i2c_read(port, addr,
+ rv = i2c_s_test->i2c_read__7bf ?
+ i2c_s_test->i2c_read__7bf(port, addr__7bf,
reg_s_info->read_reg, &data) :
i2c_s_test->i2c_read_dev(
reg_s_info->read_reg, &data);
@@ -1226,8 +1278,9 @@ static int command_i2ctest(int argc, char **argv)
j = I2C_STRESS_TEST_DATA_VERIFY_RETRY_COUNT;
do {
/* Write same value back */
- rv = i2c_s_test->i2c_write ?
- i2c_s_test->i2c_write(port, addr,
+ rv = i2c_s_test->i2c_write__7bf ?
+ i2c_s_test->i2c_write__7bf(port,
+ addr__7bf,
reg_s_info->write_reg, data) :
i2c_s_test->i2c_write_dev(
reg_s_info->write_reg, data);
@@ -1240,8 +1293,9 @@ static int command_i2ctest(int argc, char **argv)
test_s_results->write_success++;
/* Read back to verify the data */
- rv = i2c_s_test->i2c_read ?
- i2c_s_test->i2c_read(port, addr,
+ rv = i2c_s_test->i2c_read__7bf ?
+ i2c_s_test->i2c_read__7bf(port,
+ addr__7bf,
reg_s_info->read_reg, &data_verify) :
i2c_s_test->i2c_read_dev(
reg_s_info->read_reg, &data_verify);
View Lorry Controller Status