drivers/led/is31fl3194.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * 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)
	/*
	* 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)