[mirror_ubuntu-zesty-kernel.git] / drivers / leds / leds-wrap.c

/*
 * LEDs driver for PCEngines WRAP
 *
 * Copyright (C) 2006 Kristian Kielhofner <kris@krisk.org>
 *
 * Based on leds-net48xx.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/err.h>
#include <asm/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 = led_classdev_register(&pdev->dev, &wrap_power_led);
	if (ret < 0)
		return ret;

	ret = led_classdev_register(&pdev->dev, &wrap_error_led);
	if (ret < 0)
		goto err1;

	ret = led_classdev_register(&pdev->dev, &wrap_extra_led);
	if (ret < 0)
		goto err2;

	return ret;

err2:
	led_classdev_unregister(&wrap_error_led);
err1:
	led_classdev_unregister(&wrap_power_led);

	return ret;
}

static int wrap_led_remove(struct platform_device *pdev)
{
	led_classdev_unregister(&wrap_power_led);
	led_classdev_unregister(&wrap_error_led);
	led_classdev_unregister(&wrap_extra_led);
	return 0;
}

static struct platform_driver wrap_led_driver = {
	.probe		= wrap_led_probe,
	.remove		= wrap_led_remove,
	.driver		= {
		.name		= DRVNAME,
		.owner		= THIS_MODULE,
	},
};

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
0d75565f KK	1	/*
	2	* LEDs driver for PCEngines WRAP
	3	*
	4	* Copyright (C) 2006 Kristian Kielhofner <kris@krisk.org>
	5	*
	6	* Based on leds-net48xx.c
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/leds.h>
	17	#include <linux/err.h>
	18	#include <asm/io.h>
	19	#include <linux/scx200_gpio.h>
54f4dedb	20	#include <linux/module.h>
0d75565f KK	21
0d75565f KK	22	#define DRVNAME "wrap-led"
f5506a2f	23	#define WRAP_POWER_LED_GPIO 2
0d75565f	24	#define WRAP_ERROR_LED_GPIO 3
f5506a2f	25	#define WRAP_EXTRA_LED_GPIO 18
0d75565f KK	26
	27	static struct platform_device *pdev;
	28
f5506a2f ML	29	static void wrap_power_led_set(struct led_classdev *led_cdev,
	30	enum led_brightness value)
	31	{
	32	if (value)
	33	scx200_gpio_set_low(WRAP_POWER_LED_GPIO);
	34	else
	35	scx200_gpio_set_high(WRAP_POWER_LED_GPIO);
	36	}
	37
0d75565f KK	38	static void wrap_error_led_set(struct led_classdev *led_cdev,
	39	enum led_brightness value)
	40	{
	41	if (value)
	42	scx200_gpio_set_low(WRAP_ERROR_LED_GPIO);
	43	else
	44	scx200_gpio_set_high(WRAP_ERROR_LED_GPIO);
	45	}
	46
	47	static void wrap_extra_led_set(struct led_classdev *led_cdev,
	48	enum led_brightness value)
	49	{
	50	if (value)
	51	scx200_gpio_set_low(WRAP_EXTRA_LED_GPIO);
	52	else
	53	scx200_gpio_set_high(WRAP_EXTRA_LED_GPIO);
	54	}
	55
f5506a2f	56	static struct led_classdev wrap_power_led = {
6af4f55c SW	57	.name = "wrap::power",
	58	.brightness_set = wrap_power_led_set,
	59	.default_trigger = "default-on",
859cb7f2	60	.flags = LED_CORE_SUSPENDRESUME,
f5506a2f ML	61	};
f5506a2f ML	62
0d75565f	63	static struct led_classdev wrap_error_led = {
6c152bee	64	.name = "wrap::error",
0d75565f	65	.brightness_set = wrap_error_led_set,
859cb7f2	66	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	67	};
	68
	69	static struct led_classdev wrap_extra_led = {
6c152bee	70	.name = "wrap::extra",
0d75565f	71	.brightness_set = wrap_extra_led_set,
859cb7f2	72	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	73	};
0d75565f KK	74
0d75565f KK	75	static int wrap_led_probe(struct platform_device *pdev)
	76	{
	77	int ret;
	78
f5506a2f ML	79	ret = led_classdev_register(&pdev->dev, &wrap_power_led);
	80	if (ret < 0)
	81	return ret;
	82
0d75565f	83	ret = led_classdev_register(&pdev->dev, &wrap_error_led);
f5506a2f ML	84	if (ret < 0)
	85	goto err1;
	86
	87	ret = led_classdev_register(&pdev->dev, &wrap_extra_led);
	88	if (ret < 0)
	89	goto err2;
	90
	91	return ret;
	92
	93	err2:
	94	led_classdev_unregister(&wrap_error_led);
	95	err1:
	96	led_classdev_unregister(&wrap_power_led);
	97
0d75565f KK	98	return ret;
	99	}
	100
	101	static int wrap_led_remove(struct platform_device *pdev)
	102	{
f5506a2f	103	led_classdev_unregister(&wrap_power_led);
0d75565f KK	104	led_classdev_unregister(&wrap_error_led);
	105	led_classdev_unregister(&wrap_extra_led);
	106	return 0;
	107	}
	108
	109	static struct platform_driver wrap_led_driver = {
	110	.probe = wrap_led_probe,
	111	.remove = wrap_led_remove,
0d75565f KK	112	.driver = {
	113	.name = DRVNAME,
	114	.owner = THIS_MODULE,
	115	},
	116	};
	117
	118	static int __init wrap_led_init(void)
	119	{
	120	int ret;
	121
	122	if (!scx200_gpio_present()) {
	123	ret = -ENODEV;
	124	goto out;
	125	}
	126
	127	ret = platform_driver_register(&wrap_led_driver);
	128	if (ret < 0)
	129	goto out;
	130
	131	pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
	132	if (IS_ERR(pdev)) {
	133	ret = PTR_ERR(pdev);
	134	platform_driver_unregister(&wrap_led_driver);
	135	goto out;
	136	}
	137
	138	out:
	139	return ret;
	140	}
	141
	142	static void __exit wrap_led_exit(void)
	143	{
	144	platform_device_unregister(pdev);
	145	platform_driver_unregister(&wrap_led_driver);
	146	}
	147
	148	module_init(wrap_led_init);
	149	module_exit(wrap_led_exit);
	150
	151	MODULE_AUTHOR("Kristian Kielhofner <kris@krisk.org>");
	152	MODULE_DESCRIPTION("PCEngines WRAP LED driver");
	153	MODULE_LICENSE("GPL");
	154