michaelh/zephyr
1
0
Fork 0
Code Releases Activity

sensor: remove unnecessary return variables

Browse source 
Remove unnecessary return variables (ret/rc) to reduce memory footprint.

Change-Id: Ifc22fd993b4f8f2d0cf992f620f53cc510add1fa
Signed-off-by: Murtaza Alexandru <alexandru.murtaza@intel.com>
This commit is contained in:
Murtaza Alexandru 2016-05-05 16:53:52 +03:00 • committed by Anas Nashif
commit 261a448f33
16 changed files with 164 additions and 246 deletions
Download patch file Download diff file Expand all files Collapse all files

33
drivers/sensor/sensor_bma280.c
View file

@ -26,7 +26,6 @@ static int bma280_sample_fetch(struct device *dev, enum sensor_channel chan)
struct bma280_data *drv_data = dev->driver_data; struct bma280_data *drv_data = dev->driver_data;
uint8_t buf[6]; uint8_t buf[6];
uint8_t lsb; uint8_t lsb;
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL); __ASSERT(chan == SENSOR_CHAN_ALL);
@ -34,9 +33,8 @@ static int bma280_sample_fetch(struct device *dev, enum sensor_channel chan)
* since all accel data register addresses are consecutive, * since all accel data register addresses are consecutive,
* a burst read can be used to read all the samples * a burst read can be used to read all the samples
*/ */
rc = i2c_burst_read(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_burst_read(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_ACCEL_X_LSB, buf, 6); BMA280_REG_ACCEL_X_LSB, buf, 6) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not read accel axis data"); SYS_LOG_DBG("Could not read accel axis data");
return -EIO; return -EIO;
} }
@ -50,10 +48,9 @@ static int bma280_sample_fetch(struct device *dev, enum sensor_channel chan)
lsb = (buf[4] & BMA280_ACCEL_LSB_MASK) >> BMA280_ACCEL_LSB_SHIFT; lsb = (buf[4] & BMA280_ACCEL_LSB_MASK) >> BMA280_ACCEL_LSB_SHIFT;
drv_data->z_sample = (((int8_t)buf[5]) << BMA280_ACCEL_LSB_BITS) | lsb; drv_data->z_sample = (((int8_t)buf[5]) << BMA280_ACCEL_LSB_BITS) | lsb;
rc = i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_TEMP, BMA280_REG_TEMP,
(uint8_t *)&drv_data->temp_sample); (uint8_t *)&drv_data->temp_sample) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not read temperature data"); SYS_LOG_DBG("Could not read temperature data");
return -EIO; return -EIO;
} }
@ -127,7 +124,6 @@ int bma280_init(struct device *dev)
{ {
struct bma280_data *drv_data = dev->driver_data; struct bma280_data *drv_data = dev->driver_data;
uint8_t id = 0; uint8_t id = 0;
int rc;
drv_data->i2c = device_get_binding(CONFIG_BMA280_I2C_MASTER_DEV_NAME); drv_data->i2c = device_get_binding(CONFIG_BMA280_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) { if (drv_data->i2c == NULL) {
@ -137,9 +133,8 @@ int bma280_init(struct device *dev)
} }
/* read device ID */ /* read device ID */
rc = i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_read_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_CHIP_ID, &id); BMA280_REG_CHIP_ID, &id) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not read chip id"); SYS_LOG_DBG("Could not read chip id");
return -EIO; return -EIO;
} }
@ -149,25 +144,21 @@ int bma280_init(struct device *dev)
return -EIO; return -EIO;
} }
/* set the data filter bandwidth */ if (i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_PMU_BW, BMA280_PMU_BW) < 0) {
BMA280_REG_PMU_BW, BMA280_PMU_BW);
if (rc < 0) {
SYS_LOG_DBG("Could not set data filter bandwidth"); SYS_LOG_DBG("Could not set data filter bandwidth");
return -EIO; return -EIO;
} }
/* set g-range */ /* set g-range */
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_PMU_RANGE, BMA280_PMU_RANGE); BMA280_REG_PMU_RANGE, BMA280_PMU_RANGE) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not set data g-range"); SYS_LOG_DBG("Could not set data g-range");
return -EIO; return -EIO;
} }
#ifdef CONFIG_BMA280_TRIGGER #ifdef CONFIG_BMA280_TRIGGER
rc = bma280_init_interrupt(dev); if (bma280_init_interrupt(dev) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not initialize interrupts"); SYS_LOG_DBG("Could not initialize interrupts");
return -EIO; return -EIO;
} }

96
drivers/sensor/sensor_bma280_trigger.c
View file

