int ak8975_init(struct device *dev)
{
struct ak8975_data *drv_data = dev->driver_data;
u8_t id;
drv_data->i2c = device_get_binding(CONFIG_AK8975_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) {
SYS_LOG_ERR("Failed to get pointer to %s device!",
CONFIG_AK8975_I2C_MASTER_DEV_NAME);
return -EINVAL;
}
#ifdef CONFIG_MPU9150
/* wake up MPU9150 chip */
if (i2c_reg_update_byte(drv_data->i2c, MPU9150_I2C_ADDR,
MPU9150_REG_PWR_MGMT1, MPU9150_SLEEP_EN,
0) < 0) {
SYS_LOG_ERR("Failed to wake up MPU9150 chip.");
return -EIO;
}
/* enable MPU9150 pass-though to have access to AK8975 */
if (i2c_reg_update_byte(drv_data->i2c, MPU9150_I2C_ADDR,
MPU9150_REG_BYPASS_CFG, MPU9150_I2C_BYPASS_EN,
MPU9150_I2C_BYPASS_EN) < 0) {
SYS_LOG_ERR("Failed to enable pass-through mode for MPU9150.");
return -EIO;
}
#endif
/* check chip ID */
if (i2c_reg_read_byte(drv_data->i2c, CONFIG_AK8975_I2C_ADDR,
AK8975_REG_CHIP_ID, &id) < 0) {
SYS_LOG_ERR("Failed to read chip ID.");
return -EIO;
}
if (id != AK8975_CHIP_ID) {
SYS_LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
if (ak8975_read_adjustment_data(drv_data) < 0) {
return -EIO;
}
dev->driver_api = &ak8975_driver_api;
return 0;
}
static int pca9633_led_set_brightness(struct device *dev, u32_t led,
u8_t value)
{
struct pca9633_data *data = dev->driver_data;
struct led_data *dev_data = &data->dev_data;
u8_t val;
if (value < dev_data->min_brightness ||
value > dev_data->max_brightness) {
return -EINVAL;
}
/* Set the LED brightness value */
val = (value * 255) / dev_data->max_brightness;
if (i2c_reg_write_byte(data->i2c, CONFIG_PCA9633_I2C_ADDRESS,
PCA9633_PWM_BASE + led,
val)) {
LOG_ERR("LED reg write failed");
return -EIO;
}
/* Set the LED driver to be controlled through its PWMx register. */
if (i2c_reg_update_byte(data->i2c, CONFIG_PCA9633_I2C_ADDRESS,
PCA9633_LEDOUT,
PCA9633_MASK << (led << 1),
PCA9633_LED_PWM << (led << 1))) {
LOG_ERR("LED reg update failed");
return -EIO;
}
return 0;
}
static void bma280_fiber_cb(void *arg)
{
struct device *dev = arg;
struct bma280_data *drv_data = dev->driver_data;
uint8_t status = 0;
/* check for data ready */
i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_STATUS_1, &status);
if (status & BMA280_BIT_DATA_INT_STATUS &&
drv_data->data_ready_handler != NULL) {
drv_data->data_ready_handler(dev,
&drv_data->data_ready_trigger);
}
/* check for any motion */
i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_STATUS_0, &status);
if (status & BMA280_BIT_SLOPE_INT_STATUS &&
drv_data->any_motion_handler != NULL) {
drv_data->any_motion_handler(dev,
&drv_data->data_ready_trigger);
/* clear latched interrupt */
i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_RST_LATCH,
BMA280_BIT_INT_LATCH_RESET,
BMA280_BIT_INT_LATCH_RESET);
}
gpio_pin_enable_callback(drv_data->gpio, CONFIG_BMA280_GPIO_PIN_NUM);
}
static int apds9960_ambient_setup(struct device *dev, int gain)
{
struct apds9960_data *data = dev->driver_data;
u16_t th;
/* ADC value */
if (i2c_reg_write_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ATIME_REG, APDS9960_DEFAULT_ATIME)) {
LOG_ERR("Default integration time not set for ADC");
return -EIO;
}
/* ALS Gain */
if (i2c_reg_update_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_CONTROL_REG,
APDS9960_CONTROL_AGAIN,
(gain & APDS9960_AGAIN_64X))) {
LOG_ERR("Ambient Gain is not set");
return -EIO;
}
th = sys_cpu_to_le16(APDS9960_DEFAULT_AILT);
if (i2c_burst_write(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_INT_AILTL_REG,
(u8_t *)&th, sizeof(th))) {
LOG_ERR("ALS low threshold not set");
return -EIO;
}
th = sys_cpu_to_le16(APDS9960_DEFAULT_AIHT);
if (i2c_burst_write(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_INT_AIHTL_REG,
(u8_t *)&th, sizeof(th))) {
LOG_ERR("ALS low threshold not set");
return -EIO;
}
/* Enable ALS */
if (i2c_reg_update_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ENABLE_REG, APDS9960_ENABLE_AEN,
APDS9960_ENABLE_AEN)) {
LOG_ERR("ALS is not enabled");
return -EIO;
}
return 0;
}
int fxos8700_set_power(struct device *dev, enum fxos8700_power power)
{
const struct fxos8700_config *config = dev->config->config_info;
struct fxos8700_data *data = dev->driver_data;
return i2c_reg_update_byte(data->i2c, config->i2c_address,
FXOS8700_REG_CTRLREG1,
FXOS8700_CTRLREG1_ACTIVE_MASK,
power);
}
static inline int lps25hb_set_odr_raw(struct device *dev, u8_t odr)
{
struct lps25hb_data *data = dev->driver_data;
const struct lps25hb_config *config = dev->config->config_info;
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_ODR,
odr << LPS25HB_SHIFT_CTRL_REG1_ODR);
}
int fxas21002_set_power(struct device *dev, enum fxas21002_power power)
{
const struct fxas21002_config *config = dev->config->config_info;
struct fxas21002_data *data = dev->driver_data;
return i2c_reg_update_byte(data->i2c, config->i2c_address,
FXAS21002_REG_CTRLREG1,
FXAS21002_CTRLREG1_POWER_MASK,
power);
}
static inline int lsm9ds0_gyro_set_odr_raw(struct device *dev, uint8_t odr)
{
struct lsm9ds0_gyro_data *data = dev->driver_data;
const struct lsm9ds0_gyro_config *config = dev->config->config_info;
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_CTRL_REG1_G,
LSM9DS0_GYRO_MASK_CTRL_REG1_G_DR,
odr << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_BW);
}
static inline int lsm9ds0_mfd_accel_set_odr_raw(struct device *dev, u8_t odr)
{
struct lsm9ds0_mfd_data *data = dev->driver_data;
const struct lsm9ds0_mfd_config *config = dev->config->config_info;
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_CTRL_REG1_XM,
LSM9DS0_MFD_MASK_CTRL_REG1_XM_AODR,
odr << LSM9DS0_MFD_SHIFT_CTRL_REG1_XM_AODR);
}
static inline int lps25hb_power_ctrl(struct device *dev, u8_t value)
{
struct lps25hb_data *data = dev->driver_data;
const struct lps25hb_config *config = dev->config->config_info;
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_PD,
value << LPS25HB_SHIFT_CTRL_REG1_PD);
}
int fxos8700_set_odr(struct device *dev, const struct sensor_value *val)
{
const struct fxos8700_config *config = dev->config->config_info;
struct fxos8700_data *data = dev->driver_data;
s32_t dr = val->val1;
#ifdef CONFIG_FXOS8700_MODE_HYBRID
/* ODR is halved in hybrid mode */
if (val->val1 == 400 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_800;
} else if (val->val1 == 200 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_400;
} else if (val->val1 == 100 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_200;
} else if (val->val1 == 50 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_100;
} else if (val->val1 == 25 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_50;
} else if (val->val1 == 6 && val->val2 == 250000) {
dr = FXOS8700_CTRLREG1_DR_RATE_12_5;
} else if (val->val1 == 3 && val->val2 == 125000) {
dr = FXOS8700_CTRLREG1_DR_RATE_6_25;
} else if (val->val1 == 0 && val->val2 == 781300) {
dr = FXOS8700_CTRLREG1_DR_RATE_1_56;
} else {
return -EINVAL;
}
#else
if (val->val1 == 800 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_800;
} else if (val->val1 == 400 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_400;
} else if (val->val1 == 200 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_200;
} else if (val->val1 == 100 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_100;
} else if (val->val1 == 50 && val->val2 == 0) {
dr = FXOS8700_CTRLREG1_DR_RATE_50;
} else if (val->val1 == 12 && val->val2 == 500000) {
dr = FXOS8700_CTRLREG1_DR_RATE_12_5;
} else if (val->val1 == 6 && val->val2 == 250000) {
dr = FXOS8700_CTRLREG1_DR_RATE_6_25;
} else if (val->val1 == 1 && val->val2 == 562500) {
dr = FXOS8700_CTRLREG1_DR_RATE_1_56;
} else {
return -EINVAL;
}
#endif
LOG_DBG("Set ODR to 0x%x", (u8_t)dr);
return i2c_reg_update_byte(data->i2c, config->i2c_address,
FXOS8700_REG_CTRLREG1,
FXOS8700_CTRLREG1_DR_MASK, (u8_t)dr);
}
static int lsm9ds0_gyro_init_chip(struct device *dev)
{
struct lsm9ds0_gyro_data *data = dev->driver_data;
const struct lsm9ds0_gyro_config *config = dev->config->config_info;
uint8_t chip_id;
if (lsm9ds0_gyro_power_ctrl(dev, 0, 0, 0, 0) < 0) {
SYS_LOG_DBG("failed to power off device");
return -EIO;
}
if (lsm9ds0_gyro_power_ctrl(dev, 1, 1, 1, 1) < 0) {
SYS_LOG_DBG("failed to power on device");
return -EIO;
}
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_WHO_AM_I_G, &chip_id) < 0) {
SYS_LOG_DBG("failed reading chip id");
goto err_poweroff;
}
if (chip_id != LSM9DS0_GYRO_VAL_WHO_AM_I_G) {
SYS_LOG_DBG("invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
SYS_LOG_DBG("chip id 0x%x", chip_id);
if (lsm9ds0_gyro_set_fs_raw(dev, LSM9DS0_GYRO_DEFAULT_FULLSCALE) < 0) {
SYS_LOG_DBG("failed to set full-scale");
goto err_poweroff;
}
if (lsm9ds0_gyro_set_odr_raw(dev, LSM9DS0_GYRO_DEFAULT_SAMPLING_RATE)
< 0) {
SYS_LOG_DBG("failed to set sampling rate");
goto err_poweroff;
}
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_CTRL_REG4_G,
LSM9DS0_GYRO_MASK_CTRL_REG4_G_BDU |
LSM9DS0_GYRO_MASK_CTRL_REG4_G_BLE,
(1 << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BDU) |
(0 << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_BLE))
< 0) {
SYS_LOG_DBG("failed to set BDU and BLE");
goto err_poweroff;
}
return 0;
err_poweroff:
lsm9ds0_gyro_power_ctrl(dev, 0, 0, 0, 0);
return -EIO;
}
static int apds9960_device_ctrl(struct device *dev, u32_t ctrl_command,
void *context)
{
struct apds9960_data *data = dev->driver_data;
if (ctrl_command == DEVICE_PM_SET_POWER_STATE) {
u32_t device_pm_state = *(u32_t *)context;
if (device_pm_state == DEVICE_PM_ACTIVE_STATE) {
if (i2c_reg_update_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
APDS9960_ENABLE_PON)) {
return -EIO;
}
return 0;
}
if (i2c_reg_update_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON, 0)) {
return -EIO;
}
if (i2c_reg_write_byte(data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_AICLEAR_REG, 0)) {
return -EIO;
}
return 0;
} else if (ctrl_command == DEVICE_PM_GET_POWER_STATE) {
*((u32_t *)context) = DEVICE_PM_ACTIVE_STATE;
}
return 0;
}
static int lsm6ds0_accel_set_odr_raw(struct device *dev, u8_t odr)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_CTRL_REG6_XL,
LSM6DS0_MASK_CTRL_REG6_XL_ODR_XL,
odr << LSM6DS0_SHIFT_CTRL_REG6_XL_ODR_XL) < 0) {
return -EIO;
}
return 0;
}
static int lsm6ds0_gyro_set_fs_raw(struct device *dev, u8_t fs)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_CTRL_REG1_G,
LSM6DS0_MASK_CTRL_REG1_G_FS_G,
fs << LSM6DS0_SHIFT_CTRL_REG1_G_FS_G) < 0) {
return -EIO;
}
return 0;
}
int sx9500_trigger_set(struct device *dev,
const struct sensor_trigger *trig,
sensor_trigger_handler_t handler)
{
struct sx9500_data *data = dev->driver_data;
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
if (i2c_reg_update_byte(data->i2c_master,
data->i2c_slave_addr,
SX9500_REG_IRQ_MSK,
SX9500_CONV_DONE_IRQ,
SX9500_CONV_DONE_IRQ) < 0) {
return -EIO;
}
data->handler_drdy = handler;
data->trigger_drdy = *trig;
break;
case SENSOR_TRIG_NEAR_FAR:
if (i2c_reg_update_byte(data->i2c_master,
data->i2c_slave_addr,
SX9500_REG_IRQ_MSK,
SX9500_NEAR_FAR_IRQ,
SX9500_NEAR_FAR_IRQ) < 0) {
return -EIO;
}
data->handler_near_far = handler;
data->trigger_near_far = *trig;
break;
default:
return -EINVAL;
}
return 0;
}
static inline int pca9633_led_off(struct device *dev, u32_t led)
{
struct pca9633_data *data = dev->driver_data;
/* Set LED state to OFF */
if (i2c_reg_update_byte(data->i2c, CONFIG_PCA9633_I2C_ADDRESS,
PCA9633_LEDOUT,
PCA9633_MASK << (led << 1),
PCA9633_LED_OFF)) {
LOG_ERR("LED reg update failed");
return -EIO;
}
return 0;
}
static int lps25hb_init_chip(struct device *dev)
{
struct lps25hb_data *data = dev->driver_data;
const struct lps25hb_config *config = dev->config->config_info;
u8_t chip_id;
lps25hb_power_ctrl(dev, 0);
k_busy_wait(50 * USEC_PER_MSEC);
if (lps25hb_power_ctrl(dev, 1) < 0) {
SYS_LOG_DBG("failed to power on device");
return -EIO;
}
k_busy_wait(20 * USEC_PER_MSEC);
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LPS25HB_REG_WHO_AM_I, &chip_id) < 0) {
SYS_LOG_DBG("failed reading chip id");
goto err_poweroff;
}
if (chip_id != LPS25HB_VAL_WHO_AM_I) {
SYS_LOG_DBG("invalid chip id 0x%x", chip_id);
goto err_poweroff;
}
SYS_LOG_DBG("chip id 0x%x", chip_id);
if (lps25hb_set_odr_raw(dev, LPS25HB_DEFAULT_SAMPLING_RATE)
< 0) {
SYS_LOG_DBG("failed to set sampling rate");
goto err_poweroff;
}
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LPS25HB_REG_CTRL_REG1,
LPS25HB_MASK_CTRL_REG1_BDU,
(1 << LPS25HB_SHIFT_CTRL_REG1_BDU)) < 0) {
SYS_LOG_DBG("failed to set BDU");
goto err_poweroff;
}
return 0;
err_poweroff:
lps25hb_power_ctrl(dev, 0);
return -EIO;
}
static inline int lsm6ds0_gyro_axis_ctrl(struct device *dev, int x_en, int y_en,
int z_en)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
u8_t state = (x_en << LSM6DS0_SHIFT_CTRL_REG4_XEN_G) |
(y_en << LSM6DS0_SHIFT_CTRL_REG4_YEN_G) |
(z_en << LSM6DS0_SHIFT_CTRL_REG4_ZEN_G);
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_CTRL_REG4,
LSM6DS0_MASK_CTRL_REG4_XEN_G |
LSM6DS0_MASK_CTRL_REG4_YEN_G |
LSM6DS0_MASK_CTRL_REG4_ZEN_G,
state);
}
static inline int lsm6ds0_reboot(struct device *dev)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_CTRL_REG8,
LSM6DS0_MASK_CTRL_REG8_BOOT,
1 << LSM6DS0_SHIFT_CTRL_REG8_BOOT) < 0) {
return -EIO;
}
k_busy_wait(50 * USEC_PER_MSEC);
return 0;
}
static int lsm9ds0_gyro_set_fs_raw(struct device *dev, uint8_t fs)
{
struct lsm9ds0_gyro_data *data = dev->driver_data;
const struct lsm9ds0_gyro_config *config = dev->config->config_info;
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_CTRL_REG4_G,
LSM9DS0_GYRO_MASK_CTRL_REG4_G_FS,
fs << LSM9DS0_GYRO_SHIFT_CTRL_REG4_G_FS) < 0) {
return -EIO;
}
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
data->fs = fs;
#endif
return 0;
}
static inline int lsm9ds0_gyro_power_ctrl(struct device *dev, int power,
int x_en, int y_en, int z_en)
{
struct lsm9ds0_gyro_data *data = dev->driver_data;
const struct lsm9ds0_gyro_config *config = dev->config->config_info;
uint8_t state = (power << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_PD) |
(x_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_XEN) |
(y_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_YEN) |
(z_en << LSM9DS0_GYRO_SHIFT_CTRL_REG1_G_ZEN);
return i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_CTRL_REG1_G,
LSM9DS0_GYRO_MASK_CTRL_REG1_G_PD |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_XEN |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_YEN |
LSM9DS0_GYRO_MASK_CTRL_REG1_G_ZEN,
state);
}
static inline int lsm9ds0_mfd_accel_set_fs_raw(struct device *dev, u8_t fs)
{
struct lsm9ds0_mfd_data *data = dev->driver_data;
const struct lsm9ds0_mfd_config *config = dev->config->config_info;
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_CTRL_REG2_XM,
LSM9DS0_MFD_MASK_CTRL_REG2_XM_AFS,
fs << LSM9DS0_MFD_SHIFT_CTRL_REG2_XM_AFS)
< 0) {
return -EIO;
}
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
data->accel_fs = fs;
#endif
return 0;
}
static int apds9960_init_interrupt(struct device *dev)
{
struct apds9960_data *drv_data = dev->driver_data;
/* setup gpio interrupt */
drv_data->gpio = device_get_binding(DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER);
if (drv_data->gpio == NULL) {
LOG_ERR("Failed to get pointer to %s device!",
DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER);
return -EINVAL;
}
gpio_pin_configure(drv_data->gpio, DT_AVAGO_APDS9960_0_INT_GPIOS_PIN,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE |
GPIO_PUD_PULL_UP);
gpio_init_callback(&drv_data->gpio_cb,
apds9960_gpio_callback,
BIT(DT_AVAGO_APDS9960_0_INT_GPIOS_PIN));
if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
LOG_DBG("Failed to set gpio callback!");
return -EIO;
}
#ifdef CONFIG_APDS9960_TRIGGER
drv_data->work.handler = apds9960_work_cb;
drv_data->dev = dev;
if (i2c_reg_update_byte(drv_data->i2c, APDS9960_I2C_ADDRESS,
APDS9960_ENABLE_REG,
APDS9960_ENABLE_PON,
APDS9960_ENABLE_PON)) {
LOG_ERR("Power on bit not set.");
return -EIO;
}
#else
k_sem_init(&drv_data->data_sem, 0, UINT_MAX);
#endif
return 0;
}
int bmg160_update_byte(struct device *dev, uint8_t reg_addr, uint8_t mask,
uint8_t value)
{
struct bmg160_device_config *dev_cfg = dev->config->config_info;
struct bmg160_device_data *bmg160 = dev->driver_data;
int ret = 0;
bmg160_bus_config(dev);
nano_sem_take(&bmg160->sem, TICKS_UNLIMITED);
if (i2c_reg_update_byte(bmg160->i2c, dev_cfg->i2c_addr,
reg_addr, mask, value) < 0) {
ret = -EIO;
}
nano_sem_give(&bmg160->sem);
return ret;
}
int bmg160_update_byte(struct device *dev, u8_t reg_addr, u8_t mask,
u8_t value)
{
const struct bmg160_device_config *dev_cfg = dev->config->config_info;
struct bmg160_device_data *bmg160 = dev->driver_data;
int ret = 0;
bmg160_bus_config(dev);
k_sem_take(&bmg160->sem, K_FOREVER);
if (i2c_reg_update_byte(bmg160->i2c, dev_cfg->i2c_addr,
reg_addr, mask, value) < 0) {
ret = -EIO;
}
k_sem_give(&bmg160->sem);
return ret;
}
int bma280_attr_set(struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct bma280_data *drv_data = dev->driver_data;
uint64_t slope_th;
int rc;
if (chan != SENSOR_CHAN_ACCEL_ANY) {
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_SLOPE_TH) {
/* slope_th = (val * 10^6 * 2^10) / BMA280_PMU_FULL_RAGE */
slope_th = (uint64_t)val->val1 * 1000000 + (uint64_t)val->val2;
slope_th = (slope_th * (1 << 10)) / BMA280_PMU_FULL_RANGE;
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_SLOPE_TH, (uint8_t)slope_th);
if (rc != 0) {
SYS_LOG_DBG("Could not set slope threshold");
return -EIO;
}
} else if (attr == SENSOR_ATTR_SLOPE_DUR) {
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_5,
BMA280_SLOPE_DUR_MASK,
val->val1 << BMA280_SLOPE_DUR_SHIFT);
if (rc != 0) {
SYS_LOG_DBG("Could not set slope duration");
return -EIO;
}
} else {
return -ENOTSUP;
}
return 0;
}
static int fxos8700_set_mt_ths(struct device *dev,
const struct sensor_value *val)
{
#ifdef CONFIG_FXOS8700_MOTION
const struct fxos8700_config *config = dev->config->config_info;
struct fxos8700_data *data = dev->driver_data;
u64_t micro_ms2 = abs(val->val1 * 1000000LL + val->val2);
u64_t ths = micro_ms2 / FXOS8700_FF_MT_THS_SCALE;
if (ths > FXOS8700_FF_MT_THS_MASK) {
LOG_ERR("Threshold value is out of range");
return -EINVAL;
}
LOG_DBG("Set FF_MT_THS to %d", (u8_t)ths);
return i2c_reg_update_byte(data->i2c, config->i2c_address,
FXOS8700_REG_FF_MT_THS,
FXOS8700_FF_MT_THS_MASK, (u8_t)ths);
#else
return -ENOTSUP;
#endif
}
static int lsm6ds0_init_chip(struct device *dev)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
u8_t chip_id;
if (lsm6ds0_reboot(dev) < 0) {
LOG_DBG("failed to reboot device");
return -EIO;
}
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_WHO_AM_I, &chip_id) < 0) {
LOG_DBG("failed reading chip id");
return -EIO;
}
if (chip_id != LSM6DS0_VAL_WHO_AM_I) {
LOG_DBG("invalid chip id 0x%x", chip_id);
return -EIO;
}
LOG_DBG("chip id 0x%x", chip_id);
if (lsm6ds0_accel_axis_ctrl(dev, LSM6DS0_ACCEL_ENABLE_X_AXIS,
LSM6DS0_ACCEL_ENABLE_Y_AXIS,
LSM6DS0_ACCEL_ENABLE_Z_AXIS) < 0) {
LOG_DBG("failed to set accelerometer axis");
return -EIO;
}
if (lsm6ds0_accel_set_fs_raw(dev, LSM6DS0_DEFAULT_ACCEL_FULLSCALE)
< 0) {
LOG_DBG("failed to set accelerometer full-scale");
return -EIO;
}
if (lsm6ds0_accel_set_odr_raw(dev, LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set accelerometer sampling rate");
return -EIO;
}
if (lsm6ds0_gyro_axis_ctrl(dev, LSM6DS0_GYRO_ENABLE_X_AXIS,
LSM6DS0_GYRO_ENABLE_Y_AXIS,
LSM6DS0_GYRO_ENABLE_Z_AXIS) < 0) {
LOG_DBG("failed to set gyroscope axis");
return -EIO;
}
if (lsm6ds0_gyro_set_fs_raw(dev, LSM6DS0_DEFAULT_GYRO_FULLSCALE)
< 0) {
LOG_DBG("failed to set gyroscope full-scale");
return -EIO;
}
if (lsm6ds0_gyro_set_odr_raw(dev, LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE)
< 0) {
LOG_DBG("failed to set gyroscope sampling rate");
return -EIO;
}
if (i2c_reg_update_byte(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_CTRL_REG8,
LSM6DS0_MASK_CTRL_REG8_BDU |
LSM6DS0_MASK_CTRL_REG8_BLE |
LSM6DS0_MASK_CTRL_REG8_IF_ADD_INC,
(1 << LSM6DS0_SHIFT_CTRL_REG8_BDU) |
(0 << LSM6DS0_SHIFT_CTRL_REG8_BLE) |
(1 << LSM6DS0_SHIFT_CTRL_REG8_IF_ADD_INC))
< 0) {
LOG_DBG("failed to set BDU, BLE and burst");
return -EIO;
}
return 0;
}
int mpu6050_init(struct device *dev)
{
struct mpu6050_data *drv_data = dev->driver_data;
u8_t id, i;
drv_data->i2c = device_get_binding(CONFIG_MPU6050_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) {
SYS_LOG_ERR("Failed to get pointer to %s device",
CONFIG_MPU6050_I2C_MASTER_DEV_NAME);
return -EINVAL;
}
/* check chip ID */
if (i2c_reg_read_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR,
MPU6050_REG_CHIP_ID, &id) < 0) {
SYS_LOG_ERR("Failed to read chip ID.");
return -EIO;
}
if (id != MPU6050_CHIP_ID) {
SYS_LOG_ERR("Invalid chip ID.");
return -EINVAL;
}
/* wake up chip */
if (i2c_reg_update_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR,
MPU6050_REG_PWR_MGMT1, MPU6050_SLEEP_EN,
0) < 0) {
SYS_LOG_ERR("Failed to wake up chip.");
return -EIO;
}
/* set accelerometer full-scale range */
for (i = 0; i < 4; i++) {
if (BIT(i+1) == CONFIG_MPU6050_ACCEL_FS) {
break;
}
}
if (i == 4) {
SYS_LOG_ERR("Invalid value for accel full-scale range.");
return -EINVAL;
}
if (i2c_reg_write_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR,
MPU6050_REG_ACCEL_CFG,
i << MPU6050_ACCEL_FS_SHIFT) < 0) {
SYS_LOG_ERR("Failed to write accel full-scale range.");
return -EIO;
}
drv_data->accel_sensitivity_shift = 14 - i;
/* set gyroscope full-scale range */
for (i = 0; i < 4; i++) {
if (BIT(i) * 250 == CONFIG_MPU6050_GYRO_FS) {
break;
}
}
if (i == 4) {
SYS_LOG_ERR("Invalid value for gyro full-scale range.");
return -EINVAL;
}
if (i2c_reg_write_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR,
MPU6050_REG_GYRO_CFG,
i << MPU6050_GYRO_FS_SHIFT) < 0) {
SYS_LOG_ERR("Failed to write gyro full-scale range.");
return -EIO;
}
drv_data->gyro_sensitivity_x10 = mpu6050_gyro_sensitivity_x10[i];
#ifdef CONFIG_MPU6050_TRIGGER
if (mpu6050_init_interrupt(dev) < 0) {
SYS_LOG_DBG("Failed to initialize interrupts.");
return -EIO;
}
#endif
return 0;
}
