diff --git a/drivers/sensor/ti/tmp11x/CMakeLists.txt b/drivers/sensor/ti/tmp11x/CMakeLists.txt index 48d083d2b1b8a..6a90273100670 100644 --- a/drivers/sensor/ti/tmp11x/CMakeLists.txt +++ b/drivers/sensor/ti/tmp11x/CMakeLists.txt @@ -3,3 +3,4 @@ zephyr_library() zephyr_library_sources(tmp11x.c) +zephyr_library_sources_ifdef(CONFIG_TMP11X_TRIGGER tmp11x_trigger.c) diff --git a/drivers/sensor/ti/tmp11x/Kconfig b/drivers/sensor/ti/tmp11x/Kconfig index e66ea0a7a543b..10d5ad7139ff8 100644 --- a/drivers/sensor/ti/tmp11x/Kconfig +++ b/drivers/sensor/ti/tmp11x/Kconfig @@ -10,3 +10,12 @@ config TMP11X select I2C help Enable driver for TMP116, TMP117 and TMP119 temperature sensors. + +if TMP11X + +module = TMP11X +thread_priority = 10 +thread_stack_size = 1024 +source "drivers/sensor/Kconfig.trigger_template" + +endif diff --git a/drivers/sensor/ti/tmp11x/tmp11x.c b/drivers/sensor/ti/tmp11x/tmp11x.c index 20dee440068a2..0e7bdd92ed1c3 100644 --- a/drivers/sensor/ti/tmp11x/tmp11x.c +++ b/drivers/sensor/ti/tmp11x/tmp11x.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -25,8 +26,7 @@ LOG_MODULE_REGISTER(TMP11X, CONFIG_SENSOR_LOG_LEVEL); -static int tmp11x_reg_read(const struct device *dev, uint8_t reg, - uint16_t *val) +int tmp11x_reg_read(const struct device *dev, uint8_t reg, uint16_t *val) { const struct tmp11x_dev_config *cfg = dev->config; @@ -40,8 +40,7 @@ static int tmp11x_reg_read(const struct device *dev, uint8_t reg, return 0; } -static int tmp11x_reg_write(const struct device *dev, uint8_t reg, - uint16_t val) +int tmp11x_reg_write(const struct device *dev, uint8_t reg, uint16_t val) { const struct tmp11x_dev_config *cfg = dev->config; uint8_t tx_buf[3] = {reg, val >> 8, val & 0xFF}; @@ -71,6 +70,31 @@ static inline bool tmp11x_is_offset_supported(const struct tmp11x_data *drv_data return drv_data->id == TMP117_DEVICE_ID || drv_data->id == TMP119_DEVICE_ID; } +/** + * @brief Convert sensor_value temperature to TMP11X register format + * + * This function converts a temperature from sensor_value format (val1 in degrees C, + * val2 in micro-degrees C) to the TMP11X register format. It uses 64-bit arithmetic + * to prevent overflow and clamps the result to the valid int16_t range. + * + * @param val Pointer to sensor_value containing temperature + * @return Temperature value in TMP11X register format (int16_t) + */ +static inline int16_t tmp11x_sensor_value_to_reg_format(const struct sensor_value *val) +{ + int64_t temp_micro = ((int64_t)val->val1 * 1000000) + val->val2; + int64_t temp_scaled = (temp_micro * 10) / TMP11X_RESOLUTION; + + /* Clamp to int16_t range */ + if (temp_scaled > INT16_MAX) { + return INT16_MAX; + } else if (temp_scaled < INT16_MIN) { + return INT16_MIN; + } else { + return (int16_t)temp_scaled; + } +} + static bool check_eeprom_bounds(const struct device *dev, off_t offset, size_t len) { @@ -310,8 +334,7 @@ static int tmp11x_attr_set(const struct device *dev, /* * The offset is encoded into the temperature register format. */ - value = (((val->val1) * 10000000) + ((val->val2) * 10)) - / (int32_t)TMP11X_RESOLUTION; + value = tmp11x_sensor_value_to_reg_format(val); return tmp11x_reg_write(dev, TMP117_REG_TEMP_OFFSET, value); @@ -347,6 +370,41 @@ static int tmp11x_attr_set(const struct device *dev, case SENSOR_ATTR_TMP11X_ONE_SHOT_MODE: return tmp11x_write_config(dev, TMP11X_CFGR_MODE, TMP11X_MODE_ONE_SHOT); +#ifdef CONFIG_TMP11X_TRIGGER + case SENSOR_ATTR_TMP11X_ALERT_PIN_POLARITY: + if (val->val1 == TMP11X_ALERT_PIN_ACTIVE_HIGH) { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_PIN_POL, + TMP11X_CFGR_ALERT_PIN_POL); + } else { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_PIN_POL, 0); + } + + case SENSOR_ATTR_TMP11X_ALERT_MODE: + if (val->val1 == TMP11X_ALERT_THERM_MODE) { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_MODE, + TMP11X_CFGR_ALERT_MODE); + } else { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_MODE, 0); + } + + case SENSOR_ATTR_UPPER_THRESH: + /* Convert temperature to register format */ + value = tmp11x_sensor_value_to_reg_format(val); + return tmp11x_reg_write(dev, TMP11X_REG_HIGH_LIM, value); + + case SENSOR_ATTR_LOWER_THRESH: + /* Convert temperature to register format */ + value = tmp11x_sensor_value_to_reg_format(val); + return tmp11x_reg_write(dev, TMP11X_REG_LOW_LIM, value); + case SENSOR_ATTR_TMP11X_ALERT_PIN_SELECT: + if (val->val1 == TMP11X_ALERT_PIN_ALERT_SEL) { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_DR_SEL, 0); + } else { + return tmp11x_write_config(dev, TMP11X_CFGR_ALERT_DR_SEL, + TMP11X_CFGR_ALERT_DR_SEL); + } +#endif /* CONFIG_TMP11X_TRIGGER */ + default: return -ENOTSUP; } @@ -385,6 +443,25 @@ static int tmp11x_attr_get(const struct device *dev, enum sensor_channel chan, } return rc; + +#ifdef CONFIG_TMP11X_TRIGGER + case SENSOR_ATTR_UPPER_THRESH: + rc = tmp11x_reg_read(dev, TMP11X_REG_HIGH_LIM, &data); + if (rc == 0) { + tmp11x_temperature_to_sensor_value(data, val); + } + + return rc; + + case SENSOR_ATTR_LOWER_THRESH: + rc = tmp11x_reg_read(dev, TMP11X_REG_LOW_LIM, &data); + if (rc == 0) { + tmp11x_temperature_to_sensor_value(data, val); + } + + return rc; +#endif /* CONFIG_TMP11X_TRIGGER */ + default: return -ENOTSUP; } @@ -394,7 +471,10 @@ static DEVICE_API(sensor, tmp11x_driver_api) = { .attr_set = tmp11x_attr_set, .attr_get = tmp11x_attr_get, .sample_fetch = tmp11x_sample_fetch, - .channel_get = tmp11x_channel_get + .channel_get = tmp11x_channel_get, +#ifdef CONFIG_TMP11X_TRIGGER + .trigger_set = tmp11x_trigger_set, +#endif }; static int tmp11x_init(const struct device *dev) @@ -423,19 +503,86 @@ static int tmp11x_init(const struct device *dev) } rc = tmp11x_write_config(dev, TMP11X_CFGR_AVG, cfg->oversampling); + if (rc < 0) { + return rc; + } + + int8_t value = cfg->alert_pin_polarity ? TMP11X_CFGR_ALERT_PIN_POL : 0; + + rc = tmp11x_write_config(dev, TMP11X_CFGR_ALERT_PIN_POL, value); + if (rc < 0) { + return rc; + } + + value = cfg->alert_mode ? TMP11X_CFGR_ALERT_MODE : 0; + rc = tmp11x_write_config(dev, TMP11X_CFGR_ALERT_MODE, value); + if (rc < 0) { + return rc; + } + + value = cfg->alert_dr_sel ? TMP11X_CFGR_ALERT_DR_SEL : 0; + rc = tmp11x_write_config(dev, TMP11X_CFGR_ALERT_DR_SEL, value); + if (rc < 0) { + return rc; + } + +#ifdef CONFIG_TMP11X_TRIGGER + drv_data->dev = dev; + rc = tmp11x_init_interrupt(dev); + if (rc < 0) { + LOG_ERR("%s: Failed to initialize alert pin", dev->name); + return rc; + } +#endif /* CONFIG_TMP11X_TRIGGER */ return rc; } -#define DEFINE_TMP11X(_num) \ - static struct tmp11x_data tmp11x_data_##_num; \ - static const struct tmp11x_dev_config tmp11x_config_##_num = { \ - .bus = I2C_DT_SPEC_INST_GET(_num), \ - .odr = DT_INST_PROP(_num, odr), \ - .oversampling = DT_INST_PROP(_num, oversampling), \ - }; \ - SENSOR_DEVICE_DT_INST_DEFINE(_num, tmp11x_init, NULL, \ - &tmp11x_data_##_num, &tmp11x_config_##_num, POST_KERNEL, \ - CONFIG_SENSOR_INIT_PRIORITY, &tmp11x_driver_api); +#ifdef CONFIG_PM_DEVICE +BUILD_ASSERT(!DT_INST_NODE_HAS_PROP(_num, power_domains), "Driver does not support power domain"); +static int tmp11x_pm_control(const struct device *dev, enum pm_device_action action) +{ + int ret = 0; + + switch (action) { + case PM_DEVICE_ACTION_RESUME: { + const struct tmp11x_dev_config *cfg = dev->config; + + ret = tmp11x_write_config(dev, TMP11X_CFGR_CONV, cfg->odr); + if (ret < 0) { + LOG_ERR("Failed to resume TMP11X"); + } + break; + } + case PM_DEVICE_ACTION_SUSPEND: { + ret = tmp11x_write_config(dev, TMP11X_CFGR_MODE, TMP11X_MODE_SHUTDOWN); + if (ret < 0) { + LOG_ERR("Failed to suspend TMP11X"); + } + break; + } + default: + ret = -ENOTSUP; + } + + return ret; +} +#endif /* CONFIG_PM_DEVICE */ + +#define DEFINE_TMP11X(_num) \ + static struct tmp11x_data tmp11x_data_##_num; \ + static const struct tmp11x_dev_config tmp11x_config_##_num = { \ + .bus = I2C_DT_SPEC_INST_GET(_num), \ + .odr = DT_INST_PROP(_num, odr), \ + .oversampling = DT_INST_PROP(_num, oversampling), \ + .alert_pin_polarity = DT_INST_PROP(_num, alert_polarity), \ + .alert_mode = DT_INST_PROP(_num, alert_mode), \ + .alert_dr_sel = DT_INST_PROP(_num, alert_dr_sel), \ + IF_ENABLED(CONFIG_TMP11X_TRIGGER, \ + (.alert_gpio = GPIO_DT_SPEC_INST_GET_OR(_num, alert_gpios, {}),)) }; \ + PM_DEVICE_DT_INST_DEFINE(_num, tmp11x_pm_control); \ + SENSOR_DEVICE_DT_INST_DEFINE(_num, tmp11x_init, PM_DEVICE_DT_INST_GET(_num), \ + &tmp11x_data_##_num, &tmp11x_config_##_num, POST_KERNEL, \ + CONFIG_SENSOR_INIT_PRIORITY, &tmp11x_driver_api); DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMP11X) diff --git a/drivers/sensor/ti/tmp11x/tmp11x.h b/drivers/sensor/ti/tmp11x/tmp11x.h index c1e075955f2da..ede20d6a289f0 100644 --- a/drivers/sensor/ti/tmp11x/tmp11x.h +++ b/drivers/sensor/ti/tmp11x/tmp11x.h @@ -8,6 +8,8 @@ #define ZEPHYR_DRIVERS_SENSOR_TMP11X_TMP11X_H_ #include +#include +#include #define TMP11X_REG_TEMP 0x0 #define TMP11X_REG_CFGR 0x1 @@ -35,6 +37,11 @@ #define TMP11X_EEPROM_UL_UNLOCK BIT(15) #define TMP11X_EEPROM_UL_BUSY BIT(14) +/* Alert pin configuration bits */ +#define TMP11X_CFGR_ALERT_DR_SEL BIT(2) /* ALERT pin select (1=Data ready) (0=alert) */ +#define TMP11X_CFGR_ALERT_PIN_POL BIT(3) /* Alert pin polarity */ +#define TMP11X_CFGR_ALERT_MODE BIT(4) /* Alert pin mode (1=therm, 0=alert) */ + #define TMP11X_AVG_1_SAMPLE 0 #define TMP11X_AVG_8_SAMPLES BIT(5) #define TMP11X_AVG_32_SAMPLES BIT(6) @@ -46,12 +53,42 @@ struct tmp11x_data { uint16_t sample; uint16_t id; +#ifdef CONFIG_TMP11X_TRIGGER + const struct device *dev; + struct gpio_callback alert_cb; + sensor_trigger_handler_t alert_handler; + const struct sensor_trigger *alert_trigger; + +#if defined(CONFIG_TMP11X_TRIGGER_OWN_THREAD) + K_KERNEL_STACK_MEMBER(thread_stack, CONFIG_TMP11X_THREAD_STACK_SIZE); + struct k_thread thread; + struct k_sem gpio_sem; +#elif defined(CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD) + struct k_work work; +#endif /* CONFIG_TMP11X_TRIGGER_OWN_THREAD */ +#endif /* CONFIG_TMP11X_TRIGGER */ }; struct tmp11x_dev_config { struct i2c_dt_spec bus; uint16_t odr; uint16_t oversampling; + bool alert_pin_polarity; + bool alert_mode; + bool alert_dr_sel; +#ifdef CONFIG_TMP11X_TRIGGER + struct gpio_dt_spec alert_gpio; +#endif }; +/* Function declarations */ +int tmp11x_write_config(const struct device *dev, uint16_t mask, uint16_t conf); +int tmp11x_reg_read(const struct device *dev, uint8_t reg, uint16_t *val); + +#ifdef CONFIG_TMP11X_TRIGGER +int tmp11x_trigger_set(const struct device *dev, const struct sensor_trigger *trig, + sensor_trigger_handler_t handler); +int tmp11x_init_interrupt(const struct device *dev); +#endif + #endif /* ZEPHYR_DRIVERS_SENSOR_TMP11X_TMP11X_H_ */ diff --git a/drivers/sensor/ti/tmp11x/tmp11x_trigger.c b/drivers/sensor/ti/tmp11x/tmp11x_trigger.c new file mode 100644 index 0000000000000..6076dee7037ff --- /dev/null +++ b/drivers/sensor/ti/tmp11x/tmp11x_trigger.c @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2025 Tobias Meyer + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT ti_tmp11x + +#include +#include +#include +#include + +#include "tmp11x.h" + +LOG_MODULE_DECLARE(TMP11X, CONFIG_SENSOR_LOG_LEVEL); + +/** + * tmp11x_trigger_set - link external trigger to threshold event + */ +int tmp11x_trigger_set(const struct device *dev, + const struct sensor_trigger *trig, + sensor_trigger_handler_t handler) +{ + struct tmp11x_data *data = dev->data; + const struct tmp11x_dev_config *config = dev->config; + + if (!config->alert_gpio.port) { + return -ENOTSUP; + } + + if (trig->chan != SENSOR_CHAN_ALL && + trig->chan != SENSOR_CHAN_AMBIENT_TEMP) { + LOG_ERR("Unsupported sensor trigger channel %d", trig->chan); + return -ENOTSUP; + } + + if (trig->type != SENSOR_TRIG_THRESHOLD) { + LOG_ERR("Unsupported sensor trigger type %d", trig->type); + return -ENOTSUP; + } + + data->alert_handler = handler; + data->alert_trigger = trig; + + return 0; +} + +/** + * tmp11x_handle_interrupt - handle the alert event + * read status and call handler if registered + */ +static void tmp11x_handle_interrupt(const struct device *dev) +{ + struct tmp11x_data *data = dev->data; + const struct tmp11x_dev_config *cfg = dev->config; + uint16_t config_reg; + int ret; + + /* Read configuration register to check alert status */ + ret = tmp11x_reg_read(dev, TMP11X_REG_CFGR, &config_reg); + if (ret < 0) { + LOG_ERR("Failed to read config register: %d", ret); + goto re_enable; + } + + /* Call the user's alert handler if registered */ + if (data->alert_handler != NULL) { + data->alert_handler(dev, data->alert_trigger); + } + +re_enable: + /* Re-enable interrupt - TMP11X alert pin is level-triggered */ + gpio_pin_interrupt_configure_dt(&cfg->alert_gpio, GPIO_INT_LEVEL_ACTIVE); +} + +static void tmp11x_gpio_callback(const struct device *dev, + struct gpio_callback *cb, uint32_t pins) +{ + struct tmp11x_data *data = CONTAINER_OF(cb, struct tmp11x_data, alert_cb); + const struct tmp11x_dev_config *cfg = data->dev->config; + + ARG_UNUSED(pins); + + /* Disable interrupt to avoid retriggering */ + gpio_pin_interrupt_configure_dt(&cfg->alert_gpio, GPIO_INT_DISABLE); + +#if defined(CONFIG_TMP11X_TRIGGER_OWN_THREAD) + k_sem_give(&data->gpio_sem); +#elif defined(CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD) + k_work_submit(&data->work); +#endif /* CONFIG_TMP11X_TRIGGER_OWN_THREAD */ +} + +#ifdef CONFIG_TMP11X_TRIGGER_OWN_THREAD +static void tmp11x_thread(void *p1, void *p2, void *p3) +{ + ARG_UNUSED(p2); + ARG_UNUSED(p3); + + struct tmp11x_data *data = p1; + + while (1) { + k_sem_take(&data->gpio_sem, K_FOREVER); + tmp11x_handle_interrupt(data->dev); + } +} +#endif /* CONFIG_TMP11X_TRIGGER_OWN_THREAD */ + +#ifdef CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD +static void tmp11x_work_cb(struct k_work *work) +{ + struct tmp11x_data *data = CONTAINER_OF(work, struct tmp11x_data, work); + + tmp11x_handle_interrupt(data->dev); +} +#endif /* CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD */ + +int tmp11x_init_interrupt(const struct device *dev) +{ + struct tmp11x_data *data = dev->data; + const struct tmp11x_dev_config *cfg = dev->config; + int ret; + + /* Check if alert GPIO is configured in device tree */ + if (!cfg->alert_gpio.port) { + LOG_DBG("%s: Alert GPIO not configured", dev->name); + return 0; + } + + if (!gpio_is_ready_dt(&cfg->alert_gpio)) { + LOG_ERR("%s: Alert GPIO controller not ready", dev->name); + return -ENODEV; + } + +#if defined(CONFIG_TMP11X_TRIGGER_OWN_THREAD) + k_sem_init(&data->gpio_sem, 0, K_SEM_MAX_LIMIT); + + k_thread_create(&data->thread, data->thread_stack, CONFIG_TMP11X_THREAD_STACK_SIZE, + tmp11x_thread, data, NULL, NULL, K_PRIO_COOP(CONFIG_TMP11X_THREAD_PRIORITY), + 0, K_NO_WAIT); + k_thread_name_set(&data->thread, dev->name); +#elif defined(CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD) + data->work.handler = tmp11x_work_cb; +#endif /* CONFIG_TMP11X_TRIGGER_OWN_THREAD */ + + /* Configure GPIO as input */ + ret = gpio_pin_configure_dt(&cfg->alert_gpio, GPIO_INPUT); + if (ret < 0) { + LOG_ERR("%s: Failed to configure alert GPIO", dev->name); + return ret; + } + + /* Initialize GPIO callback */ + gpio_init_callback(&data->alert_cb, tmp11x_gpio_callback, BIT(cfg->alert_gpio.pin)); + + /* Add callback to GPIO controller */ + ret = gpio_add_callback(cfg->alert_gpio.port, &data->alert_cb); + if (ret < 0) { + LOG_ERR("%s: Failed to add alert GPIO callback", dev->name); + return ret; + } + /* Enable interrupt - TMP11X alert pin is level-triggered */ + ret = gpio_pin_interrupt_configure_dt(&cfg->alert_gpio, GPIO_INT_EDGE_TO_ACTIVE); + if (ret < 0) { + LOG_ERR("%s: Failed to configure alert pin interrupt", dev->name); + return ret; + } + + LOG_DBG("%s: Alert pin initialized successfully", dev->name); + return 0; +} diff --git a/dts/bindings/sensor/ti,tmp11x.yaml b/dts/bindings/sensor/ti,tmp11x.yaml index a6207360db76d..ebf1f2480656e 100644 --- a/dts/bindings/sensor/ti,tmp11x.yaml +++ b/dts/bindings/sensor/ti,tmp11x.yaml @@ -33,8 +33,30 @@ properties: description: | Set number of sample to averaging in one readout. Default is power-up configuration (8 samples). - - 0 # TMP11X_DT_OVERSAMPLING_1 - 0x20 # TMP11X_DT_OVERSAMPLING_8 - 0x40 # TMP11X_DT_OVERSAMPLING_32 - 0x60 # TMP11X_DT_OVERSAMPLING_64 + alert-polarity: + type: boolean + description: | + Set alert polarity to active high (true) or active low (false). + Default is power-up configuration (active low). + alert-mode: + type: boolean + description: | + Set alert mode to one of the following: + - 0: Alert mode (default) + - 1: Therm mode + alert-dr-sel: + type: boolean + description: | + Set alert pin mode to one of the following: + - 0: ALERT pin reflects the status of the alert flags + - 1: ALERT pin reflects the status of the data ready flag + alert-gpios: + type: phandle-array + description: | + GPIO pin used for alert/interrupt functionality. + Supported on TMP116, TMP117, and TMP119 devices. + Alert pin functionality depends on Therm/alert modus. diff --git a/include/zephyr/drivers/sensor/tmp11x.h b/include/zephyr/drivers/sensor/tmp11x.h index 10d0b24865db4..ba973d88e780e 100644 --- a/include/zephyr/drivers/sensor/tmp11x.h +++ b/include/zephyr/drivers/sensor/tmp11x.h @@ -18,8 +18,22 @@ enum sensor_attribute_tmp_11x { SENSOR_ATTR_TMP11X_SHUTDOWN_MODE, /** Turn on continuous conversion */ SENSOR_ATTR_TMP11X_CONTINUOUS_CONVERSION_MODE, + /** Configure alert pin polarity */ + SENSOR_ATTR_TMP11X_ALERT_PIN_POLARITY, + /** Configure alert mode */ + SENSOR_ATTR_TMP11X_ALERT_MODE, + /** Configure alert pin mode for alert or DR*/ + SENSOR_ATTR_TMP11X_ALERT_PIN_SELECT, }; +/* Alert pin support macros */ +#define TMP11X_ALERT_PIN_ACTIVE_LOW 0 +#define TMP11X_ALERT_PIN_ACTIVE_HIGH 1 +#define TMP11X_ALERT_ALERT_MODE 0 +#define TMP11X_ALERT_THERM_MODE 1 +#define TMP11X_ALERT_PIN_ALERT_SEL 0 +#define TMP11X_ALERT_PIN_DR_SEL 1 + #define EEPROM_TMP11X_SIZE (4 * sizeof(uint16_t)) int tmp11x_eeprom_read(const struct device *dev, off_t offset, void *data, diff --git a/tests/drivers/build_all/sensor/i2c.dtsi b/tests/drivers/build_all/sensor/i2c.dtsi index 43c1125095b6d..61fa2853c740e 100644 --- a/tests/drivers/build_all/sensor/i2c.dtsi +++ b/tests/drivers/build_all/sensor/i2c.dtsi @@ -483,6 +483,7 @@ test_i2c_tmp11x: tmp11x@47 { reg = <0x47>; odr = ; oversampling = ; + alert-gpios = <&test_gpio 0 0>; }; test_i2c_bq274xx: bq27xx@48 { diff --git a/tests/drivers/build_all/sensor/sensors_trigger_global.conf b/tests/drivers/build_all/sensor/sensors_trigger_global.conf index 4681bb2397fca..7e38af6795914 100644 --- a/tests/drivers/build_all/sensor/sensors_trigger_global.conf +++ b/tests/drivers/build_all/sensor/sensors_trigger_global.conf @@ -65,6 +65,7 @@ CONFIG_TCN75A_TRIGGER_GLOBAL_THREAD=y CONFIG_TMAG5170_TRIGGER_GLOBAL_THREAD=y CONFIG_TMD2620_TRIGGER_GLOBAL_THREAD=y CONFIG_TMP007_TRIGGER_GLOBAL_THREAD=y +CONFIG_TMP11X_TRIGGER_GLOBAL_THREAD=y CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD=y CONFIG_TSL2591_TRIGGER_GLOBAL_THREAD=y CONFIG_VCNL36825T_TRIGGER_GLOBAL_THREAD=y diff --git a/tests/drivers/build_all/sensor/sensors_trigger_none.conf b/tests/drivers/build_all/sensor/sensors_trigger_none.conf index 9ddd5d1f7fd35..37a82d60c0378 100644 --- a/tests/drivers/build_all/sensor/sensors_trigger_none.conf +++ b/tests/drivers/build_all/sensor/sensors_trigger_none.conf @@ -67,6 +67,7 @@ CONFIG_TCN75A_TRIGGER_NONE=y CONFIG_TMAG5170_TRIGGER_NONE=y CONFIG_TMD2620_TRIGGER_NONE=y CONFIG_TMP007_TRIGGER_NONE=y +CONFIG_TMP11X_TRIGGER_NONE=y CONFIG_TSL2540_TRIGGER_NONE=y CONFIG_TSL2591_TRIGGER_NONE=y CONFIG_VCNL36825T_TRIGGER_NONE=y diff --git a/tests/drivers/build_all/sensor/sensors_trigger_own.conf b/tests/drivers/build_all/sensor/sensors_trigger_own.conf index 2d501a82568f4..50b9bd1e7b6cc 100644 --- a/tests/drivers/build_all/sensor/sensors_trigger_own.conf +++ b/tests/drivers/build_all/sensor/sensors_trigger_own.conf @@ -63,6 +63,7 @@ CONFIG_SX9500_TRIGGER_OWN_THREAD=y CONFIG_TCN75A_TRIGGER_OWN_THREAD=y CONFIG_TMAG5170_TRIGGER_OWN_THREAD=y CONFIG_TMP007_TRIGGER_OWN_THREAD=y +CONFIG_TMP11X_TRIGGER_OWN_THREAD=y CONFIG_TSL2540_TRIGGER_OWN_THREAD=y CONFIG_TSL2591_TRIGGER_OWN_THREAD=y CONFIG_VCNL36825T_TRIGGER_OWN_THREAD=y