@ -29,7 +29,6 @@ int bma280_attr_set(struct device *dev,
{ {
struct bma280_data *drv_data = dev->driver_data; struct bma280_data *drv_data = dev->driver_data;
uint64_t slope_th; uint64_t slope_th;
int rc;
if (chan != SENSOR_CHAN_ACCEL_ANY) { if (chan != SENSOR_CHAN_ACCEL_ANY) {
return -ENOTSUP; return -ENOTSUP;
@ -39,18 +38,18 @@ int bma280_attr_set(struct device *dev,
/* slope_th = (val * 10^6 * 2^10) / BMA280_PMU_FULL_RAGE */ /* slope_th = (val * 10^6 * 2^10) / BMA280_PMU_FULL_RAGE */
slope_th = (uint64_t)val->val1 * 1000000 + (uint64_t)val->val2; slope_th = (uint64_t)val->val1 * 1000000 + (uint64_t)val->val2;
slope_th = (slope_th * (1 << 10)) / BMA280_PMU_FULL_RANGE; slope_th = (slope_th * (1 << 10)) / BMA280_PMU_FULL_RANGE;
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_SLOPE_TH, (uint8_t)slope_th); BMA280_REG_SLOPE_TH, (uint8_t)slope_th)
if (rc < 0) { < 0) {
SYS_LOG_DBG("Could not set slope threshold"); SYS_LOG_DBG("Could not set slope threshold");
return -EIO; return -EIO;
} }
} else if (attr == SENSOR_ATTR_SLOPE_DUR) { } else if (attr == SENSOR_ATTR_SLOPE_DUR) {
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_5, BMA280_REG_INT_5,
BMA280_SLOPE_DUR_MASK, BMA280_SLOPE_DUR_MASK,
val->val1 << BMA280_SLOPE_DUR_SHIFT); val->val1 << BMA280_SLOPE_DUR_SHIFT)
if (rc < 0) { < 0) {
SYS_LOG_DBG("Could not set slope duration"); SYS_LOG_DBG("Could not set slope duration");
return -EIO; return -EIO;
} }
@ -141,14 +140,12 @@ int bma280_trigger_set(struct device *dev,
sensor_trigger_handler_t handler) sensor_trigger_handler_t handler)
{ {
struct bma280_data *drv_data = dev->driver_data; struct bma280_data *drv_data = dev->driver_data;
int rc;
if (trig->type == SENSOR_TRIG_DATA_READY) { if (trig->type == SENSOR_TRIG_DATA_READY) {
/* disable data ready interrupt while changing trigger params */ /* disable data ready interrupt while changing trigger params */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_1, BMA280_REG_INT_EN_1,
BMA280_BIT_DATA_EN, 0); BMA280_BIT_DATA_EN, 0) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not disable data ready interrupt"); SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO; return -EIO;
} }
@ -160,20 +157,18 @@ int bma280_trigger_set(struct device *dev,
drv_data->data_ready_trigger = *trig; drv_data->data_ready_trigger = *trig;
/* enable data ready interrupt */ /* enable data ready interrupt */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_1, BMA280_REG_INT_EN_1,
BMA280_BIT_DATA_EN, BMA280_BIT_DATA_EN,
BMA280_BIT_DATA_EN); BMA280_BIT_DATA_EN) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not enable data ready interrupt"); SYS_LOG_DBG("Could not enable data ready interrupt");
return -EIO; return -EIO;
} }
} else if (trig->type == SENSOR_TRIG_DELTA) { } else if (trig->type == SENSOR_TRIG_DELTA) {
/* disable any-motion interrupt while changing trigger params */ /* disable any-motion interrupt while changing trigger params */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_0, BMA280_REG_INT_EN_0,
BMA280_SLOPE_EN_XYZ, 0); BMA280_SLOPE_EN_XYZ, 0) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not disable data ready interrupt"); SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO; return -EIO;
} }
@ -185,11 +180,10 @@ int bma280_trigger_set(struct device *dev,
drv_data->any_motion_trigger = *trig; drv_data->any_motion_trigger = *trig;
/* enable any-motion interrupt */ /* enable any-motion interrupt */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_0, BMA280_REG_INT_EN_0,
BMA280_SLOPE_EN_XYZ, BMA280_SLOPE_EN_XYZ,
BMA280_SLOPE_EN_XYZ); BMA280_SLOPE_EN_XYZ) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not enable data ready interrupt"); SYS_LOG_DBG("Could not enable data ready interrupt");
return -EIO; return -EIO;
} }
@ -203,14 +197,12 @@ int bma280_trigger_set(struct device *dev,
int bma280_init_interrupt(struct device *dev) int bma280_init_interrupt(struct device *dev)
{ {
struct bma280_data *drv_data = dev->driver_data; struct bma280_data *drv_data = dev->driver_data;
int rc;
/* set latched interrupts */ /* set latched interrupts */
rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_RST_LATCH, BMA280_REG_INT_RST_LATCH,
BMA280_BIT_INT_LATCH_RESET | BMA280_BIT_INT_LATCH_RESET |
BMA280_INT_MODE_LATCH); BMA280_INT_MODE_LATCH) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not set latched interrupts"); SYS_LOG_DBG("Could not set latched interrupts");
return -EIO; return -EIO;
} }
@ -231,46 +223,40 @@ int bma280_init_interrupt(struct device *dev)
bma280_gpio_callback, bma280_gpio_callback,
BIT(CONFIG_BMA280_GPIO_PIN_NUM)); BIT(CONFIG_BMA280_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not set gpio callback"); SYS_LOG_DBG("Could not set gpio callback");
return -EIO; return -EIO;
} }
/* map data ready interrupt to INT1 */ /* map data ready interrupt to INT1 */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_MAP_1, BMA280_REG_INT_MAP_1,
BMA280_INT_MAP_1_BIT_DATA, BMA280_INT_MAP_1_BIT_DATA,
BMA280_INT_MAP_1_BIT_DATA); BMA280_INT_MAP_1_BIT_DATA) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not map data ready interrupt pin"); SYS_LOG_DBG("Could not map data ready interrupt pin");
return -EIO; return -EIO;
} }
/* map any-motion interrupt to INT1 */ /* map any-motion interrupt to INT1 */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_MAP_0, BMA280_REG_INT_MAP_0,
BMA280_INT_MAP_0_BIT_SLOPE, BMA280_INT_MAP_0_BIT_SLOPE,
BMA280_INT_MAP_0_BIT_SLOPE); BMA280_INT_MAP_0_BIT_SLOPE) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not map any-motion interrupt pin"); SYS_LOG_DBG("Could not map any-motion interrupt pin");
return -EIO; return -EIO;
} }
/* disable data ready interrupt */ if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_EN_1,
BMA280_REG_INT_EN_1, BMA280_BIT_DATA_EN, 0) < 0) {
BMA280_BIT_DATA_EN, 0);
if (rc < 0) {
SYS_LOG_DBG("Could not disable data ready interrupt"); SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO; return -EIO;
} }
/* disable any-motion interrupt */ /* disable any-motion interrupt */
rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS,
BMA280_REG_INT_EN_0, BMA280_REG_INT_EN_0,
BMA280_SLOPE_EN_XYZ, 0); BMA280_SLOPE_EN_XYZ, 0) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not disable data ready interrupt"); SYS_LOG_DBG("Could not disable data ready interrupt");
return -EIO; return -EIO;
} }

