DM: Cmd: GPIO/LED/STM32/CLK: provide command-line support for device-tree configured gpios and leds

index 50f86d3..2457211 100644
@@ -66,7 +66,7 @@ int stm32_gpio_config(const struct stm32_gpio_dsc *dsc,
 	i = dsc->pin * 2;
 
 	clrsetbits_le32(&gpio_regs->moder, 0x3 << i, ctl->mode << i);
-	clrsetbits_le32(&gpio_regs->otyper, 0x3 << i, ctl->otype << i);
+	clrsetbits_le32(&gpio_regs->otyper, 0x1 << dsc->pin, ctl->otype << dsc->pin);
 	clrsetbits_le32(&gpio_regs->ospeedr, 0x3 << i, ctl->speed << i);
 	clrsetbits_le32(&gpio_regs->pupdr, 0x3 << i, ctl->pupd << i);
 

index 2457211..d092c8f 100644
@@ -236,6 +236,7 @@ int gpio_direction_output(unsigned gpio, int value)
 #if defined(CONFIG_STM32F4) || defined(CONFIG_STM32F7)
 	ctl.af = STM32_GPIO_AF0;
 	ctl.mode = STM32_GPIO_MODE_OUT;
+	ctl.otype = STM32_GPIO_OTYPE_PP;
 	ctl.pupd = STM32_GPIO_PUPD_NO;
 	ctl.speed = STM32_GPIO_SPEED_50M;
 #elif defined(CONFIG_STM32F1)

index d092c8f..516dfcc 100644
@@ -263,7 +263,7 @@ int gpio_get_value(unsigned gpio)
 	dsc.port = stm32_gpio_to_port(gpio);
 	dsc.pin = stm32_gpio_to_pin(gpio);
 
-	return stm32_gpin_get(&dsc);
+	return !!stm32_gpin_get(&dsc);
 }
 
 int gpio_set_value(unsigned gpio, int value)

index 8bbe580..9d275c0 100644
@@ -45,6 +45,14 @@
 #define CONFIG_BOARD_SPECIFIC_LED
 #define CONFIG_RED_LED			110
 #define CONFIG_GREEN_LED		109
+#define CONFIG_GPIO_LED		1
+#define CONFIG_STATUS_LED
+#define STATUS_LED_BIT		CONFIG_RED_LED
+#define STATUS_LED_STATE	0
+#define STATUS_LED_PERIOD	0
+#define STATUS_LED_BIT1		CONFIG_GREEN_LED
+#define STATUS_LED_STATE1	0
+#define STATUS_LED_PERIOD1	0
 
 #define CONFIG_STM32_GPIO
 #define CONFIG_STM32_FLASH

index b483c1e..462f5f8 100644
@@ -44,6 +44,16 @@ int clk_enable(struct udevice *dev, int periph)
 	return ops->enable(dev, periph);
 }
 
