| /* |
| * Copyright (c) 2022 T-Mobile USA, Inc. |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "tsl2540.h" |
| #include <zephyr/logging/log.h> |
| |
| LOG_MODULE_DECLARE(tsl2540, CONFIG_SENSOR_LOG_LEVEL); |
| |
| static void tsl2540_setup_int(const struct device *dev, bool enable) |
| { |
| const struct tsl2540_config *config = dev->config; |
| gpio_flags_t flags = enable |
| ? GPIO_INT_EDGE_TO_ACTIVE |
| : GPIO_INT_DISABLE; |
| |
| gpio_pin_interrupt_configure_dt(&config->int_gpio, flags); |
| } |
| |
| static void tsl2540_handle_int(const struct device *dev) |
| { |
| struct tsl2540_data *drv_data = dev->data; |
| |
| tsl2540_setup_int(dev, false); |
| |
| #if defined(CONFIG_TSL2540_TRIGGER_OWN_THREAD) |
| k_sem_give(&drv_data->trig_sem); |
| #elif defined(CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD) |
| k_work_submit(&drv_data->work); |
| #endif |
| } |
| |
| static void tsl2540_gpio_callback(const struct device *dev, struct gpio_callback *cb, |
| uint32_t pin_mask) |
| { |
| struct tsl2540_data *data = CONTAINER_OF(cb, struct tsl2540_data, gpio_cb); |
| |
| tsl2540_handle_int(data->dev); |
| } |
| |
| static void tsl2540_process_int(const struct device *dev) |
| { |
| const struct tsl2540_config *config = dev->config; |
| struct tsl2540_data *data = dev->data; |
| uint8_t status; |
| |
| /* Read the status, cleared automatically in CFG3 */ |
| int ret = i2c_reg_read_byte_dt(&config->i2c_spec, TSL2540_REG_STATUS, &status); |
| |
| if (ret) { |
| LOG_ERR("Could not read status register (%#x), errno: %d", TSL2540_REG_STATUS, |
| ret); |
| return; |
| } |
| |
| if (BIT(7) & status) { /* ASAT */ |
| LOG_ERR("Interrupt status(%#x): %#x: ASAT", TSL2540_REG_STATUS, status); |
| } |
| |
| if (BIT(3) & status) { /* CINT */ |
| LOG_DBG("Interrupt status(%#x): %#x: CINT", TSL2540_REG_STATUS, status); |
| } |
| |
| if (BIT(4) & status) { /* AINT */ |
| LOG_DBG("Interrupt status(%#x): %#x: AINT", TSL2540_REG_STATUS, status); |
| if (data->als_handler != NULL) { |
| data->als_handler(dev, data->als_trigger); |
| } |
| } |
| |
| tsl2540_setup_int(dev, true); |
| |
| /* Check for pin that may be asserted while we were busy */ |
| int pv = gpio_pin_get_dt(&config->int_gpio); |
| |
| if (pv > 0) { |
| tsl2540_handle_int(dev); |
| } |
| } |
| |
| #ifdef CONFIG_TSL2540_TRIGGER_OWN_THREAD |
| static void tsl2540_thread_main(void *p1, void *p2, void *p3) |
| { |
| ARG_UNUSED(p2); |
| ARG_UNUSED(p3); |
| |
| struct tsl2540_data *data = p1; |
| |
| while (true) { |
| k_sem_take(&data->trig_sem, K_FOREVER); |
| tsl2540_process_int(data->dev); |
| } |
| } |
| #endif |
| |
| #ifdef CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD |
| static void tsl2540_work_handler(struct k_work *work) |
| { |
| struct tsl2540_data *data = CONTAINER_OF(work, struct tsl2540_data, work); |
| |
| tsl2540_process_int(data->dev); |
| } |
| #endif |
| |
| int tsl2540_trigger_set(const struct device *dev, const struct sensor_trigger *trig, |
| sensor_trigger_handler_t handler) |
| { |
| const struct tsl2540_config *config = dev->config; |
| struct tsl2540_data *data = dev->data; |
| int ret; |
| |
| if (trig->type != SENSOR_TRIG_THRESHOLD) { |
| LOG_ERR("Unsupported sensor trigger type: %d", trig->type); |
| return -ENOTSUP; |
| } |
| |
| if (trig->chan != SENSOR_CHAN_LIGHT) { |
| LOG_ERR("Unsupported sensor trigger channel: %d", trig->chan); |
| return -ENOTSUP; |
| } |
| |
| |
| const struct i2c_dt_spec *i2c_spec = &config->i2c_spec; |
| |
| ret = i2c_reg_update_byte_dt(i2c_spec, TSL2540_INTENAB_ADDR, |
| TSL2540_INTENAB_MASK, TSL2540_INTENAB_CONF); |
| if (ret) { |
| LOG_ERR("%#x: I/O error: %d", TSL2540_INTENAB_ADDR, ret); |
| return -EIO; |
| } |
| |
| ret = i2c_reg_update_byte_dt(i2c_spec, TSL2540_CFG3_ADDR, |
| TSL2540_CFG3_MASK, TSL2540_CFG3_CONF); |
| if (ret) { |
| LOG_ERR("%#x: I/O error: %d", TSL2540_CFG3_ADDR, ret); |
| return -EIO; |
| } |
| |
| k_sem_take(&data->sem, K_FOREVER); |
| |
| data->als_handler = handler; |
| data->als_trigger = trig; |
| |
| if (handler != NULL) { |
| tsl2540_setup_int(dev, true); |
| |
| /* Check whether already asserted */ |
| int pv = gpio_pin_get_dt(&config->int_gpio); |
| |
| if (pv > 0) { |
| tsl2540_handle_int(dev); |
| } |
| } |
| |
| k_sem_give(&data->sem); |
| |
| return ret; |
| } |
| |
| int tsl2540_trigger_init(const struct device *dev) |
| { |
| const struct tsl2540_config *config = dev->config; |
| struct tsl2540_data *data = dev->data; |
| int rc; |
| |
| /* Check device is defined */ |
| if (config->int_gpio.port == NULL) { |
| LOG_ERR("int-gpios is not defined in the device tree."); |
| return -EINVAL; |
| } |
| |
| /* Get the GPIO device */ |
| if (!gpio_is_ready_dt(&config->int_gpio)) { |
| LOG_ERR("%s: gpio controller %s not ready", dev->name, config->int_gpio.port->name); |
| return -ENODEV; |
| } |
| |
| rc = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT); |
| if (rc < 0) { |
| return rc; |
| } |
| |
| gpio_init_callback(&data->gpio_cb, tsl2540_gpio_callback, BIT(config->int_gpio.pin)); |
| |
| if (gpio_add_callback(config->int_gpio.port, &data->gpio_cb) < 0) { |
| LOG_ERR("Failed to set gpio callback!"); |
| return -EIO; |
| } |
| |
| data->dev = dev; |
| |
| #if defined(CONFIG_TSL2540_TRIGGER_OWN_THREAD) |
| k_sem_init(&data->trig_sem, 0, K_SEM_MAX_LIMIT); |
| k_thread_create(&data->thread, data->thread_stack, CONFIG_TSL2540_THREAD_STACK_SIZE, |
| tsl2540_thread_main, data, NULL, NULL, |
| K_PRIO_COOP(CONFIG_TSL2540_THREAD_PRIORITY), 0, K_NO_WAIT); |
| k_thread_name_set(&data->thread, "TSL2540 trigger"); |
| #elif defined(CONFIG_TSL2540_TRIGGER_GLOBAL_THREAD) |
| data->work.handler = tsl2540_work_handler; |
| #endif |
| |
| return 0; |
| } |