14
drivers/sensor/sensor_bmp280.c
View file

@ -76,14 +76,12 @@ static int bmp280_sample_fetch(struct device *dev, enum sensor_channel chan)
struct bmp280_data *data = dev->driver_data; struct bmp280_data *data = dev->driver_data;
uint8_t buf[6]; uint8_t buf[6];
int32_t adc_press, adc_temp; int32_t adc_press, adc_temp;
int ret;
__ASSERT(chan == SENSOR_CHAN_ALL); __ASSERT(chan == SENSOR_CHAN_ALL);
ret = i2c_burst_read(data->i2c_master, data->i2c_slave_addr, if (i2c_burst_read(data->i2c_master, data->i2c_slave_addr,
BMP280_REG_PRESS_MSB, buf, sizeof(buf)); BMP280_REG_PRESS_MSB, buf, sizeof(buf)) < 0) {
if (ret) { return -EIO;
return ret;
} }
adc_press = (buf[0] << 12) | (buf[1] << 4) | (buf[2] >> 4); adc_press = (buf[0] << 12) | (buf[1] << 4) | (buf[2] >> 4);
@ -181,7 +179,6 @@ static int bmp280_chip_init(struct device *dev)
int bmp280_init(struct device *dev) int bmp280_init(struct device *dev)
{ {
struct bmp280_data *data = dev->driver_data; struct bmp280_data *data = dev->driver_data;
int ret;
data->i2c_master = device_get_binding(CONFIG_BMP280_I2C_MASTER_DEV_NAME); data->i2c_master = device_get_binding(CONFIG_BMP280_I2C_MASTER_DEV_NAME);
if (!data->i2c_master) { if (!data->i2c_master) {
@ -192,9 +189,8 @@ int bmp280_init(struct device *dev)
data->i2c_slave_addr = CONFIG_BMP280_I2C_ADDR; data->i2c_slave_addr = CONFIG_BMP280_I2C_ADDR;
ret = bmp280_chip_init(dev); if (bmp280_chip_init(dev) < 0) {
if (ret) { return -EINVAL;
return ret;
} }
dev->driver_api = &bmp280_api_funcs; dev->driver_api = &bmp280_api_funcs;

11
drivers/sensor/sensor_hdc1008.c
View file

@ -40,23 +40,20 @@ static int hdc1008_sample_fetch(struct device *dev, enum sensor_channel chan)
{ {
struct hdc1008_data *drv_data = dev->driver_data; struct hdc1008_data *drv_data = dev->driver_data;
uint8_t buf[4]; uint8_t buf[4];
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL); __ASSERT(chan == SENSOR_CHAN_ALL);
gpio_pin_enable_callback(drv_data->gpio, CONFIG_HDC1008_GPIO_PIN_NUM); gpio_pin_enable_callback(drv_data->gpio, CONFIG_HDC1008_GPIO_PIN_NUM);
buf[0] = HDC1008_REG_TEMP; buf[0] = HDC1008_REG_TEMP;
rc = i2c_write(drv_data->i2c, buf, 1, HDC1008_I2C_ADDRESS); if (i2c_write(drv_data->i2c, buf, 1, HDC1008_I2C_ADDRESS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to write address pointer"); SYS_LOG_DBG("Failed to write address pointer");
return -EIO; return -EIO;
} }
nano_sem_take(&drv_data->data_sem, TICKS_UNLIMITED); nano_sem_take(&drv_data->data_sem, TICKS_UNLIMITED);
rc = i2c_read(drv_data->i2c, buf, 4, HDC1008_I2C_ADDRESS); if (i2c_read(drv_data->i2c, buf, 4, HDC1008_I2C_ADDRESS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to read sample data"); SYS_LOG_DBG("Failed to read sample data");
return -EIO; return -EIO;
} }
@ -107,7 +104,6 @@ static struct sensor_driver_api hdc1008_driver_api = {
int hdc1008_init(struct device *dev) int hdc1008_init(struct device *dev)
{ {
struct hdc1008_data *drv_data = dev->driver_data; struct hdc1008_data *drv_data = dev->driver_data;
int rc;
drv_data->i2c = device_get_binding(CONFIG_HDC1008_I2C_MASTER_DEV_NAME); drv_data->i2c = device_get_binding(CONFIG_HDC1008_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) { if (drv_data->i2c == NULL) {
@ -134,8 +130,7 @@ int hdc1008_init(struct device *dev)
hdc1008_gpio_callback, hdc1008_gpio_callback,
BIT(CONFIG_HDC1008_GPIO_PIN_NUM)); BIT(CONFIG_HDC1008_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to set GPIO callback"); SYS_LOG_DBG("Failed to set GPIO callback");
return -EIO; return -EIO;
} }

67
drivers/sensor/sensor_isl29035.c
View file

@ -31,19 +31,16 @@ static int isl29035_sample_fetch(struct device *dev, enum sensor_channel chan)
{ {
struct isl29035_driver_data *drv_data = dev->driver_data; struct isl29035_driver_data *drv_data = dev->driver_data;
uint8_t msb, lsb; uint8_t msb, lsb;
int ret;
__ASSERT(chan == SENSOR_CHAN_ALL); __ASSERT(chan == SENSOR_CHAN_ALL);
ret = i2c_reg_read_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_read_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_DATA_MSB_REG, &msb); ISL29035_DATA_MSB_REG, &msb) < 0) {
if (ret < 0) {
return -EIO; return -EIO;
} }
ret = i2c_reg_read_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_read_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_DATA_LSB_REG, &lsb); ISL29035_DATA_LSB_REG, &lsb) < 0) {
if (ret < 0) {
return -EIO; return -EIO;
} }
@ -87,7 +84,6 @@ static struct sensor_driver_api isl29035_api = {
static int isl29035_init(struct device *dev) static int isl29035_init(struct device *dev)
{ {
struct isl29035_driver_data *drv_data = dev->driver_data; struct isl29035_driver_data *drv_data = dev->driver_data;
int ret;
drv_data->i2c = device_get_binding(CONFIG_ISL29035_I2C_MASTER_DEV_NAME); drv_data->i2c = device_get_binding(CONFIG_ISL29035_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) { if (drv_data->i2c == NULL) {
@ -98,63 +94,56 @@ static int isl29035_init(struct device *dev)
drv_data->data_sample = 0; drv_data->data_sample = 0;
/* clear blownout status bit */ /* clear blownout status bit */
ret = i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_ID_REG, ISL29035_BOUT_MASK, 0); ISL29035_ID_REG, ISL29035_BOUT_MASK, 0) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to clear blownout status bit."); SYS_LOG_DBG("Failed to clear blownout status bit.");
return ret; return -EIO;
} }
/* set command registers to set default attributes */ /* set command registers to set default attributes */
ret = i2c_reg_write_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_I_REG, 0); ISL29035_COMMAND_I_REG, 0) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to clear COMMAND-I."); SYS_LOG_DBG("Failed to clear COMMAND-I.");
return ret; return -EIO;
} }
ret = i2c_reg_write_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_II_REG, 0); ISL29035_COMMAND_II_REG, 0) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to clear COMMAND-II."); SYS_LOG_DBG("Failed to clear COMMAND-II.");
return ret; return -EIO;
} }
/* set operation mode */ /* set operation mode */
ret = i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_I_REG, ISL29035_COMMAND_I_REG,
ISL29035_OPMODE_MASK, ISL29035_OPMODE_MASK,
ISL29035_ACTIVE_OPMODE_BITS); ISL29035_ACTIVE_OPMODE_BITS) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to set opmode."); SYS_LOG_DBG("Failed to set opmode.");
return ret; return -EIO;
} }
/* set lux range */ /* set lux range */
ret = i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_II_REG, ISL29035_COMMAND_II_REG,
ISL29035_LUX_RANGE_MASK, ISL29035_LUX_RANGE_MASK,
ISL29035_LUX_RANGE_BITS); ISL29035_LUX_RANGE_BITS) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to set lux range."); SYS_LOG_DBG("Failed to set lux range.");
return ret; return -EIO;
} }
/* set ADC resolution */ /* set ADC resolution */
ret = i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_II_REG, ISL29035_COMMAND_II_REG,
ISL29035_ADC_RES_MASK, ISL29035_ADC_RES_MASK,
ISL29035_ADC_RES_BITS); ISL29035_ADC_RES_BITS) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to set ADC resolution."); SYS_LOG_DBG("Failed to set ADC resolution.");
return ret; return -EIO;
} }
#ifdef CONFIG_ISL29035_TRIGGER #ifdef CONFIG_ISL29035_TRIGGER
ret = isl29035_init_interrupt(dev); if (isl29035_init_interrupt(dev) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to initialize interrupt."); SYS_LOG_DBG("Failed to initialize interrupt.");
return ret; return -EIO;
} }
#endif #endif

