leds: core: Add support for composing LED class device names

Is currently of the form:

	"devicename:colour:function"

There have been calls for LED properties such as colour to be exported as

	"devicename:color:function"

- devicename:

        it should refer to a unique identifier created by the kernel,

        like e.g. phyN for network devices or inputN for input devices, rather

        than to the hardware; the information related to the product and the bus

        to which given device is hooked is available in sysfs and can be

        retrieved using get_led_device_info.sh script from tools/leds; generally

        this section is expected mostly for LEDs that are somehow associated with

        other devices.

- color:

        one of LED_COLOR_ID_* definitions from the header

        include/dt-bindings/leds/common.h.

- function:

        one of LED_FUNCTION_* definitions from the header

        include/dt-bindings/leds/common.h.

If required color or function is missing, please submit a patch

to linux-leds@vger.kernel.org.

It is possible that more than one LED with the same color and function will

be required for given platform, differing only with an ordinal number.

In this case it is preferable to just concatenate the predefined LED_FUNCTION_*

name with required "-N" suffix in the driver. fwnode based drivers can use

function-enumerator property for that and then the concatenation will be handled

automatically by the LED core upon LED class device registration.

LED subsystem has also a protection against name clash, that may occur

when LED class device is created by a driver of hot-pluggable device and

it doesn't provide unique devicename section. In this case numerical

suffix (e.g. "_1", "_2", "_3" etc.) is added to the requested LED class

device name.

There might be still LED class drivers around using vendor or product name

for devicename, but this approach is now deprecated as it doesn't convey

any added value. Product information can be found in other places in sysfs

(see tools/leds/get_led_device_info.sh).

Examples of proper LED names:

  - "red:disk"

  - "white:flash"

  - "red:indicator"

  - "phy1:green:wlan"

  - "phy3::wlan"

  - ":kbd_backlight"

  - "input5::kbd_backlight"

  - "input3::numlock"

  - "input3::scrolllock"

  - "input3::capslock"

  - "mmc1::status"

  - "white:status"

get_led_device_info.sh script can be used for verifying if the LED name

meets the requirements pointed out here. It performs validation of the LED class

devicename sections and gives hints on expected value for a section in case

the validation fails for it. So far the script supports validation

of associations between LEDs and following types of devices:

        - input devices

        - ieee80211 compliant USB devices

The script is open to extensions.

There have been calls for LED properties such as color to be exported as

individual led class attributes. As a solution which doesn't incur as much

overhead, I suggest these become part of the device name. The naming scheme

above leaves scope for further attributes should they be needed. If sections

			      struct led_classdev *led_cdev,

			      struct led_init_data *init_data)

{

	char name[LED_MAX_NAME_SIZE];

	char composed_name[LED_MAX_NAME_SIZE];

	char final_name[LED_MAX_NAME_SIZE];

	const char *proposed_name = composed_name;

	int ret;

	ret = led_classdev_next_name(led_cdev->name, name, sizeof(name));

	if (init_data) {

		if (init_data->devname_mandatory && !init_data->devicename) {

			dev_err(parent, "Mandatory device name is missing");

			return -EINVAL;

		}

		ret = led_compose_name(parent, init_data, composed_name);

		if (ret < 0)

			return ret;

	} else {

		proposed_name = led_cdev->name;

	}

	ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));

	if (ret < 0)

		return ret;

	mutex_init(&led_cdev->led_access);

	mutex_lock(&led_cdev->led_access);

	led_cdev->dev = device_create_with_groups(leds_class, parent, 0,

				led_cdev, led_cdev->groups, "%s", name);

				led_cdev, led_cdev->groups, "%s", final_name);

	if (IS_ERR(led_cdev->dev)) {

		mutex_unlock(&led_cdev->led_access);

		return PTR_ERR(led_cdev->dev);

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/of.h>

#include <linux/property.h>

#include <linux/rwsem.h>

#include <linux/slab.h>

#include <uapi/linux/uleds.h>

#include "leds.h"

DECLARE_RWSEM(leds_list_lock);

LIST_HEAD(leds_list);

EXPORT_SYMBOL_GPL(leds_list);

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",

};

EXPORT_SYMBOL_GPL(led_colors);

static int __led_set_brightness(struct led_classdev *led_cdev,

				enum led_brightness value)

{

	led_cdev->flags &= ~LED_SYSFS_DISABLE;

}

EXPORT_SYMBOL_GPL(led_sysfs_enable);

static void led_parse_fwnode_props(struct device *dev,

				   struct fwnode_handle *fwnode,

				   struct led_properties *props)

{

	int ret;

	if (!fwnode)

		return;

	if (fwnode_property_present(fwnode, "label")) {

		ret = fwnode_property_read_string(fwnode, "label", &props->label);

		if (ret)

			dev_err(dev, "Error parsing 'label' property (%d)\n", ret);

		return;

	}

