Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
leds-clevo-mail.c
Go to the documentation of this file.
1 
2 #include <linux/module.h>
3 
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 <[email protected]>");
18 MODULE_DESCRIPTION("Clevo mail LED driver");
19 MODULE_LICENSE("GPL");
20 
21 static bool __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 clevo_mail_led_dmi_table - 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 clevo_mail_led_dmi_table[] = {
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 = "Clevo M5x0V",
63  .matches = {
64  DMI_MATCH(DMI_BOARD_VENDOR, "CLEVO Co. "),
65  DMI_MATCH(DMI_BOARD_NAME, "M5X0V "),
67  }
68  },
69  {
70  .callback = clevo_mail_led_dmi_callback,
71  .ident = "Clevo D400P",
72  .matches = {
73  DMI_MATCH(DMI_BOARD_VENDOR, "Clevo"),
74  DMI_MATCH(DMI_BOARD_NAME, "D400P"),
75  DMI_MATCH(DMI_BOARD_VERSION, "Rev.A"),
77  }
78  },
79  {
80  .callback = clevo_mail_led_dmi_callback,
81  .ident = "Clevo D410V",
82  .matches = {
83  DMI_MATCH(DMI_BOARD_VENDOR, "Clevo, Co."),
84  DMI_MATCH(DMI_BOARD_NAME, "D400V/D470V"),
85  DMI_MATCH(DMI_BOARD_VERSION, "SS78B"),
86  DMI_MATCH(DMI_PRODUCT_VERSION, "Rev. A1")
87  }
88  },
89  { }
90 };
91 MODULE_DEVICE_TABLE(dmi, clevo_mail_led_dmi_table);
92 
93 static void clevo_mail_led_set(struct led_classdev *led_cdev,
94  enum led_brightness value)
95 {
97 
98  if (value == LED_OFF)
100  else if (value <= LED_HALF)
102  else
104 
106 
107 }
108 
109 static int clevo_mail_led_blink(struct led_classdev *led_cdev,
110  unsigned long *delay_on,
111  unsigned long *delay_off)
112 {
113  int status = -EINVAL;
114 
115  i8042_lock_chip();
116 
117  if (*delay_on == 0 /* ms */ && *delay_off == 0 /* ms */) {
118  /* Special case: the leds subsystem requested us to
119  * chose one user friendly blinking of the LED, and
120  * start it. Let's blink the led slowly (0.5Hz).
121  */
122  *delay_on = 1000; /* ms */
123  *delay_off = 1000; /* ms */
125  status = 0;
126 
127  } else if (*delay_on == 500 /* ms */ && *delay_off == 500 /* ms */) {
128  /* blink the led with 1Hz */
130  status = 0;
131 
132  } else if (*delay_on == 1000 /* ms */ && *delay_off == 1000 /* ms */) {
133  /* blink the led with 0.5Hz */
135  status = 0;
136 
137  } else {
138  printk(KERN_DEBUG KBUILD_MODNAME
139  ": clevo_mail_led_blink(..., %lu, %lu),"
140  " returning -EINVAL (unsupported)\n",
141  *delay_on, *delay_off);
142  }
143 
145 
146  return status;
147 }
148 
149 static struct led_classdev clevo_mail_led = {
150  .name = "clevo::mail",
151  .brightness_set = clevo_mail_led_set,
152  .blink_set = clevo_mail_led_blink,
153  .flags = LED_CORE_SUSPENDRESUME,
154 };
155 
156 static int __devinit clevo_mail_led_probe(struct platform_device *pdev)
157 {
158  return led_classdev_register(&pdev->dev, &clevo_mail_led);
159 }
160 
161 static int clevo_mail_led_remove(struct platform_device *pdev)
162 {
163  led_classdev_unregister(&clevo_mail_led);
164  return 0;
165 }
166 
167 static struct platform_driver clevo_mail_led_driver = {
168  .probe = clevo_mail_led_probe,
169  .remove = clevo_mail_led_remove,
170  .driver = {
171  .name = KBUILD_MODNAME,
172  .owner = THIS_MODULE,
173  },
174 };
175 
176 static int __init clevo_mail_led_init(void)
177 {
178  int error = 0;
179  int count = 0;
180 
181  /* Check with the help of DMI if we are running on supported hardware */
182  if (!nodetect) {
183  count = dmi_check_system(clevo_mail_led_dmi_table);
184  } else {
185  count = 1;
186  printk(KERN_ERR KBUILD_MODNAME ": Skipping DMI detection. "
187  "If the driver works on your hardware please "
188  "report model and the output of dmidecode in tracker "
189  "at http://sourceforge.net/projects/clevo-mailled/\n");
190  }
191 
192  if (!count)
193  return -ENODEV;
194 
195  pdev = platform_device_register_simple(KBUILD_MODNAME, -1, NULL, 0);
196  if (!IS_ERR(pdev)) {
197  error = platform_driver_probe(&clevo_mail_led_driver,
198  clevo_mail_led_probe);
199  if (error) {
200  printk(KERN_ERR KBUILD_MODNAME
201  ": Can't probe platform driver\n");
203  }
204  } else
205  error = PTR_ERR(pdev);
206 
207  return error;
208 }
209 
210 static void __exit clevo_mail_led_exit(void)
211 {
213  platform_driver_unregister(&clevo_mail_led_driver);
214 
215  clevo_mail_led_set(NULL, LED_OFF);
216 }
217 
218 module_init(clevo_mail_led_init);
219 module_exit(clevo_mail_led_exit);