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