+int clk_disable(struct udevice *dev, int periph)
+{
+	struct clk_ops *ops = clk_get_ops(dev);
+
+	if (!ops->disable)
+		return -ENOSYS;
+
+	return ops->disable(dev, periph);
+}
+
 ulong clk_get_periph_rate(struct udevice *dev, int periph)
 {
 	struct clk_ops *ops = clk_get_ops(dev);

index ca20c3d..395f813 100644
@@ -43,6 +43,15 @@ struct clk_ops {
 	int (*enable)(struct udevice *dev, int periph);
 
 	/**
+	 * disable() - Disable the clock for a peripheral
+	 *
+	 * @dev:	clock provider
+	 * @periph:	Peripheral ID to enable
+	 * @return zero on success, or -ve error code
+	 */
+	int (*disable)(struct udevice *dev, int periph);
+
+	/**
 	 * get_periph_rate() - Get clock rate for a peripheral
 	 *
 	 * @dev:	Device to check (UCLASS_CLK)

@@ -90,6 +99,15 @@ ulong clk_set_rate(struct udevice *dev, ulong rate);
 int clk_enable(struct udevice *dev, int periph);
 
 /**
+ * clk_disable() - Disable the clock for a peripheral
+ *
+ * @dev:	clock provider
+ * @periph:	Peripheral ID to enable
+ * @return zero on success, or -ve error code
+ */
+int clk_disable(struct udevice *dev, int periph);
+
+/**
  * clk_get_periph_rate() - Get current clock rate for a peripheral
  *
  * @dev:	Device to check (UCLASS_CLK)

112 lines not on this page · raw message

index 516dfcc..be662c3 100644
@@ -74,6 +74,23 @@ int stm32_gpio_config(const struct stm32_gpio_dsc *dsc,
 out:
 	return rv;
 }
+
+static struct stm32_gpio_ctl ctl_in = {
+	.af = STM32_GPIO_AF0,
+	.mode = STM32_GPIO_MODE_IN,
+	.otype = STM32_GPIO_OTYPE_PP,
+	.pupd = STM32_GPIO_PUPD_NO,
+	.speed = STM32_GPIO_SPEED_50M,
+};
+
+static struct stm32_gpio_ctl ctl_out = {
+	.af = STM32_GPIO_AF0,
+	.mode = STM32_GPIO_MODE_OUT,
+	.otype = STM32_GPIO_OTYPE_PP,
+	.pupd = STM32_GPIO_PUPD_NO,
+	.speed = STM32_GPIO_SPEED_50M,
+};
+
 #elif defined(CONFIG_STM32F1)
 static const unsigned long io_base[] = {
 	STM32_GPIOA_BASE, STM32_GPIOB_BASE, STM32_GPIOC_BASE,

@@ -146,6 +163,21 @@ int stm32_gpio_config(const struct stm32_gpio_dsc *dsc,
 out:
 	return rv;
 }
+
+static struct stm32_gpio_ctl ctl_in = {
+	.mode = STM32_GPIO_MODE_IN,
+	.icnf = STM32_GPIO_ICNF_IN_FLT,
+	.ocnf = STM32_GPIO_OCNF_GP_PP,	/* ignored for input */
+	.pupd = STM32_GPIO_PUPD_UP,	/* ignored for floating */
+};
+
+static struct stm32_gpio_ctl ctl_out = {
+	.mode = STM32_GPIO_MODE_OUT_50M,
+	.ocnf = STM32_GPIO_OCNF_GP_PP,
+	.icnf = STM32_GPIO_ICNF_IN_FLT,	/* ignored for output */
+	.pupd = STM32_GPIO_PUPD_UP,	/* ignored for output */
+};
+
 #else
 #error STM32 family not supported
 #endif

@@ -203,52 +235,22 @@ int gpio_free(unsigned gpio)
 int gpio_direction_input(unsigned gpio)
 {
 	struct stm32_gpio_dsc dsc;
-	struct stm32_gpio_ctl ctl;
 
 	dsc.port = stm32_gpio_to_port(gpio);
 	dsc.pin = stm32_gpio_to_pin(gpio);
-#if defined(CONFIG_STM32F4) || defined(CONFIG_STM32F7)
-	ctl.af = STM32_GPIO_AF0;
-	ctl.mode = STM32_GPIO_MODE_IN;
-	ctl.otype = STM32_GPIO_OTYPE_PP;
-	ctl.pupd = STM32_GPIO_PUPD_NO;
-	ctl.speed = STM32_GPIO_SPEED_50M;
-#elif defined(CONFIG_STM32F1)
-	ctl.mode = STM32_GPIO_MODE_IN;
-	ctl.icnf = STM32_GPIO_ICNF_IN_FLT;
-	ctl.ocnf = STM32_GPIO_OCNF_GP_PP;	/* ignored for input */
-	ctl.pupd = STM32_GPIO_PUPD_UP;		/* ignored for floating */
-#else
-#error STM32 family not supported
-#endif
 
-	return stm32_gpio_config(&dsc, &ctl);
+	return stm32_gpio_config(&dsc, &ctl_in);
 }
 
 int gpio_direction_output(unsigned gpio, int value)
 {
 	struct stm32_gpio_dsc dsc;
-	struct stm32_gpio_ctl ctl;
 	int res;
 
 	dsc.port = stm32_gpio_to_port(gpio);
 	dsc.pin = stm32_gpio_to_pin(gpio);
-#if defined(CONFIG_STM32F4) || defined(CONFIG_STM32F7)
-	ctl.af = STM32_GPIO_AF0;
-	ctl.mode = STM32_GPIO_MODE_OUT;
-	ctl.otype = STM32_GPIO_OTYPE_PP;
-	ctl.pupd = STM32_GPIO_PUPD_NO;
-	ctl.speed = STM32_GPIO_SPEED_50M;
-#elif defined(CONFIG_STM32F1)
-	ctl.mode = STM32_GPIO_MODE_OUT_50M;
-	ctl.ocnf = STM32_GPIO_OCNF_GP_PP;
-	ctl.icnf = STM32_GPIO_ICNF_IN_FLT;	/* ignored for output */
-	ctl.pupd = STM32_GPIO_PUPD_UP;		/* ignored for output */
-#else
-#error STM32 family not supported
-#endif
 
-	res = stm32_gpio_config(&dsc, &ctl);
+	res = stm32_gpio_config(&dsc, &ctl_out);
 	if (res < 0)
 		goto out;
 	res = stm32_gpout_set(&dsc, value);

index be662c3..844b3e1 100644
@@ -220,6 +220,138 @@ out:
 	return rv;
 }
 
+#ifdef CONFIG_DM_GPIO
+#include <asm-generic/gpio.h>
+#include <dm/device.h>
+#include <clk.h>
+#include <dt-bindings/gpio/gpio.h>
+
+struct stm32_gpio_priv {
+	int portnum;
+	u32 requested;
+};
+
+static int stm32_gpio_request(struct udevice *dev, unsigned offset, const char *label)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	if(priv->requested & (1<<offset))
+		return -EBUSY;
+	if(!priv->requested) {
+		struct udevice *clk = NULL;
+		int clk_id;
+		if((clk_id = clk_get_by_index(dev, 0, &clk)) >= 0)
+			clk_enable(clk, clk_id);
+	}
+	priv->requested |= 1<<offset;
+	return 0;
+}
+
+static int stm32_gpio_free(struct udevice *dev, unsigned offset)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	priv->requested &= ~(1<<offset);
+	if(!priv->requested) {
+		struct udevice *clk = NULL;
+		int clk_id;
+		if((clk_id = clk_get_by_index(dev, 0, &clk)) >= 0)
+			clk_disable(clk, clk_id);
+	}
+	return 0;
+}
+
+static int stm32_gpio_direction_input(struct udevice *dev, unsigned offset)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	struct stm32_gpio_dsc dsc = {
+		.port = priv->portnum,
+		.pin = offset,
+	};
+	return stm32_gpio_config(&dsc, &ctl_in);
+}
+
+static int stm32_gpio_direction_output(struct udevice *dev, unsigned offset, int value)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	struct stm32_gpio_dsc dsc = {
+		.port = priv->portnum,
+		.pin = offset,
+	};
+	int ret = stm32_gpio_config(&dsc, &ctl_out);
+	if(ret >= 0)
+		ret = stm32_gpout_set(&dsc, value);
+	return ret;
+}
+
+static int stm32_gpio_get_value(struct udevice *dev, unsigned offset)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	struct stm32_gpio_dsc dsc = {
+		.port = priv->portnum,
+		.pin = offset,
+	};
+	return !!stm32_gpin_get(&dsc);
+}
+
+static int stm32_gpio_set_value(struct udevice *dev, unsigned offset, int value)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	struct stm32_gpio_dsc dsc = {
+		.port = priv->portnum,
+		.pin = offset,
+	};
+	return stm32_gpout_set(&dsc, value);
+}
+
+static struct dm_gpio_ops stm32_gpio_ops = {
+	.request = stm32_gpio_request,
+	.free = stm32_gpio_free,
+	.direction_input = stm32_gpio_direction_input,
+	.direction_output = stm32_gpio_direction_output,
+	.get_value = stm32_gpio_get_value,
+	.set_value = stm32_gpio_set_value,
+};
+
+static int stm32_gpio_probe(struct udevice *dev)
+{
+	struct stm32_gpio_priv *priv = dev_get_priv(dev);
+	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
+	fdt_addr_t addr;
+	fdt_size_t size;
+	int i;
+	priv->requested = 0;
+
+	addr = fdtdec_get_addr_size(gd->fdt_blob, dev->of_offset, "reg", &size);
+	if (addr == FDT_ADDR_T_NONE)
+		return -EINVAL;
+
+	if(size < sizeof(struct stm32_gpio_ctl))
+		return -EINVAL;
+
+	for(i=0; i < sizeof(io_base)/sizeof(io_base[0]); i++) {
+		if(io_base[i] != addr)
+			continue;
+		priv->portnum = i;
+		uc_priv->bank_name = dev->name;
+		uc_priv->gpio_count = fdtdec_get_int(gd->fdt_blob, dev->of_offset, "gpio-count", 16);
+		return 0;
+	}
+	return -ENXIO;
+}
+
+static const struct udevice_id stm32_gpio_ids[] = {
+	{ .compatible = "st,stm32-gpio" },
+	{ }
+};
+
+U_BOOT_DRIVER(stm32_gpio) = {
+	.name		= "stm32_gpio",
+	.id		= UCLASS_GPIO,
+	.ops		= &stm32_gpio_ops,
+	.probe		= stm32_gpio_probe,
+	.priv_auto_alloc_size = sizeof(struct stm32_gpio_priv),
+	.of_match	= stm32_gpio_ids,
+};
+#else
 /* Common GPIO API */
 
 int gpio_request(unsigned gpio, const char *label)

