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>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/1767525
Reviewed-by: Edward Hill <ecgh@chromium.org>
Commit-Queue: Edward Hill <ecgh@chromium.org>
Tested-by: Edward Hill <ecgh@chromium.org>

8 files changed, 200 insertions, 144 deletions

diff --git a/common/cbi.c b/common/cbi.c
index f37d6950b1..1bc069939e 100644
--- a/common/cbi.c
+++ b/common/cbi.c
@@ -72,8 +72,8 @@ static struct cbi_header * const head = (struct cbi_header *)cbi;
 
 static int read_eeprom(uint8_t offset, uint8_t *in, int in_size)
 {
-	return i2c_read_block(I2C_PORT_EEPROM, I2C_ADDR_EEPROM, offset,
-			in, in_size);
+	return i2c_read_block__7bf(I2C_PORT_EEPROM, I2C_ADDR_EEPROM__7bf,
+			      offset, in, in_size);
 }
 
 /*
@@ -220,8 +220,8 @@ static int write_board_info(void)
 	while (rest > 0) {
 		int size = MIN(EEPROM_PAGE_WRITE_SIZE, rest);
 		int rv;
-		rv = i2c_write_block(I2C_PORT_EEPROM, I2C_ADDR_EEPROM,
-				p - cbi, p, size);
+		rv = i2c_write_block__7bf(I2C_PORT_EEPROM, I2C_ADDR_EEPROM__7bf,
+				     p - cbi, p, size);
 		if (rv) {
 			CPRINTS("Failed to write for %d", rv);
 			return rv;
diff --git a/common/host_command_master.c b/common/host_command_master.c
index 9ba8ba64ab..a8ca77a4c2 100644
--- a/common/host_command_master.c
+++ b/common/host_command_master.c
@@ -80,9 +80,10 @@ static int pd_host_command_internal(int command, int version,
 	 */
 	i2c_lock(I2C_PORT_PD_MCU, 1);
 	i2c_set_timeout(I2C_PORT_PD_MCU, PD_HOST_COMMAND_TIMEOUT_US);
