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.1"); 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"); 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(®s, 0, sizeof (regs)); 169 regs.eax = 0x9610; 170 regs.ebx = 0x061C; 171 regs.ecx = 0x0000; 172 call_bios(®s); 173 174 return regs.eax; 175 } 176 177 static void __devinit bios_attach(void) 178 { 179 struct regs regs; 180 181 memset(®s, 0, sizeof (regs)); 182 regs.eax = 0x9610; 183 regs.ebx = 0x012E; 184 call_bios(®s); 185 } 186 187 static void bios_detach(void) 188 { 189 struct regs regs; 190 191 memset(®s, 0, sizeof (regs)); 192 regs.eax = 0x9610; 193 regs.ebx = 0x002E; 194 call_bios(®s); 195 } 196 197 static u8 __devinit bios_get_cmos_address(void) 198 { 199 struct regs regs; 200 201 memset(®s, 0, sizeof (regs)); 202 regs.eax = 0x9610; 203 regs.ebx = 0x051C; 204 call_bios(®s); 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(®s, 0, sizeof (regs)); 214 regs.eax = 0x9610; 215 regs.ebx = 0x0200 | subsys; 216 call_bios(®s); 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(®s, 0, sizeof (regs)); 226 regs.eax = 0x9610; 227 regs.ebx = (enable ? 0x0100 : 0x0000) | subsys; 228 call_bios(®s); 229 } 230 231 /* Hardware database */ 232 233 struct key_entry { 234 char type; /* See KE_* below */ 235 u8 code; 236 unsigned keycode; /* For KE_KEY */ 237 }; 238 239 enum { KE_END, KE_KEY, KE_WIFI, KE_BLUETOOTH }; 240 241 static const struct key_entry *keymap; /* = NULL; Current key map */ 242 static int have_wifi; 243 static int have_bluetooth; 244 245 static int __init dmi_matched(struct dmi_system_id *dmi) 246 { 247 const struct key_entry *key; 248 249 keymap = dmi->driver_data; 250 for (key = keymap; key->type != KE_END; key++) { 251 if (key->type == KE_WIFI) 252 have_wifi = 1; 253 else if (key->type == KE_BLUETOOTH) 254 have_bluetooth = 1; 255 } 256 return 1; 257 } 258 259 static struct key_entry keymap_empty[] = { 260 { KE_END, 0 } 261 }; 262 263 static struct key_entry keymap_fs_amilo_pro_v2000[] = { 264 { KE_KEY, 0x01, KEY_HELP }, 265 { KE_KEY, 0x11, KEY_PROG1 }, 266 { KE_KEY, 0x12, KEY_PROG2 }, 267 { KE_WIFI, 0x30, 0 }, 268 { KE_KEY, 0x31, KEY_MAIL }, 269 { KE_KEY, 0x36, KEY_WWW }, 270 { KE_END, 0 } 271 }; 272 273 static struct key_entry keymap_fujitsu_n3510[] = { 274 { KE_KEY, 0x11, KEY_PROG1 }, 275 { KE_KEY, 0x12, KEY_PROG2 }, 276 { KE_KEY, 0x36, KEY_WWW }, 277 { KE_KEY, 0x31, KEY_MAIL }, 278 { KE_KEY, 0x71, KEY_STOPCD }, 279 { KE_KEY, 0x72, KEY_PLAYPAUSE }, 280 { KE_KEY, 0x74, KEY_REWIND }, 281 { KE_KEY, 0x78, KEY_FORWARD }, 282 { KE_END, 0 } 283 }; 284 285 static struct key_entry keymap_wistron_ms2111[] = { 286 { KE_KEY, 0x11, KEY_PROG1 }, 287 { KE_KEY, 0x12, KEY_PROG2 }, 288 { KE_KEY, 0x13, KEY_PROG3 }, 289 { KE_KEY, 0x31, KEY_MAIL }, 290 { KE_KEY, 0x36, KEY_WWW }, 291 { KE_END, 0 } 292 }; 293 294 static struct key_entry keymap_wistron_ms2141[] = { 295 { KE_KEY, 0x11, KEY_PROG1 }, 296 { KE_KEY, 0x12, KEY_PROG2 }, 297 { KE_WIFI, 0x30, 0 }, 298 { KE_KEY, 0x22, KEY_REWIND }, 299 { KE_KEY, 0x23, KEY_FORWARD }, 300 { KE_KEY, 0x24, KEY_PLAYPAUSE }, 301 { KE_KEY, 0x25, KEY_STOPCD }, 302 { KE_KEY, 0x31, KEY_MAIL }, 303 { KE_KEY, 0x36, KEY_WWW }, 304 { KE_END, 0 } 305 }; 306 307 static struct key_entry keymap_acer_aspire_1500[] = { 308 { KE_KEY, 0x11, KEY_PROG1 }, 309 { KE_KEY, 0x12, KEY_PROG2 }, 310 { KE_WIFI, 0x30, 0 }, 311 { KE_KEY, 0x31, KEY_MAIL }, 312 { KE_KEY, 0x36, KEY_WWW }, 313 { KE_BLUETOOTH, 0x44, 0 }, 314 { KE_END, 0 } 315 }; 316 317 static struct key_entry keymap_acer_travelmate_240[] = { 318 { KE_KEY, 0x31, KEY_MAIL }, 319 { KE_KEY, 0x36, KEY_WWW }, 320 { KE_KEY, 0x11, KEY_PROG1 }, 321 { KE_KEY, 0x12, KEY_PROG2 }, 322 { KE_BLUETOOTH, 0x44, 0 }, 323 { KE_WIFI, 0x30, 0 }, 324 { KE_END, 0 } 325 }; 326 327 static struct key_entry keymap_aopen_1559as[] = { 328 { KE_KEY, 0x01, KEY_HELP }, 329 { KE_KEY, 0x06, KEY_PROG3 }, 330 { KE_KEY, 0x11, KEY_PROG1 }, 331 { KE_KEY, 0x12, KEY_PROG2 }, 332 { KE_WIFI, 0x30, 0 }, 333 { KE_KEY, 0x31, KEY_MAIL }, 334 { KE_KEY, 0x36, KEY_WWW }, 335 { KE_END, 0 }, 336 }; 337 338 static struct key_entry keymap_fs_amilo_d88x0[] = { 339 { KE_KEY, 0x01, KEY_HELP }, 340 { KE_KEY, 0x08, KEY_MUTE }, 341 { KE_KEY, 0x31, KEY_MAIL }, 342 { KE_KEY, 0x36, KEY_WWW }, 343 { KE_KEY, 0x11, KEY_PROG1 }, 344 { KE_KEY, 0x12, KEY_PROG2 }, 345 { KE_KEY, 0x13, KEY_PROG3 }, 346 { KE_END, 0 } 347 }; 348 349 /* 350 * If your machine is not here (which is currently rather likely), please send 351 * a list of buttons and their key codes (reported when loading this module 352 * with force=1) and the output of dmidecode to $MODULE_AUTHOR. 353 */ 354 static struct dmi_system_id dmi_ids[] __initdata = { 355 { 356 .callback = dmi_matched, 357 .ident = "Fujitsu-Siemens Amilo Pro V2000", 358 .matches = { 359 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 360 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2000"), 361 }, 362 .driver_data = keymap_fs_amilo_pro_v2000 363 }, 364 { 365 .callback = dmi_matched, 366 .ident = "Fujitsu-Siemens Amilo M7400", 367 .matches = { 368 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 369 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO M "), 370 }, 371 .driver_data = keymap_fs_amilo_pro_v2000 372 }, 373 { 374 .callback = dmi_matched, 375 .ident = "Fujitsu N3510", 376 .matches = { 377 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), 378 DMI_MATCH(DMI_PRODUCT_NAME, "N3510"), 379 }, 380 .driver_data = keymap_fujitsu_n3510 381 }, 382 { 383 .callback = dmi_matched, 384 .ident = "Acer Aspire 1500", 385 .matches = { 386 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 387 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1500"), 388 }, 389 .driver_data = keymap_acer_aspire_1500 390 }, 391 { 392 .callback = dmi_matched, 393 .ident = "Acer TravelMate 240", 394 .matches = { 395 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 396 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 240"), 397 }, 398 .driver_data = keymap_acer_travelmate_240 399 }, 400 { 401 .callback = dmi_matched, 402 .ident = "Acer TravelMate 2424NWXCi", 403 .matches = { 404 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 405 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2420"), 406 }, 407 .driver_data = keymap_acer_travelmate_240 408 }, 409 { 410 .callback = dmi_matched, 411 .ident = "AOpen 1559AS", 412 .matches = { 413 DMI_MATCH(DMI_PRODUCT_NAME, "E2U"), 414 DMI_MATCH(DMI_BOARD_NAME, "E2U"), 415 }, 416 .driver_data = keymap_aopen_1559as 417 }, 418 { 419 .callback = dmi_matched, 420 .ident = "Medion MD 9783", 421 .matches = { 422 DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"), 423 DMI_MATCH(DMI_PRODUCT_NAME, "MD 9783"), 424 }, 425 .driver_data = keymap_wistron_ms2111 426 }, 427 { 428 .callback = dmi_matched, 429 .ident = "Fujitsu Siemens Amilo D88x0", 430 .matches = { 431 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 432 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO D"), 433 }, 434 .driver_data = keymap_fs_amilo_d88x0 435 }, 436 { NULL, } 437 }; 438 439 static int __init select_keymap(void) 440 { 441 if (keymap_name != NULL) { 442 if (strcmp (keymap_name, "1557/MS2141") == 0) 443 keymap = keymap_wistron_ms2141; 444 else { 445 printk(KERN_ERR "wistron_btns: Keymap unknown\n"); 446 return -EINVAL; 447 } 448 } 449 dmi_check_system(dmi_ids); 450 if (keymap == NULL) { 451 if (!force) { 452 printk(KERN_ERR "wistron_btns: System unknown\n"); 453 return -ENODEV; 454 } 455 keymap = keymap_empty; 456 } 457 return 0; 458 } 459 460 /* Input layer interface */ 461 462 static struct input_dev *input_dev; 463 464 static int __devinit setup_input_dev(void) 465 { 466 const struct key_entry *key; 467 int error; 468 469 input_dev = input_allocate_device(); 470 if (!input_dev) 471 return -ENOMEM; 472 473 input_dev->name = "Wistron laptop buttons"; 474 input_dev->phys = "wistron/input0"; 475 input_dev->id.bustype = BUS_HOST; 476 input_dev->cdev.dev = &wistron_device->dev; 477 478 for (key = keymap; key->type != KE_END; key++) { 479 if (key->type == KE_KEY) { 480 input_dev->evbit[LONG(EV_KEY)] = BIT(EV_KEY); 481 set_bit(key->keycode, input_dev->keybit); 482 } 483 } 484 485 error = input_register_device(input_dev); 486 if (error) { 487 input_free_device(input_dev); 488 return error; 489 } 490 491 return 0; 492 } 493 494 static void report_key(unsigned keycode) 495 { 496 input_report_key(input_dev, keycode, 1); 497 input_sync(input_dev); 498 input_report_key(input_dev, keycode, 0); 499 input_sync(input_dev); 500 } 501 502 /* Driver core */ 503 504 static int wifi_enabled; 505 static int bluetooth_enabled; 506 507 static void poll_bios(unsigned long); 508 509 static struct timer_list poll_timer = TIMER_INITIALIZER(poll_bios, 0, 0); 510 511 static void handle_key(u8 code) 512 { 513 const struct key_entry *key; 514 515 for (key = keymap; key->type != KE_END; key++) { 516 if (code == key->code) { 517 switch (key->type) { 518 case KE_KEY: 519 report_key(key->keycode); 520 break; 521 522 case KE_WIFI: 523 if (have_wifi) { 524 wifi_enabled = !wifi_enabled; 525 bios_set_state(WIFI, wifi_enabled); 526 } 527 break; 528 529 case KE_BLUETOOTH: 530 if (have_bluetooth) { 531 bluetooth_enabled = !bluetooth_enabled; 532 bios_set_state(BLUETOOTH, bluetooth_enabled); 533 } 534 break; 535 536 case KE_END: 537 default: 538 BUG(); 539 } 540 return; 541 } 542 } 543 printk(KERN_NOTICE "wistron_btns: Unknown key code %02X\n", code); 544 } 545 546 static void poll_bios(unsigned long discard) 547 { 548 u8 qlen; 549 u16 val; 550 551 for (;;) { 552 qlen = CMOS_READ(cmos_address); 553 if (qlen == 0) 554 break; 555 val = bios_pop_queue(); 556 if (val != 0 && !discard) 557 handle_key((u8)val); 558 } 559 560 mod_timer(&poll_timer, jiffies + HZ / POLL_FREQUENCY); 561 } 562 563 static int __devinit wistron_probe(struct platform_device *dev) 564 { 565 int err = setup_input_dev(); 566 if (err) 567 return err; 568 569 bios_attach(); 570 cmos_address = bios_get_cmos_address(); 571 572 if (have_wifi) { 573 u16 wifi = bios_get_default_setting(WIFI); 574 if (wifi & 1) 575 wifi_enabled = (wifi & 2) ? 1 : 0; 576 else 577 have_wifi = 0; 578 579 if (have_wifi) 580 bios_set_state(WIFI, wifi_enabled); 581 } 582 583 if (have_bluetooth) { 584 u16 bt = bios_get_default_setting(BLUETOOTH); 585 if (bt & 1) 586 bluetooth_enabled = (bt & 2) ? 1 : 0; 587 else 588 have_bluetooth = 0; 589 590 if (have_bluetooth) 591 bios_set_state(BLUETOOTH, bluetooth_enabled); 592 } 593 594 poll_bios(1); /* Flush stale event queue and arm timer */ 595 596 return 0; 597 } 598 599 static int __devexit wistron_remove(struct platform_device *dev) 600 { 601 del_timer_sync(&poll_timer); 602 input_unregister_device(input_dev); 603 bios_detach(); 604 605 return 0; 606 } 607 608 #ifdef CONFIG_PM 609 static int wistron_suspend(struct platform_device *dev, pm_message_t state) 610 { 611 del_timer_sync(&poll_timer); 612 613 if (have_wifi) 614 bios_set_state(WIFI, 0); 615 616 if (have_bluetooth) 617 bios_set_state(BLUETOOTH, 0); 618 619 return 0; 620 } 621 622 static int wistron_resume(struct platform_device *dev) 623 { 624 if (have_wifi) 625 bios_set_state(WIFI, wifi_enabled); 626 627 if (have_bluetooth) 628 bios_set_state(BLUETOOTH, bluetooth_enabled); 629 630 poll_bios(1); 631 632 return 0; 633 } 634 #else 635 #define wistron_suspend NULL 636 #define wistron_resume NULL 637 #endif 638 639 static struct platform_driver wistron_driver = { 640 .driver = { 641 .name = "wistron-bios", 642 .owner = THIS_MODULE, 643 }, 644 .probe = wistron_probe, 645 .remove = __devexit_p(wistron_remove), 646 .suspend = wistron_suspend, 647 .resume = wistron_resume, 648 }; 649 650 static int __init wb_module_init(void) 651 { 652 int err; 653 654 err = select_keymap(); 655 if (err) 656 return err; 657 658 err = map_bios(); 659 if (err) 660 return err; 661 662 err = platform_driver_register(&wistron_driver); 663 if (err) 664 goto err_unmap_bios; 665 666 wistron_device = platform_device_alloc("wistron-bios", -1); 667 if (!wistron_device) { 668 err = -ENOMEM; 669 goto err_unregister_driver; 670 } 671 672 err = platform_device_add(wistron_device); 673 if (err) 674 goto err_free_device; 675 676 return 0; 677 678 err_free_device: 679 platform_device_put(wistron_device); 680 err_unregister_driver: 681 platform_driver_unregister(&wistron_driver); 682 err_unmap_bios: 683 unmap_bios(); 684 685 return err; 686 } 687 688 static void __exit wb_module_exit(void) 689 { 690 platform_device_unregister(wistron_device); 691 platform_driver_unregister(&wistron_driver); 692 unmap_bios(); 693 } 694 695 module_init(wb_module_init); 696 module_exit(wb_module_exit); 697