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

/*
 * LEDs driver for PCEngines WRAP
 *
 * Copyright (C) 2006 Kristian Kielhofner <[email protected]>
 *
 * 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>

#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 <[email protected]>");
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 <[email protected]>
	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>
	20
	21	#define DRVNAME "wrap-led"
f5506a2f	22	#define WRAP_POWER_LED_GPIO 2
0d75565f	23	#define WRAP_ERROR_LED_GPIO 3
f5506a2f	24	#define WRAP_EXTRA_LED_GPIO 18
0d75565f KK	25
	26	static struct platform_device *pdev;
	27
f5506a2f ML	28	static void wrap_power_led_set(struct led_classdev *led_cdev,
	29	enum led_brightness value)
	30	{
	31	if (value)
	32	scx200_gpio_set_low(WRAP_POWER_LED_GPIO);
	33	else
	34	scx200_gpio_set_high(WRAP_POWER_LED_GPIO);
	35	}
	36
0d75565f KK	37	static void wrap_error_led_set(struct led_classdev *led_cdev,
	38	enum led_brightness value)
	39	{
	40	if (value)
	41	scx200_gpio_set_low(WRAP_ERROR_LED_GPIO);
	42	else
	43	scx200_gpio_set_high(WRAP_ERROR_LED_GPIO);
	44	}
	45
	46	static void wrap_extra_led_set(struct led_classdev *led_cdev,
	47	enum led_brightness value)
	48	{
	49	if (value)
	50	scx200_gpio_set_low(WRAP_EXTRA_LED_GPIO);
	51	else
	52	scx200_gpio_set_high(WRAP_EXTRA_LED_GPIO);
	53	}
	54
f5506a2f	55	static struct led_classdev wrap_power_led = {
6af4f55c SW	56	.name = "wrap::power",
	57	.brightness_set = wrap_power_led_set,
	58	.default_trigger = "default-on",
859cb7f2	59	.flags = LED_CORE_SUSPENDRESUME,
f5506a2f ML	60	};
f5506a2f ML	61
0d75565f	62	static struct led_classdev wrap_error_led = {
6c152bee	63	.name = "wrap::error",
0d75565f	64	.brightness_set = wrap_error_led_set,
859cb7f2	65	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	66	};
	67
	68	static struct led_classdev wrap_extra_led = {
6c152bee	69	.name = "wrap::extra",
0d75565f	70	.brightness_set = wrap_extra_led_set,
859cb7f2	71	.flags = LED_CORE_SUSPENDRESUME,
0d75565f KK	72	};
0d75565f KK	73
0d75565f KK	74	static int wrap_led_probe(struct platform_device *pdev)
	75	{
	76	int ret;
	77
f5506a2f ML	78	ret = led_classdev_register(&pdev->dev, &wrap_power_led);
	79	if (ret < 0)
	80	return ret;
	81
0d75565f	82	ret = led_classdev_register(&pdev->dev, &wrap_error_led);
f5506a2f ML	83	if (ret < 0)
	84	goto err1;
	85
	86	ret = led_classdev_register(&pdev->dev, &wrap_extra_led);
	87	if (ret < 0)
	88	goto err2;
	89
	90	return ret;
	91
	92	err2:
	93	led_classdev_unregister(&wrap_error_led);
	94	err1:
	95	led_classdev_unregister(&wrap_power_led);
	96
0d75565f KK	97	return ret;
	98	}
	99
	100	static int wrap_led_remove(struct platform_device *pdev)
	101	{
f5506a2f	102	led_classdev_unregister(&wrap_power_led);
0d75565f KK	103	led_classdev_unregister(&wrap_error_led);
	104	led_classdev_unregister(&wrap_extra_led);
	105	return 0;
	106	}
	107
	108	static struct platform_driver wrap_led_driver = {
	109	.probe = wrap_led_probe,
	110	.remove = wrap_led_remove,
0d75565f KK	111	.driver = {
	112	.name = DRVNAME,
	113	.owner = THIS_MODULE,
	114	},
	115	};
	116
	117	static int __init wrap_led_init(void)
	118	{
	119	int ret;
	120
	121	if (!scx200_gpio_present()) {
	122	ret = -ENODEV;
	123	goto out;
	124	}
	125
	126	ret = platform_driver_register(&wrap_led_driver);
	127	if (ret < 0)
	128	goto out;
	129
	130	pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
	131	if (IS_ERR(pdev)) {
	132	ret = PTR_ERR(pdev);
	133	platform_driver_unregister(&wrap_led_driver);
	134	goto out;
	135	}
	136
	137	out:
	138	return ret;
	139	}
	140
	141	static void __exit wrap_led_exit(void)
	142	{
	143	platform_device_unregister(pdev);
	144	platform_driver_unregister(&wrap_led_driver);
	145	}
	146
	147	module_init(wrap_led_init);
	148	module_exit(wrap_led_exit);
	149
	150	MODULE_AUTHOR("Kristian Kielhofner <[email protected]>");
	151	MODULE_DESCRIPTION("PCEngines WRAP LED driver");
	152	MODULE_LICENSE("GPL");
	153