Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * LEDs driver for PCEngines WRAP
4 *
5 * Copyright (C) 2006 Kristian Kielhofner <kris@krisk.org>
6 *
7 * Based on leds-net48xx.c
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>
15#include <linux/io.h>
16#include <linux/scx200_gpio.h>
17#include <linux/module.h>
18
19#define DRVNAME "wrap-led"
20#define WRAP_POWER_LED_GPIO 2
21#define WRAP_ERROR_LED_GPIO 3
22#define WRAP_EXTRA_LED_GPIO 18
23
24static struct platform_device *pdev;
25
26static 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
35static 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
44static 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
53static struct led_classdev wrap_power_led = {
54 .name = "wrap::power",
55 .brightness_set = wrap_power_led_set,
56 .default_trigger = "default-on",
57 .flags = LED_CORE_SUSPENDRESUME,
58};
59
60static struct led_classdev wrap_error_led = {
61 .name = "wrap::error",
62 .brightness_set = wrap_error_led_set,
63 .flags = LED_CORE_SUSPENDRESUME,
64};
65
66static struct led_classdev wrap_extra_led = {
67 .name = "wrap::extra",
68 .brightness_set = wrap_extra_led_set,
69 .flags = LED_CORE_SUSPENDRESUME,
70};
71
72static int wrap_led_probe(struct platform_device *pdev)
73{
74 int ret;
75
76 ret = devm_led_classdev_register(&pdev->dev, &wrap_power_led);
77 if (ret < 0)
78 return ret;
79
80 ret = devm_led_classdev_register(&pdev->dev, &wrap_error_led);
81 if (ret < 0)
82 return ret;
83
84 return devm_led_classdev_register(&pdev->dev, &wrap_extra_led);
85}
86
87static struct platform_driver wrap_led_driver = {
88 .probe = wrap_led_probe,
89 .driver = {
90 .name = DRVNAME,
91 },
92};
93
94static 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
114out:
115 return ret;
116}
117
118static void __exit wrap_led_exit(void)
119{
120 platform_device_unregister(pdev);
121 platform_driver_unregister(&wrap_led_driver);
122}
123
124module_init(wrap_led_init);
125module_exit(wrap_led_exit);
126
127MODULE_AUTHOR("Kristian Kielhofner <kris@krisk.org>");
128MODULE_DESCRIPTION("PCEngines WRAP LED driver");
129MODULE_LICENSE("GPL");
130
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>
20
21#define DRVNAME "wrap-led"
22#define WRAP_POWER_LED_GPIO 2
23#define WRAP_ERROR_LED_GPIO 3
24#define WRAP_EXTRA_LED_GPIO 18
25
26static struct platform_device *pdev;
27
28static 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
37static 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
46static 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
55static struct led_classdev wrap_power_led = {
56 .name = "wrap::power",
57 .brightness_set = wrap_power_led_set,
58 .default_trigger = "default-on",
59 .flags = LED_CORE_SUSPENDRESUME,
60};
61
62static struct led_classdev wrap_error_led = {
63 .name = "wrap::error",
64 .brightness_set = wrap_error_led_set,
65 .flags = LED_CORE_SUSPENDRESUME,
66};
67
68static struct led_classdev wrap_extra_led = {
69 .name = "wrap::extra",
70 .brightness_set = wrap_extra_led_set,
71 .flags = LED_CORE_SUSPENDRESUME,
72};
73
74static int wrap_led_probe(struct platform_device *pdev)
75{
76 int ret;
77
78 ret = led_classdev_register(&pdev->dev, &wrap_power_led);
79 if (ret < 0)
80 return ret;
81
82 ret = led_classdev_register(&pdev->dev, &wrap_error_led);
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
92err2:
93 led_classdev_unregister(&wrap_error_led);
94err1:
95 led_classdev_unregister(&wrap_power_led);
96
97 return ret;
98}
99
100static int wrap_led_remove(struct platform_device *pdev)
101{
102 led_classdev_unregister(&wrap_power_led);
103 led_classdev_unregister(&wrap_error_led);
104 led_classdev_unregister(&wrap_extra_led);
105 return 0;
106}
107
108static struct platform_driver wrap_led_driver = {
109 .probe = wrap_led_probe,
110 .remove = wrap_led_remove,
111 .driver = {
112 .name = DRVNAME,
113 .owner = THIS_MODULE,
114 },
115};
116
117static 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
137out:
138 return ret;
139}
140
141static void __exit wrap_led_exit(void)
142{
143 platform_device_unregister(pdev);
144 platform_driver_unregister(&wrap_led_driver);
145}
146
147module_init(wrap_led_init);
148module_exit(wrap_led_exit);
149
150MODULE_AUTHOR("Kristian Kielhofner <kris@krisk.org>");
151MODULE_DESCRIPTION("PCEngines WRAP LED driver");
152MODULE_LICENSE("GPL");
153