Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6.git] / drivers / leds / leds-clevo-mail.c
1
2 #include <linux/module.h>
3
4 #include <linux/platform_device.h>
5 #include <linux/err.h>
6 #include <linux/leds.h>
7
8 #include <linux/io.h>
9 #include <linux/dmi.h>
10
11 #include <linux/i8042.h>
12
13 #define CLEVO_MAIL_LED_OFF              0x0084
14 #define CLEVO_MAIL_LED_BLINK_1HZ        0x008A
15 #define CLEVO_MAIL_LED_BLINK_0_5HZ      0x0083
16
17 MODULE_AUTHOR("Márton Németh <nm127@freemail.hu>");
18 MODULE_DESCRIPTION("Clevo mail LED driver");
19 MODULE_LICENSE("GPL");
20
21 static unsigned int __initdata nodetect;
22 module_param_named(nodetect, nodetect, bool, 0);
23 MODULE_PARM_DESC(nodetect, "Skip DMI hardware detection");
24
25 static struct platform_device *pdev;
26
27 static int __init clevo_mail_led_dmi_callback(const struct dmi_system_id *id)
28 {
29         printk(KERN_INFO KBUILD_MODNAME ": '%s' found\n", id->ident);
30         return 1;
31 }
32
33 /*
34  * struct mail_led_whitelist - List of known good models
35  *
36  * Contains the known good models this driver is compatible with.
37  * When adding a new model try to be as strict as possible. This
38  * makes it possible to keep the false positives (the model is
39  * detected as working, but in reality it is not) as low as
40  * possible.
41  */
42 static struct dmi_system_id __initdata mail_led_whitelist[] = {
43         {
44                 .callback = clevo_mail_led_dmi_callback,
45                 .ident = "Clevo D410J",
46                 .matches = {
47                         DMI_MATCH(DMI_SYS_VENDOR, "VIA"),
48                         DMI_MATCH(DMI_PRODUCT_NAME, "K8N800"),
49                         DMI_MATCH(DMI_PRODUCT_VERSION, "VT8204B")
50                 }
51         },
52         {
53                 .callback = clevo_mail_led_dmi_callback,
54                 .ident = "Clevo M5x0N",
55                 .matches = {
56                         DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
57                         DMI_MATCH(DMI_PRODUCT_NAME, "M5x0N")
58                 }
59         },
60         {
61                 .callback = clevo_mail_led_dmi_callback,
62                 .ident = "Positivo Mobile",
63                 .matches = {
64                         DMI_MATCH(DMI_BOARD_VENDOR, "CLEVO Co. "),
65                         DMI_MATCH(DMI_BOARD_NAME, "M5X0V "),
66                         DMI_MATCH(DMI_PRODUCT_NAME, "Positivo Mobile"),
67                         DMI_MATCH(DMI_PRODUCT_VERSION, "VT6198")
68                 }
69         },
70         {
71                 .callback = clevo_mail_led_dmi_callback,
72                 .ident = "Clevo D400P",
73                 .matches = {
74                         DMI_MATCH(DMI_BOARD_VENDOR, "Clevo"),
75                         DMI_MATCH(DMI_BOARD_NAME, "D400P"),
76                         DMI_MATCH(DMI_BOARD_VERSION, "Rev.A"),
77                         DMI_MATCH(DMI_PRODUCT_VERSION, "0106")
78                 }
79         },
80         {
81                 .callback = clevo_mail_led_dmi_callback,
82                 .ident = "Clevo D410V",
83                 .matches = {
84                         DMI_MATCH(DMI_BOARD_VENDOR, "Clevo, Co."),
85                         DMI_MATCH(DMI_BOARD_NAME, "D400V/D470V"),
86                         DMI_MATCH(DMI_BOARD_VERSION, "SS78B"),
87                         DMI_MATCH(DMI_PRODUCT_VERSION, "Rev. A1")
88                 }
89         },
90         { }
91 };
92
93 static void clevo_mail_led_set(struct led_classdev *led_cdev,
94                                 enum led_brightness value)
95 {
96         if (value == LED_OFF)
97                 i8042_command(NULL, CLEVO_MAIL_LED_OFF);
98         else if (value <= LED_HALF)
99                 i8042_command(NULL, CLEVO_MAIL_LED_BLINK_0_5HZ);
100         else
101                 i8042_command(NULL, CLEVO_MAIL_LED_BLINK_1HZ);
102
103 }
104
105 static int clevo_mail_led_blink(struct led_classdev *led_cdev,
106                                 unsigned long *delay_on,
107                                 unsigned long *delay_off)
108 {
109         int status = -EINVAL;
110
111         if (*delay_on == 0 /* ms */ && *delay_off == 0 /* ms */) {
112                 /* Special case: the leds subsystem requested us to
113                  * chose one user friendly blinking of the LED, and
114                  * start it. Let's blink the led slowly (0.5Hz).
115                  */
116                 *delay_on = 1000; /* ms */
117                 *delay_off = 1000; /* ms */
118                 i8042_command(NULL, CLEVO_MAIL_LED_BLINK_0_5HZ);
119                 status = 0;
120
121         } else if (*delay_on == 500 /* ms */ && *delay_off == 500 /* ms */) {
122                 /* blink the led with 1Hz */
123                 i8042_command(NULL, CLEVO_MAIL_LED_BLINK_1HZ);
124                 status = 0;
125
126         } else if (*delay_on == 1000 /* ms */ && *delay_off == 1000 /* ms */) {
127                 /* blink the led with 0.5Hz */
128                 i8042_command(NULL, CLEVO_MAIL_LED_BLINK_0_5HZ);
129                 status = 0;
130
131         } else {
132                 printk(KERN_DEBUG KBUILD_MODNAME
133                        ": clevo_mail_led_blink(..., %lu, %lu),"
134                        " returning -EINVAL (unsupported)\n",
135                        *delay_on, *delay_off);
136         }
137
138         return status;
139 }
140
141 static struct led_classdev clevo_mail_led = {
142         .name                   = "clevo::mail",
143         .brightness_set         = clevo_mail_led_set,
144         .blink_set              = clevo_mail_led_blink,
145 };
146
147 static int __init clevo_mail_led_probe(struct platform_device *pdev)
148 {
149         return led_classdev_register(&pdev->dev, &clevo_mail_led);
150 }
151
152 static int clevo_mail_led_remove(struct platform_device *pdev)
153 {
154         led_classdev_unregister(&clevo_mail_led);
155         return 0;
156 }
157
158 #ifdef CONFIG_PM
159 static int clevo_mail_led_suspend(struct platform_device *dev,
160                                   pm_message_t state)
161 {
162         led_classdev_suspend(&clevo_mail_led);
163         return 0;
164 }
165
166 static int clevo_mail_led_resume(struct platform_device *dev)
167 {
168         led_classdev_resume(&clevo_mail_led);
169         return 0;
170 }
171 #else
172 #define clevo_mail_led_suspend    NULL
173 #define clevo_mail_led_resume     NULL
174 #endif
175
176 static struct platform_driver clevo_mail_led_driver = {
177         .probe          = clevo_mail_led_probe,
178         .remove         = clevo_mail_led_remove,
179         .suspend        = clevo_mail_led_suspend,
180         .resume         = clevo_mail_led_resume,
181         .driver         = {
182                 .name           = KBUILD_MODNAME,
183                 .owner          = THIS_MODULE,
184         },
185 };
186
187 static int __init clevo_mail_led_init(void)
188 {
189         int error = 0;
190         int count = 0;
191
192         /* Check with the help of DMI if we are running on supported hardware */
193         if (!nodetect) {
194                 count = dmi_check_system(mail_led_whitelist);
195         } else {
196                 count = 1;
197                 printk(KERN_ERR KBUILD_MODNAME ": Skipping DMI detection. "
198                        "If the driver works on your hardware please "
199                        "report model and the output of dmidecode in tracker "
200                        "at http://sourceforge.net/projects/clevo-mailled/\n");
201         }
202
203         if (!count)
204                 return -ENODEV;
205
206         pdev = platform_device_register_simple(KBUILD_MODNAME, -1, NULL, 0);
207         if (!IS_ERR(pdev)) {
208                 error = platform_driver_probe(&clevo_mail_led_driver,
209                                               clevo_mail_led_probe);
210                 if (error) {
211                         printk(KERN_ERR KBUILD_MODNAME
212                                ": Can't probe platform driver\n");
213                         platform_device_unregister(pdev);
214                 }
215         } else
216                 error = PTR_ERR(pdev);
217
218         return error;
219 }
220
221 static void __exit clevo_mail_led_exit(void)
222 {
223         platform_device_unregister(pdev);
224         platform_driver_unregister(&clevo_mail_led_driver);
225
226         clevo_mail_led_set(NULL, LED_OFF);
227 }
228
229 module_init(clevo_mail_led_init);
230 module_exit(clevo_mail_led_exit);