Use 7bit I2C/SPI slave addresses in EC

Opt for 7bit slave addresses in EC code.  If 8bit is
expected by a driver, make it local and show this in
the naming.

Use __7b, __7bf and __8b as name extensions for i2c/spi
addresses used in the EC codebase.  __7b indicates a
7bit address by itself.  __7bf indicates a 7bit address
with optional flags attached.  __8b indicates a 8bit
address by itself.

Allow space for 10bit addresses, even though this is
not currently being used by any of our attached
devices.

These extensions are for verification purposes only and
will be removed in the last pass of this ticket. I want
to make sure the variable names reflect the type to help
eliminate future 7/8/7-flags confusion.

BUG=chromium:971296
BRANCH=none
TEST=make buildall -j

Change-Id: I2fc3d1b52ce76184492b2aaff3060f486ca45f45
Signed-off-by: Denis Brockus <dbrockus@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/1699893
Reviewed-by: Jack Rosenthal <jrosenth@chromium.org>

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);