zephyr/drivers/led/is31fl3194.c

360 lines
8.4 KiB
C
Raw Normal View History

/*
* Copyright (c) 2024 Arduino SA
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT issi_is31fl3194
/**
* @file
* @brief IS31FL3194 LED driver
*
* The IS31FL3194 is a 3-channel LED driver that communicates over I2C.
*/
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/led.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/dt-bindings/led/led.h>
LOG_MODULE_REGISTER(is31fl3194, CONFIG_LED_LOG_LEVEL);
#define IS31FL3194_PROD_ID_REG 0x00
#define IS31FL3194_CONF_REG 0x01
#define IS31FL3194_CURRENT_REG 0x03
#define IS31FL3194_OUT1_REG 0x10
#define IS31FL3194_OUT2_REG 0x21
#define IS31FL3194_OUT3_REG 0x32
#define IS31FL3194_UPDATE_REG 0x40
#define IS31FL3194_PROD_ID_VAL 0xce
#define IS31FL3194_CONF_ENABLE 0x01
#define IS31FL3194_UPDATE_VAL 0xc5
#define IS31FL3194_CHANNEL_COUNT 3
static const uint8_t led_channels[] = {
IS31FL3194_OUT1_REG,
IS31FL3194_OUT2_REG,
IS31FL3194_OUT3_REG
};
struct is31fl3194_config {
struct i2c_dt_spec bus;
uint8_t num_leds;
const struct led_info *led_infos;
const uint8_t *current_limits;
};
static const struct led_info *is31fl3194_led_to_info(const struct is31fl3194_config *config,
uint32_t led)
{
if (led < config->num_leds) {
return &config->led_infos[led];
}
return NULL;
}
static int is31fl3194_get_info(const struct device *dev,
uint32_t led,
const struct led_info **info_out)
{
const struct is31fl3194_config *config = dev->config;
const struct led_info *info = is31fl3194_led_to_info(config, led);
if (info == NULL) {
return -EINVAL;
}
*info_out = info;
return 0;
}
static int is31fl3194_set_color(const struct device *dev, uint32_t led, uint8_t num_colors,
const uint8_t *color)
{
const struct is31fl3194_config *config = dev->config;
const struct led_info *info = is31fl3194_led_to_info(config, led);
int ret;
if (info == NULL) {
return -ENODEV;
}
if (info->num_colors != 3) {
return -ENOTSUP;
}
if (num_colors != 3) {
return -EINVAL;
}
for (int i = 0; i < 3; i++) {
uint8_t value;
switch (info->color_mapping[i]) {
case LED_COLOR_ID_RED:
value = color[0];
break;
case LED_COLOR_ID_GREEN:
value = color[1];
break;
case LED_COLOR_ID_BLUE:
value = color[2];
break;
default:
/* unreachable: mapping already tested in is31fl3194_check_config */
continue;
}
ret = i2c_reg_write_byte_dt(&config->bus, led_channels[i], value);
if (ret != 0) {
break;
}
}
if (ret == 0) {
ret = i2c_reg_write_byte_dt(&config->bus,
IS31FL3194_UPDATE_REG,
IS31FL3194_UPDATE_VAL);
}
if (ret != 0) {
LOG_ERR("%s: LED write failed: %d", dev->name, ret);
}
return ret;
}
static int is31fl3194_set_brightness(const struct device *dev, uint32_t led, uint8_t value)
{
const struct is31fl3194_config *config = dev->config;
const struct led_info *info = is31fl3194_led_to_info(config, led);
int ret = 0;
if (info == NULL) {
return -ENODEV;
}
if (info->num_colors != 1) {
return -ENOTSUP;
}
if (value > 100) {
return -EINVAL;
}
/* Rescale 0..100 to 0..255 */
value = value * 255 / 100;
ret = i2c_reg_write_byte_dt(&config->bus, led_channels[led], value);
if (ret == 0) {
ret = i2c_reg_write_byte_dt(&config->bus,
IS31FL3194_UPDATE_REG,
IS31FL3194_UPDATE_VAL);
}
if (ret != 0) {
LOG_ERR("%s: LED write failed", dev->name);
}
return ret;
}
static inline int is31fl3194_led_on(const struct device *dev, uint32_t led)
{
return is31fl3194_set_brightness(dev, led, 100);
}
static inline int is31fl3194_led_off(const struct device *dev, uint32_t led)
{
return is31fl3194_set_brightness(dev, led, 0);
}
/*
* Counts red, green, blue channels; returns true if color_id is valid
* and no more than one channel maps to the same color
*/
static bool is31fl3194_count_colors(const struct device *dev,
uint8_t color_id, uint8_t *rgb_counts)
{
bool ret = false;
switch (color_id) {
case LED_COLOR_ID_RED:
ret = (++rgb_counts[0] == 1);
break;
case LED_COLOR_ID_GREEN:
ret = (++rgb_counts[1] == 1);
break;
case LED_COLOR_ID_BLUE:
ret = (++rgb_counts[2] == 1);
break;
}
if (!ret) {
LOG_ERR("%s: invalid color %d (duplicate or not RGB)",
dev->name, color_id);
}
return ret;
}
static int is31fl3194_check_config(const struct device *dev)
{
const struct is31fl3194_config *config = dev->config;
const struct led_info *info;
uint8_t rgb_counts[3] = { 0 };
uint8_t i;
switch (config->num_leds) {
case 1:
/* check that it is a three-channel LED */
info = &config->led_infos[0];
if (info->num_colors != 3) {
LOG_ERR("%s: invalid number of colors %d "
"(must be 3 for RGB LED)",
dev->name, info->num_colors);
return -EINVAL;
}
for (i = 0; i < 3; i++) {
if (!is31fl3194_count_colors(dev, info->color_mapping[i], rgb_counts)) {
return -EINVAL;
}
}
break;
case 3:
/* check that each LED is single-color */
for (i = 0; i < 3; i++) {
info = &config->led_infos[i];
if (info->num_colors != 1) {
LOG_ERR("%s: invalid number of colors %d "
"(must be 1 when defining multiple LEDs)",
dev->name, info->num_colors);
return -EINVAL;
}
if (!is31fl3194_count_colors(dev, info->color_mapping[0], rgb_counts)) {
return -EINVAL;
}
}
break;
default:
LOG_ERR("%s: invalid number of LEDs %d (must be 1 or 3)",
dev->name, config->num_leds);
return -EINVAL;
}
return 0;
}
static int is31fl3194_init(const struct device *dev)
{
const struct is31fl3194_config *config = dev->config;
const struct led_info *info = NULL;
int i, ret;
uint8_t prod_id, band;
uint8_t current_reg = 0;
ret = is31fl3194_check_config(dev);
if (ret != 0) {
return ret;
}
if (!i2c_is_ready_dt(&config->bus)) {
LOG_ERR("%s: I2C device not ready", dev->name);
return -ENODEV;
}
ret = i2c_reg_read_byte_dt(&config->bus, IS31FL3194_PROD_ID_REG, &prod_id);
if (ret != 0) {
LOG_ERR("%s: failed to read product ID", dev->name);
return ret;
}
if (prod_id != IS31FL3194_PROD_ID_VAL) {
LOG_ERR("%s: invalid product ID 0x%02x (expected 0x%02x)", dev->name, prod_id,
IS31FL3194_PROD_ID_VAL);
return -ENODEV;
}
/* calc current limit register value */
info = &config->led_infos[0];
if (info->num_colors == IS31FL3194_CHANNEL_COUNT) {
/* one RGB LED: set all channels to the same current limit */
band = (config->current_limits[0] / 10) - 1;
for (i = 0; i < IS31FL3194_CHANNEL_COUNT; i++) {
current_reg |= band << (2 * i);
}
} else {
/* single-channel LEDs: independent limits */
for (i = 0; i < config->num_leds; i++) {
band = (config->current_limits[i] / 10) - 1;
current_reg |= band << (2 * i);
}
}
ret = i2c_reg_write_byte_dt(&config->bus, IS31FL3194_CURRENT_REG, current_reg);
if (ret != 0) {
LOG_ERR("%s: failed to set current limit", dev->name);
return ret;
}
/* enable device */
return i2c_reg_write_byte_dt(&config->bus, IS31FL3194_CONF_REG, IS31FL3194_CONF_ENABLE);
}
static const struct led_driver_api is31fl3194_led_api = {
.set_brightness = is31fl3194_set_brightness,
.on = is31fl3194_led_on,
.off = is31fl3194_led_off,
.get_info = is31fl3194_get_info,
.set_color = is31fl3194_set_color,
};
#define COLOR_MAPPING(led_node_id) \
static const uint8_t color_mapping_##led_node_id[] = \
DT_PROP(led_node_id, color_mapping);
#define LED_INFO(led_node_id) \
{ \
.label = DT_PROP(led_node_id, label), \
.num_colors = DT_PROP_LEN(led_node_id, color_mapping), \
.color_mapping = color_mapping_##led_node_id, \
},
#define LED_CURRENT(led_node_id) \
DT_PROP(led_node_id, current_limit),
#define IS31FL3194_DEFINE(id) \
\
DT_INST_FOREACH_CHILD(id, COLOR_MAPPING) \
\
static const struct led_info is31fl3194_leds_##id[] = \
{ DT_INST_FOREACH_CHILD(id, LED_INFO) }; \
static const uint8_t is31fl3194_currents_##id[] = \
{ DT_INST_FOREACH_CHILD(id, LED_CURRENT) }; \
BUILD_ASSERT(ARRAY_SIZE(is31fl3194_leds_##id) > 0, \
"No LEDs defined for " #id); \
\
static const struct is31fl3194_config is31fl3194_config_##id = { \
.bus = I2C_DT_SPEC_INST_GET(id), \
.num_leds = ARRAY_SIZE(is31fl3194_leds_##id), \
.led_infos = is31fl3194_leds_##id, \
.current_limits = is31fl3194_currents_##id, \
}; \
DEVICE_DT_INST_DEFINE(id, &is31fl3194_init, NULL, NULL, \
&is31fl3194_config_##id, POST_KERNEL, \
CONFIG_LED_INIT_PRIORITY, &is31fl3194_led_api);
DT_INST_FOREACH_STATUS_OKAY(IS31FL3194_DEFINE)