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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LEDs driver for PCEngines WRAP
 *
 * Copyright (C) 2006 Kristian Kielhofner <kris@krisk.org>
 *
 * Based on leds-net48xx.c
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/scx200_gpio.h>
#include <linux/module.h>

#define DRVNAME "wrap-led"
#define WRAP_POWER_LED_GPIO	2
#define WRAP_ERROR_LED_GPIO	3
#define WRAP_EXTRA_LED_GPIO	18

static struct platform_device *pdev;

static void wrap_power_led_set(struct led_classdev *led_cdev,
		enum led_brightness value)
{
	if (value)
		scx200_gpio_set_low(WRAP_POWER_LED_GPIO);
	else
		scx200_gpio_set_high(WRAP_POWER_LED_GPIO);
}

static void wrap_error_led_set(struct led_classdev *led_cdev,
		enum led_brightness value)
{
	if (value)
		scx200_gpio_set_low(WRAP_ERROR_LED_GPIO);
	else
		scx200_gpio_set_high(WRAP_ERROR_LED_GPIO);
}

static void wrap_extra_led_set(struct led_classdev *led_cdev,
		enum led_brightness value)
{
	if (value)
		scx200_gpio_set_low(WRAP_EXTRA_LED_GPIO);
	else
		scx200_gpio_set_high(WRAP_EXTRA_LED_GPIO);
}

static struct led_classdev wrap_power_led = {
	.name			= "wrap::power",
	.brightness_set		= wrap_power_led_set,
	.default_trigger	= "default-on",
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev wrap_error_led = {
	.name		= "wrap::error",
	.brightness_set	= wrap_error_led_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev wrap_extra_led = {
	.name           = "wrap::extra",
	.brightness_set = wrap_extra_led_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

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

	ret = devm_led_classdev_register(&pdev->dev, &wrap_power_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &wrap_error_led);
	if (ret < 0)
		return ret;

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

static struct platform_driver wrap_led_driver = {
	.probe		= wrap_led_probe,
	.driver		= {
		.name		= DRVNAME,
	},
};

static int __init wrap_led_init(void)
{
	int ret;

	if (!scx200_gpio_present()) {
		ret = -ENODEV;
		goto out;
	}

	ret = platform_driver_register(&wrap_led_driver);
	if (ret < 0)
		goto out;

	pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
	if (IS_ERR(pdev)) {
		ret = PTR_ERR(pdev);
		platform_driver_unregister(&wrap_led_driver);
		goto out;
	}

out:
	return ret;
}

static void __exit wrap_led_exit(void)
{
	platform_device_unregister(pdev);
	platform_driver_unregister(&wrap_led_driver);
}

module_init(wrap_led_init);
module_exit(wrap_led_exit);

MODULE_AUTHOR("Kristian Kielhofner <kris@krisk.org>");
MODULE_DESCRIPTION("PCEngines WRAP LED driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
0d75565f KK	2	/*
	3	* LEDs driver for PCEngines WRAP
	4	*
	5	* Copyright (C) 2006 Kristian Kielhofner <kris@krisk.org>
	6	*
	7	* Based on leds-net48xx.c
0d75565f KK	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/init.h>
	12	#include <linux/platform_device.h>
	13	#include <linux/leds.h>
	14	#include <linux/err.h>
572dc620	15	#include <linux/io.h>
0d75565f	16	#include <linux/scx200_gpio.h>
54f4dedb	17	#include <linux/module.h>
0d75565f KK	18
0d75565f KK	19	#define DRVNAME "wrap-led"
f5506a2f	20	#define WRAP_POWER_LED_GPIO 2
0d75565f	21	#define WRAP_ERROR_LED_GPIO 3
f5506a2f	22	#define WRAP_EXTRA_LED_GPIO 18
0d75565f KK	23
	24	static struct platform_device *pdev;
	25
f5506a2f ML	26	static void wrap_power_led_set(struct led_classdev *led_cdev,
	27	enum led_brightness value)
	28	{
	29	if (value)
	30	scx200_gpio_set_low(WRAP_POWER_LED_GPIO);
	31	else
	32	scx200_gpio_set_high(WRAP_POWER_LED_GPIO);
	33	}
	34
0d75565f KK	35	static void wrap_error_led_set(struct led_classdev *led_cdev,
	36	enum led_brightness value)
	37	{
	38	if (value)
	39	scx200_gpio_set_low(WRAP_ERROR_LED_GPIO);
	40	else
	41	scx200_gpio_set_high(WRAP_ERROR_LED_GPIO);
	42	}
	43
	44	static void wrap_extra_led_set(struct led_classdev *led_cdev,
	45	enum led_brightness value)
	46	{
	47	if (value)
	48	scx200_gpio_set_low(WRAP_EXTRA_LED_GPIO);
	49	else
	50	scx200_gpio_set_high(WRAP_EXTRA_LED_GPIO);
	51	}
	52
f5506a2f	53	static struct led_classdev wrap_power_led = {
6af4f55c SW	54	.name = "wrap::power",
	55	.brightness_set = wrap_power_led_set,
	56	.default_trigger = "default-on",
859cb7f2	57	.flags = LED_CORE_SUSPENDRESUME,
f5506a2f ML	58	};
f5506a2f ML	59
0d75565f	60	static struct led_classdev wrap_error_led = {
6c152bee	61	.name = "wrap::error",
0d75565f	62	.brightness_set = wrap_error_led_set,
859cb7f2	63	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	64	};
	65
	66	static struct led_classdev wrap_extra_led = {
6c152bee	67	.name = "wrap::extra",
0d75565f	68	.brightness_set = wrap_extra_led_set,
859cb7f2	69	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	70	};
0d75565f KK	71
0d75565f KK	72	static int wrap_led_probe(struct platform_device *pdev)
	73	{
	74	int ret;
	75
e9aadb86	76	ret = devm_led_classdev_register(&pdev->dev, &wrap_power_led);
f5506a2f ML	77	if (ret < 0)
	78	return ret;
	79
e9aadb86	80	ret = devm_led_classdev_register(&pdev->dev, &wrap_error_led);
f5506a2f	81	if (ret < 0)
e9aadb86	82	return ret;
0d75565f	83
e9aadb86	84	return devm_led_classdev_register(&pdev->dev, &wrap_extra_led);
0d75565f KK	85	}
	86
	87	static struct platform_driver wrap_led_driver = {
	88	.probe = wrap_led_probe,
0d75565f KK	89	.driver = {
0d75565f KK	90	.name = DRVNAME,
0d75565f KK	91	},
	92	};
	93
	94	static int __init wrap_led_init(void)
	95	{
	96	int ret;
	97
	98	if (!scx200_gpio_present()) {
	99	ret = -ENODEV;
	100	goto out;
	101	}
	102
	103	ret = platform_driver_register(&wrap_led_driver);
	104	if (ret < 0)
	105	goto out;
	106
	107	pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
	108	if (IS_ERR(pdev)) {
	109	ret = PTR_ERR(pdev);
	110	platform_driver_unregister(&wrap_led_driver);
	111	goto out;
	112	}
	113
	114	out:
	115	return ret;
	116	}
	117
	118	static void __exit wrap_led_exit(void)
	119	{
	120	platform_device_unregister(pdev);
	121	platform_driver_unregister(&wrap_led_driver);
	122	}
	123
	124	module_init(wrap_led_init);
	125	module_exit(wrap_led_exit);
	126
	127	MODULE_AUTHOR("Kristian Kielhofner <kris@krisk.org>");
	128	MODULE_DESCRIPTION("PCEngines WRAP LED driver");
	129	MODULE_LICENSE("GPL");
	130