13
drivers/sensor/sensor_isl29035_trigger.c
View file

@ -153,14 +153,12 @@ int isl29035_trigger_set(struct device *dev,
int isl29035_init_interrupt(struct device *dev) int isl29035_init_interrupt(struct device *dev)
{ {
struct isl29035_driver_data *drv_data = dev->driver_data; struct isl29035_driver_data *drv_data = dev->driver_data;
int ret;
/* set interrupt persistence */ /* set interrupt persistence */
ret = i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS, if (i2c_reg_update_byte(drv_data->i2c, ISL29035_I2C_ADDRESS,
ISL29035_COMMAND_I_REG, ISL29035_COMMAND_I_REG,
ISL29035_INT_PRST_MASK, ISL29035_INT_PRST_MASK,
ISL29035_INT_PRST_BITS); ISL29035_INT_PRST_BITS) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to set interrupt persistence cycles."); SYS_LOG_DBG("Failed to set interrupt persistence cycles.");
return -EIO; return -EIO;
} }
@ -180,8 +178,7 @@ int isl29035_init_interrupt(struct device *dev)
isl29035_gpio_callback, isl29035_gpio_callback,
BIT(CONFIG_ISL29035_GPIO_PIN_NUM)); BIT(CONFIG_ISL29035_GPIO_PIN_NUM));
ret = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (ret < 0) {
SYS_LOG_DBG("Failed to set gpio callback."); SYS_LOG_DBG("Failed to set gpio callback.");
return -EIO; return -EIO;
} }