-	ret = i2c_xfer_unlocked(I2C_PORT_PD_MCU, CONFIG_USB_PD_I2C_SLAVE_ADDR,
-			&req_buf[0], outsize + sizeof(rq) + 1, &resp_buf[0],
-			2, I2C_XFER_START);
+	ret = i2c_xfer_unlocked__7bf(I2C_PORT_PD_MCU,
+				CONFIG_USB_PD_I2C_SLAVE_ADDR__7BF,
+				&req_buf[0], outsize + sizeof(rq) + 1,
+				&resp_buf[0], 2, I2C_XFER_START);
 	i2c_set_timeout(I2C_PORT_PD_MCU, 0);
 	if (ret) {
 		i2c_lock(I2C_PORT_PD_MCU, 0);
@@ -94,8 +95,9 @@ static int pd_host_command_internal(int command, int version,
 
 	if (resp_len > (insize + sizeof(rs))) {
 		/* Do a dummy read to generate stop condition */
-		i2c_xfer_unlocked(I2C_PORT_PD_MCU, CONFIG_USB_PD_I2C_SLAVE_ADDR,
-			0, 0, &resp_buf[2], 1, I2C_XFER_STOP);
+		i2c_xfer_unlocked__7bf(I2C_PORT_PD_MCU,
+				  CONFIG_USB_PD_I2C_SLAVE_ADDR__7BF,
+				  0, 0, &resp_buf[2], 1, I2C_XFER_STOP);
 		i2c_lock(I2C_PORT_PD_MCU, 0);
 		CPRINTF("[%T response size is too large %d > %d]\n",
 				resp_len, insize + sizeof(rs));
@@ -103,9 +105,10 @@ static int pd_host_command_internal(int command, int version,
 	}
 
 	/* Receive remaining data */
-	ret = i2c_xfer_unlocked(I2C_PORT_PD_MCU, CONFIG_USB_PD_I2C_SLAVE_ADDR,
-			0, 0,
-			&resp_buf[2], resp_len, I2C_XFER_STOP);
+	ret = i2c_xfer_unlocked__7bf(I2C_PORT_PD_MCU,
+				CONFIG_USB_PD_I2C_SLAVE_ADDR__7BF,
+				0, 0,
+				&resp_buf[2], resp_len, I2C_XFER_STOP);
 	i2c_lock(I2C_PORT_PD_MCU, 0);
 	if (ret) {
 		CPRINTF("[%T i2c transaction 2 failed: %d]\n", ret);
diff --git a/common/i2c_master.c b/common/i2c_master.c
index 1cd60f930b..0aff1326d5 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);
diff --git a/common/i2c_trace.c b/common/i2c_trace.c
index 52603c7244..ff237ed582 100644
--- a/common/i2c_trace.c
+++ b/common/i2c_trace.c
@@ -23,16 +23,17 @@ struct i2c_trace_range {
 
 static struct i2c_trace_range trace_entries[8];
 
-void i2c_trace_notify(int port, int slave_addr, int direction,
-		      const uint8_t *data, size_t size)
+void i2c_trace_notify__7bf(int port, uint16_t slave_addr__7bf,
+		      int direction, const uint8_t *data, size_t size)
 {
 	size_t i;
+	uint16_t addr__7b = I2C_GET_ADDR__7b(slave_addr__7bf);
 
 	for (i = 0; i < ARRAY_SIZE(trace_entries); i++)
 		if (trace_entries[i].enabled
 		    && trace_entries[i].port == port
-		    && trace_entries[i].slave_addr_lo <= slave_addr
-		    && trace_entries[i].slave_addr_hi >= slave_addr)
+		    && trace_entries[i].slave_addr_lo <= addr__7b
+		    && trace_entries[i].slave_addr_hi >= addr__7b)
 			goto trace_enabled;
 	return;
 
@@ -40,7 +41,7 @@ trace_enabled:
 	CPRINTF("i2c: %s %d:0x%X ",
 		direction ? "read" : "write",
 		port,
-		slave_addr);
+		addr__7b);
 	for (i = 0; i < size; i++)
 		CPRINTF("%02X ", data[i]);
 	CPRINTF("\n");
diff --git a/common/lb_common.c b/common/lb_common.c
index f800a6a65a..8dbcd73092 100644
--- a/common/lb_common.c
+++ b/common/lb_common.c
@@ -111,7 +111,7 @@
 /* Since there's absolutely nothing we can do about it if an I2C access
  * isn't working, we're completely ignoring any failures. */
 
-static const uint8_t i2c_addr[] = { 0x54, 0x56 };
+static const uint16_t i2c_addr__7bf[] = { 0x2A, 0x2B };
 
 static inline void controller_write(int ctrl_num, uint8_t reg, uint8_t val)
 {
@@ -119,9 +119,10 @@ static inline void controller_write(int ctrl_num, uint8_t reg, uint8_t val)
 
 	buf[0] = reg;
 	buf[1] = val;
-	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
-	i2c_xfer_unlocked(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num], buf, 2, 0, 0,
-		 I2C_XFER_SINGLE);
+	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr__7bf);
+	i2c_xfer_unlocked__7bf(I2C_PORT_LIGHTBAR, i2c_addr__7bf[ctrl_num],
+			buf, 2, 0, 0,
+			I2C_XFER_SINGLE);
 }
 
 static inline uint8_t controller_read(int ctrl_num, uint8_t reg)
@@ -129,8 +130,8 @@ static inline uint8_t controller_read(int ctrl_num, uint8_t reg)
 	uint8_t buf[1];
 	int rv;
 
-	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
-	rv = i2c_xfer_unlocked(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num],
+	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr__7bf);
+	rv = i2c_xfer_unlocked__7bf(I2C_PORT_LIGHTBAR, i2c_addr__7bf[ctrl_num],
 			&reg, 1, buf, 1, I2C_XFER_SINGLE);
 	return rv ? 0 : buf[0];
 }
diff --git a/common/motion_sense.c b/common/motion_sense.c
index 414b35b95a..7d9993b1e0 100644
--- a/common/motion_sense.c
+++ b/common/motion_sense.c
@@ -2051,7 +2051,8 @@ static int command_display_accel_info(int argc, char **argv)
 		ccprintf("type: %d\n", motion_sensors[i].type);
 		ccprintf("location: %d\n", motion_sensors[i].location);
 		ccprintf("port: %d\n", motion_sensors[i].port);