@@ -277,3 +409,4 @@ int gpio_set_value(unsigned gpio, int value)
 
 	return stm32_gpout_set(&dsc, value);
 }
+#endif

index 9d275c0..04066ff 100644
@@ -42,17 +42,21 @@
 #define CONFIG_ENV_SECT_SIZE		(128 << 10)
 #define CONFIG_ENV_SIZE			(8 << 10)
 
-#define CONFIG_BOARD_SPECIFIC_LED
+#define CONFIG_GPIO_LED		1
+#ifndef CONFIG_DM_GPIO
 #define CONFIG_RED_LED			110
 #define CONFIG_GREEN_LED		109
-#define CONFIG_GPIO_LED		1
-#define CONFIG_STATUS_LED
+#ifdef CONFIG_STATUS_LED
+#define CONFIG_BOARD_SPECIFIC_LED
+#define STATUS_LED_RED	CONFIG_RED_LED
 #define STATUS_LED_BIT		CONFIG_RED_LED
 #define STATUS_LED_STATE	0
 #define STATUS_LED_PERIOD	0
 #define STATUS_LED_BIT1		CONFIG_GREEN_LED
 #define STATUS_LED_STATE1	0
 #define STATUS_LED_PERIOD1	0
+#endif
+#endif
 
 #define CONFIG_STM32_GPIO
 #define CONFIG_STM32_FLASH

index 164c30d..9c0ea13 100644
@@ -13,6 +13,10 @@
 #define CONFIG_GPIO_LED_INVERTED_TABLE {}
 #endif
 
+#ifndef STATUS_LED_ON
+#define STATUS_LED_ON 2
+#endif
+
 static led_id_t gpio_led_inv[] = CONFIG_GPIO_LED_INVERTED_TABLE;
 
 static int gpio_led_gpio_value(led_id_t mask, int state)

