Commit a917d4b4 authored by Linus Walleij's avatar Linus Walleij
Browse files

leds: syscon: instantiate from platform device 



Currently syscon LEDs will traverse the device tree looking for syscon devices
and if found, traverse any subnodes of these to identify matching children
and from there instantiate LED class devices.

This is not a good use of the Linux device model. Instead we have converted the
device trees to add the "simple-mfd" property to the MFD nexi spawning syscon
LEDs so that these will appear as platform devices in the system and we can
use the proper device probing mechanism.

Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Lee Jones <lee.jones@linaro.org>
Cc: Pawel Moll <pawel.moll@arm.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: default avatarBjorn Andersson <bjorn.andersson@sonymobile.com>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
parent 480aa74c

drivers/leds/leds-syscon.c

+85 −85
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 
 * MA 02111-1307 USA

 */

#include <linux/io.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/of_address.h>

#include <linux/platform_device.h>
@@ -66,21 +67,26 @@ static void syscon_led_set(struct led_classdev *led_cdev, 
		dev_err(sled->cdev.dev, "error updating LED status\n");

}



static int __init syscon_leds_spawn(struct device_node *np,

				    struct device *dev,

				    struct regmap *map)

static int syscon_led_probe(struct platform_device *pdev)

{

	struct device_node *child;

	int ret;



	for_each_available_child_of_node(np, child) {

	struct device *dev = &pdev->dev;

	struct device_node *np = dev->of_node;

	struct device *parent;

	struct regmap *map;

	struct syscon_led *sled;

	const char *state;

	int ret;



		/* Only check for register-bit-leds */

		if (of_property_match_string(child, "compatible",

					     "register-bit-led") < 0)

			continue;

	parent = dev->parent;

	if (!parent) {

		dev_err(dev, "no parent for syscon LED\n");

		return -ENODEV;

	}

	map = syscon_node_to_regmap(parent->of_node);

	if (!map) {

		dev_err(dev, "no regmap for syscon LED parent\n");

		return -ENODEV;

	}



	sled = devm_kzalloc(dev, sizeof(*sled), GFP_KERNEL);

	if (!sled)
@@ -88,16 +94,16 @@ static int __init syscon_leds_spawn(struct device_node *np, 


	sled->map = map;



		if (of_property_read_u32(child, "offset", &sled->offset))

	if (of_property_read_u32(np, "offset", &sled->offset))

		return -EINVAL;

		if (of_property_read_u32(child, "mask", &sled->mask))

	if (of_property_read_u32(np, "mask", &sled->mask))

		return -EINVAL;

	sled->cdev.name =

			of_get_property(child, "label", NULL) ? : child->name;

		of_get_property(np, "label", NULL) ? : np->name;

	sled->cdev.default_trigger =

			of_get_property(child, "linux,default-trigger", NULL);

		of_get_property(np, "linux,default-trigger", NULL);



		state = of_get_property(child, "default-state", NULL);

	state = of_get_property(np, "default-state", NULL);

	if (state) {

		if (!strcmp(state, "keep")) {

			u32 val;
@@ -127,41 +133,35 @@ static int __init syscon_leds_spawn(struct device_node *np, 
	if (ret < 0)

		return ret;



	platform_set_drvdata(pdev, sled);

	dev_info(dev, "registered LED %s\n", sled->cdev.name);

	}



	return 0;

}



static int __init syscon_leds_init(void)

static int syscon_led_remove(struct platform_device *pdev)

{

	struct device_node *np;



	for_each_of_allnodes(np) {

		struct platform_device *pdev;

		struct regmap *map;

		int ret;



		if (!of_device_is_compatible(np, "syscon"))

			continue;

	struct syscon_led *sled = platform_get_drvdata(pdev);



		map = syscon_node_to_regmap(np);

		if (IS_ERR(map)) {

			pr_err("error getting regmap for syscon LEDs\n");

			continue;

	led_classdev_unregister(&sled->cdev);

	/* Turn it off */

	regmap_update_bits(sled->map, sled->offset, sled->mask, 0);

	return 0;

}



		/*

		 * If the map is there, the device should be there, we allocate

		 * memory on the syscon device's behalf here.

		 */

		pdev = of_find_device_by_node(np);

		if (!pdev)

			return -ENODEV;

		ret = syscon_leds_spawn(np, &pdev->dev, map);

		if (ret)

			dev_err(&pdev->dev, "could not spawn syscon LEDs\n");

	}

static const struct of_device_id of_syscon_leds_match[] = {

	{ .compatible = "register-bit-led", },

	{},

};



	return 0;

}

device_initcall(syscon_leds_init);
 
MODULE_DEVICE_TABLE(of, of_syscon_leds_match);



static struct platform_driver syscon_led_driver = {

	.probe		= syscon_led_probe,

	.remove		= syscon_led_remove,

	.driver		= {

		.name	= "leds-syscon",

		.of_match_table = of_syscon_leds_match,

	},

};

module_platform_driver(syscon_led_driver);

CRA Git | Maintained and supported by SUSTech CRA and CCSE