-		ccprintf("addr: %d\n", motion_sensors[i].addr);
+		ccprintf("addr: %d\n", I2C_GET_ADDR__7b(motion_sensors[i]
+						    .i2c_spi_addr__7bf));
 		ccprintf("range: %d\n", motion_sensors[i].default_range);
 		ccprintf("min_freq: %d\n", motion_sensors[i].min_frequency);
 		ccprintf("max_freq: %d\n", motion_sensors[i].max_frequency);
diff --git a/common/peripheral.c b/common/peripheral.c
index 4f16cd981d..4ad9ed3b9f 100644
--- a/common/peripheral.c
+++ b/common/peripheral.c
@@ -22,8 +22,7 @@ static int hc_locate_chip(struct host_cmd_handler_args *args)
 			return EC_RES_OVERFLOW;
 		resp->bus_type = EC_BUS_TYPE_I2C;
 		resp->i2c_info.port = I2C_PORT_EEPROM;
-		/* Convert from 8-bit address to 7-bit address */
-		resp->i2c_info.addr = I2C_ADDR_EEPROM >> 1;
+		resp->i2c_info.addr__7bf = I2C_ADDR_EEPROM__7bf;
 #else
 		/* Lookup type is supported, but not present on system. */
 		return EC_RES_UNAVAILABLE;
@@ -37,8 +36,8 @@ static int hc_locate_chip(struct host_cmd_handler_args *args)
 		if (resp->bus_type == EC_BUS_TYPE_I2C) {
 			resp->i2c_info.port =
 				tcpc_config[params->index].i2c_info.port;
-			resp->i2c_info.addr =
-				tcpc_config[params->index].i2c_info.addr >> 1;
+			resp->i2c_info.addr__7bf =
+				tcpc_config[params->index].i2c_info.addr__7bf;
 		}
 #else
 		return EC_RES_UNAVAILABLE;
diff --git a/common/usb_i2c.c b/common/usb_i2c.c
index 241e86b5ce..bf162b0e2b 100644
--- a/common/usb_i2c.c
+++ b/common/usb_i2c.c
@@ -107,9 +107,7 @@ static void usb_i2c_execute(struct usb_i2c_config const *config)
 	/* Payload is ready to execute. */
 	uint32_t count      = usb_i2c_read_packet(config);
 	int portindex       = (config->buffer[0] >> 0) & 0xf;
-	/* Convert 7-bit slave address to chromium EC 8-bit address. */
-	uint8_t slave_addr  = (config->buffer[0] >> 7) & 0xfe;
-
+	uint16_t addr__7bf  = (config->buffer[0] >> 8) & 0x7f;
 	int write_count     = ((config->buffer[0] << 4) & 0xf00) |
 		((config->buffer[1] >> 0) & 0xff);
 	int read_count      = (config->buffer[1] >> 8) & 0xff;
@@ -136,7 +134,7 @@ static void usb_i2c_execute(struct usb_i2c_config const *config)
 		config->buffer[0] = USB_I2C_READ_COUNT_INVALID;
 	} else if (portindex >= i2c_ports_used) {
 		config->buffer[0] = USB_I2C_PORT_INVALID;
-	} else if (slave_addr == USB_I2C_CMD_ADDR) {
+	} else if (addr__7bf == USB_I2C_CMD_ADDR__7bf) {
 		/*
 		 * This is a non-i2c command, invoke the handler if it has
 		 * been registered, if not - report the appropriate error.
@@ -157,8 +155,7 @@ static void usb_i2c_execute(struct usb_i2c_config const *config)
 		 * knows about.  It should behave closer to
 		 * EC_CMD_I2C_PASSTHRU, which can protect ports and ranges.
 		 */
-		ret = i2c_xfer(i2c_ports[portindex].port,
-				 slave_addr,
+		ret = i2c_xfer__7bf(i2c_ports[portindex].port, addr__7bf,
 				 (uint8_t *)(config->buffer + 2) + offset,
 				 write_count,
 				 (uint8_t *)(config->buffer + 2),