drivers/led/led-uclass.c - filogic/uboot - Gitiles

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (c) 2015 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  */

 #define LOG_CATEGORY UCLASS_LED

 #include <dm.h>
 #include <errno.h>
 #include <led.h>
 #include <dm/device-internal.h>
 #include <dm/lists.h>
 #include <dm/root.h>
 #include <dm/uclass-internal.h>
 #include <dt-bindings/leds/common.h>

 static const char * const led_colors[LED_COLOR_ID_MAX] = {
 	[LED_COLOR_ID_WHITE] = "white",
 	[LED_COLOR_ID_RED] = "red",
 	[LED_COLOR_ID_GREEN] = "green",
 	[LED_COLOR_ID_BLUE] = "blue",
 	[LED_COLOR_ID_AMBER] = "amber",
 	[LED_COLOR_ID_VIOLET] = "violet",
 	[LED_COLOR_ID_YELLOW] = "yellow",
 	[LED_COLOR_ID_IR] = "ir",
 	[LED_COLOR_ID_MULTI] = "multicolor",
 	[LED_COLOR_ID_RGB] = "rgb",
 	[LED_COLOR_ID_PURPLE] = "purple",
 	[LED_COLOR_ID_ORANGE] = "orange",
 	[LED_COLOR_ID_PINK] = "pink",
 	[LED_COLOR_ID_CYAN] = "cyan",
 	[LED_COLOR_ID_LIME] = "lime",
 };

 int led_bind_generic(struct udevice *parent, const char *driver_name)
 {
 	struct udevice *dev;
 	ofnode node;
 	int ret;

 	dev_for_each_subnode(node, parent) {
 		ret = device_bind_driver_to_node(parent, driver_name,
 						 ofnode_get_name(node),
 						 node, &dev);
 		if (ret)
 			return ret;
 	}

 	return 0;
 }

 int led_get_by_label(const char *label, struct udevice **devp)
 {
 	struct udevice *dev;
 	struct uclass *uc;
 	int ret;

 	ret = uclass_get(UCLASS_LED, &uc);
 	if (ret)
 		return ret;
 	uclass_foreach_dev(dev, uc) {
 		struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);

 		/* Ignore the top-level LED node */
 		if (uc_plat->label && !strcmp(label, uc_plat->label))
 			return uclass_get_device_tail(dev, 0, devp);
 	}

 	return -ENODEV;
 }

 int led_set_state(struct udevice *dev, enum led_state_t state)
 {
 	struct led_ops *ops = led_get_ops(dev);

 	if (!ops->set_state)
 		return -ENOSYS;

 	if (IS_ENABLED(CONFIG_LED_SW_BLINK) &&
 	    led_sw_on_state_change(dev, state))
 		return 0;

 	return ops->set_state(dev, state);
 }

 enum led_state_t led_get_state(struct udevice *dev)
 {
 	struct led_ops *ops = led_get_ops(dev);

 	if (!ops->get_state)
 		return -ENOSYS;

 	if (IS_ENABLED(CONFIG_LED_SW_BLINK) &&
 	    led_sw_is_blinking(dev))
 		return LEDST_BLINK;

 	return ops->get_state(dev);
 }

 int led_set_period(struct udevice *dev, int period_ms)
 {
 #ifdef CONFIG_LED_BLINK
 	struct led_ops *ops = led_get_ops(dev);

 	if (ops->set_period)
 		return ops->set_period(dev, period_ms);
 #endif

 	if (IS_ENABLED(CONFIG_LED_SW_BLINK))
 		return led_sw_set_period(dev, period_ms);

 	return -ENOSYS;
 }

 #ifdef CONFIG_LED_BOOT
 static int led_boot_get(struct udevice **devp, int *period_ms)
 {
 	struct led_uc_priv *priv;
 	struct uclass *uc;
 	int ret;

 	ret = uclass_get(UCLASS_LED, &uc);
 	if (ret)
 		return ret;

 	priv = uclass_get_priv(uc);
 	if (!priv->boot_led_label)
 		return -ENOENT;

 	if (period_ms)
 		*period_ms = priv->boot_led_period;

 	return led_get_by_label(priv->boot_led_label, devp);
 }

 int led_boot_on(void)
 {
 	struct udevice *dev;
 	int ret;

 	ret = led_boot_get(&dev, NULL);
 	if (ret)
 		return ret;

 	return led_set_state(dev, LEDST_ON);
 }

 int led_boot_off(void)
 {
 	struct udevice *dev;
 	int ret;

 	ret = led_boot_get(&dev, NULL);
 	if (ret)
 		return ret;

 	return led_set_state(dev, LEDST_OFF);
 }

 #if defined(CONFIG_LED_BLINK) || defined(CONFIG_LED_SW_BLINK)
 int led_boot_blink(void)
 {
 	struct udevice *dev;
 	int period_ms, ret;

 	ret = led_boot_get(&dev, &period_ms);
 	if (ret)
 		return ret;

 	ret = led_set_period(dev, period_ms);
 	if (ret) {
 		if (ret != -ENOSYS)
 			return ret;

 		/* fallback to ON with no set_period and no SW_BLINK */
 		return led_set_state(dev, LEDST_ON);
 	}

 	return led_set_state(dev, LEDST_BLINK);
 }
 #endif
 #endif

 #ifdef CONFIG_LED_ACTIVITY
 static int led_activity_get(struct udevice **devp, int *period_ms)
 {
 	struct led_uc_priv *priv;
 	struct uclass *uc;
 	int ret;

 	ret = uclass_get(UCLASS_LED, &uc);
 	if (ret)
 		return ret;

 	priv = uclass_get_priv(uc);
 	if (!priv->activity_led_label)
 		return -ENOENT;

 	if (period_ms)
 		*period_ms = priv->activity_led_period;

 	return led_get_by_label(priv->activity_led_label, devp);
 }

 int led_activity_on(void)
 {
 	struct udevice *dev;
 	int ret;

 	ret = led_activity_get(&dev, NULL);
 	if (ret)
 		return ret;

 	return led_set_state(dev, LEDST_ON);
 }

 int led_activity_off(void)
 {
 	struct udevice *dev;
 	int ret;

 	ret = led_activity_get(&dev, NULL);
 	if (ret)
 		return ret;

 	return led_set_state(dev, LEDST_OFF);
 }

 #if defined(CONFIG_LED_BLINK) || defined(CONFIG_LED_SW_BLINK)
 int led_activity_blink(void)
 {
 	struct udevice *dev;
 	int period_ms, ret;

 	ret = led_activity_get(&dev, &period_ms);
 	if (ret)
 		return ret;

 	ret = led_set_period(dev, period_ms);
 	if (ret) {
 		if (ret != -ENOSYS)
 			return ret;

 		/* fallback to ON with no set_period and no SW_BLINK */
 		return led_set_state(dev, LEDST_ON);
 	}

 	return led_set_state(dev, LEDST_BLINK);
 }
 #endif
 #endif

 static const char *led_get_function_name(struct udevice *dev)
 {
 	struct led_uc_plat *uc_plat;
 	const char *func;
 	u32 color;
 	u32 enumerator;
 	int ret;
 	int cp;

 	if (!dev)
 		return NULL;

 	uc_plat = dev_get_uclass_plat(dev);
 	if (!uc_plat)
 		return NULL;

 	if (uc_plat->label)
 		return uc_plat->label;

 	/* Now try to detect function label name */
 	func = dev_read_string(dev, "function");
 	cp = dev_read_u32(dev, "color", &color);
 	/*
 	 *  prevent coverity scan error CID 541279: (TAINTED_SCALAR)
 	 *  only check the upper bound. No need to check the lower bound
 	 *  as color is from type u32 and never can be lower than 0.
 	 */
 	if (color >= LED_COLOR_ID_MAX)
 		cp = -EINVAL;

 	if (cp == 0 || func) {
 		ret = dev_read_u32(dev, "function-enumerator", &enumerator);
 		if (!ret) {
 			snprintf(uc_plat->name, LED_MAX_NAME_SIZE,
 				 "%s:%s-%d",
 				 cp ? "" : led_colors[color],
 				 func ? func : "", enumerator);
 		} else {
 			snprintf(uc_plat->name, LED_MAX_NAME_SIZE,
 				 "%s:%s",
 				 cp ? "" : led_colors[color],
 				 func ? func : "");
 		}
 		uc_plat->label = uc_plat->name;
 	}

 	return uc_plat->label;
 }

 static const char *led_get_label(struct udevice *dev, ofnode node)
 {
 	const char *label;

 	label = ofnode_read_string(node, "label");
 	if (!label)
 		label = led_get_function_name(dev);
 	if (!label && !ofnode_read_string(node, "compatible"))
 		label = ofnode_get_name(node);

 	return label;
 }

 static int led_post_bind(struct udevice *dev)
 {
 	struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
 	const char *default_state;

 	if (!uc_plat->label)
 		uc_plat->label = led_get_label(dev, dev_ofnode(dev));

 	uc_plat->default_state = LEDST_COUNT;

 	default_state = dev_read_string(dev, "default-state");
 	if (!default_state)
 		return 0;

 	if (!strncmp(default_state, "on", 2))
 		uc_plat->default_state = LEDST_ON;
 	else if (!strncmp(default_state, "off", 3))
 		uc_plat->default_state = LEDST_OFF;
 	else
 		return 0;

 	if (IS_ENABLED(CONFIG_LED_BLINK)) {
 		const char *trigger;

 		trigger = dev_read_string(dev, "linux,default-trigger");
 		if (trigger && !strncmp(trigger, "pattern", 7))
 			uc_plat->default_state = LEDST_BLINK;
 	}

 	/*
 	 * In case the LED has default-state DT property, trigger
 	 * probe() to configure its default state during startup.
 	 */
 	dev_or_flags(dev, DM_FLAG_PROBE_AFTER_BIND);

 	return 0;
 }

 static int led_post_probe(struct udevice *dev)
 {
 	struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
 	int default_period_ms = 1000;
 	int ret = 0;

 	switch (uc_plat->default_state) {
 	case LEDST_ON:
 	case LEDST_OFF:
 		ret = led_set_state(dev, uc_plat->default_state);
 		break;
 	case LEDST_BLINK:
 		ret = led_set_period(dev, default_period_ms);
 		if (!ret)
 			ret = led_set_state(dev, uc_plat->default_state);
 		break;
 	default:
 		break;
 	}

 	return ret;
 }

 #if defined(CONFIG_LED_BOOT) || defined(CONFIG_LED_ACTIVITY)
 static int led_init(struct uclass *uc)
 {
 	struct led_uc_priv *priv = uclass_get_priv(uc);
 	ofnode led_node;
 	int ret;

 #ifdef CONFIG_LED_BOOT
 	ret = ofnode_options_get_by_phandle("boot-led", &led_node);
 	if (!ret)
 		priv->boot_led_label = led_get_label(NULL, led_node);
 	priv->boot_led_period = ofnode_options_read_int("boot-led-period-ms", 250);
 #endif

 #ifdef CONFIG_LED_ACTIVITY
 	ret = ofnode_options_get_by_phandle("activity-led", &led_node);
 	if (!ret)
 		priv->activity_led_label = led_get_label(NULL, led_node);
 	priv->activity_led_period = ofnode_options_read_int("activity-led-period-ms",
 							    250);
 #endif

 	return 0;
 }
 #endif

 UCLASS_DRIVER(led) = {
 	.id		= UCLASS_LED,
 	.name		= "led",
 	.per_device_plat_auto	= sizeof(struct led_uc_plat),
 	.post_bind	= led_post_bind,
 	.post_probe	= led_post_probe,
 #if defined(CONFIG_LED_BOOT) || defined(CONFIG_LED_ACTIVITY)
 	.init		= led_init,
 	.priv_auto	= sizeof(struct led_uc_priv),
 #endif
 };
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Copyright (c) 2015 Google, Inc
	* Written by Simon Glass <sjg@chromium.org>
	*/

	#define LOG_CATEGORY UCLASS_LED

	#include <dm.h>
	#include <errno.h>
	#include <led.h>
	#include <dm/device-internal.h>
	#include <dm/lists.h>
	#include <dm/root.h>
	#include <dm/uclass-internal.h>
	#include <dt-bindings/leds/common.h>

	static const char * const led_colors[LED_COLOR_ID_MAX] = {
	[LED_COLOR_ID_WHITE] = "white",
	[LED_COLOR_ID_RED] = "red",
	[LED_COLOR_ID_GREEN] = "green",
	[LED_COLOR_ID_BLUE] = "blue",
	[LED_COLOR_ID_AMBER] = "amber",
	[LED_COLOR_ID_VIOLET] = "violet",
	[LED_COLOR_ID_YELLOW] = "yellow",
	[LED_COLOR_ID_IR] = "ir",
	[LED_COLOR_ID_MULTI] = "multicolor",
	[LED_COLOR_ID_RGB] = "rgb",
	[LED_COLOR_ID_PURPLE] = "purple",
	[LED_COLOR_ID_ORANGE] = "orange",
	[LED_COLOR_ID_PINK] = "pink",
	[LED_COLOR_ID_CYAN] = "cyan",
	[LED_COLOR_ID_LIME] = "lime",
	};

	int led_bind_generic(struct udevice parent, const char driver_name)
	{
	struct udevice *dev;
	ofnode node;
	int ret;

	dev_for_each_subnode(node, parent) {
	ret = device_bind_driver_to_node(parent, driver_name,
	ofnode_get_name(node),
	node, &dev);
	if (ret)
	return ret;
	}

	return 0;
	}

	int led_get_by_label(const char label, struct udevice *devp)
	{
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	ret = uclass_get(UCLASS_LED, &uc);
	if (ret)
	return ret;
	uclass_foreach_dev(dev, uc) {
	struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);

	/* Ignore the top-level LED node */
	if (uc_plat->label && !strcmp(label, uc_plat->label))
	return uclass_get_device_tail(dev, 0, devp);
	}

	return -ENODEV;
	}

	int led_set_state(struct udevice *dev, enum led_state_t state)
	{
	struct led_ops *ops = led_get_ops(dev);

	if (!ops->set_state)
	return -ENOSYS;

	if (IS_ENABLED(CONFIG_LED_SW_BLINK) &&
	led_sw_on_state_change(dev, state))
	return 0;

	return ops->set_state(dev, state);
	}

	enum led_state_t led_get_state(struct udevice *dev)
	{
	struct led_ops *ops = led_get_ops(dev);

	if (!ops->get_state)
	return -ENOSYS;

	if (IS_ENABLED(CONFIG_LED_SW_BLINK) &&
	led_sw_is_blinking(dev))
	return LEDST_BLINK;

	return ops->get_state(dev);
	}

	int led_set_period(struct udevice *dev, int period_ms)
	{
	#ifdef CONFIG_LED_BLINK
	struct led_ops *ops = led_get_ops(dev);

	if (ops->set_period)
	return ops->set_period(dev, period_ms);
	#endif

	if (IS_ENABLED(CONFIG_LED_SW_BLINK))
	return led_sw_set_period(dev, period_ms);

	return -ENOSYS;
	}

	#ifdef CONFIG_LED_BOOT
	static int led_boot_get(struct udevice *devp, int period_ms)
	{
	struct led_uc_priv *priv;
	struct uclass *uc;
	int ret;

	ret = uclass_get(UCLASS_LED, &uc);
	if (ret)
	return ret;

	priv = uclass_get_priv(uc);
	if (!priv->boot_led_label)
	return -ENOENT;

	if (period_ms)
	*period_ms = priv->boot_led_period;

	return led_get_by_label(priv->boot_led_label, devp);
	}

	int led_boot_on(void)
	{
	struct udevice *dev;
	int ret;

	ret = led_boot_get(&dev, NULL);
	if (ret)
	return ret;

	return led_set_state(dev, LEDST_ON);
	}

	int led_boot_off(void)
	{
	struct udevice *dev;
	int ret;

	ret = led_boot_get(&dev, NULL);
	if (ret)
	return ret;

	return led_set_state(dev, LEDST_OFF);
	}

	#if defined(CONFIG_LED_BLINK) \|\| defined(CONFIG_LED_SW_BLINK)
	int led_boot_blink(void)
	{
	struct udevice *dev;
	int period_ms, ret;

	ret = led_boot_get(&dev, &period_ms);
	if (ret)
	return ret;

	ret = led_set_period(dev, period_ms);
	if (ret) {
	if (ret != -ENOSYS)
	return ret;

	/* fallback to ON with no set_period and no SW_BLINK */
	return led_set_state(dev, LEDST_ON);
	}

	return led_set_state(dev, LEDST_BLINK);
	}
	#endif
	#endif

	#ifdef CONFIG_LED_ACTIVITY
	static int led_activity_get(struct udevice *devp, int period_ms)
	{
	struct led_uc_priv *priv;
	struct uclass *uc;
	int ret;

	ret = uclass_get(UCLASS_LED, &uc);
	if (ret)
	return ret;

	priv = uclass_get_priv(uc);
	if (!priv->activity_led_label)
	return -ENOENT;

	if (period_ms)
	*period_ms = priv->activity_led_period;

	return led_get_by_label(priv->activity_led_label, devp);
	}

	int led_activity_on(void)
	{
	struct udevice *dev;
	int ret;

	ret = led_activity_get(&dev, NULL);
	if (ret)
	return ret;

	return led_set_state(dev, LEDST_ON);
	}

	int led_activity_off(void)
	{
	struct udevice *dev;
	int ret;

	ret = led_activity_get(&dev, NULL);
	if (ret)
	return ret;

	return led_set_state(dev, LEDST_OFF);
	}

	#if defined(CONFIG_LED_BLINK) \|\| defined(CONFIG_LED_SW_BLINK)
	int led_activity_blink(void)
	{
	struct udevice *dev;
	int period_ms, ret;

	ret = led_activity_get(&dev, &period_ms);
	if (ret)
	return ret;

	ret = led_set_period(dev, period_ms);
	if (ret) {
	if (ret != -ENOSYS)
	return ret;

	/* fallback to ON with no set_period and no SW_BLINK */
	return led_set_state(dev, LEDST_ON);
	}

	return led_set_state(dev, LEDST_BLINK);
	}
	#endif
	#endif

	static const char led_get_function_name(struct udevice dev)
	{
	struct led_uc_plat *uc_plat;
	const char *func;
	u32 color;
	u32 enumerator;
	int ret;
	int cp;

	if (!dev)
	return NULL;

	uc_plat = dev_get_uclass_plat(dev);
	if (!uc_plat)
	return NULL;

	if (uc_plat->label)
	return uc_plat->label;

	/* Now try to detect function label name */
	func = dev_read_string(dev, "function");
	cp = dev_read_u32(dev, "color", &color);
	/*
	* prevent coverity scan error CID 541279: (TAINTED_SCALAR)
	* only check the upper bound. No need to check the lower bound
	* as color is from type u32 and never can be lower than 0.
	*/
	if (color >= LED_COLOR_ID_MAX)
	cp = -EINVAL;

	if (cp == 0 \|\| func) {
	ret = dev_read_u32(dev, "function-enumerator", &enumerator);
	if (!ret) {
	snprintf(uc_plat->name, LED_MAX_NAME_SIZE,
	"%s:%s-%d",
	cp ? "" : led_colors[color],
	func ? func : "", enumerator);
	} else {
	snprintf(uc_plat->name, LED_MAX_NAME_SIZE,
	"%s:%s",
	cp ? "" : led_colors[color],
	func ? func : "");
	}
	uc_plat->label = uc_plat->name;
	}

	return uc_plat->label;
	}

	static const char led_get_label(struct udevice dev, ofnode node)
	{
	const char *label;

	label = ofnode_read_string(node, "label");
	if (!label)
	label = led_get_function_name(dev);
	if (!label && !ofnode_read_string(node, "compatible"))
	label = ofnode_get_name(node);

	return label;
	}

	static int led_post_bind(struct udevice *dev)
	{
	struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
	const char *default_state;

	if (!uc_plat->label)
	uc_plat->label = led_get_label(dev, dev_ofnode(dev));

	uc_plat->default_state = LEDST_COUNT;

	default_state = dev_read_string(dev, "default-state");
	if (!default_state)
	return 0;

	if (!strncmp(default_state, "on", 2))
	uc_plat->default_state = LEDST_ON;
	else if (!strncmp(default_state, "off", 3))
	uc_plat->default_state = LEDST_OFF;
	else
	return 0;

	if (IS_ENABLED(CONFIG_LED_BLINK)) {
	const char *trigger;

	trigger = dev_read_string(dev, "linux,default-trigger");
	if (trigger && !strncmp(trigger, "pattern", 7))
	uc_plat->default_state = LEDST_BLINK;
	}

	/*
	* In case the LED has default-state DT property, trigger
	* probe() to configure its default state during startup.
	*/
	dev_or_flags(dev, DM_FLAG_PROBE_AFTER_BIND);

	return 0;
	}

	static int led_post_probe(struct udevice *dev)
	{
	struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
	int default_period_ms = 1000;
	int ret = 0;

	switch (uc_plat->default_state) {
	case LEDST_ON:
	case LEDST_OFF:
	ret = led_set_state(dev, uc_plat->default_state);
	break;
	case LEDST_BLINK:
	ret = led_set_period(dev, default_period_ms);
	if (!ret)
	ret = led_set_state(dev, uc_plat->default_state);
	break;
	default:
	break;
	}

	return ret;
	}

	#if defined(CONFIG_LED_BOOT) \|\| defined(CONFIG_LED_ACTIVITY)
	static int led_init(struct uclass *uc)
	{
	struct led_uc_priv *priv = uclass_get_priv(uc);
	ofnode led_node;
	int ret;

	#ifdef CONFIG_LED_BOOT
	ret = ofnode_options_get_by_phandle("boot-led", &led_node);
	if (!ret)
	priv->boot_led_label = led_get_label(NULL, led_node);
	priv->boot_led_period = ofnode_options_read_int("boot-led-period-ms", 250);
	#endif

	#ifdef CONFIG_LED_ACTIVITY
	ret = ofnode_options_get_by_phandle("activity-led", &led_node);
	if (!ret)
	priv->activity_led_label = led_get_label(NULL, led_node);
	priv->activity_led_period = ofnode_options_read_int("activity-led-period-ms",
	250);
	#endif

	return 0;
	}
	#endif

	UCLASS_DRIVER(led) = {
	.id = UCLASS_LED,
	.name = "led",
	.per_device_plat_auto = sizeof(struct led_uc_plat),
	.post_bind = led_post_bind,
	.post_probe = led_post_probe,
	#if defined(CONFIG_LED_BOOT) \|\| defined(CONFIG_LED_ACTIVITY)
	.init = led_init,
	.priv_auto = sizeof(struct led_uc_priv),
	#endif
	};