index 31e8831..052ecf0 100644
@@ -27,11 +27,13 @@ typedef struct {
 } led_dev_t;
 
 led_dev_t led_dev[] = {
+#if defined(STATUS_LED_BIT)
     {	STATUS_LED_BIT,
 	STATUS_LED_STATE,
 	STATUS_LED_PERIOD,
 	0,
     },
+#endif
 #if defined(STATUS_LED_BIT1)
     {	STATUS_LED_BIT1,
 	STATUS_LED_STATE1,

index 396ea88..c3795a7 100644
@@ -103,6 +103,10 @@ void __led_blink(led_id_t mask, int freq);
 # include <asm/status_led.h>
 #endif
 
+#else
+
+typedef unsigned long led_id_t;
+
 #endif	/* CONFIG_STATUS_LED	*/
 
 /*

index b0f1a61..5295a6e 100644
@@ -2,6 +2,9 @@
  * (C) Copyright 2010
  * Jason Kridner <[email protected]>
  *
+ * (C) Copyright 2016
+ * Benjamin Tietz <[email protected]>
+ *
  * Based on cmd_led.c patch from:
  * http://www.mail-archive.com/u-boot at lists.denx.de/msg06873.html
  * (C) Copyright 2008

@@ -15,53 +18,241 @@
 #include <command.h>
 #include <status_led.h>
 
+enum led_cmd { LED_ON, LED_OFF, LED_TOGGLE, LED_BLINK, LED_LIST, LED_MAX_OP };
+
+struct led_tbl_s;
+
+typedef void (* led_op)(const struct led_tbl_s *, enum led_cmd, char *arg);
+
 struct led_tbl_s {
-	char		*string;	/* String for use in the command */
+	const char	*string;	/* String for use in the command */
 	led_id_t	mask;		/* Mask used for calling __led_set() */
-	void		(*off)(void);	/* Optional function for turning LED off */
-	void		(*on)(void);	/* Optional function for turning LED on */
-	void		(*toggle)(void);/* Optional function for toggling LED */
+	led_op op[LED_MAX_OP];		/* functions for handling LED commands */
 };
 
 typedef struct led_tbl_s led_tbl_t;
 
-static const led_tbl_t led_commands[] = {
+static int call_led(const char *name, enum led_cmd cmd, char *arg);
+
+static void _led_list_name(const led_tbl_t *led, enum led_cmd cmd, char *arg) {
+	printf("%s\n", led->string);
+}
+
+#define LED_MASK_FUNC(fnc)	((led_op) fnc)
+#define LED_TEST_RET(name, ret)	if(strcmp(name, ret.string) == 0) return &ret;
+#define LED_TBL_COLOURED(clr)	static const led_tbl_t _led_##clr = { \
+	.string = #clr, \
+	.op = { \
+		[LED_ON] = LED_MASK_FUNC(clr ## _led_on), \
+		[LED_OFF] = LED_MASK_FUNC(clr ## _led_off), \
+		[LED_LIST] = _led_list_name, \
+	}, \
+}
+
+#ifdef STATUS_LED_GREEN
+LED_TBL_COLOURED(green);
+#define LED_NAME_GREEN		_led_green.string
+#define LED_TEST_GREEN(name)	LED_TEST_RET(name, _led_green)
+#else
+#define LED_NAME_GREEN		NULL
+#define LED_TEST_GREEN(name)	while(0)
+#endif
+
+#ifdef STATUS_LED_YELLOW
+LED_TBL_COLOURED(yellow);
+#define LED_NAME_YELLOW		_led_yellow.string
+#define LED_TEST_YELLOW(name)	LED_TEST_RET(name, _led_yellow)
+#else
+#define LED_NAME_YELLOW		NULL
+#define LED_TEST_YELLOW(name)	while(0)
+#endif
+
+#ifdef STATUS_LED_RED
+LED_TBL_COLOURED(red);
+#define LED_NAME_RED		_led_red.string
+#define LED_TEST_RED(name)	LED_TEST_RET(name, _led_red)
+#else
+#define LED_NAME_RED		NULL
+#define LED_TEST_RED(name)	while(0)
+#endif
+
+#ifdef STATUS_LED_BLUE
+LED_TBL_COLOURED(blue);
+#define LED_NAME_BLUE		_led_blue.string
+#define LED_TEST_BLUE(name)	LED_TEST_RET(name, _led_blue)
+#else
+#define LED_NAME_BLUE		NULL
+#define LED_TEST_BLUE(name)	while(0)
+#endif
+
 #ifdef CONFIG_BOARD_SPECIFIC_LED
+/*
+ * LED drivers providing a blinking LED functionality, like the
+ * PCA9551, can override this empty weak function
+ */
+void __weak __led_blink(led_id_t mask, int freq)
+{
+}
+
+static void _led_status_onoff(const led_tbl_t *led, enum led_cmd cmd, char *arg) {
+	__led_set(led->mask, cmd != LED_ON ? STATUS_LED_OFF : STATUS_LED_ON);
+}
+static void _led_status_toggle(const led_tbl_t *led, enum led_cmd cmd, char *arg) {
+	__led_toggle(led->mask);
+}
+static void _led_status_blink(const led_tbl_t *led, enum led_cmd cmd, char *freq) {
+	if (!freq)
+		return;
+
+	__led_blink(led->mask, simple_strtoul(freq, NULL, 10));
+}
+
+#define LED_TBL_STATUS(name, _mask)	static const led_tbl_t _led_##name = { \
+	.string = #name, \
+	.mask = _mask, \
+	.op = { \
+		[LED_ON] = _led_status_onoff, \
+		[LED_OFF] = _led_status_onoff, \
+		[LED_TOGGLE] = _led_status_toggle, \
+		[LED_BLINK] = _led_status_blink, \
+		[LED_LIST] = _led_list_name, \
+	}, \
+}
+
 #ifdef STATUS_LED_BIT
-	{ "0", STATUS_LED_BIT, NULL, NULL, NULL },
+LED_TBL_STATUS(0, STATUS_LED_BIT);
+#define LED_NAME_0		_led_0.string
+#define LED_TEST_0(name)	LED_TEST_RET(name, _led_0)
 #endif
+
 #ifdef STATUS_LED_BIT1
-	{ "1", STATUS_LED_BIT1, NULL, NULL, NULL },
+LED_TBL_STATUS(1, STATUS_LED_BIT1);
+#define LED_NAME_1		_led_1.string
+#define LED_TEST_1(name)	LED_TEST_RET(name, _led_1)
 #endif
+
 #ifdef STATUS_LED_BIT2
-	{ "2", STATUS_LED_BIT2, NULL, NULL, NULL },
+LED_TBL_STATUS(2, STATUS_LED_BIT2);
+#define LED_NAME_2		_led_2.string
+#define LED_TEST_2(name)	LED_TEST_RET(name, _led_2)
 #endif
+
 #ifdef STATUS_LED_BIT3
-	{ "3", STATUS_LED_BIT3, NULL, NULL, NULL },
+LED_TBL_STATUS(3, STATUS_LED_BIT3);
+#define LED_NAME_3		_led_3.string
+#define LED_TEST_3(name)	LED_TEST_RET(name, _led_3)
 #endif
+
 #ifdef STATUS_LED_BIT4
-	{ "4", STATUS_LED_BIT4, NULL, NULL, NULL },
+LED_TBL_STATUS(4, STATUS_LED_BIT4);
+#define LED_NAME_4		_led_4.string
+#define LED_TEST_4(name)	LED_TEST_RET(name, _led_4)
 #endif
+
 #ifdef STATUS_LED_BIT5
-	{ "5", STATUS_LED_BIT5, NULL, NULL, NULL },
+LED_TBL_STATUS(5, STATUS_LED_BIT5);
+#define LED_NAME_5		_led_5.string
+#define LED_TEST_5(name)	LED_TEST_RET(name, _led_5)
 #endif
+#endif  /* CONFIG_BOARD_SPECIFIC_LED */
+
+#ifndef LED_NAME_0
+#define LED_NAME_0		NULL
+#define LED_TEST_0(name)	while(0)
 #endif
-#ifdef STATUS_LED_GREEN
-	{ "green", STATUS_LED_GREEN, green_led_off, green_led_on, NULL },
+
+#ifndef LED_NAME_1
+#define LED_NAME_1		NULL
+#define LED_TEST_1(name)	while(0)
 #endif
-#ifdef STATUS_LED_YELLOW
-	{ "yellow", STATUS_LED_YELLOW, yellow_led_off, yellow_led_on, NULL },
+
+#ifndef LED_NAME_2
+#define LED_NAME_2		NULL
+#define LED_TEST_2(name)	while(0)
 #endif
-#ifdef STATUS_LED_RED
-	{ "red", STATUS_LED_RED, red_led_off, red_led_on, NULL },
+
+#ifndef LED_NAME_3
+#define LED_NAME_3		NULL
+#define LED_TEST_3(name)	while(0)
 #endif
-#ifdef STATUS_LED_BLUE
-	{ "blue", STATUS_LED_BLUE, blue_led_off, blue_led_on, NULL },
+
+#ifndef LED_NAME_4
+#define LED_NAME_4		NULL
+#define LED_TEST_4(name)	while(0)
 #endif
-	{ NULL, 0, NULL, NULL, NULL }
+
+#ifndef LED_NAME_5
+#define LED_NAME_5		NULL
+#define LED_TEST_5(name)	while(0)
+#endif
+
+static int _led_count(void) {
+	int i = 0;
+	if(LED_NAME_GREEN) i++;
+	if(LED_NAME_RED) i++;
+	if(LED_NAME_BLUE) i++;
+	if(LED_NAME_YELLOW) i++;
+	if(LED_NAME_0) i++;
+	if(LED_NAME_1) i++;
+	if(LED_NAME_2) i++;
+	if(LED_NAME_3) i++;
+	if(LED_NAME_4) i++;
+	if(LED_NAME_5) i++;
+	return i;
+}
+
+#define TEST_ADD_NAME(name, tbl, size) do { if((name) && ((size) > 0)) { *tbl++ = name; size--; } } while(0)
+static int _led_list(const char **tbl, int size) {
+	int init_size = size;
+	TEST_ADD_NAME(LED_NAME_GREEN, tbl, size);
+	TEST_ADD_NAME(LED_NAME_RED, tbl, size);
+	TEST_ADD_NAME(LED_NAME_BLUE, tbl, size);
+	TEST_ADD_NAME(LED_NAME_YELLOW, tbl, size);
+	TEST_ADD_NAME(LED_NAME_0, tbl, size);
+	TEST_ADD_NAME(LED_NAME_1, tbl, size);
+	TEST_ADD_NAME(LED_NAME_2, tbl, size);
+	TEST_ADD_NAME(LED_NAME_3, tbl, size);
+	TEST_ADD_NAME(LED_NAME_4, tbl, size);
+	TEST_ADD_NAME(LED_NAME_5, tbl, size);
+	return init_size - size;
+}
+
+static void _led_all_cmd(const led_tbl_t *led, enum led_cmd cmd, char *arg) {
+	int cnt = _led_count();
+	const char *leds[cnt];
+	int i;
+
+	_led_list(leds, cnt);
+	for(i=0; i < cnt; i++)
+		call_led(leds[i], cmd, arg);
+}
+
+static const led_tbl_t _led_all = {
+	.string = "all",
+	.op = {
+		[LED_ON] = _led_all_cmd,
+		[LED_OFF] = _led_all_cmd,
+		[LED_TOGGLE] = _led_all_cmd,
+		[LED_BLINK] = _led_all_cmd,
+		[LED_LIST] = _led_all_cmd,
+	},
 };
+#define LED_TEST_ALL(name)	LED_TEST_RET(name, _led_all)
 
-enum led_cmd { LED_ON, LED_OFF, LED_TOGGLE, LED_BLINK };
+static const led_tbl_t *get_led(const char *name) {
+	LED_TEST_ALL(name);
+	LED_TEST_GREEN(name);
+	LED_TEST_YELLOW(name);
+	LED_TEST_RED(name);
+	LED_TEST_BLUE(name);
+	LED_TEST_0(name);
+	LED_TEST_1(name);
+	LED_TEST_2(name);
+	LED_TEST_3(name);
+	LED_TEST_4(name);
+	LED_TEST_5(name);
+	return NULL;
+}
 
 enum led_cmd get_led_cmd(char *var)
 {

@@ -73,23 +264,29 @@ enum led_cmd get_led_cmd(char *var)
 		return LED_TOGGLE;
 	if (strcmp(var, "blink") == 0)
 		return LED_BLINK;
+	if (strcmp(var, "list") == 0)
+		return LED_LIST;
 
 	return -1;
 }
 
-/*
- * LED drivers providing a blinking LED functionality, like the
- * PCA9551, can override this empty weak function
- */
-void __weak __led_blink(led_id_t mask, int freq)
+static int call_led(const char *name, enum led_cmd cmd, char *arg)
 {
+	const led_tbl_t *led = get_led(name);
+	if(!led)
+		return CMD_RET_USAGE;
+
+	if(cmd >= LED_MAX_OP)
+		return CMD_RET_USAGE;
+	if(led->op[cmd])
+		led->op[cmd](led, cmd, arg);
+	return 0;
+
 }
 
 int do_led (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
-	int i, match = 0;
 	enum led_cmd cmd;
-	int freq;
 
 	/* Validate arguments */
 	if ((argc < 3) || (argc > 4))

@@ -100,87 +297,16 @@ int do_led (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 		return CMD_RET_USAGE;
 	}
 
-	for (i = 0; led_commands[i].string; i++) {
-		if ((strcmp("all", argv[1]) == 0) ||
-		    (strcmp(led_commands[i].string, argv[1]) == 0)) {
-			match = 1;
-			switch (cmd) {
-			case LED_ON:
-				if (led_commands[i].on)
-					led_commands[i].on();
-				else
-					__led_set(led_commands[i].mask,
-							  STATUS_LED_ON);
-				break;
-			case LED_OFF:
-				if (led_commands[i].off)
-					led_commands[i].off();
-				else
-					__led_set(led_commands[i].mask,
-							  STATUS_LED_OFF);
-				break;
-			case LED_TOGGLE:
-				if (led_commands[i].toggle)
-					led_commands[i].toggle();
-				else
-					__led_toggle(led_commands[i].mask);
-				break;
-			case LED_BLINK:
-				if (argc != 4)
-					return CMD_RET_USAGE;
-
-				freq = simple_strtoul(argv[3], NULL, 10);
-				__led_blink(led_commands[i].mask, freq);
-			}
-			/* Need to set only 1 led if led_name wasn't 'all' */
-			if (strcmp("all", argv[1]) != 0)
-				break;
-		}
-	}
-
-	/* If we ran out of matches, print Usage */
-	if (!match) {
-		return CMD_RET_USAGE;
-	}
-
-	return 0;
+	return call_led(argv[1], cmd, argc != 4 ? NULL : argv[3]);
 }
 
 U_BOOT_CMD(
 	led, 4, 1, do_led,
-	"["
-#ifdef CONFIG_BOARD_SPECIFIC_LED
-#ifdef STATUS_LED_BIT
-	"0|"
-#endif
-#ifdef STATUS_LED_BIT1
-	"1|"
-#endif
-#ifdef STATUS_LED_BIT2
-	"2|"
-#endif
-#ifdef STATUS_LED_BIT3
-	"3|"
-#endif
-#ifdef STATUS_LED_BIT4
-	"4|"
-#endif
-#ifdef STATUS_LED_BIT5
-	"5|"
-#endif
-#endif
-#ifdef STATUS_LED_GREEN
-	"green|"
-#endif
-#ifdef STATUS_LED_YELLOW
-	"yellow|"
-#endif
-#ifdef STATUS_LED_RED
-	"red|"
-#endif
-#ifdef STATUS_LED_BLUE
-	"blue|"
-#endif
-	"all] [on|off|toggle|blink] [blink-freq in ms]",
-	"[led_name] [on|off|toggle|blink] sets or clears led(s)"
+	"[led_name|all] [on|off|toggle|blink|list] [blink-freq in ms]",
+	"if 'all' is given as led-name, all known leds will be affected by the command\n"
+	"[on] sets an led\n"
+	"[off] clears an led\n"
+	"[toggle] inverts an led\n"
+	"[blink freq] let an led blink, if supported by the controller\n"
+	"[list] shows the name of known led\n"
 );

index 784ac87..f5fbbcb 100644
@@ -32,6 +32,12 @@ int led_get_by_label(const char *label, struct udevice **devp)
 	return -ENODEV;
 }
 
+const char *led_get_label(struct udevice *dev)
+{
+	struct led_uclass_plat *uc_plat = dev_get_uclass_platdata(dev);
+	return uc_plat->label;
+}
+
 int led_set_on(struct udevice *dev, int on)
 {
 	struct led_ops *ops = led_get_ops(dev);

index b929d0c..32e0dec 100644
@@ -40,6 +40,14 @@ struct led_ops {
 int led_get_by_label(const char *label, struct udevice **devp);
 
 /**
+ * led_get_label() - get the label of a given led-device
+ *
+ * @dev:	led device
+ * @return the name of the led
+ */
+const char *led_get_label(struct udevice *dev);
+
+/**
  * led_set_on() - set the state of an LED
  *
  * @dev:	LED device to change

index f5fbbcb..ce519d0 100644
@@ -32,6 +32,59 @@ int led_get_by_label(const char *label, struct udevice **devp)
 	return -ENODEV;
 }
 
+int led_count(void)
+{
+	int cnt = 0;
+	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_uclass_plat *uc_plat = dev_get_uclass_platdata(dev);
+
+		/* Ignore the top-level LED node */
+		if (uc_plat->label)
+			cnt++;
+	}
+
+	return cnt;
+}
+
+int led_get_all(struct udevice **devarr, int maxret)
+{
+	int cnt = 0;
+	struct udevice *dev;
+	struct uclass *uc;
+	int ret;
+
+	ret = uclass_get(UCLASS_LED, &uc);
+	if (ret)
+		return ret;
+
+	if(maxret <= cnt)
+		return cnt;
+
+	uclass_foreach_dev(dev, uc) {
+		struct led_uclass_plat *uc_plat = dev_get_uclass_platdata(dev);
+
+		/* Ignore the top-level LED node */
+		if (uc_plat->label) {
+			ret = uclass_get_device_tail(dev, 0, &devarr[cnt]);
+			if(ret)
+				return ret;
+			cnt++;
+			if(cnt >= maxret)
+				return cnt;
+		}
+	}
+
+	return cnt;
+}
+
 const char *led_get_label(struct udevice *dev)
 {
 	struct led_uclass_plat *uc_plat = dev_get_uclass_platdata(dev);

index 32e0dec..4b1bd56 100644
@@ -48,6 +48,24 @@ int led_get_by_label(const char *label, struct udevice **devp);
 const char *led_get_label(struct udevice *dev);
 
 /**
+ * led_count() - retrieve the number of DM-configured LEDs
+ *
+ * @return the number of leds found
+ */
+int led_count(void);
+
+/**
+ * led_get_all() - retrieve an array of DM-configured LEDs
+ *
+ * Should return at most led_count() leds.
+ *
+ * @devarr:	pointer to an array of led-device, to be filled.
+ * @maxitm:	pre-allocated size of the array
+ * @return number of leds filled into @devarr
+ */
+int led_get_all(struct udevice **devarr, int maxitm);
+
+/**
  * led_set_on() - set the state of an LED
  *
  * @dev:	LED device to change

index 5295a6e..7632074 100644
@@ -186,6 +186,54 @@ LED_TBL_STATUS(5, STATUS_LED_BIT5);
 #define LED_TEST_5(name)	while(0)
 #endif
 
+#ifdef CONFIG_LED
+#include <led.h>
+
+static void _led_dm_onoff(const led_tbl_t *led, enum led_cmd cmd, char *arg)
+{
+	struct udevice *dev = NULL;
+	if(led_get_by_label(led->string, &dev))
+		return;
+	if(dev)
+		led_set_on(dev, cmd == LED_ON);
+}
+
+// this isn't const, as the string will be replaced by the current led's label, always.
+static led_tbl_t _led_dm = {
+	.op = {
+		[LED_ON] = _led_dm_onoff,
+		[LED_OFF] = _led_dm_onoff,
+		[LED_LIST] = _led_list_name,
+	},
+};
+
+static const led_tbl_t *_led_dm_get(const char *name) {
+	struct udevice *dev = NULL;
+	if(led_get_by_label(name, &dev))
+		return NULL;
+	if(!dev)
+		return NULL;
+	_led_dm.string = name;
+	return &_led_dm;
+}
+
+#define LED_DM_COUNT()	led_count()
+static int led_dm_list(const char **tbl, int size) {
+	struct udevice *devs[size];
+	int cnt = led_get_all(devs, size);
+	int i;
+	for(i = 0; i < cnt; i++)
+		tbl[i] = led_get_label(devs[i]);
+	return cnt;
+}
+#define LED_TEST_DM(name) return _led_dm_get(name)
+
+#else
+#define LED_TEST_DM(name)	return NULL
+#define LED_DM_COUNT()		0
+#define led_dm_list(tbl, size)	0
+#endif
+
 static int _led_count(void) {
 	int i = 0;
 	if(LED_NAME_GREEN) i++;

@@ -198,6 +246,7 @@ static int _led_count(void) {
 	if(LED_NAME_3) i++;
 	if(LED_NAME_4) i++;
 	if(LED_NAME_5) i++;
+	i += LED_DM_COUNT();
 	return i;
 }
 

@@ -214,6 +263,7 @@ static int _led_list(const char **tbl, int size) {
 	TEST_ADD_NAME(LED_NAME_3, tbl, size);
 	TEST_ADD_NAME(LED_NAME_4, tbl, size);
 	TEST_ADD_NAME(LED_NAME_5, tbl, size);
+	size -= led_dm_list(tbl, size);
 	return init_size - size;
 }
 

@@ -251,7 +301,8 @@ static const led_tbl_t *get_led(const char *name) {
 	LED_TEST_3(name);
 	LED_TEST_4(name);
 	LED_TEST_5(name);
-	return NULL;
+	// must be last, returns always
+	LED_TEST_DM(name);
 }
 
 enum led_cmd get_led_cmd(char *var)

index ce519d0..7d7dec3 100644
@@ -101,6 +101,16 @@ int led_set_on(struct udevice *dev, int on)
 	return ops->set_on(dev, on);
 }
 
+int led_get_on(struct udevice *dev)
+{
+	struct led_ops *ops = led_get_ops(dev);
+
+	if (!ops->get_on)
+		return -ENOSYS;
+
+	return ops->get_on(dev);
+}
+
 UCLASS_DRIVER(led) = {
 	.id		= UCLASS_LED,
 	.name		= "led",

index 4b1bd56..4709013 100644
@@ -26,6 +26,16 @@ struct led_ops {
 	 * @return 0 if OK, -ve on error
 	 */
 	int (*set_on)(struct udevice *dev, int on);
+
+	/**
+	 * get_on() - get the current state of an LED
+	 *
+	 * function is optional.
+	 *
+	 * @dev:	LED device to check
+	 * @return 0 if OFF, 1 if ON, -ve on error
+	 */
+	int (*get_on)(struct udevice *dev);
 };
 
 #define led_get_ops(dev)	((struct led_ops *)(dev)->driver->ops)

@@ -74,4 +84,12 @@ int led_get_all(struct udevice **devarr, int maxitm);
  */
 int led_set_on(struct udevice *dev, int on);
 
+/**
+ * led_get_on() - get the current state of an LED
+ *
+ * @dev:	LED device to check
+ * @return 0 if OFF, 1 if ON, -ve on error
+ */
+int led_get_on(struct udevice *dev);
+
 #endif

index cb6e996..80e0f72 100644
@@ -28,6 +28,16 @@ static int gpio_led_set_on(struct udevice *dev, int on)
 	return dm_gpio_set_value(&priv->gpio, on);
 }
 