22
drivers/sensor/sensor_lis3dh.c
View file

@ -63,7 +63,6 @@ int lis3dh_sample_fetch(struct device *dev, enum sensor_channel chan)
{ {
struct lis3dh_data *drv_data = dev->driver_data; struct lis3dh_data *drv_data = dev->driver_data;
uint8_t buf[6]; uint8_t buf[6];
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_ACCEL_ANY); __ASSERT(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_ACCEL_ANY);
@ -71,9 +70,8 @@ int lis3dh_sample_fetch(struct device *dev, enum sensor_channel chan)
* since all accel data register addresses are consecutive, * since all accel data register addresses are consecutive,
* a burst read can be used to read all the samples * a burst read can be used to read all the samples
*/ */
rc = i2c_burst_read(drv_data->i2c, LIS3DH_I2C_ADDRESS, if (i2c_burst_read(drv_data->i2c, LIS3DH_I2C_ADDRESS,
LIS3DH_REG_ACCEL_X_LSB, buf, 6); LIS3DH_REG_ACCEL_X_LSB, buf, 6) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not read accel axis data"); SYS_LOG_DBG("Could not read accel axis data");
return -EIO; return -EIO;
} }
@ -96,7 +94,6 @@ static struct sensor_driver_api lis3dh_driver_api = {
int lis3dh_init(struct device *dev) int lis3dh_init(struct device *dev)
{ {
struct lis3dh_data *drv_data = dev->driver_data; struct lis3dh_data *drv_data = dev->driver_data;
int rc;
drv_data->i2c = device_get_binding(CONFIG_LIS3DH_I2C_MASTER_DEV_NAME); drv_data->i2c = device_get_binding(CONFIG_LIS3DH_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) { if (drv_data->i2c == NULL) {
@ -106,24 +103,21 @@ int lis3dh_init(struct device *dev)
} }
/* enable accel measurements and set power mode and data rate */ /* enable accel measurements and set power mode and data rate */
rc = i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS,
LIS3DH_REG_CTRL1, LIS3DH_ACCEL_EN_BITS | LIS3DH_REG_CTRL1, LIS3DH_ACCEL_EN_BITS |
LIS3DH_LP_EN_BIT | LIS3DH_ODR_BITS); LIS3DH_LP_EN_BIT | LIS3DH_ODR_BITS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to configure chip."); SYS_LOG_DBG("Failed to configure chip.");
} }
/* set full scale range */ /* set full scale range */
rc = i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS,
LIS3DH_REG_CTRL4, LIS3DH_FS_BITS); LIS3DH_REG_CTRL4, LIS3DH_FS_BITS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to set full scale range."); SYS_LOG_DBG("Failed to set full scale range.");
return -EIO; return -EIO;
} }
#ifdef CONFIG_LIS3DH_TRIGGER #ifdef CONFIG_LIS3DH_TRIGGER
rc = lis3dh_init_interrupt(dev); if (lis3dh_init_interrupt(dev) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to initialize interrupts."); SYS_LOG_DBG("Failed to initialize interrupts.");
return -EIO; return -EIO;
} }

12
drivers/sensor/sensor_lis3dh_trigger.c
View file

@ -103,7 +103,6 @@ static void lis3dh_work_cb(struct nano_work *work)
int lis3dh_init_interrupt(struct device *dev) int lis3dh_init_interrupt(struct device *dev)
{ {
struct lis3dh_data *drv_data = dev->driver_data; struct lis3dh_data *drv_data = dev->driver_data;
int rc;
/* setup data ready gpio interrupt */ /* setup data ready gpio interrupt */
drv_data->gpio = device_get_binding(CONFIG_LIS3DH_GPIO_DEV_NAME); drv_data->gpio = device_get_binding(CONFIG_LIS3DH_GPIO_DEV_NAME);
@ -121,23 +120,20 @@ int lis3dh_init_interrupt(struct device *dev)
lis3dh_gpio_callback, lis3dh_gpio_callback,
BIT(CONFIG_LIS3DH_GPIO_PIN_NUM)); BIT(CONFIG_LIS3DH_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not set gpio callback"); SYS_LOG_DBG("Could not set gpio callback");
return -EIO; return -EIO;
} }
/* clear data ready interrupt line by reading sample data */ /* clear data ready interrupt line by reading sample data */
rc = lis3dh_sample_fetch(dev, SENSOR_CHAN_ALL); if (lis3dh_sample_fetch(dev, SENSOR_CHAN_ALL) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Could not clear data ready interrupt line."); SYS_LOG_DBG("Could not clear data ready interrupt line.");
return -EIO; return -EIO;
} }
/* enable data ready interrupt on INT1 line */ /* enable data ready interrupt on INT1 line */
rc = i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS, if (i2c_reg_write_byte(drv_data->i2c, LIS3DH_I2C_ADDRESS,
LIS3DH_REG_CTRL3, LIS3DH_EN_DRDY1_INT1); LIS3DH_REG_CTRL3, LIS3DH_EN_DRDY1_INT1) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to enable data ready interrupt."); SYS_LOG_DBG("Failed to enable data ready interrupt.");
return -EIO; return -EIO;
} }