	if (fwnode_property_present(fwnode, "color")) {

		ret = fwnode_property_read_u32(fwnode, "color", &props->color);

		if (ret)

			dev_err(dev, "Error parsing 'color' property (%d)\n", ret);

		else if (props->color >= LED_COLOR_ID_MAX)

			dev_err(dev, "LED color identifier out of range\n");

		else

			props->color_present = true;

	}

	if (!fwnode_property_present(fwnode, "function"))

		return;

	ret = fwnode_property_read_string(fwnode, "function", &props->function);

	if (ret) {

		dev_err(dev,

			"Error parsing 'function' property (%d)\n",

			ret);

	}

	if (!fwnode_property_present(fwnode, "function-enumerator"))

		return;

	ret = fwnode_property_read_u32(fwnode, "function-enumerator",

				       &props->func_enum);

	if (ret) {

		dev_err(dev,

			"Error parsing 'function-enumerator' property (%d)\n",

			ret);

	} else {

		props->func_enum_present = true;

	}

}

int led_compose_name(struct device *dev, struct led_init_data *init_data,

		     char *led_classdev_name)

{

	struct led_properties props = {};

	struct fwnode_handle *fwnode = init_data->fwnode;

	const char *devicename = init_data->devicename;

	if (!led_classdev_name)

		return -EINVAL;

	led_parse_fwnode_props(dev, fwnode, &props);

	if (props.label) {

		/*

		 * If init_data.devicename is NULL, then it indicates that

		 * DT label should be used as-is for LED class device name.

		 * Otherwise the label is prepended with devicename to compose

		 * the final LED class device name.

		 */

		if (!devicename) {

			strscpy(led_classdev_name, props.label,

				LED_MAX_NAME_SIZE);

		} else {

			snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",

				 devicename, props.label);

		}

	} else if (props.function || props.color_present) {

		char tmp_buf[LED_MAX_NAME_SIZE];

		if (props.func_enum_present) {

			snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s-%d",

				 props.color_present ? led_colors[props.color] : "",

				 props.function ?: "", props.func_enum);

		} else {

			snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s",

				 props.color_present ? led_colors[props.color] : "",

				 props.function ?: "");

		}

		if (init_data->devname_mandatory) {

			snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",

				 devicename, tmp_buf);

		} else {

			strscpy(led_classdev_name, tmp_buf, LED_MAX_NAME_SIZE);

		}

	} else if (init_data->default_label) {

		if (!devicename) {

			dev_err(dev, "Legacy LED naming requires devicename segment");

			return -EINVAL;

		}

		snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",

			 devicename, init_data->default_label);

	} else if (is_of_node(fwnode)) {

		strscpy(led_classdev_name, to_of_node(fwnode)->name,

			LED_MAX_NAME_SIZE);

	} else

		return -EINVAL;

	return 0;

}

EXPORT_SYMBOL_GPL(led_compose_name);

extern struct rw_semaphore leds_list_lock;

extern struct list_head leds_list;

extern struct list_head trigger_list;

extern const char * const led_colors[LED_COLOR_ID_MAX];

#endif	/* __LEDS_H_INCLUDED */

#ifndef __LINUX_LEDS_H_INCLUDED

#define __LINUX_LEDS_H_INCLUDED

#include <dt-bindings/leds/common.h>

#include <linux/device.h>

#include <linux/kernfs.h>

#include <linux/list.h>

struct led_init_data {

	/* device fwnode handle */

	struct fwnode_handle *fwnode;

	/*

	 * default <color:function> tuple, for backward compatibility

	 * with in-driver hard-coded LED names used as a fallback when

	 * DT "label" property is absent; it should be set to NULL

	 * in new LED class drivers.

	 */

	const char *default_label;

	/*

	 * string to be used for devicename section of LED class device

	 * either for label based LED name composition path or for fwnode

	 * based when devname_mandatory is true

	 */

	const char *devicename;

	/*

	 * indicates if LED name should always comprise devicename section;

	 * only LEDs exposed by drivers of hot-pluggable devices should

	 * set it to true

	 */

	bool devname_mandatory;

};

struct led_classdev {

 */

extern void led_sysfs_enable(struct led_classdev *led_cdev);

/**

 * led_compose_name - compose LED class device name

 * @dev: LED controller device object

 * @child: child fwnode_handle describing a LED or a group of synchronized LEDs;

 *	   it must be provided only for fwnode based LEDs

 * @led_classdev_name: composed LED class device name

 *

 * Create LED class device name basing on the provided init_data argument.

 * The name can have <devicename:color:function> or <color:function>.

 * form, depending on the init_data configuration.

 *

 * Returns: 0 on success or negative error value on failure

 */

extern int led_compose_name(struct device *dev, struct led_init_data *init_data,

			    char *led_classdev_name);

/**

 * led_sysfs_is_disabled - check if LED sysfs interface is disabled

 * @led_cdev: the LED to query

	struct led_info	*leds;

};

struct led_properties {

	u32		color;

	bool		color_present;

	const char	*function;

	u32		func_enum;

	bool		func_enum_present;

	const char	*label;

};

struct gpio_desc;

typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,

				unsigned long *delay_on,