+static int gpio_led_get_on(struct udevice *dev)
+{
+	struct led_gpio_priv *priv = dev_get_priv(dev);
+
+	if (!dm_gpio_is_valid(&priv->gpio))
+		return -EREMOTEIO;
+
+	return dm_gpio_get_value(&priv->gpio);
+}
+
 static int led_gpio_probe(struct udevice *dev)
 {
 	struct led_uclass_plat *uc_plat = dev_get_uclass_platdata(dev);

@@ -88,6 +98,7 @@ static int led_gpio_bind(struct udevice *parent)
 
 static const struct led_ops gpio_led_ops = {
 	.set_on		= gpio_led_set_on,
+	.get_on		= gpio_led_get_on,
 };
 
 static const struct udevice_id led_gpio_ids[] = {

index 7d7dec3..22d2264 100644
@@ -111,6 +111,20 @@ int led_get_on(struct udevice *dev)
 	return ops->get_on(dev);
 }
 
+int led_toggle(struct udevice *dev)
+{
+	struct led_ops *ops = led_get_ops(dev);
+	int on;
+
+	if (ops->toggle)
+		return ops->toggle(dev);
+
+	on = led_get_on(dev);
+	if(on < 0)
+		return -ENOSYS;
+	return led_set_on(dev, !on);
+}
+
 UCLASS_DRIVER(led) = {
 	.id		= UCLASS_LED,
 	.name		= "led",

index 4709013..f70db00 100644
@@ -36,6 +36,17 @@ struct led_ops {
 	 * @return 0 if OFF, 1 if ON, -ve on error
 	 */
 	int (*get_on)(struct udevice *dev);
+
+	/**
+	 * toggle() - toggle the state of an LED
+	 *
+	 * will turn off the LED if it's on and vice versa.
+	 * Optional. If not given, a fallback using get_on/set_on is provided.
+	 *
+	 * @dev:	LED device to change
+	 * @return 0 if OK, -ve on error
+	 */
+	int (*toggle)(struct udevice *dev);
 };
 
 #define led_get_ops(dev)	((struct led_ops *)(dev)->driver->ops)

@@ -92,4 +103,14 @@ int led_set_on(struct udevice *dev, int on);
  */
 int led_get_on(struct udevice *dev);
 
+/**
+ * led_toggle() - toggle the state of an LED
+ *
+ * will turn off the LED if it's on and vice versa.
+ *
+ * @dev:	LED device to change
+ * @return 0 if OK, -ve on error
+ */
+int led_toggle(struct udevice *dev);
+
 #endif

index 7632074..217ec5a 100644
@@ -198,11 +198,21 @@ static void _led_dm_onoff(const led_tbl_t *led, enum led_cmd cmd, char *arg)
 		led_set_on(dev, cmd == LED_ON);
 }
 
+static void _led_dm_toggle(const led_tbl_t *led, enum led_cmd cmd, char *arg)
+{
+	struct udevice *dev = NULL;
+	if(led_get_by_label(led->string, &dev))
+		return;
+	if(dev)
+		led_toggle(dev);
+}
+
 // this isn't const, as the string will be replaced by the current led's label, always.
 static led_tbl_t _led_dm = {
 	.op = {
 		[LED_ON] = _led_dm_onoff,
 		[LED_OFF] = _led_dm_onoff,
+		[LED_TOGGLE] = _led_dm_toggle,
 		[LED_LIST] = _led_list_name,
 	},
 };