sensor: update sensor driver to use I2C port from motion_sensor_t

this allow motion sensor devices to be locate on different I2C port

BUG=none
BRANCH=none
TEST=make buildall

Change-Id: Ia7ba2f5729ebb19561768ec87fdb267e79aafb6a
Signed-off-by: Kevin K Wong <kevin.k.wong@intel.com>
Reviewed-on: https://chromium-review.googlesource.com/334269
Reviewed-by: Shawn N <shawnn@chromium.org>

1 files changed, 104 insertions, 93 deletions

diff --git a/driver/accelgyro_bmi160.c b/driver/accelgyro_bmi160.c
index a9b869f02a..0cc192aec2 100644
--- a/driver/accelgyro_bmi160.c
+++ b/driver/accelgyro_bmi160.c
@@ -128,8 +128,8 @@ static int get_engineering_val(const int reg_val,
 }
 
 #ifdef CONFIG_SPI_ACCEL_PORT
-static inline int spi_raw_read(const int addr, const uint8_t reg, uint8_t *data,
-			       const int len)
+static inline int spi_raw_read(const int addr, const uint8_t reg,
+			       uint8_t *data, const int len)
 {
 	uint8_t cmd = 0x80 | reg;
 
@@ -139,7 +139,8 @@ static inline int spi_raw_read(const int addr, const uint8_t reg, uint8_t *data,
 /**
  * Read 8bit register from accelerometer.
  */
-static int raw_read8(const int addr, const uint8_t reg, int *data_ptr)
+static int raw_read8(const int port, const int addr, const uint8_t reg,
+					 int *data_ptr)
 {
 	int rv = -EC_ERROR_PARAM1;
 
@@ -152,7 +153,7 @@ static int raw_read8(const int addr, const uint8_t reg, int *data_ptr)
 #endif
 	} else {
 #ifdef I2C_PORT_ACCEL
-		rv = i2c_read8(I2C_PORT_ACCEL, BMI160_I2C_ADDRESS(addr),
+		rv = i2c_read8(port, BMI160_I2C_ADDRESS(addr),
 			       reg, data_ptr);
 #endif
 	}
@@ -162,7 +163,8 @@ static int raw_read8(const int addr, const uint8_t reg, int *data_ptr)
 /**
  * Write 8bit register from accelerometer.
  */
-static int raw_write8(const int addr, const uint8_t reg, int data)
+static int raw_write8(const int port, const int addr, const uint8_t reg,
+					  int data)
 {
 	int rv = -EC_ERROR_PARAM1;
 
@@ -174,7 +176,7 @@ static int raw_write8(const int addr, const uint8_t reg, int data)
 #endif
 	} else {
 #ifdef I2C_PORT_ACCEL
-		rv = i2c_write8(I2C_PORT_ACCEL, BMI160_I2C_ADDRESS(addr),
+		rv = i2c_write8(port, BMI160_I2C_ADDRESS(addr),
 				reg, data);
 #endif
 	}
@@ -192,7 +194,8 @@ static int raw_write8(const int addr, const uint8_t reg, int data)
 /**
  * Read 32bit register from accelerometer.
  */
-static int raw_read32(const int addr, const uint8_t reg, int *data_ptr)
+static int raw_read32(const int port, const int addr, const uint8_t reg,
+					  int *data_ptr)
 {
 	int rv = -EC_ERROR_PARAM1;
 	if (BMI160_IS_SPI(addr)) {
@@ -202,7 +205,7 @@ static int raw_read32(const int addr, const uint8_t reg, int *data_ptr)
 #endif
 	} else {
 #ifdef I2C_PORT_ACCEL
-		rv = i2c_read32(I2C_PORT_ACCEL, BMI160_I2C_ADDRESS(addr),
+		rv = i2c_read32(port, BMI160_I2C_ADDRESS(addr),
 				reg, data_ptr);
 #endif
 	}
@@ -213,7 +216,7 @@ static int raw_read32(const int addr, const uint8_t reg, int *data_ptr)
 /**
  * Read n bytes from accelerometer.
  */
-static int raw_read_n(const int addr, const uint8_t reg,
+static int raw_read_n(const int port, const int addr, const uint8_t reg,
 		uint8_t *data_ptr, const int len)
 {
 	int rv = -EC_ERROR_PARAM1;
@@ -224,10 +227,10 @@ static int raw_read_n(const int addr, const uint8_t reg,
 #endif
 	} else {
 #ifdef I2C_PORT_ACCEL
-		i2c_lock(I2C_PORT_ACCEL, 1);
-		rv = i2c_xfer(I2C_PORT_ACCEL, BMI160_I2C_ADDRESS(addr), &reg, 1,
+		i2c_lock(port, 1);
+		rv = i2c_xfer(port, BMI160_I2C_ADDRESS(addr), &reg, 1,
 				data_ptr, len, I2C_XFER_SINGLE);
-		i2c_lock(I2C_PORT_ACCEL, 0);
+		i2c_lock(port, 0);
 #endif
 	}
 	return rv;
@@ -240,10 +243,11 @@ static int raw_read_n(const int addr, const uint8_t reg,
  * 1: manual access, we can issue i2c to the compass
  * 0: data access: BMI160 gather data periodically from the compass.
  */
-static int bmm150_mag_access_ctrl(const int addr, const int enable)
+static int bmm150_mag_access_ctrl(const int port, const int addr,
+				  const int enable)
 {
 	int mag_if_ctrl;
-	raw_read8(addr, BMI160_MAG_IF_1, &mag_if_ctrl);
+	raw_read8(port, addr, BMI160_MAG_IF_1, &mag_if_ctrl);
 	if (enable) {
 		mag_if_ctrl |= BMI160_MAG_MANUAL_EN;
 		mag_if_ctrl &= ~BMI160_MAG_READ_BURST_MASK;
@@ -253,28 +257,29 @@ static int bmm150_mag_access_ctrl(const int addr, const int enable)
 		mag_if_ctrl &= ~BMI160_MAG_READ_BURST_MASK;
 		mag_if_ctrl |= BMI160_MAG_READ_BURST_8;
 	}
-	return raw_write8(addr, BMI160_MAG_IF_1, mag_if_ctrl);
+	return raw_write8(port, addr, BMI160_MAG_IF_1, mag_if_ctrl);
 }
 
 /**
  * Read register from compass.
  * Assuming we are in manual access mode, read compass i2c register.
  */
-int raw_mag_read8(const int addr, const uint8_t reg, int *data_ptr)
+int raw_mag_read8(const int port, const int addr, const uint8_t reg,
+				  int *data_ptr)
 {
 	/* Only read 1 bytes */
-	raw_write8(addr, BMI160_MAG_I2C_READ_ADDR, reg);
-	return raw_read8(addr, BMI160_MAG_I2C_READ_DATA, data_ptr);
+	raw_write8(port, addr, BMI160_MAG_I2C_READ_ADDR, reg);
+	return raw_read8(port, addr, BMI160_MAG_I2C_READ_DATA, data_ptr);
 }
 
 /**
  * Write register from compass.
  * Assuming we are in manual access mode, write to compass i2c register.
  */
-int raw_mag_write8(const int addr, const uint8_t reg, int data)
+int raw_mag_write8(const int port, const int addr, const uint8_t reg, int data)
 {
-	raw_write8(addr, BMI160_MAG_I2C_WRITE_DATA, data);
-	return raw_write8(addr, BMI160_MAG_I2C_WRITE_ADDR, reg);
+	raw_write8(port, addr, BMI160_MAG_I2C_WRITE_DATA, data);
+	return raw_write8(port, addr, BMI160_MAG_I2C_WRITE_ADDR, reg);
 }
 #endif
 
@@ -286,17 +291,17 @@ static int enable_fifo(const struct motion_sensor_t *s, int enable)
 
 	if (enable) {
 		/* FIFO start collecting events */
-		ret = raw_read8(s->addr, BMI160_FIFO_CONFIG_1, &val);
+		ret = raw_read8(s->port, s->addr, BMI160_FIFO_CONFIG_1, &val);
 		val |= BMI160_FIFO_SENSOR_EN(s->type);
-		ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1, val);
+		ret = raw_write8(s->port, s->addr, BMI160_FIFO_CONFIG_1, val);
 		if (ret == EC_SUCCESS)
 			data->flags |= 1 << (s->type + BMI160_FIFO_FLAG_OFFSET);
 
 	} else {
 		/* FIFO stop collecting events */
-		ret = raw_read8(s->addr, BMI160_FIFO_CONFIG_1, &val);
+		ret = raw_read8(s->port, s->addr, BMI160_FIFO_CONFIG_1, &val);
 		val &= ~BMI160_FIFO_SENSOR_EN(s->type);
-		ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1, val);
+		ret = raw_write8(s->port, s->addr, BMI160_FIFO_CONFIG_1, val);
 		if (ret == EC_SUCCESS)
 			data->flags &=
 				~(1 << (s->type + BMI160_FIFO_FLAG_OFFSET));
@@ -323,7 +328,7 @@ static int set_range(const struct motion_sensor_t *s,
 	ranges = get_range_table(s->type, &range_tbl_size);
 	reg_val = get_reg_val(range, rnd, ranges, range_tbl_size);
 
-	ret = raw_write8(s->addr, ctrl_reg, reg_val);
+	ret = raw_write8(s->port, s->addr, ctrl_reg, reg_val);
 	/* Now that we have set the range, update the driver's value. */
 	if (ret == EC_SUCCESS)
 		data->range = get_engineering_val(reg_val, ranges,
@@ -368,7 +373,7 @@ static int set_data_rate(const struct motion_sensor_t *s,
 		enable_fifo(s, 0);
 #endif
 		/* go to suspend mode */
-		ret = raw_write8(s->addr, BMI160_CMD_REG,
+		ret = raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				 BMI160_CMD_MODE_SUSPEND(s->type));
 		msleep(3);
 		data->odr = 0;
@@ -379,7 +384,7 @@ static int set_data_rate(const struct motion_sensor_t *s,
 		return ret;
 	} else if (data->odr == 0) {
 		/* back from suspend mode. */
-		ret = raw_write8(s->addr, BMI160_CMD_REG,
+		ret = raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				 BMI160_CMD_MODE_NORMAL(s->type));
 		msleep(wakeup_time[s->type]);
 	}
@@ -431,12 +436,12 @@ static int set_data_rate(const struct motion_sensor_t *s,
 	 */
 	mutex_lock(s->mutex);
 
-	ret = raw_read8(s->addr, ctrl_reg, &val);
+	ret = raw_read8(s->port, s->addr, ctrl_reg, &val);
 	if (ret != EC_SUCCESS)
 		goto accel_cleanup;
 
 	val = (val & ~BMI160_ODR_MASK) | reg_val;
-	ret = raw_write8(s->addr, ctrl_reg, val);
+	ret = raw_write8(s->port, s->addr, ctrl_reg, val);
 	if (ret != EC_SUCCESS)
 		goto accel_cleanup;
 
@@ -493,7 +498,8 @@ static int get_offset(const struct motion_sensor_t *s,
 		 * range selected for the accelerometer.
 		 */
 		for (i = X; i <= Z; i++) {
-			raw_read8(s->addr, BMI160_OFFSET_ACC70 + i, &val);
+			raw_read8(s->port, s->addr, BMI160_OFFSET_ACC70 + i,
+				  &val);
 			if (val > 0x7f)
 				val = -256 + val;
 			v[i] = val * BMI160_OFFSET_ACC_MULTI_MG /
@@ -502,7 +508,7 @@ static int get_offset(const struct motion_sensor_t *s,
 		break;
 	case MOTIONSENSE_TYPE_GYRO:
 		/* Read the MSB first */
-		raw_read8(s->addr, BMI160_OFFSET_EN_GYR98, &val98);
+		raw_read8(s->port, s->addr, BMI160_OFFSET_EN_GYR98, &val98);
 		/*
 		 * The offset of the gyroscope off_gyr_[xyz] is a 10 bit
 		 * two-complement number in units of 0.061 °/s.
@@ -510,7 +516,8 @@ static int get_offset(const struct motion_sensor_t *s,
 		 * -31.25 °/s to +31.25 °/s
 		 */
 		for (i = X; i <= Z; i++) {
-			raw_read8(s->addr, BMI160_OFFSET_GYR70 + i, &val);
+			raw_read8(s->port, s->addr, BMI160_OFFSET_GYR70 + i,
+				  &val);
 			val |= ((val98 >> (2 * i)) & 0x3) << 8;
 			if (val > 0x1ff)
 				val = -1024 + val;
@@ -545,7 +552,7 @@ static int set_offset(const struct motion_sensor_t *s,
 
 	rotate_inv(v, *s->rot_standard_ref, v);
 
-	ret = raw_read8(s->addr, BMI160_OFFSET_EN_GYR98, &val98);
+	ret = raw_read8(s->port, s->addr, BMI160_OFFSET_EN_GYR98, &val98);
 	if (ret != 0)
 		return ret;
 
@@ -560,9 +567,10 @@ static int set_offset(const struct motion_sensor_t *s,
 				val = -128;
 			if (val < 0)
 				val = 256 + val;
-			raw_write8(s->addr, BMI160_OFFSET_ACC70 + i, val);
+			raw_write8(s->port, s->addr, BMI160_OFFSET_ACC70 + i,
+				   val);
 		}
-		ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98,
+		ret = raw_write8(s->port, s->addr, BMI160_OFFSET_EN_GYR98,
 				 val98 | BMI160_OFFSET_ACC_EN);
 		break;
 	case MOTIONSENSE_TYPE_GYRO:
@@ -575,12 +583,12 @@ static int set_offset(const struct motion_sensor_t *s,
 				val = -512;
 			if (val < 0)
 				val = 1024 + val;
-			raw_write8(s->addr, BMI160_OFFSET_GYR70 + i,
+			raw_write8(s->port, s->addr, BMI160_OFFSET_GYR70 + i,
 					val & 0xFF);
 			val98 &= ~(0x3 << (2 * i));
 			val98 |= (val >> 8) << (2 * i);
 		}
-		ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98,
+		ret = raw_write8(s->port, s->addr, BMI160_OFFSET_EN_GYR98,
 				 val98 | BMI160_OFFSET_GYRO_EN);
 		break;
 #ifdef CONFIG_MAG_BMI160_BMM150
@@ -622,23 +630,25 @@ int perform_calib(const struct motion_sensor_t *s)
 		ret = EC_RES_INVALID_PARAM;
 		goto end_perform_calib;
 	}
-	ret = raw_write8(s->addr, BMI160_FOC_CONF, val);
-	ret = raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_START_FOC);
+	ret = raw_write8(s->port, s->addr, BMI160_FOC_CONF, val);
+	ret = raw_write8(s->port, s->addr, BMI160_CMD_REG,
+			 BMI160_CMD_START_FOC);
 	do {
 		if (timeout > 400) {
 			ret = EC_RES_TIMEOUT;
 			goto end_perform_calib;
 		}
 		msleep(50);
-		ret = raw_read8(s->addr, BMI160_STATUS, &status);
+		ret = raw_read8(s->port, s->addr, BMI160_STATUS, &status);
 		if (ret != EC_SUCCESS)
 			goto end_perform_calib;
 		timeout += 50;
 	} while ((status & BMI160_FOC_RDY) == 0);
 
 	/* Calibration is successful, and loaded, use the result */
-	ret = raw_read8(s->addr, BMI160_OFFSET_EN_GYR98, &val);
-	ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98, val | en_flag);
+	ret = raw_read8(s->port, s->addr, BMI160_OFFSET_EN_GYR98, &val);
+	ret = raw_write8(s->port, s->addr, BMI160_OFFSET_EN_GYR98,
+			 val | en_flag);
 end_perform_calib:
 	set_data_rate(s, rate, 0);
 	return ret;
@@ -676,12 +686,12 @@ int manage_activity(const struct motion_sensor_t *s,
 #ifdef CONFIG_GESTURE_SIGMO
 	case MOTIONSENSE_ACTIVITY_SIG_MOTION: {
 		int tmp;
-		ret = raw_read8(s->addr, BMI160_INT_EN_0, &tmp);
+		ret = raw_read8(s->port, s->addr, BMI160_INT_EN_0, &tmp);
 		if (ret)
 			return ret;
 		if (enable) {
 			/* We should use parameters from caller */
-			raw_write8(s->addr, BMI160_INT_MOTION_3,
+			raw_write8(s->port, s->addr, BMI160_INT_MOTION_3,
 				BMI160_MOTION_PROOF_TIME(
 					CONFIG_GESTURE_SIGMO_PROOF_MS) <<
 				BMI160_MOTION_PROOF_OFF |
@@ -689,7 +699,7 @@ int manage_activity(const struct motion_sensor_t *s,
 					CONFIG_GESTURE_SIGMO_SKIP_MS) <<
 				BMI160_MOTION_SKIP_OFF |
 				BMI160_MOTION_SIG_MOT_SEL);
-			raw_write8(s->addr, BMI160_INT_MOTION_1,
+			raw_write8(s->port, s->addr, BMI160_INT_MOTION_1,
 				BMI160_MOTION_TH(s,
 					CONFIG_GESTURE_SIGMO_THRES_MG));
 			tmp |= BMI160_INT_ANYMO_X_EN |
@@ -700,7 +710,7 @@ int manage_activity(const struct motion_sensor_t *s,
 				 BMI160_INT_ANYMO_Y_EN |
 				 BMI160_INT_ANYMO_Z_EN);
 		}
-		ret = raw_write8(s->addr, BMI160_INT_EN_0, tmp);
+		ret = raw_write8(s->port, s->addr, BMI160_INT_EN_0, tmp);
 		if (ret)
 			ret = EC_RES_UNAVAILABLE;
 		break;
@@ -710,14 +720,14 @@ int manage_activity(const struct motion_sensor_t *s,
 	case MOTIONSENSE_ACTIVITY_DOUBLE_TAP: {
 		int tmp;
 		/* Set double tap interrupt */
-		ret = raw_read8(s->addr, BMI160_INT_EN_0, &tmp);
+		ret = raw_read8(s->port, s->addr, BMI160_INT_EN_0, &tmp);
 		if (ret)
 			return ret;
 		if (enable)
 			tmp |= BMI160_INT_D_TAP_EN;
 		else
 			tmp &= ~BMI160_INT_D_TAP_EN;
-		ret = raw_write8(s->addr, BMI160_INT_EN_0, tmp);
+		ret = raw_write8(s->port, s->addr, BMI160_INT_EN_0, tmp);
 		if (ret)
 			ret = EC_RES_UNAVAILABLE;
 		break;
@@ -772,14 +782,14 @@ static int config_interrupt(const struct motion_sensor_t *s)
 		return EC_SUCCESS;
 
 	mutex_lock(s->mutex);
-	raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_FIFO_FLUSH);
+	raw_write8(s->port, s->addr, BMI160_CMD_REG, BMI160_CMD_FIFO_FLUSH);
 	msleep(30);
-	raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
+	raw_write8(s->port, s->addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
 
 #ifdef CONFIG_GESTURE_SENSOR_BATTERY_TAP
-	raw_write8(s->addr, BMI160_INT_TAP_0,
+	raw_write8(s->port, s->addr, BMI160_INT_TAP_0,
 		BMI160_TAP_TH(s, CONFIG_GESTURE_TAP_MAX_INTERSTICE_T));
-	ret = raw_write8(s->addr, BMI160_INT_TAP_1,
+	ret = raw_write8(s->port, s->addr, BMI160_INT_TAP_1,
 		BMI160_TAP_TH(s, CONFIG_GESTURE_TAP_THRES_MG));
 #endif
 	/*
@@ -787,11 +797,11 @@ static int config_interrupt(const struct motion_sensor_t *s)
 	 * Set a 5ms latch to be sure the EC can read the interrupt register
 	 * properly, even when it is running more slowly.
 	 */
-	ret = raw_write8(s->addr, BMI160_INT_LATCH,
+	ret = raw_write8(s->port, s->addr, BMI160_INT_LATCH,
 		BMI160_INT2_INPUT_EN | BMI160_LATCH_5MS);
 
 	/* configure int1 as an interupt */
-	ret = raw_write8(s->addr, BMI160_INT_OUT_CTRL,
+	ret = raw_write8(s->port, s->addr, BMI160_INT_OUT_CTRL,
 		BMI160_INT_CTRL(1, OUTPUT_EN));
 
 	/* Map activity interrupt to int 1 */
@@ -802,26 +812,26 @@ static int config_interrupt(const struct motion_sensor_t *s)
 #ifdef CONFIG_GESTURE_SENSOR_BATTERY_TAP
 	tmp |= BMI160_INT_D_TAP;
 #endif
-	ret = raw_write8(s->addr, BMI160_INT_MAP_REG(1), tmp);
+	ret = raw_write8(s->port, s->addr, BMI160_INT_MAP_REG(1), tmp);
 
 #ifdef CONFIG_ACCEL_FIFO
 	/* map fifo water mark to int 1 */
-	ret = raw_write8(s->addr, BMI160_INT_FIFO_MAP,
+	ret = raw_write8(s->port, s->addr, BMI160_INT_FIFO_MAP,
 			BMI160_INT_MAP(1, FWM) |
 			BMI160_INT_MAP(1, FFULL));
 
 	/* configure fifo watermark at 50% */
-	ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_0,
+	ret = raw_write8(s->port, s->addr, BMI160_FIFO_CONFIG_0,
 			512 / sizeof(uint32_t));
-	ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1,
+	ret = raw_write8(s->port, s->addr, BMI160_FIFO_CONFIG_1,
 			BMI160_FIFO_TAG_INT1_EN |
 			BMI160_FIFO_TAG_INT2_EN |
 			BMI160_FIFO_HEADER_EN);
 
 	/* Set fifo*/
-	ret = raw_read8(s->addr, BMI160_INT_EN_1, &tmp);
+	ret = raw_read8(s->port, s->addr, BMI160_INT_EN_1, &tmp);
 	tmp |= BMI160_INT_FWM_EN | BMI160_INT_FFUL_EN;
-	ret = raw_write8(s->addr, BMI160_INT_EN_1, tmp);
+	ret = raw_write8(s->port, s->addr, BMI160_INT_EN_1, tmp);
 #endif
 	mutex_unlock(s->mutex);
 	return ret;
@@ -842,7 +852,7 @@ static int irq_handler(struct motion_sensor_t *s, uint32_t *event)
 	    (!(*event & CONFIG_ACCELGYRO_BMI160_INT_EVENT)))
 		return EC_ERROR_NOT_HANDLED;
 
-	raw_read32(s->addr, BMI160_INT_STATUS_0, &interrupt);
+	raw_read32(s->port, s->addr, BMI160_INT_STATUS_0, &interrupt);
 
 #ifdef CONFIG_GESTURE_SENSOR_BATTERY_TAP
 	if (interrupt & BMI160_D_TAP_INT)
@@ -955,12 +965,12 @@ static int load_fifo(struct motion_sensor_t *s)
 			 * Flush potential left over:
 			 * When sensor is resumed, we won't read old data.
 			 */
-			raw_write8(s->addr, BMI160_CMD_REG,
+			raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				   BMI160_CMD_FIFO_FLUSH);
 			return EC_SUCCESS;
 		}
 
-		raw_read_n(s->addr, BMI160_FIFO_DATA, bmi160_buffer,
+		raw_read_n(s->port, s->addr, BMI160_FIFO_DATA, bmi160_buffer,
 				sizeof(bmi160_buffer));
 		beginning = *(uint32_t *)bmi160_buffer;
 		/*
@@ -1004,7 +1014,8 @@ static int load_fifo(struct motion_sensor_t *s)
 				default:
 					CPRINTS("Unknown header: 0x%02x @ %d",
 						hdr, bp - bmi160_buffer);
-					raw_write8(s->addr, BMI160_CMD_REG,
+					raw_write8(s->port, s->addr,
+						   BMI160_CMD_REG,
 						   BMI160_CMD_FIFO_FLUSH);
 					done = 1;
 				}
@@ -1045,7 +1056,7 @@ static int read(const struct motion_sensor_t *s, vector_3_t v)
 	uint8_t data[6];
 	int ret, status = 0;
 
-	ret = raw_read8(s->addr, BMI160_STATUS, &status);
+	ret = raw_read8(s->port, s->addr, BMI160_STATUS, &status);
 	if (ret != EC_SUCCESS)
 		return ret;
 
@@ -1061,7 +1072,7 @@ static int read(const struct motion_sensor_t *s, vector_3_t v)
 	}
 
 	/* Read 6 bytes starting at xyz_reg */
-	raw_read_n(s->addr, get_xyz_reg(s->type), data, 6);
+	raw_read_n(s->port, s->addr, get_xyz_reg(s->type), data, 6);
 
 	if (ret != EC_SUCCESS) {
 		CPRINTF("[%T %s type:0x%X RD XYZ Error %d]",
@@ -1076,21 +1087,21 @@ static int init(const struct motion_sensor_t *s)
 {
 	int ret = 0, tmp;
 
-	ret = raw_read8(s->addr, BMI160_CHIP_ID, &tmp);
+	ret = raw_read8(s->port, s->addr, BMI160_CHIP_ID, &tmp);
 	if (ret)
 		return EC_ERROR_UNKNOWN;
 
 	if (tmp != BMI160_CHIP_ID_MAJOR) {
 		/* The device may be lock on paging mode. Try to unlock it. */
-		raw_write8(s->addr, BMI160_CMD_REG,
+		raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				BMI160_CMD_EXT_MODE_EN_B0);
-		raw_write8(s->addr, BMI160_CMD_REG,
+		raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				BMI160_CMD_EXT_MODE_EN_B1);
-		raw_write8(s->addr, BMI160_CMD_REG,
+		raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				BMI160_CMD_EXT_MODE_EN_B2);
-		raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+		raw_write8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 				BMI160_CMD_PAGING_EN);
-		raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR, 0);
+		raw_write8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR, 0);
 		return EC_ERROR_ACCESS_DENIED;
 	}
 
@@ -1099,7 +1110,7 @@ static int init(const struct motion_sensor_t *s)
 		struct bmi160_drv_data_t *data = BMI160_GET_DATA(s);
 
 		/* Reset the chip to be in a good state */
-		raw_write8(s->addr, BMI160_CMD_REG,
+		raw_write8(s->port, s->addr, BMI160_CMD_REG,
 				BMI160_CMD_SOFT_RESET);
 		msleep(30);
 		data->flags &= ~(BMI160_FLAG_SEC_I2C_ENABLED |
@@ -1118,10 +1129,10 @@ static int init(const struct motion_sensor_t *s)
 #endif
 #endif
 		/* To avoid gyro wakeup */
-		raw_write8(s->addr, BMI160_PMU_TRIGGER, 0);
+		raw_write8(s->port, s->addr, BMI160_PMU_TRIGGER, 0);
 	}
 
-	raw_write8(s->addr, BMI160_CMD_REG,
+	raw_write8(s->port, s->addr, BMI160_CMD_REG,
 			BMI160_CMD_MODE_NORMAL(s->type));
 	msleep(wakeup_time[s->type]);
 
@@ -1138,48 +1149,48 @@ static int init(const struct motion_sensor_t *s)
 			 *
 			 * Magic command sequences
 			 */
-			raw_write8(s->addr, BMI160_CMD_REG,
+			raw_write8(s->port, s->addr, BMI160_CMD_REG,
 					BMI160_CMD_EXT_MODE_EN_B0);
-			raw_write8(s->addr, BMI160_CMD_REG,
+			raw_write8(s->port, s->addr, BMI160_CMD_REG,
 					BMI160_CMD_EXT_MODE_EN_B1);
-			raw_write8(s->addr, BMI160_CMD_REG,
+			raw_write8(s->port, s->addr, BMI160_CMD_REG,
 					BMI160_CMD_EXT_MODE_EN_B2);
 
 			/*
 			 * Change the register page to target mode, to change
 			 * the internal pull ups of the secondary interface.
 			 */
-			raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_read8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					&ext_page_reg);
-			raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_write8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					ext_page_reg | BMI160_CMD_TARGET_PAGE);
-			raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_read8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					&ext_page_reg);
-			raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_write8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					ext_page_reg | BMI160_CMD_PAGING_EN);
-			raw_read8(s->addr, BMI160_COM_C_TRIM_ADDR,
+			raw_read8(s->port, s->addr, BMI160_COM_C_TRIM_ADDR,
 					&pullup_reg);
-			raw_write8(s->addr, BMI160_COM_C_TRIM_ADDR,
+			raw_write8(s->port, s->addr, BMI160_COM_C_TRIM_ADDR,
 					pullup_reg | BMI160_COM_C_TRIM);
-			raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_read8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					&ext_page_reg);
-			raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_write8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					ext_page_reg & ~BMI160_CMD_TARGET_PAGE);
-			raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
+			raw_read8(s->port, s->addr, BMI160_CMD_EXT_MODE_ADDR,
 					&ext_page_reg);
 
 			/* Set the i2c address of the compass */
-			ret = raw_write8(s->addr, BMI160_MAG_IF_0,
+			ret = raw_write8(s->port, s->addr, BMI160_MAG_IF_0,
 					BMM150_I2C_ADDRESS);
 
 			/* Enable the secondary interface as I2C */
-			ret = raw_write8(s->addr, BMI160_IF_CONF,
+			ret = raw_write8(s->port, s->addr, BMI160_IF_CONF,
 				BMI160_IF_MODE_AUTO_I2C << BMI160_IF_MODE_OFF);
 			data->flags |= BMI160_FLAG_SEC_I2C_ENABLED;
 		}
 
 
-		bmm150_mag_access_ctrl(s->addr, 1);
+		bmm150_mag_access_ctrl(s->port, s->addr, 1);
 
 		ret = bmm150_init(s);
 		if (ret)
@@ -1187,13 +1198,13 @@ static int init(const struct motion_sensor_t *s)
 			return ret;
 
 		/* Leave the address for reading the data */
-		raw_write8(s->addr, BMI160_MAG_I2C_READ_ADDR,
+		raw_write8(s->port, s->addr, BMI160_MAG_I2C_READ_ADDR,
 				BMM150_BASE_DATA);
 		/*
 		 * Put back the secondary interface in normal mode.
 		 * BMI160 will poll based on the configure ODR.
 		 */
-		bmm150_mag_access_ctrl(s->addr, 0);
+		bmm150_mag_access_ctrl(s->port, s->addr, 0);
 	}
 #endif