961aad7a0476236c0002f1f476f8d482dcb2616b
[pandora-kernel.git] / drivers / input / misc / wistron_btns.c
1 /*
2  * Wistron laptop button driver
3  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
4  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
5  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
6  *
7  * You can redistribute and/or modify this program under the terms of the
8  * GNU General Public License version 2 as published by the Free Software
9  * Foundation.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
14  * Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 59 Temple Place Suite 330, Boston, MA 02111-1307, USA.
19  */
20 #include <linux/io.h>
21 #include <linux/dmi.h>
22 #include <linux/init.h>
23 #include <linux/input.h>
24 #include <linux/interrupt.h>
25 #include <linux/kernel.h>
26 #include <linux/mc146818rtc.h>
27 #include <linux/module.h>
28 #include <linux/preempt.h>
29 #include <linux/string.h>
30 #include <linux/timer.h>
31 #include <linux/types.h>
32 #include <linux/platform_device.h>
33
34 /*
35  * Number of attempts to read data from queue per poll;
36  * the queue can hold up to 31 entries
37  */
38 #define MAX_POLL_ITERATIONS 64
39
40 #define POLL_FREQUENCY 10 /* Number of polls per second */
41
42 #if POLL_FREQUENCY > HZ
43 #error "POLL_FREQUENCY too high"
44 #endif
45
46 /* BIOS subsystem IDs */
47 #define WIFI            0x35
48 #define BLUETOOTH       0x34
49
50 MODULE_AUTHOR("Miloslav Trmac <mitr@volny.cz>");
51 MODULE_DESCRIPTION("Wistron laptop button driver");
52 MODULE_LICENSE("GPL v2");
53 MODULE_VERSION("0.2");
54
55 static int force; /* = 0; */
56 module_param(force, bool, 0);
57 MODULE_PARM_DESC(force, "Load even if computer is not in database");
58
59 static char *keymap_name; /* = NULL; */
60 module_param_named(keymap, keymap_name, charp, 0);
61 MODULE_PARM_DESC(keymap, "Keymap name, if it can't be autodetected [generic, 1557/MS2141]");
62
63 static struct platform_device *wistron_device;
64
65  /* BIOS interface implementation */
66
67 static void __iomem *bios_entry_point; /* BIOS routine entry point */
68 static void __iomem *bios_code_map_base;
69 static void __iomem *bios_data_map_base;
70
71 static u8 cmos_address;
72
73 struct regs {
74         u32 eax, ebx, ecx;
75 };
76
77 static void call_bios(struct regs *regs)
78 {
79         unsigned long flags;
80
81         preempt_disable();
82         local_irq_save(flags);
83         asm volatile ("pushl %%ebp;"
84                       "movl %7, %%ebp;"
85                       "call *%6;"
86                       "popl %%ebp"
87                       : "=a" (regs->eax), "=b" (regs->ebx), "=c" (regs->ecx)
88                       : "0" (regs->eax), "1" (regs->ebx), "2" (regs->ecx),
89                         "m" (bios_entry_point), "m" (bios_data_map_base)
90                       : "edx", "edi", "esi", "memory");
91         local_irq_restore(flags);
92         preempt_enable();
93 }
94
95 static ssize_t __init locate_wistron_bios(void __iomem *base)
96 {
97         static unsigned char __initdata signature[] =
98                 { 0x42, 0x21, 0x55, 0x30 };
99         ssize_t offset;
100
101         for (offset = 0; offset < 0x10000; offset += 0x10) {
102                 if (check_signature(base + offset, signature,
103                                     sizeof(signature)) != 0)
104                         return offset;
105         }
106         return -1;
107 }
108
109 static int __init map_bios(void)
110 {
111         void __iomem *base;
112         ssize_t offset;
113         u32 entry_point;
114
115         base = ioremap(0xF0000, 0x10000); /* Can't fail */
116         offset = locate_wistron_bios(base);
117         if (offset < 0) {
118                 printk(KERN_ERR "wistron_btns: BIOS entry point not found\n");
119                 iounmap(base);
120                 return -ENODEV;
121         }
122
123         entry_point = readl(base + offset + 5);
124         printk(KERN_DEBUG
125                 "wistron_btns: BIOS signature found at %p, entry point %08X\n",
126                 base + offset, entry_point);
127
128         if (entry_point >= 0xF0000) {
129                 bios_code_map_base = base;
130                 bios_entry_point = bios_code_map_base + (entry_point & 0xFFFF);
131         } else {
132                 iounmap(base);
133                 bios_code_map_base = ioremap(entry_point & ~0x3FFF, 0x4000);
134                 if (bios_code_map_base == NULL) {
135                         printk(KERN_ERR
136                                 "wistron_btns: Can't map BIOS code at %08X\n",
137                                 entry_point & ~0x3FFF);
138                         goto err;
139                 }
140                 bios_entry_point = bios_code_map_base + (entry_point & 0x3FFF);
141         }
142         /* The Windows driver maps 0x10000 bytes, we keep only one page... */
143         bios_data_map_base = ioremap(0x400, 0xc00);
144         if (bios_data_map_base == NULL) {
145                 printk(KERN_ERR "wistron_btns: Can't map BIOS data\n");
146                 goto err_code;
147         }
148         return 0;
149
150 err_code:
151         iounmap(bios_code_map_base);
152 err:
153         return -ENOMEM;
154 }
155
156 static inline void unmap_bios(void)
157 {
158         iounmap(bios_code_map_base);
159         iounmap(bios_data_map_base);
160 }
161
162  /* BIOS calls */
163
164 static u16 bios_pop_queue(void)
165 {
166         struct regs regs;
167
168         memset(&regs, 0, sizeof (regs));
169         regs.eax = 0x9610;
170         regs.ebx = 0x061C;
171         regs.ecx = 0x0000;
172         call_bios(&regs);
173
174         return regs.eax;
175 }
176
177 static void __devinit bios_attach(void)
178 {
179         struct regs regs;
180
181         memset(&regs, 0, sizeof (regs));
182         regs.eax = 0x9610;
183         regs.ebx = 0x012E;
184         call_bios(&regs);
185 }
186
187 static void bios_detach(void)
188 {
189         struct regs regs;
190
191         memset(&regs, 0, sizeof (regs));
192         regs.eax = 0x9610;
193         regs.ebx = 0x002E;
194         call_bios(&regs);
195 }
196
197 static u8 __devinit bios_get_cmos_address(void)
198 {
199         struct regs regs;
200
201         memset(&regs, 0, sizeof (regs));
202         regs.eax = 0x9610;
203         regs.ebx = 0x051C;
204         call_bios(&regs);
205
206         return regs.ecx;
207 }
208
209 static u16 __devinit bios_get_default_setting(u8 subsys)
210 {
211         struct regs regs;
212
213         memset(&regs, 0, sizeof (regs));
214         regs.eax = 0x9610;
215         regs.ebx = 0x0200 | subsys;
216         call_bios(&regs);
217
218         return regs.eax;
219 }
220
221 static void bios_set_state(u8 subsys, int enable)
222 {
223         struct regs regs;
224
225         memset(&regs, 0, sizeof (regs));
226         regs.eax = 0x9610;
227         regs.ebx = (enable ? 0x0100 : 0x0000) | subsys;
228         call_bios(&regs);
229 }
230
231 /* Hardware database */
232
233 struct key_entry {
234         char type;              /* See KE_* below */
235         u8 code;
236         union {
237                 u16 keycode;            /* For KE_KEY */
238                 struct {                /* For KE_SW */
239                         u8 code;
240                         u8 value;
241                 } sw;
242         };
243 };
244
245 enum { KE_END, KE_KEY, KE_SW, KE_WIFI, KE_BLUETOOTH };
246
247 #define FE_MAIL_LED 0x01
248 #define FE_WIFI_LED 0x02
249 #define FE_UNTESTED 0x80
250
251 static const struct key_entry *keymap; /* = NULL; Current key map */
252 static int have_wifi;
253 static int have_bluetooth;
254
255 static int __init dmi_matched(struct dmi_system_id *dmi)
256 {
257         const struct key_entry *key;
258
259         keymap = dmi->driver_data;
260         for (key = keymap; key->type != KE_END; key++) {
261                 if (key->type == KE_WIFI)
262                         have_wifi = 1;
263                 else if (key->type == KE_BLUETOOTH)
264                         have_bluetooth = 1;
265         }
266         return 1;
267 }
268
269 static struct key_entry keymap_empty[] __initdata = {
270         { KE_END, 0 }
271 };
272
273 static struct key_entry keymap_fs_amilo_pro_v2000[] __initdata = {
274         { KE_KEY,  0x01, {KEY_HELP} },
275         { KE_KEY,  0x11, {KEY_PROG1} },
276         { KE_KEY,  0x12, {KEY_PROG2} },
277         { KE_WIFI, 0x30 },
278         { KE_KEY,  0x31, {KEY_MAIL} },
279         { KE_KEY,  0x36, {KEY_WWW} },
280         { KE_END,  0 }
281 };
282
283 static struct key_entry keymap_fujitsu_n3510[] __initdata = {
284         { KE_KEY, 0x11, {KEY_PROG1} },
285         { KE_KEY, 0x12, {KEY_PROG2} },
286         { KE_KEY, 0x36, {KEY_WWW} },
287         { KE_KEY, 0x31, {KEY_MAIL} },
288         { KE_KEY, 0x71, {KEY_STOPCD} },
289         { KE_KEY, 0x72, {KEY_PLAYPAUSE} },
290         { KE_KEY, 0x74, {KEY_REWIND} },
291         { KE_KEY, 0x78, {KEY_FORWARD} },
292         { KE_END, 0 }
293 };
294
295 static struct key_entry keymap_wistron_ms2111[] __initdata = {
296         { KE_KEY,  0x11, {KEY_PROG1} },
297         { KE_KEY,  0x12, {KEY_PROG2} },
298         { KE_KEY,  0x13, {KEY_PROG3} },
299         { KE_KEY,  0x31, {KEY_MAIL} },
300         { KE_KEY,  0x36, {KEY_WWW} },
301         { KE_END, FE_MAIL_LED }
302 };
303
304 static struct key_entry keymap_wistron_md40100[] __initdata = {
305         { KE_KEY, 0x01, {KEY_HELP} },
306         { KE_KEY, 0x02, {KEY_CONFIG} },
307         { KE_KEY, 0x31, {KEY_MAIL} },
308         { KE_KEY, 0x36, {KEY_WWW} },
309         { KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
310         { KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
311 };
312
313 static struct key_entry keymap_wistron_ms2141[] __initdata = {
314         { KE_KEY,  0x11, {KEY_PROG1} },
315         { KE_KEY,  0x12, {KEY_PROG2} },
316         { KE_WIFI, 0x30 },
317         { KE_KEY,  0x22, {KEY_REWIND} },
318         { KE_KEY,  0x23, {KEY_FORWARD} },
319         { KE_KEY,  0x24, {KEY_PLAYPAUSE} },
320         { KE_KEY,  0x25, {KEY_STOPCD} },
321         { KE_KEY,  0x31, {KEY_MAIL} },
322         { KE_KEY,  0x36, {KEY_WWW} },
323         { KE_END,  0 }
324 };
325
326 static struct key_entry keymap_acer_aspire_1500[] __initdata = {
327         { KE_KEY, 0x01, {KEY_HELP} },
328         { KE_KEY, 0x03, {KEY_POWER} },
329         { KE_KEY, 0x11, {KEY_PROG1} },
330         { KE_KEY, 0x12, {KEY_PROG2} },
331         { KE_WIFI, 0x30 },
332         { KE_KEY, 0x31, {KEY_MAIL} },
333         { KE_KEY, 0x36, {KEY_WWW} },
334         { KE_KEY, 0x49, {KEY_CONFIG} },
335         { KE_BLUETOOTH, 0x44 },
336         { KE_END, FE_UNTESTED }
337 };
338
339 static struct key_entry keymap_acer_aspire_1600[] __initdata = {
340         { KE_KEY, 0x01, {KEY_HELP} },
341         { KE_KEY, 0x03, {KEY_POWER} },
342         { KE_KEY, 0x08, {KEY_MUTE} },
343         { KE_KEY, 0x11, {KEY_PROG1} },
344         { KE_KEY, 0x12, {KEY_PROG2} },
345         { KE_KEY, 0x13, {KEY_PROG3} },
346         { KE_KEY, 0x31, {KEY_MAIL} },
347         { KE_KEY, 0x36, {KEY_WWW} },
348         { KE_KEY, 0x49, {KEY_CONFIG} },
349         { KE_WIFI, 0x30 },
350         { KE_BLUETOOTH, 0x44 },
351         { KE_END, FE_MAIL_LED | FE_UNTESTED }
352 };
353
354 /* 3020 has been tested */
355 static struct key_entry keymap_acer_aspire_5020[] __initdata = {
356         { KE_KEY, 0x01, {KEY_HELP} },
357         { KE_KEY, 0x03, {KEY_POWER} },
358         { KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
359         { KE_KEY, 0x11, {KEY_PROG1} },
360         { KE_KEY, 0x12, {KEY_PROG2} },
361         { KE_KEY, 0x31, {KEY_MAIL} },
362         { KE_KEY, 0x36, {KEY_WWW} },
363         { KE_KEY, 0x6a, {KEY_CONFIG} },
364         { KE_WIFI, 0x30 },
365         { KE_BLUETOOTH, 0x44 },
366         { KE_END, FE_MAIL_LED | FE_UNTESTED }
367 };
368
369 static struct key_entry keymap_acer_travelmate_2410[] __initdata = {
370         { KE_KEY, 0x01, {KEY_HELP} },
371         { KE_KEY, 0x6d, {KEY_POWER} },
372         { KE_KEY, 0x11, {KEY_PROG1} },
373         { KE_KEY, 0x12, {KEY_PROG2} },
374         { KE_KEY, 0x31, {KEY_MAIL} },
375         { KE_KEY, 0x36, {KEY_WWW} },
376         { KE_KEY, 0x6a, {KEY_CONFIG} },
377         { KE_WIFI, 0x30 },
378         { KE_BLUETOOTH, 0x44 },
379         { KE_END, FE_MAIL_LED | FE_UNTESTED }
380 };
381
382 static struct key_entry keymap_acer_travelmate_110[] __initdata = {
383         { KE_KEY, 0x01, {KEY_HELP} },
384         { KE_KEY, 0x02, {KEY_CONFIG} },
385         { KE_KEY, 0x03, {KEY_POWER} },
386         { KE_KEY, 0x08, {KEY_MUTE} },
387         { KE_KEY, 0x11, {KEY_PROG1} },
388         { KE_KEY, 0x12, {KEY_PROG2} },
389         { KE_KEY, 0x20, {KEY_VOLUMEUP} },
390         { KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
391         { KE_KEY, 0x31, {KEY_MAIL} },
392         { KE_KEY, 0x36, {KEY_WWW} },
393         { KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
394         { KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
395         { KE_WIFI, 0x30 },
396         { KE_END, FE_MAIL_LED | FE_UNTESTED }
397 };
398
399 static struct key_entry keymap_acer_travelmate_300[] __initdata = {
400         { KE_KEY, 0x01, {KEY_HELP} },
401         { KE_KEY, 0x02, {KEY_CONFIG} },
402         { KE_KEY, 0x03, {KEY_POWER} },
403         { KE_KEY, 0x08, {KEY_MUTE} },
404         { KE_KEY, 0x11, {KEY_PROG1} },
405         { KE_KEY, 0x12, {KEY_PROG2} },
406         { KE_KEY, 0x20, {KEY_VOLUMEUP} },
407         { KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
408         { KE_KEY, 0x31, {KEY_MAIL} },
409         { KE_KEY, 0x36, {KEY_WWW} },
410         { KE_WIFI, 0x30 },
411         { KE_BLUETOOTH, 0x44 },
412         { KE_END, FE_MAIL_LED | FE_UNTESTED }
413 };
414
415 static struct key_entry keymap_acer_travelmate_380[] __initdata = {
416         { KE_KEY, 0x01, {KEY_HELP} },
417         { KE_KEY, 0x02, {KEY_CONFIG} },
418         { KE_KEY, 0x03, {KEY_POWER} }, /* not 370 */
419         { KE_KEY, 0x11, {KEY_PROG1} },
420         { KE_KEY, 0x12, {KEY_PROG2} },
421         { KE_KEY, 0x13, {KEY_PROG3} },
422         { KE_KEY, 0x31, {KEY_MAIL} },
423         { KE_KEY, 0x36, {KEY_WWW} },
424         { KE_WIFI, 0x30 },
425         { KE_END, FE_MAIL_LED | FE_UNTESTED }
426 };
427
428 /* unusual map */
429 static struct key_entry keymap_acer_travelmate_220[] __initdata = {
430         { KE_KEY, 0x01, {KEY_HELP} },
431         { KE_KEY, 0x02, {KEY_CONFIG} },
432         { KE_KEY, 0x11, {KEY_MAIL} },
433         { KE_KEY, 0x12, {KEY_WWW} },
434         { KE_KEY, 0x13, {KEY_PROG2} },
435         { KE_KEY, 0x31, {KEY_PROG1} },
436         { KE_END, FE_WIFI_LED | FE_UNTESTED }
437 };
438
439 static struct key_entry keymap_acer_travelmate_230[] __initdata = {
440         { KE_KEY, 0x01, {KEY_HELP} },
441         { KE_KEY, 0x02, {KEY_CONFIG} },
442         { KE_KEY, 0x11, {KEY_PROG1} },
443         { KE_KEY, 0x12, {KEY_PROG2} },
444         { KE_KEY, 0x31, {KEY_MAIL} },
445         { KE_KEY, 0x36, {KEY_WWW} },
446         { KE_END, FE_WIFI_LED | FE_UNTESTED }
447 };
448
449 static struct key_entry keymap_acer_travelmate_240[] __initdata = {
450         { KE_KEY, 0x01, {KEY_HELP} },
451         { KE_KEY, 0x02, {KEY_CONFIG} },
452         { KE_KEY, 0x03, {KEY_POWER} },
453         { KE_KEY, 0x08, {KEY_MUTE} },
454         { KE_KEY, 0x31, {KEY_MAIL} },
455         { KE_KEY, 0x36, {KEY_WWW} },
456         { KE_KEY, 0x11, {KEY_PROG1} },
457         { KE_KEY, 0x12, {KEY_PROG2} },
458         { KE_BLUETOOTH, 0x44 },
459         { KE_WIFI, 0x30 },
460         { KE_END, FE_UNTESTED }
461 };
462
463 static struct key_entry keymap_acer_travelmate_350[] __initdata = {
464         { KE_KEY, 0x01, {KEY_HELP} },
465         { KE_KEY, 0x02, {KEY_CONFIG} },
466         { KE_KEY, 0x11, {KEY_PROG1} },
467         { KE_KEY, 0x12, {KEY_PROG2} },
468         { KE_KEY, 0x13, {KEY_MAIL} },
469         { KE_KEY, 0x14, {KEY_PROG3} },
470         { KE_KEY, 0x15, {KEY_WWW} },
471         { KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
472 };
473
474 static struct key_entry keymap_acer_travelmate_360[] __initdata = {
475         { KE_KEY, 0x01, {KEY_HELP} },
476         { KE_KEY, 0x02, {KEY_CONFIG} },
477         { KE_KEY, 0x11, {KEY_PROG1} },
478         { KE_KEY, 0x12, {KEY_PROG2} },
479         { KE_KEY, 0x13, {KEY_MAIL} },
480         { KE_KEY, 0x14, {KEY_PROG3} },
481         { KE_KEY, 0x15, {KEY_WWW} },
482         { KE_KEY, 0x40, {KEY_WLAN} },
483         { KE_END, FE_WIFI_LED | FE_UNTESTED } /* no mail led */
484 };
485
486 /* Wifi subsystem only activates the led. Therefore we need to pass
487  * wifi event as a normal key, then userspace can really change the wifi state.
488  * TODO we need to export led state to userspace (wifi and mail) */
489 static struct key_entry keymap_acer_travelmate_610[] __initdata = {
490         { KE_KEY, 0x01, {KEY_HELP} },
491         { KE_KEY, 0x02, {KEY_CONFIG} },
492         { KE_KEY, 0x11, {KEY_PROG1} },
493         { KE_KEY, 0x12, {KEY_PROG2} },
494         { KE_KEY, 0x13, {KEY_PROG3} },
495         { KE_KEY, 0x14, {KEY_MAIL} },
496         { KE_KEY, 0x15, {KEY_WWW} },
497         { KE_KEY, 0x40, {KEY_WLAN} },
498         { KE_END, FE_MAIL_LED | FE_WIFI_LED }
499 };
500
501 static struct key_entry keymap_acer_travelmate_630[] __initdata = {
502         { KE_KEY, 0x01, {KEY_HELP} },
503         { KE_KEY, 0x02, {KEY_CONFIG} },
504         { KE_KEY, 0x03, {KEY_POWER} },
505         { KE_KEY, 0x08, {KEY_MUTE} }, /* not 620 */
506         { KE_KEY, 0x11, {KEY_PROG1} },
507         { KE_KEY, 0x12, {KEY_PROG2} },
508         { KE_KEY, 0x13, {KEY_PROG3} },
509         { KE_KEY, 0x20, {KEY_VOLUMEUP} },
510         { KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
511         { KE_KEY, 0x31, {KEY_MAIL} },
512         { KE_KEY, 0x36, {KEY_WWW} },
513         { KE_WIFI, 0x30 },
514         { KE_END, FE_MAIL_LED | FE_UNTESTED }
515 };
516
517 static struct key_entry keymap_aopen_1559as[] __initdata = {
518         { KE_KEY,  0x01, {KEY_HELP} },
519         { KE_KEY,  0x06, {KEY_PROG3} },
520         { KE_KEY,  0x11, {KEY_PROG1} },
521         { KE_KEY,  0x12, {KEY_PROG2} },
522         { KE_WIFI, 0x30 },
523         { KE_KEY,  0x31, {KEY_MAIL} },
524         { KE_KEY,  0x36, {KEY_WWW} },
525         { KE_END,  0 },
526 };
527
528 static struct key_entry keymap_fs_amilo_d88x0[] __initdata = {
529         { KE_KEY, 0x01, {KEY_HELP} },
530         { KE_KEY, 0x08, {KEY_MUTE} },
531         { KE_KEY, 0x31, {KEY_MAIL} },
532         { KE_KEY, 0x36, {KEY_WWW} },
533         { KE_KEY, 0x11, {KEY_PROG1} },
534         { KE_KEY, 0x12, {KEY_PROG2} },
535         { KE_KEY, 0x13, {KEY_PROG3} },
536         { KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
537 };
538
539 static struct key_entry keymap_wistron_md2900[] __initdata = {
540         { KE_KEY, 0x01, {KEY_HELP} },
541         { KE_KEY, 0x02, {KEY_CONFIG} },
542         { KE_KEY, 0x11, {KEY_PROG1} },
543         { KE_KEY, 0x12, {KEY_PROG2} },
544         { KE_KEY, 0x31, {KEY_MAIL} },
545         { KE_KEY, 0x36, {KEY_WWW} },
546         { KE_WIFI, 0x30 },
547         { KE_END, FE_MAIL_LED | FE_UNTESTED }
548 };
549
550 static struct key_entry keymap_wistron_md96500[] __initdata = {
551         { KE_KEY, 0x01, {KEY_HELP} },
552         { KE_KEY, 0x02, {KEY_CONFIG} },
553         { KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
554         { KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
555         { KE_KEY, 0x08, {KEY_MUTE} },
556         { KE_KEY, 0x11, {KEY_PROG1} },
557         { KE_KEY, 0x12, {KEY_PROG2} },
558         { KE_KEY, 0x20, {KEY_VOLUMEUP} },
559         { KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
560         { KE_KEY, 0x22, {KEY_REWIND} },
561         { KE_KEY, 0x23, {KEY_FORWARD} },
562         { KE_KEY, 0x24, {KEY_PLAYPAUSE} },
563         { KE_KEY, 0x25, {KEY_STOPCD} },
564         { KE_KEY, 0x31, {KEY_MAIL} },
565         { KE_KEY, 0x36, {KEY_WWW} },
566         { KE_WIFI, 0x30 },
567         { KE_BLUETOOTH, 0x44 },
568         { KE_END, FE_UNTESTED }
569 };
570
571 static struct key_entry keymap_wistron_generic[] __initdata = {
572         { KE_KEY, 0x01, {KEY_HELP} },
573         { KE_KEY, 0x02, {KEY_CONFIG} },
574         { KE_KEY, 0x03, {KEY_POWER} },
575         { KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
576         { KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
577         { KE_KEY, 0x08, {KEY_MUTE} },
578         { KE_KEY, 0x11, {KEY_PROG1} },
579         { KE_KEY, 0x12, {KEY_PROG2} },
580         { KE_KEY, 0x13, {KEY_PROG3} },
581         { KE_KEY, 0x14, {KEY_MAIL} },
582         { KE_KEY, 0x15, {KEY_WWW} },
583         { KE_KEY, 0x20, {KEY_VOLUMEUP} },
584         { KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
585         { KE_KEY, 0x22, {KEY_REWIND} },
586         { KE_KEY, 0x23, {KEY_FORWARD} },
587         { KE_KEY, 0x24, {KEY_PLAYPAUSE} },
588         { KE_KEY, 0x25, {KEY_STOPCD} },
589         { KE_KEY, 0x31, {KEY_MAIL} },
590         { KE_KEY, 0x36, {KEY_WWW} },
591         { KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
592         { KE_KEY, 0x40, {KEY_WLAN} },
593         { KE_KEY, 0x49, {KEY_CONFIG} },
594         { KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
595         { KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
596         { KE_KEY, 0x6a, {KEY_CONFIG} },
597         { KE_KEY, 0x6d, {KEY_POWER} },
598         { KE_KEY, 0x71, {KEY_STOPCD} },
599         { KE_KEY, 0x72, {KEY_PLAYPAUSE} },
600         { KE_KEY, 0x74, {KEY_REWIND} },
601         { KE_KEY, 0x78, {KEY_FORWARD} },
602         { KE_WIFI, 0x30 },
603         { KE_BLUETOOTH, 0x44 },
604         { KE_END, 0 }
605 };
606
607 /*
608  * If your machine is not here (which is currently rather likely), please send
609  * a list of buttons and their key codes (reported when loading this module
610  * with force=1) and the output of dmidecode to $MODULE_AUTHOR.
611  */
612 static struct dmi_system_id dmi_ids[] __initdata = {
613         {
614                 .callback = dmi_matched,
615                 .ident = "Fujitsu-Siemens Amilo Pro V2000",
616                 .matches = {
617                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
618                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2000"),
619                 },
620                 .driver_data = keymap_fs_amilo_pro_v2000
621         },
622         {
623                 .callback = dmi_matched,
624                 .ident = "Fujitsu-Siemens Amilo M7400",
625                 .matches = {
626                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
627                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO M        "),
628                 },
629                 .driver_data = keymap_fs_amilo_pro_v2000
630         },
631         {
632                 .callback = dmi_matched,
633                 .ident = "Fujitsu N3510",
634                 .matches = {
635                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
636                         DMI_MATCH(DMI_PRODUCT_NAME, "N3510"),
637                 },
638                 .driver_data = keymap_fujitsu_n3510
639         },
640         {
641                 .callback = dmi_matched,
642                 .ident = "Acer Aspire 1500",
643                 .matches = {
644                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
645                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1500"),
646                 },
647                 .driver_data = keymap_acer_aspire_1500
648         },
649         {
650                 .callback = dmi_matched,
651                 .ident = "Acer Aspire 1600",
652                 .matches = {
653                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
654                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1600"),
655                 },
656                 .driver_data = keymap_acer_aspire_1600
657         },
658         {
659                 .callback = dmi_matched,
660                 .ident = "Acer Aspire 3020",
661                 .matches = {
662                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
663                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3020"),
664                 },
665                 .driver_data = keymap_acer_aspire_5020
666         },
667         {
668                 .callback = dmi_matched,
669                 .ident = "Acer Aspire 5020",
670                 .matches = {
671                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
672                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5020"),
673                 },
674                 .driver_data = keymap_acer_aspire_5020
675         },
676         {
677                 .callback = dmi_matched,
678                 .ident = "Acer TravelMate 2100",
679                 .matches = {
680                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
681                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2100"),
682                 },
683                 .driver_data = keymap_acer_aspire_5020
684         },
685         {
686                 .callback = dmi_matched,
687                 .ident = "Acer TravelMate 2410",
688                 .matches = {
689                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
690                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2410"),
691                 },
692                 .driver_data = keymap_acer_travelmate_2410
693         },
694         {
695                 .callback = dmi_matched,
696                 .ident = "Acer TravelMate C300",
697                 .matches = {
698                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
699                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C300"),
700                 },
701                 .driver_data = keymap_acer_travelmate_300
702         },
703         {
704                 .callback = dmi_matched,
705                 .ident = "Acer TravelMate C100",
706                 .matches = {
707                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
708                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C100"),
709                 },
710                 .driver_data = keymap_acer_travelmate_300
711         },
712         {
713                 .callback = dmi_matched,
714                 .ident = "Acer TravelMate C110",
715                 .matches = {
716                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
717                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C110"),
718                 },
719                 .driver_data = keymap_acer_travelmate_110
720         },
721         {
722                 .callback = dmi_matched,
723                 .ident = "Acer TravelMate 380",
724                 .matches = {
725                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
726                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 380"),
727                 },
728                 .driver_data = keymap_acer_travelmate_380
729         },
730         {
731                 .callback = dmi_matched,
732                 .ident = "Acer TravelMate 370",
733                 .matches = {
734                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
735                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 370"),
736                 },
737                 .driver_data = keymap_acer_travelmate_380 /* keyboard minus 1 key */
738         },
739         {
740                 .callback = dmi_matched,
741                 .ident = "Acer TravelMate 220",
742                 .matches = {
743                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
744                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 220"),
745                 },
746                 .driver_data = keymap_acer_travelmate_220
747         },
748         {
749                 .callback = dmi_matched,
750                 .ident = "Acer TravelMate 260",
751                 .matches = {
752                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
753                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 260"),
754                 },
755                 .driver_data = keymap_acer_travelmate_220
756         },
757         {
758                 .callback = dmi_matched,
759                 .ident = "Acer TravelMate 230",
760                 .matches = {
761                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
762                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 230"),
763                         /* acerhk looks for "TravelMate F4..." ?! */
764                 },
765                 .driver_data = keymap_acer_travelmate_230
766         },
767         {
768                 .callback = dmi_matched,
769                 .ident = "Acer TravelMate 280",
770                 .matches = {
771                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
772                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 280"),
773                 },
774                 .driver_data = keymap_acer_travelmate_230
775         },
776         {
777                 .callback = dmi_matched,
778                 .ident = "Acer TravelMate 240",
779                 .matches = {
780                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
781                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 240"),
782                 },
783                 .driver_data = keymap_acer_travelmate_240
784         },
785         {
786                 .callback = dmi_matched,
787                 .ident = "Acer TravelMate 250",
788                 .matches = {
789                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
790                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 250"),
791                 },
792                 .driver_data = keymap_acer_travelmate_240
793         },
794         {
795                 .callback = dmi_matched,
796                 .ident = "Acer TravelMate 2424NWXCi",
797                 .matches = {
798                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
799                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2420"),
800                 },
801                 .driver_data = keymap_acer_travelmate_240
802         },
803         {
804                 .callback = dmi_matched,
805                 .ident = "Acer TravelMate 350",
806                 .matches = {
807                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
808                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 350"),
809                 },
810                 .driver_data = keymap_acer_travelmate_350
811         },
812         {
813                 .callback = dmi_matched,
814                 .ident = "Acer TravelMate 360",
815                 .matches = {
816                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
817                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
818                 },
819                 .driver_data = keymap_acer_travelmate_360
820         },
821         {
822                 .callback = dmi_matched,
823                 .ident = "Acer TravelMate 610",
824                 .matches = {
825                         DMI_MATCH(DMI_SYS_VENDOR, "ACER"),
826                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 610"),
827                 },
828                 .driver_data = keymap_acer_travelmate_610
829         },
830         {
831                 .callback = dmi_matched,
832                 .ident = "Acer TravelMate 620",
833                 .matches = {
834                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
835                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 620"),
836                 },
837                 .driver_data = keymap_acer_travelmate_630
838         },
839         {
840                 .callback = dmi_matched,
841                 .ident = "Acer TravelMate 630",
842                 .matches = {
843                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
844                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 630"),
845                 },
846                 .driver_data = keymap_acer_travelmate_630
847         },
848         {
849                 .callback = dmi_matched,
850                 .ident = "AOpen 1559AS",
851                 .matches = {
852                         DMI_MATCH(DMI_PRODUCT_NAME, "E2U"),
853                         DMI_MATCH(DMI_BOARD_NAME, "E2U"),
854                 },
855                 .driver_data = keymap_aopen_1559as
856         },
857         {
858                 .callback = dmi_matched,
859                 .ident = "Medion MD 9783",
860                 .matches = {
861                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
862                         DMI_MATCH(DMI_PRODUCT_NAME, "MD 9783"),
863                 },
864                 .driver_data = keymap_wistron_ms2111
865         },
866         {
867                 .callback = dmi_matched,
868                 .ident = "Medion MD 40100",
869                 .matches = {
870                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
871                         DMI_MATCH(DMI_PRODUCT_NAME, "WID2000"),
872                 },
873                 .driver_data = keymap_wistron_md40100
874         },
875         {
876                 .callback = dmi_matched,
877                 .ident = "Medion MD 2900",
878                 .matches = {
879                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
880                         DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2000"),
881                 },
882                 .driver_data = keymap_wistron_md2900
883         },
884         {
885                 .callback = dmi_matched,
886                 .ident = "Medion MD 96500",
887                 .matches = {
888                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
889                         DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2040"),
890                 },
891                 .driver_data = keymap_wistron_md96500
892         },
893         {
894                 .callback = dmi_matched,
895                 .ident = "Medion MD 95400",
896                 .matches = {
897                         DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
898                         DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2050"),
899                 },
900                 .driver_data = keymap_wistron_md96500
901         },
902         {
903                 .callback = dmi_matched,
904                 .ident = "Fujitsu Siemens Amilo D7820",
905                 .matches = {
906                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), /* not sure */
907                         DMI_MATCH(DMI_PRODUCT_NAME, "Amilo D"),
908                 },
909                 .driver_data = keymap_fs_amilo_d88x0
910         },
911         {
912                 .callback = dmi_matched,
913                 .ident = "Fujitsu Siemens Amilo D88x0",
914                 .matches = {
915                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
916                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO D"),
917                 },
918                 .driver_data = keymap_fs_amilo_d88x0
919         },
920         { NULL, }
921 };
922
923 /* Copy the good keymap, as the original ones are free'd */
924 static int __init copy_keymap(void)
925 {
926         const struct key_entry *key;
927         struct key_entry *new_keymap;
928         unsigned int length = 1;
929
930         for (key = keymap; key->type != KE_END; key++)
931                 length++;
932
933         new_keymap = kmalloc(length * sizeof(struct key_entry), GFP_KERNEL);
934         if (!new_keymap)
935                 return -ENOMEM;
936
937         memcpy(new_keymap, keymap, length * sizeof(struct key_entry));
938         keymap = new_keymap;
939
940         return 0;
941 }
942
943 static int __init select_keymap(void)
944 {
945         dmi_check_system(dmi_ids);
946         if (keymap_name != NULL) {
947                 if (strcmp (keymap_name, "1557/MS2141") == 0)
948                         keymap = keymap_wistron_ms2141;
949                 else if (strcmp (keymap_name, "generic") == 0)
950                         keymap = keymap_wistron_generic;
951                 else {
952                         printk(KERN_ERR "wistron_btns: Keymap unknown\n");
953                         return -EINVAL;
954                 }
955         }
956         if (keymap == NULL) {
957                 if (!force) {
958                         printk(KERN_ERR "wistron_btns: System unknown\n");
959                         return -ENODEV;
960                 }
961                 keymap = keymap_empty;
962         }
963
964         return copy_keymap();
965 }
966
967  /* Input layer interface */
968
969 static struct input_dev *input_dev;
970
971 static int __devinit setup_input_dev(void)
972 {
973         const struct key_entry *key;
974         int error;
975
976         input_dev = input_allocate_device();
977         if (!input_dev)
978                 return -ENOMEM;
979
980         input_dev->name = "Wistron laptop buttons";
981         input_dev->phys = "wistron/input0";
982         input_dev->id.bustype = BUS_HOST;
983         input_dev->cdev.dev = &wistron_device->dev;
984
985         for (key = keymap; key->type != KE_END; key++) {
986                 switch (key->type) {
987                         case KE_KEY:
988                                 set_bit(EV_KEY, input_dev->evbit);
989                                 set_bit(key->keycode, input_dev->keybit);
990                                 break;
991
992                         case KE_SW:
993                                 set_bit(EV_SW, input_dev->evbit);
994                                 set_bit(key->sw.code, input_dev->swbit);
995                                 break;
996
997                         default:
998                                 ;
999                 }
1000         }
1001
1002         /* reads information flags on KE_END */
1003         if (key->code & FE_UNTESTED)
1004                 printk(KERN_WARNING "Untested laptop multimedia keys, "
1005                         "please report success or failure to eric.piel"
1006                         "@tremplin-utc.net\n");
1007
1008         error = input_register_device(input_dev);
1009         if (error) {
1010                 input_free_device(input_dev);
1011                 return error;
1012         }
1013
1014         return 0;
1015 }
1016
1017 static void report_key(unsigned keycode)
1018 {
1019         input_report_key(input_dev, keycode, 1);
1020         input_sync(input_dev);
1021         input_report_key(input_dev, keycode, 0);
1022         input_sync(input_dev);
1023 }
1024
1025 static void report_switch(unsigned code, int value)
1026 {
1027         input_report_switch(input_dev, code, value);
1028         input_sync(input_dev);
1029 }
1030
1031  /* Driver core */
1032
1033 static int wifi_enabled;
1034 static int bluetooth_enabled;
1035
1036 static void poll_bios(unsigned long);
1037
1038 static struct timer_list poll_timer = TIMER_INITIALIZER(poll_bios, 0, 0);
1039
1040 static void handle_key(u8 code)
1041 {
1042         const struct key_entry *key;
1043
1044         for (key = keymap; key->type != KE_END; key++) {
1045                 if (code == key->code) {
1046                         switch (key->type) {
1047                         case KE_KEY:
1048                                 report_key(key->keycode);
1049                                 break;
1050
1051                         case KE_SW:
1052                                 report_switch(key->sw.code, key->sw.value);
1053                                 break;
1054
1055                         case KE_WIFI:
1056                                 if (have_wifi) {
1057                                         wifi_enabled = !wifi_enabled;
1058                                         bios_set_state(WIFI, wifi_enabled);
1059                                 }
1060                                 break;
1061
1062                         case KE_BLUETOOTH:
1063                                 if (have_bluetooth) {
1064                                         bluetooth_enabled = !bluetooth_enabled;
1065                                         bios_set_state(BLUETOOTH, bluetooth_enabled);
1066                                 }
1067                                 break;
1068
1069                         case KE_END:
1070                                 break;
1071                         default:
1072                                 BUG();
1073                         }
1074                         return;
1075                 }
1076         }
1077         printk(KERN_NOTICE "wistron_btns: Unknown key code %02X\n", code);
1078 }
1079
1080 static void poll_bios(unsigned long discard)
1081 {
1082         u8 qlen;
1083         u16 val;
1084
1085         for (;;) {
1086                 qlen = CMOS_READ(cmos_address);
1087                 if (qlen == 0)
1088                         break;
1089                 val = bios_pop_queue();
1090                 if (val != 0 && !discard)
1091                         handle_key((u8)val);
1092         }
1093
1094         mod_timer(&poll_timer, jiffies + HZ / POLL_FREQUENCY);
1095 }
1096
1097 static int __devinit wistron_probe(struct platform_device *dev)
1098 {
1099         int err = setup_input_dev();
1100         if (err)
1101                 return err;
1102
1103         bios_attach();
1104         cmos_address = bios_get_cmos_address();
1105
1106         if (have_wifi) {
1107                 u16 wifi = bios_get_default_setting(WIFI);
1108                 if (wifi & 1)
1109                         wifi_enabled = (wifi & 2) ? 1 : 0;
1110                 else
1111                         have_wifi = 0;
1112
1113                 if (have_wifi)
1114                         bios_set_state(WIFI, wifi_enabled);
1115         }
1116
1117         if (have_bluetooth) {
1118                 u16 bt = bios_get_default_setting(BLUETOOTH);
1119                 if (bt & 1)
1120                         bluetooth_enabled = (bt & 2) ? 1 : 0;
1121                 else
1122                         have_bluetooth = 0;
1123
1124                 if (have_bluetooth)
1125                         bios_set_state(BLUETOOTH, bluetooth_enabled);
1126         }
1127
1128         poll_bios(1); /* Flush stale event queue and arm timer */
1129
1130         return 0;
1131 }
1132
1133 static int __devexit wistron_remove(struct platform_device *dev)
1134 {
1135         del_timer_sync(&poll_timer);
1136         input_unregister_device(input_dev);
1137         bios_detach();
1138
1139         return 0;
1140 }
1141
1142 #ifdef CONFIG_PM
1143 static int wistron_suspend(struct platform_device *dev, pm_message_t state)
1144 {
1145         del_timer_sync(&poll_timer);
1146
1147         if (have_wifi)
1148                 bios_set_state(WIFI, 0);
1149
1150         if (have_bluetooth)
1151                 bios_set_state(BLUETOOTH, 0);
1152
1153         return 0;
1154 }
1155
1156 static int wistron_resume(struct platform_device *dev)
1157 {
1158         if (have_wifi)
1159                 bios_set_state(WIFI, wifi_enabled);
1160
1161         if (have_bluetooth)
1162                 bios_set_state(BLUETOOTH, bluetooth_enabled);
1163
1164         poll_bios(1);
1165
1166         return 0;
1167 }
1168 #else
1169 #define wistron_suspend         NULL
1170 #define wistron_resume          NULL
1171 #endif
1172
1173 static struct platform_driver wistron_driver = {
1174         .driver         = {
1175                 .name   = "wistron-bios",
1176                 .owner  = THIS_MODULE,
1177         },
1178         .probe          = wistron_probe,
1179         .remove         = __devexit_p(wistron_remove),
1180         .suspend        = wistron_suspend,
1181         .resume         = wistron_resume,
1182 };
1183
1184 static int __init wb_module_init(void)
1185 {
1186         int err;
1187
1188         err = select_keymap();
1189         if (err)
1190                 return err;
1191
1192         err = map_bios();
1193         if (err)
1194                 return err;
1195
1196         err = platform_driver_register(&wistron_driver);
1197         if (err)
1198                 goto err_unmap_bios;
1199
1200         wistron_device = platform_device_alloc("wistron-bios", -1);
1201         if (!wistron_device) {
1202                 err = -ENOMEM;
1203                 goto err_unregister_driver;
1204         }
1205
1206         err = platform_device_add(wistron_device);
1207         if (err)
1208                 goto err_free_device;
1209
1210         return 0;
1211
1212  err_free_device:
1213         platform_device_put(wistron_device);
1214  err_unregister_driver:
1215         platform_driver_unregister(&wistron_driver);
1216  err_unmap_bios:
1217         unmap_bios();
1218
1219         return err;
1220 }
1221
1222 static void __exit wb_module_exit(void)
1223 {
1224         platform_device_unregister(wistron_device);
1225         platform_driver_unregister(&wistron_driver);
1226         unmap_bios();
1227         kfree(keymap);
1228 }
1229
1230 module_init(wb_module_init);
1231 module_exit(wb_module_exit);