8
drivers/sensor/sensor_mcp9808.c
View file

@ -29,8 +29,6 @@
int mcp9808_reg_read(struct mcp9808_data *data, uint8_t reg, uint16_t *val) int mcp9808_reg_read(struct mcp9808_data *data, uint8_t reg, uint16_t *val)
{ {
int ret;
struct i2c_msg msgs[2] = { struct i2c_msg msgs[2] = {
{ {
.buf = &reg, .buf = &reg,
@ -44,9 +42,9 @@ int mcp9808_reg_read(struct mcp9808_data *data, uint8_t reg, uint16_t *val)
}, },
}; };
ret = i2c_transfer(data->i2c_master, msgs, 2, data->i2c_slave_addr); if (i2c_transfer(data->i2c_master, msgs, 2, data->i2c_slave_addr)
if (ret) { < 0) {
return ret; return -EIO;
} }
*val = sys_be16_to_cpu(*val); *val = sys_be16_to_cpu(*val);

6
drivers/sensor/sensor_mcp9808_trigger.c
View file

@ -46,12 +46,10 @@ static int mcp9808_reg_write(struct mcp9808_data *data, uint8_t reg, uint16_t va
static int mcp9808_reg_update(struct mcp9808_data *data, uint8_t reg, static int mcp9808_reg_update(struct mcp9808_data *data, uint8_t reg,
uint16_t mask, uint16_t val) uint16_t mask, uint16_t val)
{ {
int ret;
uint16_t old_val, new_val; uint16_t old_val, new_val;
ret = mcp9808_reg_read(data, reg, &old_val); if (mcp9808_reg_read(data, reg, &old_val) < 0) {
if (ret) { return -EIO;
return ret;
} }
new_val = old_val & ~mask; new_val = old_val & ~mask;

17
drivers/sensor/sensor_sht3xd.c
View file

@ -75,7 +75,6 @@ static int sht3xd_sample_fetch(struct device *dev, enum sensor_channel chan)
struct sht3xd_data *drv_data = dev->driver_data; struct sht3xd_data *drv_data = dev->driver_data;
uint8_t rx_buf[6]; uint8_t rx_buf[6];
uint16_t t_sample, rh_sample; uint16_t t_sample, rh_sample;
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL); __ASSERT(chan == SENSOR_CHAN_ALL);
@ -97,8 +96,7 @@ static int sht3xd_sample_fetch(struct device *dev, enum sensor_channel chan)
}, },
}; };
rc = i2c_transfer(drv_data->i2c, msgs, 2, SHT3XD_I2C_ADDRESS); if (i2c_transfer(drv_data->i2c, msgs, 2, SHT3XD_I2C_ADDRESS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to read data sample!"); SYS_LOG_DBG("Failed to read data sample!");
return -EIO; return -EIO;
} }
@ -163,7 +161,6 @@ static struct sensor_driver_api sht3xd_driver_api = {
static int sht3xd_init(struct device *dev) static int sht3xd_init(struct device *dev)
{ {
struct sht3xd_data *drv_data = dev->driver_data; struct sht3xd_data *drv_data = dev->driver_data;
int rc;
drv_data->i2c = device_get_binding(CONFIG_SHT3XD_I2C_MASTER_DEV_NAME); drv_data->i2c = device_get_binding(CONFIG_SHT3XD_I2C_MASTER_DEV_NAME);
if (drv_data->i2c == NULL) { if (drv_data->i2c == NULL) {
@ -173,8 +170,7 @@ static int sht3xd_init(struct device *dev)
} }
/* clear status register */ /* clear status register */
rc = sht3xd_write_command(drv_data, SHT3XD_CMD_CLEAR_STATUS); if (sht3xd_write_command(drv_data, SHT3XD_CMD_CLEAR_STATUS) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to clear status register!"); SYS_LOG_DBG("Failed to clear status register!");
return -EIO; return -EIO;
} }
@ -182,9 +178,9 @@ static int sht3xd_init(struct device *dev)
sys_thread_busy_wait(SHT3XD_CLEAR_STATUS_WAIT_USEC); sys_thread_busy_wait(SHT3XD_CLEAR_STATUS_WAIT_USEC);
/* set periodic measurement mode */ /* set periodic measurement mode */
rc = sht3xd_write_command(drv_data, if (sht3xd_write_command(drv_data,
sht3xd_measure_cmd[SHT3XD_MPS_IDX][SHT3XD_REPEATABILITY_IDX]); sht3xd_measure_cmd[SHT3XD_MPS_IDX][SHT3XD_REPEATABILITY_IDX])
if (rc < 0) { < 0) {
SYS_LOG_DBG("Failed to set measurement mode!"); SYS_LOG_DBG("Failed to set measurement mode!");
return -EIO; return -EIO;
} }
@ -192,8 +188,7 @@ static int sht3xd_init(struct device *dev)
sys_thread_busy_wait(sht3xd_measure_wait[SHT3XD_REPEATABILITY_IDX]); sys_thread_busy_wait(sht3xd_measure_wait[SHT3XD_REPEATABILITY_IDX]);
#ifdef CONFIG_SHT3XD_TRIGGER #ifdef CONFIG_SHT3XD_TRIGGER
rc = sht3xd_init_interrupt(dev); if (sht3xd_init_interrupt(dev) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to initialize interrupt"); SYS_LOG_DBG("Failed to initialize interrupt");
return -EIO; return -EIO;
} }

19
drivers/sensor/sensor_sht3xd_trigger.c
View file

@ -182,7 +182,6 @@ int sht3xd_trigger_set(struct device *dev,
int sht3xd_init_interrupt(struct device *dev) int sht3xd_init_interrupt(struct device *dev)
{ {
struct sht3xd_data *drv_data = dev->driver_data; struct sht3xd_data *drv_data = dev->driver_data;
int rc;
drv_data->t_low = 0; drv_data->t_low = 0;
drv_data->rh_low = 0; drv_data->rh_low = 0;
@ -190,27 +189,24 @@ int sht3xd_init_interrupt(struct device *dev)
drv_data->rh_high = 0xFFFF; drv_data->rh_high = 0xFFFF;
/* set alert thresholds to match reamsurement ranges */ /* set alert thresholds to match reamsurement ranges */
rc = sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_HIGH_SET, 0xFFFF); if (sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_HIGH_SET, 0xFFFF)
if (rc < 0) { < 0) {
SYS_LOG_DBG("Failed to write threshold high set value!"); SYS_LOG_DBG("Failed to write threshold high set value!");
return -EIO; return -EIO;
} }
rc = sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_HIGH_CLEAR, if (sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_HIGH_CLEAR,
0xFFFF); 0xFFFF) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to write threshold high clear value!"); SYS_LOG_DBG("Failed to write threshold high clear value!");
return -EIO; return -EIO;
} }
rc = sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_LOW_SET, 0); if (sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_LOW_SET, 0) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to write threshold low set value!"); SYS_LOG_DBG("Failed to write threshold low set value!");
return -EIO; return -EIO;
} }
rc = sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_LOW_SET, 0); if (sht3xd_write_reg(drv_data, SHT3XD_CMD_WRITE_TH_LOW_SET, 0) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to write threshold low clear value!"); SYS_LOG_DBG("Failed to write threshold low clear value!");
return -EIO; return -EIO;
} }
@ -231,8 +227,7 @@ int sht3xd_init_interrupt(struct device *dev)
sht3xd_gpio_callback, sht3xd_gpio_callback,
BIT(CONFIG_SHT3XD_GPIO_PIN_NUM)); BIT(CONFIG_SHT3XD_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to set gpio callback!"); SYS_LOG_DBG("Failed to set gpio callback!");
return -EIO; return -EIO;
} }

