summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--board/cyan/board.c4
-rw-r--r--board/kunimitsu/board.c4
-rw-r--r--board/ryu/board.c6
-rw-r--r--board/samus/board.c6
-rw-r--r--board/strago/board.c4
-rw-r--r--driver/accel_kxcj9.c40
-rw-r--r--driver/accelgyro_bmi160.c122
-rw-r--r--driver/accelgyro_lsm6ds0.c24
-rw-r--r--driver/mag_bmm150.c22
-rw-r--r--include/motion_sense.h3
-rw-r--r--test/motion_lid.c4
11 files changed, 120 insertions, 119 deletions
diff --git a/board/cyan/board.c b/board/cyan/board.c
index 5d315b0e5f..0f23707016 100644
--- a/board/cyan/board.c
+++ b/board/cyan/board.c
@@ -123,7 +123,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,
@@ -139,7 +139,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/board/kunimitsu/board.c b/board/kunimitsu/board.c
index 04dbadade1..39b385422b 100644
--- a/board/kunimitsu/board.c
+++ b/board/kunimitsu/board.c
@@ -213,7 +213,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,
@@ -229,7 +229,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/board/ryu/board.c b/board/ryu/board.c
index 91c8fa750f..43843e653c 100644
--- a/board/ryu/board.c
+++ b/board/ryu/board.c
@@ -327,7 +327,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &bmi160_drv,
.mutex = &g_mutex,
.drv_data = &g_bmi160_data,
- .i2c_addr = BMI160_ADDR0,
+ .addr = BMI160_ADDR0,
.rot_standard_ref = &accelgyro_standard_ref,
.default_config = {
.odr = 100000,
@@ -344,7 +344,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &bmi160_drv,
.mutex = &g_mutex,
.drv_data = &g_bmi160_data,
- .i2c_addr = BMI160_ADDR0,
+ .addr = BMI160_ADDR0,
.rot_standard_ref = &accelgyro_standard_ref,
.default_config = {
.odr = 0,
@@ -361,7 +361,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &bmi160_drv,
.mutex = &g_mutex,
.drv_data = &g_bmi160_data,
- .i2c_addr = BMI160_ADDR0,
+ .addr = BMI160_ADDR0,
.rot_standard_ref = &mag_standard_ref,
.default_config = {
.odr = 0,
diff --git a/board/samus/board.c b/board/samus/board.c
index c665f23a6d..35365754dc 100644
--- a/board/samus/board.c
+++ b/board/samus/board.c
@@ -305,7 +305,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &lsm6ds0_drv,
.mutex = &g_base_mutex,
.drv_data = &g_saved_data[0],
- .i2c_addr = LSM6DS0_ADDR1,
+ .addr = LSM6DS0_ADDR1,
.rot_standard_ref = &base_standard_ref,
.default_config = {
.odr = 119000,
@@ -322,7 +322,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &kxcj9_drv,
.mutex = &g_lid_mutex,
.drv_data = &g_kxcj9_data,
- .i2c_addr = KXCJ9_ADDR0,
+ .addr = KXCJ9_ADDR0,
.rot_standard_ref = &lid_standard_ref,
.default_config = {
.odr = 100000,
@@ -339,7 +339,7 @@ struct motion_sensor_t motion_sensors[] = {
.drv = &lsm6ds0_drv,
.mutex = &g_base_mutex,
.drv_data = &g_saved_data[1],
- .i2c_addr = LSM6DS0_ADDR1,
+ .addr = LSM6DS0_ADDR1,
.rot_standard_ref = NULL,
.default_config = {
.odr = 119000,
diff --git a/board/strago/board.c b/board/strago/board.c
index 24c8fabef0..63bd12b66b 100644
--- a/board/strago/board.c
+++ b/board/strago/board.c
@@ -240,7 +240,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,
@@ -256,7 +256,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_bmi160.c b/driver/accelgyro_bmi160.c
index ce50203e9f..8f31c2b173 100644
--- a/driver/accelgyro_bmi160.c
+++ b/driver/accelgyro_bmi160.c
@@ -213,7 +213,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->i2c_addr, ctrl_reg, reg_val);
+ ret = raw_write8(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,
@@ -262,19 +262,19 @@ static int set_data_rate(const struct motion_sensor_t *s,
if (rate == 0) {
#ifdef CONFIG_ACCEL_FIFO
/* FIFO stop collecting events */
- ret = raw_read8(s->i2c_addr, BMI160_FIFO_CONFIG_1, &val);
+ ret = raw_read8(s->addr, BMI160_FIFO_CONFIG_1, &val);
val &= ~BMI160_FIFO_SENSOR_EN(s->type);
- ret = raw_write8(s->i2c_addr, BMI160_FIFO_CONFIG_1, val);
+ ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1, val);
#endif
/* go to suspend mode */
- ret = raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ ret = raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_MODE_SUSPEND(s->type));
msleep(3);
data->odr = 0;
return ret;
} else if (data->odr == 0) {
/* back from suspend mode. */
- ret = raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ ret = raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_MODE_NORMAL(s->type));
msleep(wakeup_time[s->type]);
}
@@ -325,12 +325,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 & ~BMI160_ODR_MASK) | reg_val;
- ret = raw_write8(s->i2c_addr, ctrl_reg, val);
+ ret = raw_write8(s->addr, ctrl_reg, val);
if (ret != EC_SUCCESS)
goto accel_cleanup;
@@ -339,9 +339,9 @@ static int set_data_rate(const struct motion_sensor_t *s,
#ifdef CONFIG_ACCEL_FIFO
/* FIFO start collecting events */
- ret = raw_read8(s->i2c_addr, BMI160_FIFO_CONFIG_1, &val);
+ ret = raw_read8(s->addr, BMI160_FIFO_CONFIG_1, &val);
val |= BMI160_FIFO_SENSOR_EN(s->type);
- ret = raw_write8(s->i2c_addr, BMI160_FIFO_CONFIG_1, val);
+ ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1, val);
#endif
accel_cleanup:
@@ -370,7 +370,7 @@ static int get_offset(const struct motion_sensor_t *s,
* range selected for the accelerometer.
*/
for (i = X; i <= Z; i++) {
- raw_read8(s->i2c_addr, BMI160_OFFSET_ACC70 + i, &val);
+ raw_read8(s->addr, BMI160_OFFSET_ACC70 + i, &val);
if (val > 0x7f)
val = -256 + val;
offset[i] = val * BMI160_OFFSET_ACC_MULTI_MG /
@@ -379,7 +379,7 @@ static int get_offset(const struct motion_sensor_t *s,
break;
case MOTIONSENSE_TYPE_GYRO:
/* Read the MSB first */
- raw_read8(s->i2c_addr, BMI160_OFFSET_EN_GYR98, &val98);
+ raw_read8(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.
@@ -387,7 +387,7 @@ 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->i2c_addr, BMI160_OFFSET_GYR70 + i, &val);
+ raw_read8(s->addr, BMI160_OFFSET_GYR70 + i, &val);
val |= ((val98 >> (2 * i)) & 0x3) << 8;
if (val > 0x1ff)
val = -1024 + val;
@@ -409,7 +409,7 @@ static int set_offset(const struct motion_sensor_t *s,
int16_t temp)
{
int ret, i, val, val98;
- ret = raw_read8(s->i2c_addr, BMI160_OFFSET_EN_GYR98, &val98);
+ ret = raw_read8(s->addr, BMI160_OFFSET_EN_GYR98, &val98);
if (ret != 0)
return ret;
@@ -424,9 +424,9 @@ static int set_offset(const struct motion_sensor_t *s,
val = -128;
if (val < 0)
val = 256 + val;
- raw_write8(s->i2c_addr, BMI160_OFFSET_ACC70 + i, val);
+ raw_write8(s->addr, BMI160_OFFSET_ACC70 + i, val);
}
- ret = raw_write8(s->i2c_addr, BMI160_OFFSET_EN_GYR98,
+ ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98,
val98 | BMI160_OFFSET_ACC_EN);
break;
case MOTIONSENSE_TYPE_GYRO:
@@ -439,12 +439,12 @@ static int set_offset(const struct motion_sensor_t *s,
val = -512;
if (val < 0)
val = 1024 + val;
- raw_write8(s->i2c_addr, BMI160_OFFSET_GYR70 + i,
+ raw_write8(s->addr, BMI160_OFFSET_GYR70 + i,
val & 0xFF);
val98 &= ~(0x3 << (2 * i));
val98 |= (val >> 8) << (2 * i);
}
- ret = raw_write8(s->i2c_addr, BMI160_OFFSET_EN_GYR98,
+ ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98,
val98 | BMI160_OFFSET_GYRO_EN);
break;
default:
@@ -481,23 +481,23 @@ int perform_calib(const struct motion_sensor_t *s)
ret = EC_RES_INVALID_PARAM;
goto end_perform_calib;
}
- ret = raw_write8(s->i2c_addr, BMI160_FOC_CONF, val);
- ret = raw_write8(s->i2c_addr, BMI160_CMD_REG, BMI160_CMD_START_FOC);
+ ret = raw_write8(s->addr, BMI160_FOC_CONF, val);
+ ret = raw_write8(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->i2c_addr, BMI160_STATUS, &status);
+ ret = raw_read8(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->i2c_addr, BMI160_OFFSET_EN_GYR98, &val);
- ret = raw_write8(s->i2c_addr, BMI160_OFFSET_EN_GYR98, val | en_flag);
+ ret = raw_read8(s->addr, BMI160_OFFSET_EN_GYR98, &val);
+ ret = raw_write8(s->addr, BMI160_OFFSET_EN_GYR98, val | en_flag);
end_perform_calib:
set_data_rate(s, rate, 0);
return ret;
@@ -539,48 +539,48 @@ static int config_interrupt(const struct motion_sensor_t *s)
return EC_SUCCESS;
mutex_lock(s->mutex);
- raw_write8(s->i2c_addr, BMI160_CMD_REG, BMI160_CMD_FIFO_FLUSH);
+ raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_FIFO_FLUSH);
msleep(30);
- raw_write8(s->i2c_addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
+ raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
/* Latch until interupts */
/* configure int2 as an external input */
tmp = BMI160_INT2_INPUT_EN | BMI160_LATCH_FOREVER;
- ret = raw_write8(s->i2c_addr, BMI160_INT_LATCH, tmp);
+ ret = raw_write8(s->addr, BMI160_INT_LATCH, tmp);
/* configure int1 as an interupt */
- ret = raw_write8(s->i2c_addr, BMI160_INT_OUT_CTRL,
+ ret = raw_write8(s->addr, BMI160_INT_OUT_CTRL,
BMI160_INT_CTRL(1, OUTPUT_EN));
/* Map Simple/Double Tap to int 1
* Map Flat interrupt to int 1
*/
- ret = raw_write8(s->i2c_addr, BMI160_INT_MAP_REG(1),
+ ret = raw_write8(s->addr, BMI160_INT_MAP_REG(1),
BMI160_INT_FLAT | BMI160_INT_D_TAP | BMI160_INT_S_TAP);
#ifdef CONFIG_ACCEL_FIFO
/* map fifo water mark to int 1 */
- ret = raw_write8(s->i2c_addr, BMI160_INT_FIFO_MAP,
+ ret = raw_write8(s->addr, BMI160_INT_FIFO_MAP,
BMI160_INT_MAP(1, FWM));
/* configure fifo watermark at 50% */
- ret = raw_write8(s->i2c_addr, BMI160_FIFO_CONFIG_0,
+ ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_0,
512 / sizeof(uint32_t));
- ret = raw_write8(s->i2c_addr, BMI160_FIFO_CONFIG_1,
+ ret = raw_write8(s->addr, BMI160_FIFO_CONFIG_1,
BMI160_FIFO_TAG_INT1_EN |
BMI160_FIFO_TAG_INT2_EN |
BMI160_FIFO_HEADER_EN);
#endif
/* Set double tap interrupt and fifo*/
- ret = raw_read8(s->i2c_addr, BMI160_INT_EN_0, &tmp);
+ ret = raw_read8(s->addr, BMI160_INT_EN_0, &tmp);
tmp |= BMI160_INT_FLAT_EN | BMI160_INT_D_TAP_EN | BMI160_INT_S_TAP_EN;
- ret = raw_write8(s->i2c_addr, BMI160_INT_EN_0, tmp);
+ ret = raw_write8(s->addr, BMI160_INT_EN_0, tmp);
#ifdef CONFIG_ACCEL_FIFO
- ret = raw_read8(s->i2c_addr, BMI160_INT_EN_1, &tmp);
+ ret = raw_read8(s->addr, BMI160_INT_EN_1, &tmp);
tmp |= BMI160_INT_FWM_EN;
- ret = raw_write8(s->i2c_addr, BMI160_INT_EN_1, tmp);
+ ret = raw_write8(s->addr, BMI160_INT_EN_1, tmp);
#endif
mutex_unlock(s->mutex);
@@ -598,8 +598,8 @@ int irq_handler(const struct motion_sensor_t *s)
{
int interrupt;
- raw_read32(s->i2c_addr, BMI160_INT_STATUS_0, &interrupt);
- raw_write8(s->i2c_addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
+ raw_read32(s->addr, BMI160_INT_STATUS_0, &interrupt);
+ raw_write8(s->addr, BMI160_CMD_REG, BMI160_CMD_INT_RESET);
if (interrupt & BMI160_S_TAP_INT)
CPRINTS("single tap: %08x", interrupt);
@@ -697,7 +697,7 @@ static int load_fifo(struct motion_sensor_t *s)
return EC_SUCCESS;
/* Read fifo length */
- raw_read16(s->i2c_addr, BMI160_FIFO_LENGTH_0, &fifo_length);
+ raw_read16(s->addr, BMI160_FIFO_LENGTH_0, &fifo_length);
fifo_length &= BMI160_FIFO_LENGTH_MASK;
if (fifo_length == 0)
return EC_SUCCESS;
@@ -706,7 +706,7 @@ static int load_fifo(struct motion_sensor_t *s)
uint8_t fifo_reg = BMI160_FIFO_DATA;
uint8_t *bp = bmi160_buffer;
i2c_lock(I2C_PORT_ACCEL, 1);
- i2c_xfer(I2C_PORT_ACCEL, s->i2c_addr,
+ i2c_xfer(I2C_PORT_ACCEL, s->addr,
&fifo_reg, 1, bmi160_buffer,
sizeof(bmi160_buffer), I2C_XFER_SINGLE);
i2c_lock(I2C_PORT_ACCEL, 0);
@@ -772,7 +772,7 @@ static int read(const struct motion_sensor_t *s, vector_3_t v)
uint8_t xyz_reg;
int ret, status = 0;
- ret = raw_read8(s->i2c_addr, BMI160_STATUS, &status);
+ ret = raw_read8(s->addr, BMI160_STATUS, &status);
if (ret != EC_SUCCESS)
return ret;
@@ -791,7 +791,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, data, 6, I2C_XFER_SINGLE);
i2c_lock(I2C_PORT_ACCEL, 0);
@@ -808,7 +808,7 @@ static int init(const struct motion_sensor_t *s)
{
int ret = 0, tmp;
- ret = raw_read8(s->i2c_addr, BMI160_CHIP_ID, &tmp);
+ ret = raw_read8(s->addr, BMI160_CHIP_ID, &tmp);
if (ret)
return EC_ERROR_UNKNOWN;
@@ -820,15 +820,15 @@ 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->i2c_addr, BMI160_CMD_REG,
+ raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_SOFT_RESET);
msleep(30);
data->flags &= ~BMI160_FLAG_SEC_I2C_ENABLED;
/* To avoid gyro wakeup */
- raw_write8(s->i2c_addr, BMI160_PMU_TRIGGER, 0);
+ raw_write8(s->addr, BMI160_PMU_TRIGGER, 0);
}
- raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_MODE_NORMAL(s->type));
msleep(30);
@@ -845,48 +845,48 @@ static int init(const struct motion_sensor_t *s)
*
* Magic command sequences
*/
- raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_EXT_MODE_EN_B0);
- raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ raw_write8(s->addr, BMI160_CMD_REG,
BMI160_CMD_EXT_MODE_EN_B1);
- raw_write8(s->i2c_addr, BMI160_CMD_REG,
+ raw_write8(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->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
&ext_page_reg);
- raw_write8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
ext_page_reg | BMI160_CMD_TARGET_PAGE);
- raw_read8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
&ext_page_reg);
- raw_write8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
ext_page_reg | BMI160_CMD_PAGING_EN);
- raw_read8(s->i2c_addr, BMI160_COM_C_TRIM_ADDR,
+ raw_read8(s->addr, BMI160_COM_C_TRIM_ADDR,
&pullup_reg);
- raw_write8(s->i2c_addr, BMI160_COM_C_TRIM_ADDR,
+ raw_write8(s->addr, BMI160_COM_C_TRIM_ADDR,
pullup_reg | BMI160_COM_C_TRIM);
- raw_read8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
&ext_page_reg);
- raw_write8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_write8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
ext_page_reg & ~BMI160_CMD_TARGET_PAGE);
- raw_read8(s->i2c_addr, BMI160_CMD_EXT_MODE_ADDR,
+ raw_read8(s->addr, BMI160_CMD_EXT_MODE_ADDR,
&ext_page_reg);
/* Set the i2c address of the compass */
- ret = raw_write8(s->i2c_addr, BMI160_MAG_IF_0,
+ ret = raw_write8(s->addr, BMI160_MAG_IF_0,
BMM150_I2C_ADDRESS);
/* Enable the secondary interface as I2C */
- ret = raw_write8(s->i2c_addr, BMI160_IF_CONF,
+ ret = raw_write8(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->i2c_addr, 1);
+ bmm150_mag_access_ctrl(s->addr, 1);
ret = bmm150_init(s);
if (ret)
@@ -894,13 +894,13 @@ static int init(const struct motion_sensor_t *s)
return ret;
/* Leave the address for reading the data */
- raw_write8(s->i2c_addr, BMI160_MAG_I2C_READ_ADDR,
+ raw_write8(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->i2c_addr, 0);
+ bmm150_mag_access_ctrl(s->addr, 0);
}
#endif
#ifdef CONFIG_ACCEL_INTERRUPTS
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/driver/mag_bmm150.c b/driver/mag_bmm150.c
index 54a4598e77..772b147d70 100644
--- a/driver/mag_bmm150.c
+++ b/driver/mag_bmm150.c
@@ -67,9 +67,9 @@
#define BMI150_READ_16BIT_COM_REG(store_, addr_) do { \
int val; \
- raw_mag_read8(s->i2c_addr, (addr_), &val); \
+ raw_mag_read8(s->addr, (addr_), &val); \
store_ = val; \
- raw_mag_read8(s->i2c_addr, (addr_) + 1, &val); \
+ raw_mag_read8(s->addr, (addr_) + 1, &val); \
store_ |= (val << 8); \
} while (0)
@@ -81,9 +81,9 @@ int bmm150_init(const struct motion_sensor_t *s)
struct bmm150_comp_registers *regs = BMM150_COMP_REG(s);
/* Set the compass from Suspend to Sleep */
- ret = raw_mag_write8(s->i2c_addr, BMM150_PWR_CTRL, BMM150_PWR_ON);
+ ret = raw_mag_write8(s->addr, BMM150_PWR_CTRL, BMM150_PWR_ON);
/* Now we can read the device id */
- ret = raw_mag_read8(s->i2c_addr, BMM150_CHIP_ID, &val);
+ ret = raw_mag_read8(s->addr, BMM150_CHIP_ID, &val);
if (ret)
return EC_ERROR_UNKNOWN;
@@ -91,21 +91,21 @@ int bmm150_init(const struct motion_sensor_t *s)
return EC_ERROR_ACCESS_DENIED;
/* Read the private registers for compensation */
- ret = raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_X1, &val);
+ ret = raw_mag_read8(s->addr, BMM150_REGA_DIG_X1, &val);
if (ret)
return EC_ERROR_UNKNOWN;
regs->dig1[X] = val;
- raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_Y1, &val);
+ raw_mag_read8(s->addr, BMM150_REGA_DIG_Y1, &val);
regs->dig1[Y] = val;
- raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_X2, &val);
+ raw_mag_read8(s->addr, BMM150_REGA_DIG_X2, &val);
regs->dig2[X] = val;
- raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_Y2, &val);
+ raw_mag_read8(s->addr, BMM150_REGA_DIG_Y2, &val);
regs->dig2[Y] = val;
- raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_XY1, &val);
+ raw_mag_read8(s->addr, BMM150_REGA_DIG_XY1, &val);
regs->dig_xy1 = val;
- raw_mag_read8(s->i2c_addr, BMM150_REGA_DIG_XY2, &val);
+ raw_mag_read8(s->addr, BMM150_REGA_DIG_XY2, &val);
regs->dig_xy2 = val;
BMI150_READ_16BIT_COM_REG(regs->dig_z1, BMM150_REGA_DIG_Z1_LSB);
@@ -117,7 +117,7 @@ int bmm150_init(const struct motion_sensor_t *s)
/*
* Set the compass forced mode, to sleep after each measure.
*/
- ret = raw_mag_write8(s->i2c_addr, BMM150_OP_CTRL,
+ ret = raw_mag_write8(s->addr, BMM150_OP_CTRL,
BMM150_OP_MODE_FORCED << BMM150_OP_MODE_OFFSET);
return ret;
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,
View Lorry Controller Status