[linux-2.6-block.git] / drivers / leds / leds-ip30.c

// SPDX-License-Identifier: GPL-2.0
/*
 * LED Driver for SGI Octane machines
 */

#include <asm/io.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/leds.h>

#define IP30_LED_SYSTEM	0
#define IP30_LED_FAULT	1

struct ip30_led {
	struct led_classdev cdev;
	u32 __iomem *reg;
};

static void ip30led_set(struct led_classdev *led_cdev,
			enum led_brightness value)
{
	struct ip30_led *led = container_of(led_cdev, struct ip30_led, cdev);

	writel(value, led->reg);
}

static int ip30led_create(struct platform_device *pdev, int num)
{
	struct resource *res;
	struct ip30_led *data;

	res = platform_get_resource(pdev, IORESOURCE_MEM, num);
	if (!res)
		return -EBUSY;

	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->reg = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(data->reg))
		return PTR_ERR(data->reg);


	switch (num) {
	case IP30_LED_SYSTEM:
		data->cdev.name = "white:power";
		break;
	case IP30_LED_FAULT:
		data->cdev.name = "red:fault";
		break;
	default:
		return -EINVAL;
	}

	data->cdev.brightness = readl(data->reg);
	data->cdev.max_brightness = 1;
	data->cdev.brightness_set = ip30led_set;

	return devm_led_classdev_register(&pdev->dev, &data->cdev);
}

static int ip30led_probe(struct platform_device *pdev)
{
	int ret;

	ret = ip30led_create(pdev, IP30_LED_SYSTEM);
	if (ret < 0)
		return ret;

	return ip30led_create(pdev, IP30_LED_FAULT);
}

static struct platform_driver ip30led_driver = {
	.probe		= ip30led_probe,
	.driver		= {
		.name		= "ip30-leds",
	},
};

module_platform_driver(ip30led_driver);

MODULE_AUTHOR("Thomas Bogendoerfer <tbogendoerfer@suse.de>");
MODULE_DESCRIPTION("SGI Octane LED driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ip30-leds");
Commit	Line	Data
64d7e231 TB	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* LED Driver for SGI Octane machines
	4	*/
	5
2aebb780	6	#include <asm/io.h>
64d7e231 TB	7	#include <linux/module.h>
	8	#include <linux/kernel.h>
	9	#include <linux/platform_device.h>
	10	#include <linux/leds.h>
	11
	12	#define IP30_LED_SYSTEM 0
	13	#define IP30_LED_FAULT 1
	14
	15	struct ip30_led {
	16	struct led_classdev cdev;
	17	u32 __iomem *reg;
	18	};
	19
	20	static void ip30led_set(struct led_classdev *led_cdev,
	21	enum led_brightness value)
	22	{
	23	struct ip30_led *led = container_of(led_cdev, struct ip30_led, cdev);
	24
	25	writel(value, led->reg);
	26	}
	27
	28	static int ip30led_create(struct platform_device *pdev, int num)
	29	{
	30	struct resource *res;
	31	struct ip30_led *data;
	32
	33	res = platform_get_resource(pdev, IORESOURCE_MEM, num);
	34	if (!res)
	35	return -EBUSY;
	36
	37	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	38	if (!data)
	39	return -ENOMEM;
	40
	41	data->reg = devm_ioremap_resource(&pdev->dev, res);
	42	if (IS_ERR(data->reg))
	43	return PTR_ERR(data->reg);
	44
	45
	46	switch (num) {
	47	case IP30_LED_SYSTEM:
19aa9840	48	data->cdev.name = "white:power";
64d7e231 TB	49	break;
	50	case IP30_LED_FAULT:
	51	data->cdev.name = "red:fault";
	52	break;
	53	default:
	54	return -EINVAL;
	55	}
	56
	57	data->cdev.brightness = readl(data->reg);
	58	data->cdev.max_brightness = 1;
	59	data->cdev.brightness_set = ip30led_set;
	60
	61	return devm_led_classdev_register(&pdev->dev, &data->cdev);
	62	}
	63
	64	static int ip30led_probe(struct platform_device *pdev)
	65	{
	66	int ret;
	67
	68	ret = ip30led_create(pdev, IP30_LED_SYSTEM);
	69	if (ret < 0)
	70	return ret;
	71
	72	return ip30led_create(pdev, IP30_LED_FAULT);
	73	}
	74
	75	static struct platform_driver ip30led_driver = {
	76	.probe = ip30led_probe,
	77	.driver = {
	78	.name = "ip30-leds",
	79	},
	80	};
	81
	82	module_platform_driver(ip30led_driver);
	83
	84	MODULE_AUTHOR("Thomas Bogendoerfer <tbogendoerfer@suse.de>");
	85	MODULE_DESCRIPTION("SGI Octane LED driver");
	86	MODULE_LICENSE("GPL");
	87	MODULE_ALIAS("platform:ip30-leds");