34
drivers/sensor/sensor_sx9500.c
View file

@ -90,29 +90,26 @@ static struct sensor_driver_api sx9500_api_funcs = {
static int sx9500_init_chip(struct device *dev) static int sx9500_init_chip(struct device *dev)
{ {
struct sx9500_data *data = (struct sx9500_data *) dev->driver_data; struct sx9500_data *data = (struct sx9500_data *) dev->driver_data;
int ret;
uint8_t val; uint8_t val;
ret = i2c_write(data->i2c_master, sx9500_reg_defaults, if (i2c_write(data->i2c_master, sx9500_reg_defaults,
sizeof(sx9500_reg_defaults), data->i2c_slave_addr); sizeof(sx9500_reg_defaults), data->i2c_slave_addr)
if (ret) { < 0) {
return ret; return -EIO;
} }
/* No interrupts active. We only activate them when an /* No interrupts active. We only activate them when an
* application registers a trigger. * application registers a trigger.
*/ */
ret = i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr, if (i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr,
SX9500_REG_IRQ_MSK, 0); SX9500_REG_IRQ_MSK, 0) < 0) {
if (ret) { return -EIO;
return ret;
} }
/* Read irq source reg to clear reset status. */ /* Read irq source reg to clear reset status. */
ret = i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr, if (i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr,
SX9500_REG_IRQ_SRC, &val); SX9500_REG_IRQ_SRC, &val) < 0) {
if (ret) { return -EIO;
return ret;
} }
return i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr, return i2c_reg_write_byte(data->i2c_master, data->i2c_slave_addr,
@ -123,7 +120,6 @@ static int sx9500_init_chip(struct device *dev)
int sx9500_init(struct device *dev) int sx9500_init(struct device *dev)
{ {
struct sx9500_data *data = dev->driver_data; struct sx9500_data *data = dev->driver_data;
int ret;
data->i2c_master = device_get_binding(CONFIG_SX9500_I2C_DEV_NAME); data->i2c_master = device_get_binding(CONFIG_SX9500_I2C_DEV_NAME);
if (!data->i2c_master) { if (!data->i2c_master) {
@ -134,16 +130,14 @@ int sx9500_init(struct device *dev)
data->i2c_slave_addr = CONFIG_SX9500_I2C_ADDR; data->i2c_slave_addr = CONFIG_SX9500_I2C_ADDR;
ret = sx9500_init_chip(dev); if (sx9500_init_chip(dev) < 0) {
if (ret) {
SYS_LOG_DBG("sx9500: failed to initialize chip err %d", ret); SYS_LOG_DBG("sx9500: failed to initialize chip err %d", ret);
return ret; return -EINVAL;
} }
ret = sx9500_setup_interrupt(dev); if (sx9500_setup_interrupt(dev) < 0) {
if (ret) {
SYS_LOG_DBG("sx9500: failed to setup interrupt err %d", ret); SYS_LOG_DBG("sx9500: failed to setup interrupt err %d", ret);
return ret; return -EINVAL;
} }
dev->driver_api = &sx9500_api_funcs; dev->driver_api = &sx9500_api_funcs;

41
drivers/sensor/sensor_sx9500_trigger.c
View file

@ -32,29 +32,28 @@ int sx9500_trigger_set(struct device *dev,
sensor_trigger_handler_t handler) sensor_trigger_handler_t handler)
{ {
struct sx9500_data *data = dev->driver_data; struct sx9500_data *data = dev->driver_data;
int ret;
switch (trig->type) { switch (trig->type) {
case SENSOR_TRIG_DATA_READY: case SENSOR_TRIG_DATA_READY:
ret = i2c_reg_update_byte(data->i2c_master, if (i2c_reg_update_byte(data->i2c_master,
data->i2c_slave_addr, data->i2c_slave_addr,
SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK,
SX9500_CONV_DONE_IRQ, SX9500_CONV_DONE_IRQ,
SX9500_CONV_DONE_IRQ); SX9500_CONV_DONE_IRQ) < 0) {
if (ret) return -EIO;
return ret; }
data->handler_drdy = handler; data->handler_drdy = handler;
data->trigger_drdy = *trig; data->trigger_drdy = *trig;
break; break;
case SENSOR_TRIG_NEAR_FAR: case SENSOR_TRIG_NEAR_FAR:
ret = i2c_reg_update_byte(data->i2c_master, if (i2c_reg_update_byte(data->i2c_master,
data->i2c_slave_addr, data->i2c_slave_addr,
SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK,
SX9500_NEAR_FAR_IRQ, SX9500_NEAR_FAR_IRQ,
SX9500_NEAR_FAR_IRQ); SX9500_NEAR_FAR_IRQ) < 0) {
if (ret) return -EIO;
return ret; }
data->handler_near_far = handler; data->handler_near_far = handler;
data->trigger_near_far = *trig; data->trigger_near_far = *trig;
break; break;
@ -84,16 +83,14 @@ static void sx9500_fiber_main(int arg1, int unused)
struct device *dev = INT_TO_POINTER(arg1); struct device *dev = INT_TO_POINTER(arg1);
struct sx9500_data *data = dev->driver_data; struct sx9500_data *data = dev->driver_data;
uint8_t reg_val; uint8_t reg_val;
int ret;
ARG_UNUSED(unused); ARG_UNUSED(unused);
while (1) { while (1) {
nano_fiber_sem_take(&data->sem, TICKS_UNLIMITED); nano_fiber_sem_take(&data->sem, TICKS_UNLIMITED);
ret = i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr, if (i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr,
SX9500_REG_IRQ_SRC, &reg_val); SX9500_REG_IRQ_SRC, &reg_val) < 0) {
if (ret) {
SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret); SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret);
continue; continue;
} }
@ -126,11 +123,9 @@ static void sx9500_gpio_fiber_cb(void *arg)
struct device *dev = arg; struct device *dev = arg;
struct sx9500_data *data = dev->driver_data; struct sx9500_data *data = dev->driver_data;
uint8_t reg_val; uint8_t reg_val;
int ret;
ret = i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr, if (i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr,
SX9500_REG_IRQ_SRC, &reg_val); SX9500_REG_IRQ_SRC, &reg_val) < 0) {
if (ret) {
SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret); SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret);
return; return;
} }

8
drivers/sensor/sensor_tmp007.c
View file

@ -76,12 +76,14 @@ static int tmp007_sample_fetch(struct device *dev, enum sensor_channel chan)
{ {
struct tmp007_data *drv_data = dev->driver_data; struct tmp007_data *drv_data = dev->driver_data;
uint16_t val; uint16_t val;
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_TEMP); __ASSERT(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_TEMP);
rc = tmp007_reg_read(drv_data, TMP007_REG_TOBJ, &val); if (tmp007_reg_read(drv_data, TMP007_REG_TOBJ, &val) < 0) {
if (rc < 0 || val & TMP007_DATA_INVALID_BIT) { return -EIO;
}
if (val & TMP007_DATA_INVALID_BIT) {
return -EIO; return -EIO;
} }

9
drivers/sensor/sensor_tmp007_trigger.c
View file

@ -143,11 +143,9 @@ int tmp007_trigger_set(struct device *dev,
int tmp007_init_interrupt(struct device *dev) int tmp007_init_interrupt(struct device *dev)
{ {
struct tmp007_data *drv_data = dev->driver_data; struct tmp007_data *drv_data = dev->driver_data;
int rc;
rc = tmp007_reg_update(drv_data, TMP007_REG_CONFIG, if (tmp007_reg_update(drv_data, TMP007_REG_CONFIG,
TMP007_ALERT_EN_BIT, TMP007_ALERT_EN_BIT); TMP007_ALERT_EN_BIT, TMP007_ALERT_EN_BIT) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to enable interrupt pin!"); SYS_LOG_DBG("Failed to enable interrupt pin!");
return -EIO; return -EIO;
} }
@ -168,8 +166,7 @@ int tmp007_init_interrupt(struct device *dev)
tmp007_gpio_callback, tmp007_gpio_callback,
BIT(CONFIG_TMP007_GPIO_PIN_NUM)); BIT(CONFIG_TMP007_GPIO_PIN_NUM));
rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) {
if (rc < 0) {
SYS_LOG_DBG("Failed to set gpio callback!"); SYS_LOG_DBG("Failed to set gpio callback!");
return -EIO; return -EIO;
} }