drivers/input/misc/wistron_btns.c

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