BACKPORT: accel: mechanical changes from i2c_addr to addr

Encode both the I2C address and SPI GPIO CS in addr field.
Mechanical change to rename i2c_addr into addr.

BRANCH=smaug, cyan
TEST=compile
BUG=chrome-os-partner:42304, b:27849483

Change-Id: I1c7435398deacb27211445afa27a08716d224c06
Signed-off-by: Gwendal Grignou <gwendal@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/288513
Reviewed-by: Vincent Palatin <vpalatin@chromium.org>
Commit-Queue: David James <davidjames@chromium.org>
(cherry picked from commit a3a5c90b54670ddc865defc16757f1fef78ca322)
Signed-off-by: Gwendal Grignou <gwendal@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/359324

5 files changed, 38 insertions, 37 deletions

diff --git a/board/cyan/board.c b/board/cyan/board.c
index 4695c71531..74dfdb188e 100644
--- a/board/cyan/board.c
+++ b/board/cyan/board.c
@@ -117,7 +117,7 @@ struct motion_sensor_t motion_sensors[] = {
 	 .drv = &kxcj9_drv,
 	 .mutex = &g_kxcj9_mutex[0],
 	 .drv_data = &g_kxcj9_data[0],
-	 .i2c_addr = KXCJ9_ADDR1,
+	 .addr = KXCJ9_ADDR1,
 	 .rot_standard_ref = &base_standard_ref,
 	 .default_config = {
 		 .odr = 100000,
@@ -133,7 +133,7 @@ struct motion_sensor_t motion_sensors[] = {
 	 .drv = &kxcj9_drv,
 	 .mutex = &g_kxcj9_mutex[1],
 	 .drv_data = &g_kxcj9_data[1],
-	 .i2c_addr = KXCJ9_ADDR0,
+	 .addr = KXCJ9_ADDR0,
 	 .rot_standard_ref = &lid_standard_ref,
 	 .default_config = {
 		 .odr = 100000,
diff --git a/driver/accel_kxcj9.c b/driver/accel_kxcj9.c
index cabd7ef589..24d98719a1 100644
--- a/driver/accel_kxcj9.c
+++ b/driver/accel_kxcj9.c
@@ -124,13 +124,13 @@ static int disable_sensor(const struct motion_sensor_t *s, int *ctrl1)
 	 * so that we can restore it later.
 	 */
 	for (i = 0; i < SENSOR_ENABLE_ATTEMPTS; i++) {
-		ret = raw_read8(s->i2c_addr, KXCJ9_CTRL1, ctrl1);
+		ret = raw_read8(s->addr, KXCJ9_CTRL1, ctrl1);
 		if (ret != EC_SUCCESS)
 			continue;
 
 		*ctrl1 &= ~KXCJ9_CTRL1_PC1;
 
-		ret = raw_write8(s->i2c_addr, KXCJ9_CTRL1, *ctrl1);
+		ret = raw_write8(s->addr, KXCJ9_CTRL1, *ctrl1);
 		if (ret == EC_SUCCESS)
 			return EC_SUCCESS;
 	}
@@ -153,12 +153,12 @@ static int enable_sensor(const struct motion_sensor_t *s, int ctrl1)
 	int i, ret;
 
 	for (i = 0; i < SENSOR_ENABLE_ATTEMPTS; i++) {
-		ret = raw_read8(s->i2c_addr, KXCJ9_CTRL1, &ctrl1);
+		ret = raw_read8(s->addr, KXCJ9_CTRL1, &ctrl1);
 		if (ret != EC_SUCCESS)
 			continue;
 
 		/* Enable accelerometer based on ctrl1 value. */
-		ret = raw_write8(s->i2c_addr, KXCJ9_CTRL1,
+		ret = raw_write8(s->addr, KXCJ9_CTRL1,
 				ctrl1 | KXCJ9_CTRL1_PC1);
 
 		/* On first success, we are done. */
@@ -191,7 +191,7 @@ static int set_range(const struct motion_sensor_t *s,
 
 	/* Determine new value of CTRL1 reg and attempt to write it. */
 	ctrl1_new = (ctrl1 & ~KXCJ9_GSEL_ALL) | ranges[index].reg;
-	ret = raw_write8(s->i2c_addr,  KXCJ9_CTRL1, ctrl1_new);
+	ret = raw_write8(s->addr,  KXCJ9_CTRL1, ctrl1_new);
 
 	/* If successfully written, then save the range. */
 	if (ret == EC_SUCCESS) {
@@ -236,7 +236,7 @@ static int set_resolution(const struct motion_sensor_t *s,
 
 	/* Determine new value of CTRL1 reg and attempt to write it. */
 	ctrl1_new = (ctrl1 & ~KXCJ9_RES_12BIT) | resolutions[index].reg;
-	ret = raw_write8(s->i2c_addr,  KXCJ9_CTRL1, ctrl1_new);
+	ret = raw_write8(s->addr,  KXCJ9_CTRL1, ctrl1_new);
 
 	/* If successfully written, then save the range. */
 	if (ret == EC_SUCCESS) {
@@ -279,7 +279,7 @@ static int set_data_rate(const struct motion_sensor_t *s,
 	}
 
 	/* Set output data rate. */
-	ret = raw_write8(s->i2c_addr,  KXCJ9_DATA_CTRL,
+	ret = raw_write8(s->addr,  KXCJ9_DATA_CTRL,
 			datarates[index].reg);
 
 	/* If successfully written, then save the range. */
@@ -342,7 +342,7 @@ static int set_interrupt(const struct motion_sensor_t *s,
 	}
 
 	/* Set interrupt timer to 1 so it wakes up immediately. */
-	ret = raw_write8(s->i2c_addr, KXCJ9_WAKEUP_TIMER, 1);
+	ret = raw_write8(s->addr, KXCJ9_WAKEUP_TIMER, 1);
 	if (ret != EC_SUCCESS)
 		goto error_enable_sensor;
 
@@ -351,7 +351,7 @@ static int set_interrupt(const struct motion_sensor_t *s,
 	 * first we need to divide by 16 to get the value to send.
 	 */
 	threshold >>= 4;
-	ret = raw_write8(s->i2c_addr, KXCJ9_WAKEUP_THRESHOLD, threshold);
+	ret = raw_write8(s->addr, KXCJ9_WAKEUP_THRESHOLD, threshold);
 	if (ret != EC_SUCCESS)
 		goto error_enable_sensor;
 
@@ -360,11 +360,11 @@ static int set_interrupt(const struct motion_sensor_t *s,
 	 * function is called once, the interrupt stays enabled and it is
 	 * only necessary to clear KXCJ9_INT_REL to allow the next interrupt.
 	 */
-	ret = raw_read8(s->i2c_addr, KXCJ9_INT_CTRL1, &tmp);
+	ret = raw_read8(s->addr, KXCJ9_INT_CTRL1, &tmp);
 	if (ret != EC_SUCCESS)
 		goto error_enable_sensor;
 	if (!(tmp & KXCJ9_INT_CTRL1_IEN)) {
-		ret = raw_write8(s->i2c_addr, KXCJ9_INT_CTRL1,
+		ret = raw_write8(s->addr, KXCJ9_INT_CTRL1,
 				tmp | KXCJ9_INT_CTRL1_IEN);
 		if (ret != EC_SUCCESS)
 			goto error_enable_sensor;
@@ -375,7 +375,7 @@ static int set_interrupt(const struct motion_sensor_t *s,
 	 * Note: this register latches motion detected above threshold. Once
 	 * latched, no interrupt can occur until this register is cleared.
 	 */
-	ret = raw_read8(s->i2c_addr, KXCJ9_INT_REL, &tmp);
+	ret = raw_read8(s->addr, KXCJ9_INT_REL, &tmp);
 
 error_enable_sensor:
 	/* Re-enable the sensor. */
@@ -396,7 +396,7 @@ static int read(const struct motion_sensor_t *s, vector_3_t v)
 	/* Read 6 bytes starting at KXCJ9_XOUT_L. */
 	mutex_lock(s->mutex);
 	i2c_lock(I2C_PORT_ACCEL, 1);
-	ret = i2c_xfer(I2C_PORT_ACCEL, s->i2c_addr, &reg, 1, acc, 6,
+	ret = i2c_xfer(I2C_PORT_ACCEL, s->addr, &reg, 1, acc, 6,
 			I2C_XFER_SINGLE);
 	i2c_lock(I2C_PORT_ACCEL, 0);
 	mutex_unlock(s->mutex);
@@ -442,25 +442,25 @@ static int config_interrupt(const struct motion_sensor_t *s)
 		goto cleanup_exit;
 
 	/* Enable wake up (motion detect) functionality. */
-	ret = raw_read8(s->i2c_addr, KXCJ9_CTRL1, &tmp);
+	ret = raw_read8(s->addr, KXCJ9_CTRL1, &tmp);
 	tmp &= ~KXCJ9_CTRL1_PC1;
 	tmp |= KXCJ9_CTRL1_WUFE;
-	ret = raw_write8(s->i2c_addr, KXCJ9_CTRL1, tmp);
+	ret = raw_write8(s->addr, KXCJ9_CTRL1, tmp);
 
 	/* Set interrupt polarity to rising edge and keep interrupt disabled. */
-	ret = raw_write8(s->i2c_addr,
+	ret = raw_write8(s->addr,
 			  KXCJ9_INT_CTRL1,
 			  KXCJ9_INT_CTRL1_IEA);
 	if (ret != EC_SUCCESS)
 		goto cleanup_exit;
 
 	/* Set output data rate for wake-up interrupt function. */
-	ret = raw_write8(s->i2c_addr, KXCJ9_CTRL2, KXCJ9_OWUF_100_0HZ);
+	ret = raw_write8(s->addr, KXCJ9_CTRL2, KXCJ9_OWUF_100_0HZ);
 	if (ret != EC_SUCCESS)
 		goto cleanup_exit;
 
 	/* Set interrupt to trigger on motion on any axis. */
-	ret = raw_write8(s->i2c_addr, KXCJ9_INT_CTRL2,
+	ret = raw_write8(s->addr, KXCJ9_INT_CTRL2,
 			KXCJ9_INT_SRC2_XNWU | KXCJ9_INT_SRC2_XPWU |
 			KXCJ9_INT_SRC2_YNWU | KXCJ9_INT_SRC2_YPWU |
 			KXCJ9_INT_SRC2_ZNWU | KXCJ9_INT_SRC2_ZPWU);
@@ -493,7 +493,7 @@ static int init(const struct motion_sensor_t *s)
 	 * sensor to default.
 	 */
 	mutex_lock(s->mutex);
-	ret = raw_write8(s->i2c_addr, KXCJ9_CTRL2, KXCJ9_CTRL2_SRST);
+	ret = raw_write8(s->addr, KXCJ9_CTRL2, KXCJ9_CTRL2_SRST);
 	mutex_unlock(s->mutex);
 	if (ret != EC_SUCCESS)
 		return ret;
@@ -503,7 +503,7 @@ static int init(const struct motion_sensor_t *s)
 		/* Added 1m delay after software reset */
 		msleep(1);
 
-		ret = raw_read8(s->i2c_addr, KXCJ9_CTRL2, &tmp);
+		ret = raw_read8(s->addr, KXCJ9_CTRL2, &tmp);
 		if (ret != EC_SUCCESS)
 			return ret;
 
diff --git a/driver/accelgyro_lsm6ds0.c b/driver/accelgyro_lsm6ds0.c
index 001f7bb5c7..357710d56e 100644
--- a/driver/accelgyro_lsm6ds0.c
+++ b/driver/accelgyro_lsm6ds0.c
@@ -183,12 +183,12 @@ static int set_range(const struct motion_sensor_t *s,
 	 */
 	mutex_lock(s->mutex);
 
-	ret = raw_read8(s->i2c_addr, ctrl_reg, &ctrl_val);
+	ret = raw_read8(s->addr, ctrl_reg, &ctrl_val);
 	if (ret != EC_SUCCESS)
 		goto accel_cleanup;
 
 	ctrl_val = (ctrl_val & ~LSM6DS0_RANGE_MASK) | reg_val;
-	ret = raw_write8(s->i2c_addr, ctrl_reg, ctrl_val);
+	ret = raw_write8(s->addr, ctrl_reg, ctrl_val);
 
 	/* Now that we have set the range, update the driver's value. */
 	if (ret == EC_SUCCESS)
@@ -243,12 +243,12 @@ static int set_data_rate(const struct motion_sensor_t *s,
 	 */
 	mutex_lock(s->mutex);
 
-	ret = raw_read8(s->i2c_addr, ctrl_reg, &val);
+	ret = raw_read8(s->addr, ctrl_reg, &val);
 	if (ret != EC_SUCCESS)
 		goto accel_cleanup;
 
 	val = (val & ~LSM6DS0_ODR_MASK) | reg_val;
-	ret = raw_write8(s->i2c_addr, ctrl_reg, val);
+	ret = raw_write8(s->addr, ctrl_reg, val);
 
 	/* Now that we have set the odr, update the driver's value. */
 	if (ret == EC_SUCCESS)
@@ -263,14 +263,14 @@ static int set_data_rate(const struct motion_sensor_t *s,
 	 *       Table 48 Gyroscope high-pass filter cutoff frequency
 	 */
 	if (MOTIONSENSE_TYPE_GYRO == s->type) {
-		ret = raw_read8(s->i2c_addr, LSM6DS0_CTRL_REG3_G, &val);
+		ret = raw_read8(s->addr, LSM6DS0_CTRL_REG3_G, &val);
 		if (ret != EC_SUCCESS)
 			goto accel_cleanup;
 		val &= ~(0x3 << 4); /* clear bit [5:4] */
 		val = (rate > 119000) ?
 			(val | (1<<7))   /* set high-power mode */ :
 			(val & ~(1<<7)); /* set low-power mode */
-		ret = raw_write8(s->i2c_addr, LSM6DS0_CTRL_REG3_G, val);
+		ret = raw_write8(s->addr, LSM6DS0_CTRL_REG3_G, val);
 	}
 
 accel_cleanup:
@@ -324,7 +324,7 @@ static int is_data_ready(const struct motion_sensor_t *s, int *ready)
 {
 	int ret, tmp;
 
-	ret = raw_read8(s->i2c_addr, LSM6DS0_STATUS_REG, &tmp);
+	ret = raw_read8(s->addr, LSM6DS0_STATUS_REG, &tmp);
 
 	if (ret != EC_SUCCESS) {
 		CPRINTF("[%T %s type:0x%X RS Error]", s->name, s->type);
@@ -365,7 +365,7 @@ static int read(const struct motion_sensor_t *s, vector_3_t v)
 
 	/* Read 6 bytes starting at xyz_reg */
 	i2c_lock(I2C_PORT_ACCEL, 1);
-	ret = i2c_xfer(I2C_PORT_ACCEL, s->i2c_addr,
+	ret = i2c_xfer(I2C_PORT_ACCEL, s->addr,
 			&xyz_reg, 1, raw, 6, I2C_XFER_SINGLE);
 	i2c_lock(I2C_PORT_ACCEL, 0);
 
@@ -390,7 +390,7 @@ static int init(const struct motion_sensor_t *s)
 {
 	int ret = 0, tmp;
 
-	ret = raw_read8(s->i2c_addr, LSM6DS0_WHO_AM_I_REG, &tmp);
+	ret = raw_read8(s->addr, LSM6DS0_WHO_AM_I_REG, &tmp);
 	if (ret)
 		return EC_ERROR_UNKNOWN;
 
@@ -412,20 +412,20 @@ static int init(const struct motion_sensor_t *s)
 	if (MOTIONSENSE_TYPE_ACCEL == s->type) {
 
 		mutex_lock(s->mutex);
-		ret = raw_read8(s->i2c_addr, LSM6DS0_CTRL_REG8, &tmp);
+		ret = raw_read8(s->addr, LSM6DS0_CTRL_REG8, &tmp);
 		if (ret) {
 			mutex_unlock(s->mutex);
 			return EC_ERROR_UNKNOWN;
 		}
 		tmp |= (1 | LSM6DS0_BDU_ENABLE);
-		ret = raw_write8(s->i2c_addr, LSM6DS0_CTRL_REG8, tmp);
+		ret = raw_write8(s->addr, LSM6DS0_CTRL_REG8, tmp);
 		mutex_unlock(s->mutex);
 
 		if (ret)
 			return EC_ERROR_UNKNOWN;
 
 		/* Power Down Gyro */
-		ret = raw_write8(s->i2c_addr,
+		ret = raw_write8(s->addr,
 			LSM6DS0_CTRL_REG1_G, 0x0);
 		if (ret)
 			return EC_ERROR_UNKNOWN;
diff --git a/include/motion_sense.h b/include/motion_sense.h
index 8233049565..7f0ac57edd 100644
--- a/include/motion_sense.h
+++ b/include/motion_sense.h
@@ -69,7 +69,8 @@ struct motion_sensor_t {
 	const struct accelgyro_drv *drv;
 	struct mutex *mutex;
 	void *drv_data;
-	uint8_t i2c_addr;
+	/* i2c address or SPI slage logic GPIO. */
+	uint8_t addr;
 	const matrix_3x3_t *rot_standard_ref;
 
 	/* Default configuration parameters, RO only */
diff --git a/test/motion_lid.c b/test/motion_lid.c
index a3ce4925f1..18c4f64f33 100644
--- a/test/motion_lid.c
+++ b/test/motion_lid.c
@@ -118,7 +118,7 @@ struct motion_sensor_t motion_sensors[] = {
 	 .drv = &test_motion_sense,
 	 .mutex = NULL,
 	 .drv_data = NULL,
-	 .i2c_addr = 0,
+	 .addr = 0,
 	 .rot_standard_ref = &base_standard_ref,
 	 .default_config = {
 		 .odr = 119000,
@@ -134,7 +134,7 @@ struct motion_sensor_t motion_sensors[] = {
 	 .drv = &test_motion_sense,
 	 .mutex = NULL,
 	 .drv_data = NULL,
-	 .i2c_addr = 0,
+	 .addr = 0,
 	 .rot_standard_ref = &lid_standard_ref,
 	 .default_config = {
 		 .odr = 119000,