1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Acer WMI Laptop Extras 4 * 5 * Copyright (C) 2007-2009 Carlos Corbacho <carlos@strangeworlds.co.uk> 6 * 7 * Based on acer_acpi: 8 * Copyright (C) 2005-2007 E.M. Smith 9 * Copyright (C) 2007-2008 Carlos Corbacho <cathectic@gmail.com> 10 */ 11 12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14#include <linux/kernel.h> 15#include <linux/module.h> 16#include <linux/init.h> 17#include <linux/types.h> 18#include <linux/dmi.h> 19#include <linux/fb.h> 20#include <linux/backlight.h> 21#include <linux/leds.h> 22#include <linux/platform_device.h> 23#include <linux/acpi.h> 24#include <linux/i8042.h> 25#include <linux/rfkill.h> 26#include <linux/workqueue.h> 27#include <linux/debugfs.h> 28#include <linux/slab.h> 29#include <linux/input.h> 30#include <linux/input/sparse-keymap.h> 31#include <acpi/video.h> 32 33ACPI_MODULE_NAME(KBUILD_MODNAME); 34MODULE_AUTHOR("Carlos Corbacho"); 35MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver"); 36MODULE_LICENSE("GPL"); 37 38/* 39 * Magic Number 40 * Meaning is unknown - this number is required for writing to ACPI for AMW0 41 * (it's also used in acerhk when directly accessing the BIOS) 42 */ 43#define ACER_AMW0_WRITE 0x9610 44 45/* 46 * Bit masks for the AMW0 interface 47 */ 48#define ACER_AMW0_WIRELESS_MASK 0x35 49#define ACER_AMW0_BLUETOOTH_MASK 0x34 50#define ACER_AMW0_MAILLED_MASK 0x31 51 52/* 53 * Method IDs for WMID interface 54 */ 55#define ACER_WMID_GET_WIRELESS_METHODID 1 56#define ACER_WMID_GET_BLUETOOTH_METHODID 2 57#define ACER_WMID_GET_BRIGHTNESS_METHODID 3 58#define ACER_WMID_SET_WIRELESS_METHODID 4 59#define ACER_WMID_SET_BLUETOOTH_METHODID 5 60#define ACER_WMID_SET_BRIGHTNESS_METHODID 6 61#define ACER_WMID_GET_THREEG_METHODID 10 62#define ACER_WMID_SET_THREEG_METHODID 11 63 64/* 65 * Acer ACPI method GUIDs 66 */ 67#define AMW0_GUID1 "67C3371D-95A3-4C37-BB61-DD47B491DAAB" 68#define AMW0_GUID2 "431F16ED-0C2B-444C-B267-27DEB140CF9C" 69#define WMID_GUID1 "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3" 70#define WMID_GUID2 "95764E09-FB56-4E83-B31A-37761F60994A" 71#define WMID_GUID3 "61EF69EA-865C-4BC3-A502-A0DEBA0CB531" 72 73/* 74 * Acer ACPI event GUIDs 75 */ 76#define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026" 77 78MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB"); 79MODULE_ALIAS("wmi:6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"); 80MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026"); 81 82enum acer_wmi_event_ids { 83 WMID_HOTKEY_EVENT = 0x1, 84 WMID_ACCEL_OR_KBD_DOCK_EVENT = 0x5, 85}; 86 87static const struct key_entry acer_wmi_keymap[] __initconst = { 88 {KE_KEY, 0x01, {KEY_WLAN} }, /* WiFi */ 89 {KE_KEY, 0x03, {KEY_WLAN} }, /* WiFi */ 90 {KE_KEY, 0x04, {KEY_WLAN} }, /* WiFi */ 91 {KE_KEY, 0x12, {KEY_BLUETOOTH} }, /* BT */ 92 {KE_KEY, 0x21, {KEY_PROG1} }, /* Backup */ 93 {KE_KEY, 0x22, {KEY_PROG2} }, /* Arcade */ 94 {KE_KEY, 0x23, {KEY_PROG3} }, /* P_Key */ 95 {KE_KEY, 0x24, {KEY_PROG4} }, /* Social networking_Key */ 96 {KE_KEY, 0x27, {KEY_HELP} }, 97 {KE_KEY, 0x29, {KEY_PROG3} }, /* P_Key for TM8372 */ 98 {KE_IGNORE, 0x41, {KEY_MUTE} }, 99 {KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} }, 100 {KE_IGNORE, 0x4d, {KEY_PREVIOUSSONG} }, 101 {KE_IGNORE, 0x43, {KEY_NEXTSONG} }, 102 {KE_IGNORE, 0x4e, {KEY_NEXTSONG} }, 103 {KE_IGNORE, 0x44, {KEY_PLAYPAUSE} }, 104 {KE_IGNORE, 0x4f, {KEY_PLAYPAUSE} }, 105 {KE_IGNORE, 0x45, {KEY_STOP} }, 106 {KE_IGNORE, 0x50, {KEY_STOP} }, 107 {KE_IGNORE, 0x48, {KEY_VOLUMEUP} }, 108 {KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} }, 109 {KE_IGNORE, 0x4a, {KEY_VOLUMEDOWN} }, 110 /* 111 * 0x61 is KEY_SWITCHVIDEOMODE. Usually this is a duplicate input event 112 * with the "Video Bus" input device events. But sometimes it is not 113 * a dup. Map it to KEY_UNKNOWN instead of using KE_IGNORE so that 114 * udev/hwdb can override it on systems where it is not a dup. 115 */ 116 {KE_KEY, 0x61, {KEY_UNKNOWN} }, 117 {KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} }, 118 {KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} }, 119 {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */ 120 {KE_IGNORE, 0x81, {KEY_SLEEP} }, 121 {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad Toggle */ 122 {KE_IGNORE, 0x84, {KEY_KBDILLUMTOGGLE} }, /* Automatic Keyboard background light toggle */ 123 {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} }, 124 {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} }, 125 {KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} }, 126 {KE_KEY, 0x85, {KEY_TOUCHPAD_TOGGLE} }, 127 {KE_KEY, 0x86, {KEY_WLAN} }, 128 {KE_KEY, 0x87, {KEY_POWER} }, 129 {KE_END, 0} 130}; 131 132static struct input_dev *acer_wmi_input_dev; 133static struct input_dev *acer_wmi_accel_dev; 134 135struct event_return_value { 136 u8 function; 137 u8 key_num; 138 u16 device_state; 139 u16 reserved1; 140 u8 kbd_dock_state; 141 u8 reserved2; 142} __attribute__((packed)); 143 144/* 145 * GUID3 Get Device Status device flags 146 */ 147#define ACER_WMID3_GDS_WIRELESS (1<<0) /* WiFi */ 148#define ACER_WMID3_GDS_THREEG (1<<6) /* 3G */ 149#define ACER_WMID3_GDS_WIMAX (1<<7) /* WiMAX */ 150#define ACER_WMID3_GDS_BLUETOOTH (1<<11) /* BT */ 151#define ACER_WMID3_GDS_RFBTN (1<<14) /* RF Button */ 152 153#define ACER_WMID3_GDS_TOUCHPAD (1<<1) /* Touchpad */ 154 155/* Hotkey Customized Setting and Acer Application Status. 156 * Set Device Default Value and Report Acer Application Status. 157 * When Acer Application starts, it will run this method to inform 158 * BIOS/EC that Acer Application is on. 159 * App Status 160 * Bit[0]: Launch Manager Status 161 * Bit[1]: ePM Status 162 * Bit[2]: Device Control Status 163 * Bit[3]: Acer Power Button Utility Status 164 * Bit[4]: RF Button Status 165 * Bit[5]: ODD PM Status 166 * Bit[6]: Device Default Value Control 167 * Bit[7]: Hall Sensor Application Status 168 */ 169struct func_input_params { 170 u8 function_num; /* Function Number */ 171 u16 commun_devices; /* Communication type devices default status */ 172 u16 devices; /* Other type devices default status */ 173 u8 app_status; /* Acer Device Status. LM, ePM, RF Button... */ 174 u8 app_mask; /* Bit mask to app_status */ 175 u8 reserved; 176} __attribute__((packed)); 177 178struct func_return_value { 179 u8 error_code; /* Error Code */ 180 u8 ec_return_value; /* EC Return Value */ 181 u16 reserved; 182} __attribute__((packed)); 183 184struct wmid3_gds_set_input_param { /* Set Device Status input parameter */ 185 u8 function_num; /* Function Number */ 186 u8 hotkey_number; /* Hotkey Number */ 187 u16 devices; /* Set Device */ 188 u8 volume_value; /* Volume Value */ 189} __attribute__((packed)); 190 191struct wmid3_gds_get_input_param { /* Get Device Status input parameter */ 192 u8 function_num; /* Function Number */ 193 u8 hotkey_number; /* Hotkey Number */ 194 u16 devices; /* Get Device */ 195} __attribute__((packed)); 196 197struct wmid3_gds_return_value { /* Get Device Status return value*/ 198 u8 error_code; /* Error Code */ 199 u8 ec_return_value; /* EC Return Value */ 200 u16 devices; /* Current Device Status */ 201 u32 reserved; 202} __attribute__((packed)); 203 204struct hotkey_function_type_aa { 205 u8 type; 206 u8 length; 207 u16 handle; 208 u16 commun_func_bitmap; 209 u16 application_func_bitmap; 210 u16 media_func_bitmap; 211 u16 display_func_bitmap; 212 u16 others_func_bitmap; 213 u8 commun_fn_key_number; 214} __attribute__((packed)); 215 216/* 217 * Interface capability flags 218 */ 219#define ACER_CAP_MAILLED BIT(0) 220#define ACER_CAP_WIRELESS BIT(1) 221#define ACER_CAP_BLUETOOTH BIT(2) 222#define ACER_CAP_BRIGHTNESS BIT(3) 223#define ACER_CAP_THREEG BIT(4) 224#define ACER_CAP_SET_FUNCTION_MODE BIT(5) 225#define ACER_CAP_KBD_DOCK BIT(6) 226 227/* 228 * Interface type flags 229 */ 230enum interface_flags { 231 ACER_AMW0, 232 ACER_AMW0_V2, 233 ACER_WMID, 234 ACER_WMID_v2, 235}; 236 237#define ACER_DEFAULT_WIRELESS 0 238#define ACER_DEFAULT_BLUETOOTH 0 239#define ACER_DEFAULT_MAILLED 0 240#define ACER_DEFAULT_THREEG 0 241 242static int max_brightness = 0xF; 243 244static int mailled = -1; 245static int brightness = -1; 246static int threeg = -1; 247static int force_series; 248static int force_caps = -1; 249static bool ec_raw_mode; 250static bool has_type_aa; 251static u16 commun_func_bitmap; 252static u8 commun_fn_key_number; 253 254module_param(mailled, int, 0444); 255module_param(brightness, int, 0444); 256module_param(threeg, int, 0444); 257module_param(force_series, int, 0444); 258module_param(force_caps, int, 0444); 259module_param(ec_raw_mode, bool, 0444); 260MODULE_PARM_DESC(mailled, "Set initial state of Mail LED"); 261MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness"); 262MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware"); 263MODULE_PARM_DESC(force_series, "Force a different laptop series"); 264MODULE_PARM_DESC(force_caps, "Force the capability bitmask to this value"); 265MODULE_PARM_DESC(ec_raw_mode, "Enable EC raw mode"); 266 267struct acer_data { 268 int mailled; 269 int threeg; 270 int brightness; 271}; 272 273struct acer_debug { 274 struct dentry *root; 275 u32 wmid_devices; 276}; 277 278static struct rfkill *wireless_rfkill; 279static struct rfkill *bluetooth_rfkill; 280static struct rfkill *threeg_rfkill; 281static bool rfkill_inited; 282 283/* Each low-level interface must define at least some of the following */ 284struct wmi_interface { 285 /* The WMI device type */ 286 u32 type; 287 288 /* The capabilities this interface provides */ 289 u32 capability; 290 291 /* Private data for the current interface */ 292 struct acer_data data; 293 294 /* debugfs entries associated with this interface */ 295 struct acer_debug debug; 296}; 297 298/* The static interface pointer, points to the currently detected interface */ 299static struct wmi_interface *interface; 300 301/* 302 * Embedded Controller quirks 303 * Some laptops require us to directly access the EC to either enable or query 304 * features that are not available through WMI. 305 */ 306 307struct quirk_entry { 308 u8 wireless; 309 u8 mailled; 310 s8 brightness; 311 u8 bluetooth; 312}; 313 314static struct quirk_entry *quirks; 315 316static void __init set_quirks(void) 317{ 318 if (!interface) 319 return; 320 321 if (quirks->mailled) 322 interface->capability |= ACER_CAP_MAILLED; 323 324 if (quirks->brightness) 325 interface->capability |= ACER_CAP_BRIGHTNESS; 326} 327 328static int __init dmi_matched(const struct dmi_system_id *dmi) 329{ 330 quirks = dmi->driver_data; 331 return 1; 332} 333 334static int __init set_force_caps(const struct dmi_system_id *dmi) 335{ 336 if (force_caps == -1) { 337 force_caps = (uintptr_t)dmi->driver_data; 338 pr_info("Found %s, set force_caps to 0x%x\n", dmi->ident, force_caps); 339 } 340 return 1; 341} 342 343static struct quirk_entry quirk_unknown = { 344}; 345 346static struct quirk_entry quirk_acer_aspire_1520 = { 347 .brightness = -1, 348}; 349 350static struct quirk_entry quirk_acer_travelmate_2490 = { 351 .mailled = 1, 352}; 353 354/* This AMW0 laptop has no bluetooth */ 355static struct quirk_entry quirk_medion_md_98300 = { 356 .wireless = 1, 357}; 358 359static struct quirk_entry quirk_fujitsu_amilo_li_1718 = { 360 .wireless = 2, 361}; 362 363static struct quirk_entry quirk_lenovo_ideapad_s205 = { 364 .wireless = 3, 365}; 366 367/* The Aspire One has a dummy ACPI-WMI interface - disable it */ 368static const struct dmi_system_id acer_blacklist[] __initconst = { 369 { 370 .ident = "Acer Aspire One (SSD)", 371 .matches = { 372 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 373 DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"), 374 }, 375 }, 376 { 377 .ident = "Acer Aspire One (HDD)", 378 .matches = { 379 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 380 DMI_MATCH(DMI_PRODUCT_NAME, "AOA150"), 381 }, 382 }, 383 {} 384}; 385 386static const struct dmi_system_id amw0_whitelist[] __initconst = { 387 { 388 .ident = "Acer", 389 .matches = { 390 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 391 }, 392 }, 393 { 394 .ident = "Gateway", 395 .matches = { 396 DMI_MATCH(DMI_SYS_VENDOR, "Gateway"), 397 }, 398 }, 399 { 400 .ident = "Packard Bell", 401 .matches = { 402 DMI_MATCH(DMI_SYS_VENDOR, "Packard Bell"), 403 }, 404 }, 405 {} 406}; 407 408/* 409 * This quirk table is only for Acer/Gateway/Packard Bell family 410 * that those machines are supported by acer-wmi driver. 411 */ 412static const struct dmi_system_id acer_quirks[] __initconst = { 413 { 414 .callback = dmi_matched, 415 .ident = "Acer Aspire 1360", 416 .matches = { 417 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 418 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"), 419 }, 420 .driver_data = &quirk_acer_aspire_1520, 421 }, 422 { 423 .callback = dmi_matched, 424 .ident = "Acer Aspire 1520", 425 .matches = { 426 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 427 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1520"), 428 }, 429 .driver_data = &quirk_acer_aspire_1520, 430 }, 431 { 432 .callback = dmi_matched, 433 .ident = "Acer Aspire 3100", 434 .matches = { 435 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 436 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3100"), 437 }, 438 .driver_data = &quirk_acer_travelmate_2490, 439 }, 440 { 441 .callback = dmi_matched, 442 .ident = "Acer Aspire 3610", 443 .matches = { 444 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 445 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3610"), 446 }, 447 .driver_data = &quirk_acer_travelmate_2490, 448 }, 449 { 450 .callback = dmi_matched, 451 .ident = "Acer Aspire 5100", 452 .matches = { 453 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 454 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"), 455 }, 456 .driver_data = &quirk_acer_travelmate_2490, 457 }, 458 { 459 .callback = dmi_matched, 460 .ident = "Acer Aspire 5610", 461 .matches = { 462 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 463 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5610"), 464 }, 465 .driver_data = &quirk_acer_travelmate_2490, 466 }, 467 { 468 .callback = dmi_matched, 469 .ident = "Acer Aspire 5630", 470 .matches = { 471 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 472 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"), 473 }, 474 .driver_data = &quirk_acer_travelmate_2490, 475 }, 476 { 477 .callback = dmi_matched, 478 .ident = "Acer Aspire 5650", 479 .matches = { 480 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 481 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"), 482 }, 483 .driver_data = &quirk_acer_travelmate_2490, 484 }, 485 { 486 .callback = dmi_matched, 487 .ident = "Acer Aspire 5680", 488 .matches = { 489 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 490 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"), 491 }, 492 .driver_data = &quirk_acer_travelmate_2490, 493 }, 494 { 495 .callback = dmi_matched, 496 .ident = "Acer Aspire 9110", 497 .matches = { 498 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 499 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"), 500 }, 501 .driver_data = &quirk_acer_travelmate_2490, 502 }, 503 { 504 .callback = dmi_matched, 505 .ident = "Acer TravelMate 2490", 506 .matches = { 507 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 508 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"), 509 }, 510 .driver_data = &quirk_acer_travelmate_2490, 511 }, 512 { 513 .callback = dmi_matched, 514 .ident = "Acer TravelMate 4200", 515 .matches = { 516 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 517 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4200"), 518 }, 519 .driver_data = &quirk_acer_travelmate_2490, 520 }, 521 { 522 .callback = set_force_caps, 523 .ident = "Acer Aspire Switch 10E SW3-016", 524 .matches = { 525 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 526 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW3-016"), 527 }, 528 .driver_data = (void *)ACER_CAP_KBD_DOCK, 529 }, 530 { 531 .callback = set_force_caps, 532 .ident = "Acer Aspire Switch 10 SW5-012", 533 .matches = { 534 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 535 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"), 536 }, 537 .driver_data = (void *)ACER_CAP_KBD_DOCK, 538 }, 539 { 540 .callback = set_force_caps, 541 .ident = "Acer Aspire Switch V 10 SW5-017", 542 .matches = { 543 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"), 544 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SW5-017"), 545 }, 546 .driver_data = (void *)ACER_CAP_KBD_DOCK, 547 }, 548 { 549 .callback = set_force_caps, 550 .ident = "Acer One 10 (S1003)", 551 .matches = { 552 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"), 553 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "One S1003"), 554 }, 555 .driver_data = (void *)ACER_CAP_KBD_DOCK, 556 }, 557 {} 558}; 559 560/* 561 * This quirk list is for those non-acer machines that have AMW0_GUID1 562 * but supported by acer-wmi in past days. Keeping this quirk list here 563 * is only for backward compatible. Please do not add new machine to 564 * here anymore. Those non-acer machines should be supported by 565 * appropriate wmi drivers. 566 */ 567static const struct dmi_system_id non_acer_quirks[] __initconst = { 568 { 569 .callback = dmi_matched, 570 .ident = "Fujitsu Siemens Amilo Li 1718", 571 .matches = { 572 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 573 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Li 1718"), 574 }, 575 .driver_data = &quirk_fujitsu_amilo_li_1718, 576 }, 577 { 578 .callback = dmi_matched, 579 .ident = "Medion MD 98300", 580 .matches = { 581 DMI_MATCH(DMI_SYS_VENDOR, "MEDION"), 582 DMI_MATCH(DMI_PRODUCT_NAME, "WAM2030"), 583 }, 584 .driver_data = &quirk_medion_md_98300, 585 }, 586 { 587 .callback = dmi_matched, 588 .ident = "Lenovo Ideapad S205", 589 .matches = { 590 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 591 DMI_MATCH(DMI_PRODUCT_NAME, "10382LG"), 592 }, 593 .driver_data = &quirk_lenovo_ideapad_s205, 594 }, 595 { 596 .callback = dmi_matched, 597 .ident = "Lenovo Ideapad S205 (Brazos)", 598 .matches = { 599 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 600 DMI_MATCH(DMI_PRODUCT_NAME, "Brazos"), 601 }, 602 .driver_data = &quirk_lenovo_ideapad_s205, 603 }, 604 { 605 .callback = dmi_matched, 606 .ident = "Lenovo 3000 N200", 607 .matches = { 608 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 609 DMI_MATCH(DMI_PRODUCT_NAME, "0687A31"), 610 }, 611 .driver_data = &quirk_fujitsu_amilo_li_1718, 612 }, 613 { 614 .callback = dmi_matched, 615 .ident = "Lenovo Ideapad S205-10382JG", 616 .matches = { 617 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 618 DMI_MATCH(DMI_PRODUCT_NAME, "10382JG"), 619 }, 620 .driver_data = &quirk_lenovo_ideapad_s205, 621 }, 622 { 623 .callback = dmi_matched, 624 .ident = "Lenovo Ideapad S205-1038DPG", 625 .matches = { 626 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 627 DMI_MATCH(DMI_PRODUCT_NAME, "1038DPG"), 628 }, 629 .driver_data = &quirk_lenovo_ideapad_s205, 630 }, 631 {} 632}; 633 634static int __init 635video_set_backlight_video_vendor(const struct dmi_system_id *d) 636{ 637 interface->capability &= ~ACER_CAP_BRIGHTNESS; 638 pr_info("Brightness must be controlled by generic video driver\n"); 639 return 0; 640} 641 642static const struct dmi_system_id video_vendor_dmi_table[] __initconst = { 643 { 644 .callback = video_set_backlight_video_vendor, 645 .ident = "Acer TravelMate 4750", 646 .matches = { 647 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 648 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4750"), 649 }, 650 }, 651 { 652 .callback = video_set_backlight_video_vendor, 653 .ident = "Acer Extensa 5235", 654 .matches = { 655 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 656 DMI_MATCH(DMI_PRODUCT_NAME, "Extensa 5235"), 657 }, 658 }, 659 { 660 .callback = video_set_backlight_video_vendor, 661 .ident = "Acer TravelMate 5760", 662 .matches = { 663 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 664 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 5760"), 665 }, 666 }, 667 { 668 .callback = video_set_backlight_video_vendor, 669 .ident = "Acer Aspire 5750", 670 .matches = { 671 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 672 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5750"), 673 }, 674 }, 675 { 676 .callback = video_set_backlight_video_vendor, 677 .ident = "Acer Aspire 5741", 678 .matches = { 679 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"), 680 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5741"), 681 }, 682 }, 683 { 684 /* 685 * Note no video_set_backlight_video_vendor, we must use the 686 * acer interface, as there is no native backlight interface. 687 */ 688 .ident = "Acer KAV80", 689 .matches = { 690 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 691 DMI_MATCH(DMI_PRODUCT_NAME, "KAV80"), 692 }, 693 }, 694 {} 695}; 696 697/* Find which quirks are needed for a particular vendor/ model pair */ 698static void __init find_quirks(void) 699{ 700 if (!force_series) { 701 dmi_check_system(acer_quirks); 702 dmi_check_system(non_acer_quirks); 703 } else if (force_series == 2490) { 704 quirks = &quirk_acer_travelmate_2490; 705 } 706 707 if (quirks == NULL) 708 quirks = &quirk_unknown; 709 710 set_quirks(); 711} 712 713/* 714 * General interface convenience methods 715 */ 716 717static bool has_cap(u32 cap) 718{ 719 return interface->capability & cap; 720} 721 722/* 723 * AMW0 (V1) interface 724 */ 725struct wmab_args { 726 u32 eax; 727 u32 ebx; 728 u32 ecx; 729 u32 edx; 730}; 731 732struct wmab_ret { 733 u32 eax; 734 u32 ebx; 735 u32 ecx; 736 u32 edx; 737 u32 eex; 738}; 739 740static acpi_status wmab_execute(struct wmab_args *regbuf, 741struct acpi_buffer *result) 742{ 743 struct acpi_buffer input; 744 acpi_status status; 745 input.length = sizeof(struct wmab_args); 746 input.pointer = (u8 *)regbuf; 747 748 status = wmi_evaluate_method(AMW0_GUID1, 0, 1, &input, result); 749 750 return status; 751} 752 753static acpi_status AMW0_get_u32(u32 *value, u32 cap) 754{ 755 int err; 756 u8 result; 757 758 switch (cap) { 759 case ACER_CAP_MAILLED: 760 switch (quirks->mailled) { 761 default: 762 err = ec_read(0xA, &result); 763 if (err) 764 return AE_ERROR; 765 *value = (result >> 7) & 0x1; 766 return AE_OK; 767 } 768 break; 769 case ACER_CAP_WIRELESS: 770 switch (quirks->wireless) { 771 case 1: 772 err = ec_read(0x7B, &result); 773 if (err) 774 return AE_ERROR; 775 *value = result & 0x1; 776 return AE_OK; 777 case 2: 778 err = ec_read(0x71, &result); 779 if (err) 780 return AE_ERROR; 781 *value = result & 0x1; 782 return AE_OK; 783 case 3: 784 err = ec_read(0x78, &result); 785 if (err) 786 return AE_ERROR; 787 *value = result & 0x1; 788 return AE_OK; 789 default: 790 err = ec_read(0xA, &result); 791 if (err) 792 return AE_ERROR; 793 *value = (result >> 2) & 0x1; 794 return AE_OK; 795 } 796 break; 797 case ACER_CAP_BLUETOOTH: 798 switch (quirks->bluetooth) { 799 default: 800 err = ec_read(0xA, &result); 801 if (err) 802 return AE_ERROR; 803 *value = (result >> 4) & 0x1; 804 return AE_OK; 805 } 806 break; 807 case ACER_CAP_BRIGHTNESS: 808 switch (quirks->brightness) { 809 default: 810 err = ec_read(0x83, &result); 811 if (err) 812 return AE_ERROR; 813 *value = result; 814 return AE_OK; 815 } 816 break; 817 default: 818 return AE_ERROR; 819 } 820 return AE_OK; 821} 822 823static acpi_status AMW0_set_u32(u32 value, u32 cap) 824{ 825 struct wmab_args args; 826 827 args.eax = ACER_AMW0_WRITE; 828 args.ebx = value ? (1<<8) : 0; 829 args.ecx = args.edx = 0; 830 831 switch (cap) { 832 case ACER_CAP_MAILLED: 833 if (value > 1) 834 return AE_BAD_PARAMETER; 835 args.ebx |= ACER_AMW0_MAILLED_MASK; 836 break; 837 case ACER_CAP_WIRELESS: 838 if (value > 1) 839 return AE_BAD_PARAMETER; 840 args.ebx |= ACER_AMW0_WIRELESS_MASK; 841 break; 842 case ACER_CAP_BLUETOOTH: 843 if (value > 1) 844 return AE_BAD_PARAMETER; 845 args.ebx |= ACER_AMW0_BLUETOOTH_MASK; 846 break; 847 case ACER_CAP_BRIGHTNESS: 848 if (value > max_brightness) 849 return AE_BAD_PARAMETER; 850 switch (quirks->brightness) { 851 default: 852 return ec_write(0x83, value); 853 break; 854 } 855 default: 856 return AE_ERROR; 857 } 858 859 /* Actually do the set */ 860 return wmab_execute(&args, NULL); 861} 862 863static acpi_status __init AMW0_find_mailled(void) 864{ 865 struct wmab_args args; 866 struct wmab_ret ret; 867 acpi_status status = AE_OK; 868 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL }; 869 union acpi_object *obj; 870 871 args.eax = 0x86; 872 args.ebx = args.ecx = args.edx = 0; 873 874 status = wmab_execute(&args, &out); 875 if (ACPI_FAILURE(status)) 876 return status; 877 878 obj = (union acpi_object *) out.pointer; 879 if (obj && obj->type == ACPI_TYPE_BUFFER && 880 obj->buffer.length == sizeof(struct wmab_ret)) { 881 ret = *((struct wmab_ret *) obj->buffer.pointer); 882 } else { 883 kfree(out.pointer); 884 return AE_ERROR; 885 } 886 887 if (ret.eex & 0x1) 888 interface->capability |= ACER_CAP_MAILLED; 889 890 kfree(out.pointer); 891 892 return AE_OK; 893} 894 895static const struct acpi_device_id norfkill_ids[] __initconst = { 896 { "VPC2004", 0}, 897 { "IBM0068", 0}, 898 { "LEN0068", 0}, 899 { "SNY5001", 0}, /* sony-laptop in charge */ 900 { "HPQ6601", 0}, 901 { "", 0}, 902}; 903 904static int __init AMW0_set_cap_acpi_check_device(void) 905{ 906 const struct acpi_device_id *id; 907 908 for (id = norfkill_ids; id->id[0]; id++) 909 if (acpi_dev_found(id->id)) 910 return true; 911 912 return false; 913} 914 915static acpi_status __init AMW0_set_capabilities(void) 916{ 917 struct wmab_args args; 918 struct wmab_ret ret; 919 acpi_status status; 920 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL }; 921 union acpi_object *obj; 922 923 /* 924 * On laptops with this strange GUID (non Acer), normal probing doesn't 925 * work. 926 */ 927 if (wmi_has_guid(AMW0_GUID2)) { 928 if ((quirks != &quirk_unknown) || 929 !AMW0_set_cap_acpi_check_device()) 930 interface->capability |= ACER_CAP_WIRELESS; 931 return AE_OK; 932 } 933 934 args.eax = ACER_AMW0_WRITE; 935 args.ecx = args.edx = 0; 936 937 args.ebx = 0xa2 << 8; 938 args.ebx |= ACER_AMW0_WIRELESS_MASK; 939 940 status = wmab_execute(&args, &out); 941 if (ACPI_FAILURE(status)) 942 return status; 943 944 obj = out.pointer; 945 if (obj && obj->type == ACPI_TYPE_BUFFER && 946 obj->buffer.length == sizeof(struct wmab_ret)) { 947 ret = *((struct wmab_ret *) obj->buffer.pointer); 948 } else { 949 status = AE_ERROR; 950 goto out; 951 } 952 953 if (ret.eax & 0x1) 954 interface->capability |= ACER_CAP_WIRELESS; 955 956 args.ebx = 2 << 8; 957 args.ebx |= ACER_AMW0_BLUETOOTH_MASK; 958 959 /* 960 * It's ok to use existing buffer for next wmab_execute call. 961 * But we need to kfree(out.pointer) if next wmab_execute fail. 962 */ 963 status = wmab_execute(&args, &out); 964 if (ACPI_FAILURE(status)) 965 goto out; 966 967 obj = (union acpi_object *) out.pointer; 968 if (obj && obj->type == ACPI_TYPE_BUFFER 969 && obj->buffer.length == sizeof(struct wmab_ret)) { 970 ret = *((struct wmab_ret *) obj->buffer.pointer); 971 } else { 972 status = AE_ERROR; 973 goto out; 974 } 975 976 if (ret.eax & 0x1) 977 interface->capability |= ACER_CAP_BLUETOOTH; 978 979 /* 980 * This appears to be safe to enable, since all Wistron based laptops 981 * appear to use the same EC register for brightness, even if they 982 * differ for wireless, etc 983 */ 984 if (quirks->brightness >= 0) 985 interface->capability |= ACER_CAP_BRIGHTNESS; 986 987 status = AE_OK; 988out: 989 kfree(out.pointer); 990 return status; 991} 992 993static struct wmi_interface AMW0_interface = { 994 .type = ACER_AMW0, 995}; 996 997static struct wmi_interface AMW0_V2_interface = { 998 .type = ACER_AMW0_V2, 999}; 1000 1001/* 1002 * New interface (The WMID interface) 1003 */ 1004static acpi_status 1005WMI_execute_u32(u32 method_id, u32 in, u32 *out) 1006{ 1007 struct acpi_buffer input = { (acpi_size) sizeof(u32), (void *)(&in) }; 1008 struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL }; 1009 union acpi_object *obj; 1010 u32 tmp = 0; 1011 acpi_status status; 1012 1013 status = wmi_evaluate_method(WMID_GUID1, 0, method_id, &input, &result); 1014 1015 if (ACPI_FAILURE(status)) 1016 return status; 1017 1018 obj = (union acpi_object *) result.pointer; 1019 if (obj) { 1020 if (obj->type == ACPI_TYPE_BUFFER && 1021 (obj->buffer.length == sizeof(u32) || 1022 obj->buffer.length == sizeof(u64))) { 1023 tmp = *((u32 *) obj->buffer.pointer); 1024 } else if (obj->type == ACPI_TYPE_INTEGER) { 1025 tmp = (u32) obj->integer.value; 1026 } 1027 } 1028 1029 if (out) 1030 *out = tmp; 1031 1032 kfree(result.pointer); 1033 1034 return status; 1035} 1036 1037static acpi_status WMID_get_u32(u32 *value, u32 cap) 1038{ 1039 acpi_status status; 1040 u8 tmp; 1041 u32 result, method_id = 0; 1042 1043 switch (cap) { 1044 case ACER_CAP_WIRELESS: 1045 method_id = ACER_WMID_GET_WIRELESS_METHODID; 1046 break; 1047 case ACER_CAP_BLUETOOTH: 1048 method_id = ACER_WMID_GET_BLUETOOTH_METHODID; 1049 break; 1050 case ACER_CAP_BRIGHTNESS: 1051 method_id = ACER_WMID_GET_BRIGHTNESS_METHODID; 1052 break; 1053 case ACER_CAP_THREEG: 1054 method_id = ACER_WMID_GET_THREEG_METHODID; 1055 break; 1056 case ACER_CAP_MAILLED: 1057 if (quirks->mailled == 1) { 1058 ec_read(0x9f, &tmp); 1059 *value = tmp & 0x1; 1060 return 0; 1061 } 1062 fallthrough; 1063 default: 1064 return AE_ERROR; 1065 } 1066 status = WMI_execute_u32(method_id, 0, &result); 1067 1068 if (ACPI_SUCCESS(status)) 1069 *value = (u8)result; 1070 1071 return status; 1072} 1073 1074static acpi_status WMID_set_u32(u32 value, u32 cap) 1075{ 1076 u32 method_id = 0; 1077 char param; 1078 1079 switch (cap) { 1080 case ACER_CAP_BRIGHTNESS: 1081 if (value > max_brightness) 1082 return AE_BAD_PARAMETER; 1083 method_id = ACER_WMID_SET_BRIGHTNESS_METHODID; 1084 break; 1085 case ACER_CAP_WIRELESS: 1086 if (value > 1) 1087 return AE_BAD_PARAMETER; 1088 method_id = ACER_WMID_SET_WIRELESS_METHODID; 1089 break; 1090 case ACER_CAP_BLUETOOTH: 1091 if (value > 1) 1092 return AE_BAD_PARAMETER; 1093 method_id = ACER_WMID_SET_BLUETOOTH_METHODID; 1094 break; 1095 case ACER_CAP_THREEG: 1096 if (value > 1) 1097 return AE_BAD_PARAMETER; 1098 method_id = ACER_WMID_SET_THREEG_METHODID; 1099 break; 1100 case ACER_CAP_MAILLED: 1101 if (value > 1) 1102 return AE_BAD_PARAMETER; 1103 if (quirks->mailled == 1) { 1104 param = value ? 0x92 : 0x93; 1105 i8042_lock_chip(); 1106 i8042_command(¶m, 0x1059); 1107 i8042_unlock_chip(); 1108 return 0; 1109 } 1110 break; 1111 default: 1112 return AE_ERROR; 1113 } 1114 return WMI_execute_u32(method_id, (u32)value, NULL); 1115} 1116 1117static acpi_status wmid3_get_device_status(u32 *value, u16 device) 1118{ 1119 struct wmid3_gds_return_value return_value; 1120 acpi_status status; 1121 union acpi_object *obj; 1122 struct wmid3_gds_get_input_param params = { 1123 .function_num = 0x1, 1124 .hotkey_number = commun_fn_key_number, 1125 .devices = device, 1126 }; 1127 struct acpi_buffer input = { 1128 sizeof(struct wmid3_gds_get_input_param), 1129 ¶ms 1130 }; 1131 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 1132 1133 status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output); 1134 if (ACPI_FAILURE(status)) 1135 return status; 1136 1137 obj = output.pointer; 1138 1139 if (!obj) 1140 return AE_ERROR; 1141 else if (obj->type != ACPI_TYPE_BUFFER) { 1142 kfree(obj); 1143 return AE_ERROR; 1144 } 1145 if (obj->buffer.length != 8) { 1146 pr_warn("Unknown buffer length %d\n", obj->buffer.length); 1147 kfree(obj); 1148 return AE_ERROR; 1149 } 1150 1151 return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer); 1152 kfree(obj); 1153 1154 if (return_value.error_code || return_value.ec_return_value) 1155 pr_warn("Get 0x%x Device Status failed: 0x%x - 0x%x\n", 1156 device, 1157 return_value.error_code, 1158 return_value.ec_return_value); 1159 else 1160 *value = !!(return_value.devices & device); 1161 1162 return status; 1163} 1164 1165static acpi_status wmid_v2_get_u32(u32 *value, u32 cap) 1166{ 1167 u16 device; 1168 1169 switch (cap) { 1170 case ACER_CAP_WIRELESS: 1171 device = ACER_WMID3_GDS_WIRELESS; 1172 break; 1173 case ACER_CAP_BLUETOOTH: 1174 device = ACER_WMID3_GDS_BLUETOOTH; 1175 break; 1176 case ACER_CAP_THREEG: 1177 device = ACER_WMID3_GDS_THREEG; 1178 break; 1179 default: 1180 return AE_ERROR; 1181 } 1182 return wmid3_get_device_status(value, device); 1183} 1184 1185static acpi_status wmid3_set_device_status(u32 value, u16 device) 1186{ 1187 struct wmid3_gds_return_value return_value; 1188 acpi_status status; 1189 union acpi_object *obj; 1190 u16 devices; 1191 struct wmid3_gds_get_input_param get_params = { 1192 .function_num = 0x1, 1193 .hotkey_number = commun_fn_key_number, 1194 .devices = commun_func_bitmap, 1195 }; 1196 struct acpi_buffer get_input = { 1197 sizeof(struct wmid3_gds_get_input_param), 1198 &get_params 1199 }; 1200 struct wmid3_gds_set_input_param set_params = { 1201 .function_num = 0x2, 1202 .hotkey_number = commun_fn_key_number, 1203 .devices = commun_func_bitmap, 1204 }; 1205 struct acpi_buffer set_input = { 1206 sizeof(struct wmid3_gds_set_input_param), 1207 &set_params 1208 }; 1209 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 1210 struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL }; 1211 1212 status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &get_input, &output); 1213 if (ACPI_FAILURE(status)) 1214 return status; 1215 1216 obj = output.pointer; 1217 1218 if (!obj) 1219 return AE_ERROR; 1220 else if (obj->type != ACPI_TYPE_BUFFER) { 1221 kfree(obj); 1222 return AE_ERROR; 1223 } 1224 if (obj->buffer.length != 8) { 1225 pr_warn("Unknown buffer length %d\n", obj->buffer.length); 1226 kfree(obj); 1227 return AE_ERROR; 1228 } 1229 1230 return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer); 1231 kfree(obj); 1232 1233 if (return_value.error_code || return_value.ec_return_value) { 1234 pr_warn("Get Current Device Status failed: 0x%x - 0x%x\n", 1235 return_value.error_code, 1236 return_value.ec_return_value); 1237 return status; 1238 } 1239 1240 devices = return_value.devices; 1241 set_params.devices = (value) ? (devices | device) : (devices & ~device); 1242 1243 status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &set_input, &output2); 1244 if (ACPI_FAILURE(status)) 1245 return status; 1246 1247 obj = output2.pointer; 1248 1249 if (!obj) 1250 return AE_ERROR; 1251 else if (obj->type != ACPI_TYPE_BUFFER) { 1252 kfree(obj); 1253 return AE_ERROR; 1254 } 1255 if (obj->buffer.length != 4) { 1256 pr_warn("Unknown buffer length %d\n", obj->buffer.length); 1257 kfree(obj); 1258 return AE_ERROR; 1259 } 1260 1261 return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer); 1262 kfree(obj); 1263 1264 if (return_value.error_code || return_value.ec_return_value) 1265 pr_warn("Set Device Status failed: 0x%x - 0x%x\n", 1266 return_value.error_code, 1267 return_value.ec_return_value); 1268 1269 return status; 1270} 1271 1272static acpi_status wmid_v2_set_u32(u32 value, u32 cap) 1273{ 1274 u16 device; 1275 1276 switch (cap) { 1277 case ACER_CAP_WIRELESS: 1278 device = ACER_WMID3_GDS_WIRELESS; 1279 break; 1280 case ACER_CAP_BLUETOOTH: 1281 device = ACER_WMID3_GDS_BLUETOOTH; 1282 break; 1283 case ACER_CAP_THREEG: 1284 device = ACER_WMID3_GDS_THREEG; 1285 break; 1286 default: 1287 return AE_ERROR; 1288 } 1289 return wmid3_set_device_status(value, device); 1290} 1291 1292static void __init type_aa_dmi_decode(const struct dmi_header *header, void *d) 1293{ 1294 struct hotkey_function_type_aa *type_aa; 1295 1296 /* We are looking for OEM-specific Type AAh */ 1297 if (header->type != 0xAA) 1298 return; 1299 1300 has_type_aa = true; 1301 type_aa = (struct hotkey_function_type_aa *) header; 1302 1303 pr_info("Function bitmap for Communication Button: 0x%x\n", 1304 type_aa->commun_func_bitmap); 1305 commun_func_bitmap = type_aa->commun_func_bitmap; 1306 1307 if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS) 1308 interface->capability |= ACER_CAP_WIRELESS; 1309 if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_THREEG) 1310 interface->capability |= ACER_CAP_THREEG; 1311 if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_BLUETOOTH) 1312 interface->capability |= ACER_CAP_BLUETOOTH; 1313 if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_RFBTN) 1314 commun_func_bitmap &= ~ACER_WMID3_GDS_RFBTN; 1315 1316 commun_fn_key_number = type_aa->commun_fn_key_number; 1317} 1318 1319static acpi_status __init WMID_set_capabilities(void) 1320{ 1321 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL}; 1322 union acpi_object *obj; 1323 acpi_status status; 1324 u32 devices; 1325 1326 status = wmi_query_block(WMID_GUID2, 0, &out); 1327 if (ACPI_FAILURE(status)) 1328 return status; 1329 1330 obj = (union acpi_object *) out.pointer; 1331 if (obj) { 1332 if (obj->type == ACPI_TYPE_BUFFER && 1333 (obj->buffer.length == sizeof(u32) || 1334 obj->buffer.length == sizeof(u64))) { 1335 devices = *((u32 *) obj->buffer.pointer); 1336 } else if (obj->type == ACPI_TYPE_INTEGER) { 1337 devices = (u32) obj->integer.value; 1338 } else { 1339 kfree(out.pointer); 1340 return AE_ERROR; 1341 } 1342 } else { 1343 kfree(out.pointer); 1344 return AE_ERROR; 1345 } 1346 1347 pr_info("Function bitmap for Communication Device: 0x%x\n", devices); 1348 if (devices & 0x07) 1349 interface->capability |= ACER_CAP_WIRELESS; 1350 if (devices & 0x40) 1351 interface->capability |= ACER_CAP_THREEG; 1352 if (devices & 0x10) 1353 interface->capability |= ACER_CAP_BLUETOOTH; 1354 1355 if (!(devices & 0x20)) 1356 max_brightness = 0x9; 1357 1358 kfree(out.pointer); 1359 return status; 1360} 1361 1362static struct wmi_interface wmid_interface = { 1363 .type = ACER_WMID, 1364}; 1365 1366static struct wmi_interface wmid_v2_interface = { 1367 .type = ACER_WMID_v2, 1368}; 1369 1370/* 1371 * Generic Device (interface-independent) 1372 */ 1373 1374static acpi_status get_u32(u32 *value, u32 cap) 1375{ 1376 acpi_status status = AE_ERROR; 1377 1378 switch (interface->type) { 1379 case ACER_AMW0: 1380 status = AMW0_get_u32(value, cap); 1381 break; 1382 case ACER_AMW0_V2: 1383 if (cap == ACER_CAP_MAILLED) { 1384 status = AMW0_get_u32(value, cap); 1385 break; 1386 } 1387 fallthrough; 1388 case ACER_WMID: 1389 status = WMID_get_u32(value, cap); 1390 break; 1391 case ACER_WMID_v2: 1392 if (cap & (ACER_CAP_WIRELESS | 1393 ACER_CAP_BLUETOOTH | 1394 ACER_CAP_THREEG)) 1395 status = wmid_v2_get_u32(value, cap); 1396 else if (wmi_has_guid(WMID_GUID2)) 1397 status = WMID_get_u32(value, cap); 1398 break; 1399 } 1400 1401 return status; 1402} 1403 1404static acpi_status set_u32(u32 value, u32 cap) 1405{ 1406 acpi_status status; 1407 1408 if (interface->capability & cap) { 1409 switch (interface->type) { 1410 case ACER_AMW0: 1411 return AMW0_set_u32(value, cap); 1412 case ACER_AMW0_V2: 1413 if (cap == ACER_CAP_MAILLED) 1414 return AMW0_set_u32(value, cap); 1415 1416 /* 1417 * On some models, some WMID methods don't toggle 1418 * properly. For those cases, we want to run the AMW0 1419 * method afterwards to be certain we've really toggled 1420 * the device state. 1421 */ 1422 if (cap == ACER_CAP_WIRELESS || 1423 cap == ACER_CAP_BLUETOOTH) { 1424 status = WMID_set_u32(value, cap); 1425 if (ACPI_FAILURE(status)) 1426 return status; 1427 1428 return AMW0_set_u32(value, cap); 1429 } 1430 fallthrough; 1431 case ACER_WMID: 1432 return WMID_set_u32(value, cap); 1433 case ACER_WMID_v2: 1434 if (cap & (ACER_CAP_WIRELESS | 1435 ACER_CAP_BLUETOOTH | 1436 ACER_CAP_THREEG)) 1437 return wmid_v2_set_u32(value, cap); 1438 else if (wmi_has_guid(WMID_GUID2)) 1439 return WMID_set_u32(value, cap); 1440 fallthrough; 1441 default: 1442 return AE_BAD_PARAMETER; 1443 } 1444 } 1445 return AE_BAD_PARAMETER; 1446} 1447 1448static void __init acer_commandline_init(void) 1449{ 1450 /* 1451 * These will all fail silently if the value given is invalid, or the 1452 * capability isn't available on the given interface 1453 */ 1454 if (mailled >= 0) 1455 set_u32(mailled, ACER_CAP_MAILLED); 1456 if (!has_type_aa && threeg >= 0) 1457 set_u32(threeg, ACER_CAP_THREEG); 1458 if (brightness >= 0) 1459 set_u32(brightness, ACER_CAP_BRIGHTNESS); 1460} 1461 1462/* 1463 * LED device (Mail LED only, no other LEDs known yet) 1464 */ 1465static void mail_led_set(struct led_classdev *led_cdev, 1466enum led_brightness value) 1467{ 1468 set_u32(value, ACER_CAP_MAILLED); 1469} 1470 1471static struct led_classdev mail_led = { 1472 .name = "acer-wmi::mail", 1473 .brightness_set = mail_led_set, 1474}; 1475 1476static int acer_led_init(struct device *dev) 1477{ 1478 return led_classdev_register(dev, &mail_led); 1479} 1480 1481static void acer_led_exit(void) 1482{ 1483 set_u32(LED_OFF, ACER_CAP_MAILLED); 1484 led_classdev_unregister(&mail_led); 1485} 1486 1487/* 1488 * Backlight device 1489 */ 1490static struct backlight_device *acer_backlight_device; 1491 1492static int read_brightness(struct backlight_device *bd) 1493{ 1494 u32 value; 1495 get_u32(&value, ACER_CAP_BRIGHTNESS); 1496 return value; 1497} 1498 1499static int update_bl_status(struct backlight_device *bd) 1500{ 1501 int intensity = bd->props.brightness; 1502 1503 if (bd->props.power != FB_BLANK_UNBLANK) 1504 intensity = 0; 1505 if (bd->props.fb_blank != FB_BLANK_UNBLANK) 1506 intensity = 0; 1507 1508 set_u32(intensity, ACER_CAP_BRIGHTNESS); 1509 1510 return 0; 1511} 1512 1513static const struct backlight_ops acer_bl_ops = { 1514 .get_brightness = read_brightness, 1515 .update_status = update_bl_status, 1516}; 1517 1518static int acer_backlight_init(struct device *dev) 1519{ 1520 struct backlight_properties props; 1521 struct backlight_device *bd; 1522 1523 memset(&props, 0, sizeof(struct backlight_properties)); 1524 props.type = BACKLIGHT_PLATFORM; 1525 props.max_brightness = max_brightness; 1526 bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops, 1527 &props); 1528 if (IS_ERR(bd)) { 1529 pr_err("Could not register Acer backlight device\n"); 1530 acer_backlight_device = NULL; 1531 return PTR_ERR(bd); 1532 } 1533 1534 acer_backlight_device = bd; 1535 1536 bd->props.power = FB_BLANK_UNBLANK; 1537 bd->props.brightness = read_brightness(bd); 1538 backlight_update_status(bd); 1539 return 0; 1540} 1541 1542static void acer_backlight_exit(void) 1543{ 1544 backlight_device_unregister(acer_backlight_device); 1545} 1546 1547/* 1548 * Accelerometer device 1549 */ 1550static acpi_handle gsensor_handle; 1551 1552static int acer_gsensor_init(void) 1553{ 1554 acpi_status status; 1555 struct acpi_buffer output; 1556 union acpi_object out_obj; 1557 1558 output.length = sizeof(out_obj); 1559 output.pointer = &out_obj; 1560 status = acpi_evaluate_object(gsensor_handle, "_INI", NULL, &output); 1561 if (ACPI_FAILURE(status)) 1562 return -1; 1563 1564 return 0; 1565} 1566 1567static int acer_gsensor_open(struct input_dev *input) 1568{ 1569 return acer_gsensor_init(); 1570} 1571 1572static int acer_gsensor_event(void) 1573{ 1574 acpi_status status; 1575 struct acpi_buffer output; 1576 union acpi_object out_obj[5]; 1577 1578 if (!acer_wmi_accel_dev) 1579 return -1; 1580 1581 output.length = sizeof(out_obj); 1582 output.pointer = out_obj; 1583 1584 status = acpi_evaluate_object(gsensor_handle, "RDVL", NULL, &output); 1585 if (ACPI_FAILURE(status)) 1586 return -1; 1587 1588 if (out_obj->package.count != 4) 1589 return -1; 1590 1591 input_report_abs(acer_wmi_accel_dev, ABS_X, 1592 (s16)out_obj->package.elements[0].integer.value); 1593 input_report_abs(acer_wmi_accel_dev, ABS_Y, 1594 (s16)out_obj->package.elements[1].integer.value); 1595 input_report_abs(acer_wmi_accel_dev, ABS_Z, 1596 (s16)out_obj->package.elements[2].integer.value); 1597 input_sync(acer_wmi_accel_dev); 1598 return 0; 1599} 1600 1601/* 1602 * Switch series keyboard dock status 1603 */ 1604static int acer_kbd_dock_state_to_sw_tablet_mode(u8 kbd_dock_state) 1605{ 1606 switch (kbd_dock_state) { 1607 case 0x01: /* Docked, traditional clamshell laptop mode */ 1608 return 0; 1609 case 0x04: /* Stand-alone tablet */ 1610 case 0x40: /* Docked, tent mode, keyboard not usable */ 1611 return 1; 1612 default: 1613 pr_warn("Unknown kbd_dock_state 0x%02x\n", kbd_dock_state); 1614 } 1615 1616 return 0; 1617} 1618 1619static void acer_kbd_dock_get_initial_state(void) 1620{ 1621 u8 *output, input[8] = { 0x05, 0x00, }; 1622 struct acpi_buffer input_buf = { sizeof(input), input }; 1623 struct acpi_buffer output_buf = { ACPI_ALLOCATE_BUFFER, NULL }; 1624 union acpi_object *obj; 1625 acpi_status status; 1626 int sw_tablet_mode; 1627 1628 status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input_buf, &output_buf); 1629 if (ACPI_FAILURE(status)) { 1630 ACPI_EXCEPTION((AE_INFO, status, "Error getting keyboard-dock initial status")); 1631 return; 1632 } 1633 1634 obj = output_buf.pointer; 1635 if (!obj || obj->type != ACPI_TYPE_BUFFER || obj->buffer.length != 8) { 1636 pr_err("Unexpected output format getting keyboard-dock initial status\n"); 1637 goto out_free_obj; 1638 } 1639 1640 output = obj->buffer.pointer; 1641 if (output[0] != 0x00 || (output[3] != 0x05 && output[3] != 0x45)) { 1642 pr_err("Unexpected output [0]=0x%02x [3]=0x%02x getting keyboard-dock initial status\n", 1643 output[0], output[3]); 1644 goto out_free_obj; 1645 } 1646 1647 sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(output[4]); 1648 input_report_switch(acer_wmi_input_dev, SW_TABLET_MODE, sw_tablet_mode); 1649 1650out_free_obj: 1651 kfree(obj); 1652} 1653 1654static void acer_kbd_dock_event(const struct event_return_value *event) 1655{ 1656 int sw_tablet_mode; 1657 1658 if (!has_cap(ACER_CAP_KBD_DOCK)) 1659 return; 1660 1661 sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(event->kbd_dock_state); 1662 input_report_switch(acer_wmi_input_dev, SW_TABLET_MODE, sw_tablet_mode); 1663 input_sync(acer_wmi_input_dev); 1664} 1665 1666/* 1667 * Rfkill devices 1668 */ 1669static void acer_rfkill_update(struct work_struct *ignored); 1670static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update); 1671static void acer_rfkill_update(struct work_struct *ignored) 1672{ 1673 u32 state; 1674 acpi_status status; 1675 1676 if (has_cap(ACER_CAP_WIRELESS)) { 1677 status = get_u32(&state, ACER_CAP_WIRELESS); 1678 if (ACPI_SUCCESS(status)) { 1679 if (quirks->wireless == 3) 1680 rfkill_set_hw_state(wireless_rfkill, !state); 1681 else 1682 rfkill_set_sw_state(wireless_rfkill, !state); 1683 } 1684 } 1685 1686 if (has_cap(ACER_CAP_BLUETOOTH)) { 1687 status = get_u32(&state, ACER_CAP_BLUETOOTH); 1688 if (ACPI_SUCCESS(status)) 1689 rfkill_set_sw_state(bluetooth_rfkill, !state); 1690 } 1691 1692 if (has_cap(ACER_CAP_THREEG) && wmi_has_guid(WMID_GUID3)) { 1693 status = get_u32(&state, ACER_WMID3_GDS_THREEG); 1694 if (ACPI_SUCCESS(status)) 1695 rfkill_set_sw_state(threeg_rfkill, !state); 1696 } 1697 1698 schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ)); 1699} 1700 1701static int acer_rfkill_set(void *data, bool blocked) 1702{ 1703 acpi_status status; 1704 u32 cap = (unsigned long)data; 1705 1706 if (rfkill_inited) { 1707 status = set_u32(!blocked, cap); 1708 if (ACPI_FAILURE(status)) 1709 return -ENODEV; 1710 } 1711 1712 return 0; 1713} 1714 1715static const struct rfkill_ops acer_rfkill_ops = { 1716 .set_block = acer_rfkill_set, 1717}; 1718 1719static struct rfkill *acer_rfkill_register(struct device *dev, 1720 enum rfkill_type type, 1721 char *name, u32 cap) 1722{ 1723 int err; 1724 struct rfkill *rfkill_dev; 1725 u32 state; 1726 acpi_status status; 1727 1728 rfkill_dev = rfkill_alloc(name, dev, type, 1729 &acer_rfkill_ops, 1730 (void *)(unsigned long)cap); 1731 if (!rfkill_dev) 1732 return ERR_PTR(-ENOMEM); 1733 1734 status = get_u32(&state, cap); 1735 1736 err = rfkill_register(rfkill_dev); 1737 if (err) { 1738 rfkill_destroy(rfkill_dev); 1739 return ERR_PTR(err); 1740 } 1741 1742 if (ACPI_SUCCESS(status)) 1743 rfkill_set_sw_state(rfkill_dev, !state); 1744 1745 return rfkill_dev; 1746} 1747 1748static int acer_rfkill_init(struct device *dev) 1749{ 1750 int err; 1751 1752 if (has_cap(ACER_CAP_WIRELESS)) { 1753 wireless_rfkill = acer_rfkill_register(dev, RFKILL_TYPE_WLAN, 1754 "acer-wireless", ACER_CAP_WIRELESS); 1755 if (IS_ERR(wireless_rfkill)) { 1756 err = PTR_ERR(wireless_rfkill); 1757 goto error_wireless; 1758 } 1759 } 1760 1761 if (has_cap(ACER_CAP_BLUETOOTH)) { 1762 bluetooth_rfkill = acer_rfkill_register(dev, 1763 RFKILL_TYPE_BLUETOOTH, "acer-bluetooth", 1764 ACER_CAP_BLUETOOTH); 1765 if (IS_ERR(bluetooth_rfkill)) { 1766 err = PTR_ERR(bluetooth_rfkill); 1767 goto error_bluetooth; 1768 } 1769 } 1770 1771 if (has_cap(ACER_CAP_THREEG)) { 1772 threeg_rfkill = acer_rfkill_register(dev, 1773 RFKILL_TYPE_WWAN, "acer-threeg", 1774 ACER_CAP_THREEG); 1775 if (IS_ERR(threeg_rfkill)) { 1776 err = PTR_ERR(threeg_rfkill); 1777 goto error_threeg; 1778 } 1779 } 1780 1781 rfkill_inited = true; 1782 1783 if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) && 1784 has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG)) 1785 schedule_delayed_work(&acer_rfkill_work, 1786 round_jiffies_relative(HZ)); 1787 1788 return 0; 1789 1790error_threeg: 1791 if (has_cap(ACER_CAP_BLUETOOTH)) { 1792 rfkill_unregister(bluetooth_rfkill); 1793 rfkill_destroy(bluetooth_rfkill); 1794 } 1795error_bluetooth: 1796 if (has_cap(ACER_CAP_WIRELESS)) { 1797 rfkill_unregister(wireless_rfkill); 1798 rfkill_destroy(wireless_rfkill); 1799 } 1800error_wireless: 1801 return err; 1802} 1803 1804static void acer_rfkill_exit(void) 1805{ 1806 if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) && 1807 has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG)) 1808 cancel_delayed_work_sync(&acer_rfkill_work); 1809 1810 if (has_cap(ACER_CAP_WIRELESS)) { 1811 rfkill_unregister(wireless_rfkill); 1812 rfkill_destroy(wireless_rfkill); 1813 } 1814 1815 if (has_cap(ACER_CAP_BLUETOOTH)) { 1816 rfkill_unregister(bluetooth_rfkill); 1817 rfkill_destroy(bluetooth_rfkill); 1818 } 1819 1820 if (has_cap(ACER_CAP_THREEG)) { 1821 rfkill_unregister(threeg_rfkill); 1822 rfkill_destroy(threeg_rfkill); 1823 } 1824 return; 1825} 1826 1827static void acer_wmi_notify(u32 value, void *context) 1828{ 1829 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; 1830 union acpi_object *obj; 1831 struct event_return_value return_value; 1832 acpi_status status; 1833 u16 device_state; 1834 const struct key_entry *key; 1835 u32 scancode; 1836 1837 status = wmi_get_event_data(value, &response); 1838 if (status != AE_OK) { 1839 pr_warn("bad event status 0x%x\n", status); 1840 return; 1841 } 1842 1843 obj = (union acpi_object *)response.pointer; 1844 1845 if (!obj) 1846 return; 1847 if (obj->type != ACPI_TYPE_BUFFER) { 1848 pr_warn("Unknown response received %d\n", obj->type); 1849 kfree(obj); 1850 return; 1851 } 1852 if (obj->buffer.length != 8) { 1853 pr_warn("Unknown buffer length %d\n", obj->buffer.length); 1854 kfree(obj); 1855 return; 1856 } 1857 1858 return_value = *((struct event_return_value *)obj->buffer.pointer); 1859 kfree(obj); 1860 1861 switch (return_value.function) { 1862 case WMID_HOTKEY_EVENT: 1863 device_state = return_value.device_state; 1864 pr_debug("device state: 0x%x\n", device_state); 1865 1866 key = sparse_keymap_entry_from_scancode(acer_wmi_input_dev, 1867 return_value.key_num); 1868 if (!key) { 1869 pr_warn("Unknown key number - 0x%x\n", 1870 return_value.key_num); 1871 } else { 1872 scancode = return_value.key_num; 1873 switch (key->keycode) { 1874 case KEY_WLAN: 1875 case KEY_BLUETOOTH: 1876 if (has_cap(ACER_CAP_WIRELESS)) 1877 rfkill_set_sw_state(wireless_rfkill, 1878 !(device_state & ACER_WMID3_GDS_WIRELESS)); 1879 if (has_cap(ACER_CAP_THREEG)) 1880 rfkill_set_sw_state(threeg_rfkill, 1881 !(device_state & ACER_WMID3_GDS_THREEG)); 1882 if (has_cap(ACER_CAP_BLUETOOTH)) 1883 rfkill_set_sw_state(bluetooth_rfkill, 1884 !(device_state & ACER_WMID3_GDS_BLUETOOTH)); 1885 break; 1886 case KEY_TOUCHPAD_TOGGLE: 1887 scancode = (device_state & ACER_WMID3_GDS_TOUCHPAD) ? 1888 KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF; 1889 } 1890 sparse_keymap_report_event(acer_wmi_input_dev, scancode, 1, true); 1891 } 1892 break; 1893 case WMID_ACCEL_OR_KBD_DOCK_EVENT: 1894 acer_gsensor_event(); 1895 acer_kbd_dock_event(&return_value); 1896 break; 1897 default: 1898 pr_warn("Unknown function number - %d - %d\n", 1899 return_value.function, return_value.key_num); 1900 break; 1901 } 1902} 1903 1904static acpi_status __init 1905wmid3_set_function_mode(struct func_input_params *params, 1906 struct func_return_value *return_value) 1907{ 1908 acpi_status status; 1909 union acpi_object *obj; 1910 1911 struct acpi_buffer input = { sizeof(struct func_input_params), params }; 1912 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 1913 1914 status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output); 1915 if (ACPI_FAILURE(status)) 1916 return status; 1917 1918 obj = output.pointer; 1919 1920 if (!obj) 1921 return AE_ERROR; 1922 else if (obj->type != ACPI_TYPE_BUFFER) { 1923 kfree(obj); 1924 return AE_ERROR; 1925 } 1926 if (obj->buffer.length != 4) { 1927 pr_warn("Unknown buffer length %d\n", obj->buffer.length); 1928 kfree(obj); 1929 return AE_ERROR; 1930 } 1931 1932 *return_value = *((struct func_return_value *)obj->buffer.pointer); 1933 kfree(obj); 1934 1935 return status; 1936} 1937 1938static int __init acer_wmi_enable_ec_raw(void) 1939{ 1940 struct func_return_value return_value; 1941 acpi_status status; 1942 struct func_input_params params = { 1943 .function_num = 0x1, 1944 .commun_devices = 0xFFFF, 1945 .devices = 0xFFFF, 1946 .app_status = 0x00, /* Launch Manager Deactive */ 1947 .app_mask = 0x01, 1948 }; 1949 1950 status = wmid3_set_function_mode(¶ms, &return_value); 1951 1952 if (return_value.error_code || return_value.ec_return_value) 1953 pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n", 1954 return_value.error_code, 1955 return_value.ec_return_value); 1956 else 1957 pr_info("Enabled EC raw mode\n"); 1958 1959 return status; 1960} 1961 1962static int __init acer_wmi_enable_lm(void) 1963{ 1964 struct func_return_value return_value; 1965 acpi_status status; 1966 struct func_input_params params = { 1967 .function_num = 0x1, 1968 .commun_devices = 0xFFFF, 1969 .devices = 0xFFFF, 1970 .app_status = 0x01, /* Launch Manager Active */ 1971 .app_mask = 0x01, 1972 }; 1973 1974 status = wmid3_set_function_mode(¶ms, &return_value); 1975 1976 if (return_value.error_code || return_value.ec_return_value) 1977 pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n", 1978 return_value.error_code, 1979 return_value.ec_return_value); 1980 1981 return status; 1982} 1983 1984static int __init acer_wmi_enable_rf_button(void) 1985{ 1986 struct func_return_value return_value; 1987 acpi_status status; 1988 struct func_input_params params = { 1989 .function_num = 0x1, 1990 .commun_devices = 0xFFFF, 1991 .devices = 0xFFFF, 1992 .app_status = 0x10, /* RF Button Active */ 1993 .app_mask = 0x10, 1994 }; 1995 1996 status = wmid3_set_function_mode(¶ms, &return_value); 1997 1998 if (return_value.error_code || return_value.ec_return_value) 1999 pr_warn("Enabling RF Button failed: 0x%x - 0x%x\n", 2000 return_value.error_code, 2001 return_value.ec_return_value); 2002 2003 return status; 2004} 2005 2006static int __init acer_wmi_accel_setup(void) 2007{ 2008 struct acpi_device *adev; 2009 int err; 2010 2011 adev = acpi_dev_get_first_match_dev("BST0001", NULL, -1); 2012 if (!adev) 2013 return -ENODEV; 2014 2015 gsensor_handle = acpi_device_handle(adev); 2016 acpi_dev_put(adev); 2017 2018 acer_wmi_accel_dev = input_allocate_device(); 2019 if (!acer_wmi_accel_dev) 2020 return -ENOMEM; 2021 2022 acer_wmi_accel_dev->open = acer_gsensor_open; 2023 2024 acer_wmi_accel_dev->name = "Acer BMA150 accelerometer"; 2025 acer_wmi_accel_dev->phys = "wmi/input1"; 2026 acer_wmi_accel_dev->id.bustype = BUS_HOST; 2027 acer_wmi_accel_dev->evbit[0] = BIT_MASK(EV_ABS); 2028 input_set_abs_params(acer_wmi_accel_dev, ABS_X, -16384, 16384, 0, 0); 2029 input_set_abs_params(acer_wmi_accel_dev, ABS_Y, -16384, 16384, 0, 0); 2030 input_set_abs_params(acer_wmi_accel_dev, ABS_Z, -16384, 16384, 0, 0); 2031 2032 err = input_register_device(acer_wmi_accel_dev); 2033 if (err) 2034 goto err_free_dev; 2035 2036 return 0; 2037 2038err_free_dev: 2039 input_free_device(acer_wmi_accel_dev); 2040 return err; 2041} 2042 2043static int __init acer_wmi_input_setup(void) 2044{ 2045 acpi_status status; 2046 int err; 2047 2048 acer_wmi_input_dev = input_allocate_device(); 2049 if (!acer_wmi_input_dev) 2050 return -ENOMEM; 2051 2052 acer_wmi_input_dev->name = "Acer WMI hotkeys"; 2053 acer_wmi_input_dev->phys = "wmi/input0"; 2054 acer_wmi_input_dev->id.bustype = BUS_HOST; 2055 2056 err = sparse_keymap_setup(acer_wmi_input_dev, acer_wmi_keymap, NULL); 2057 if (err) 2058 goto err_free_dev; 2059 2060 if (has_cap(ACER_CAP_KBD_DOCK)) 2061 input_set_capability(acer_wmi_input_dev, EV_SW, SW_TABLET_MODE); 2062 2063 status = wmi_install_notify_handler(ACERWMID_EVENT_GUID, 2064 acer_wmi_notify, NULL); 2065 if (ACPI_FAILURE(status)) { 2066 err = -EIO; 2067 goto err_free_dev; 2068 } 2069 2070 if (has_cap(ACER_CAP_KBD_DOCK)) 2071 acer_kbd_dock_get_initial_state(); 2072 2073 err = input_register_device(acer_wmi_input_dev); 2074 if (err) 2075 goto err_uninstall_notifier; 2076 2077 return 0; 2078 2079err_uninstall_notifier: 2080 wmi_remove_notify_handler(ACERWMID_EVENT_GUID); 2081err_free_dev: 2082 input_free_device(acer_wmi_input_dev); 2083 return err; 2084} 2085 2086static void acer_wmi_input_destroy(void) 2087{ 2088 wmi_remove_notify_handler(ACERWMID_EVENT_GUID); 2089 input_unregister_device(acer_wmi_input_dev); 2090} 2091 2092/* 2093 * debugfs functions 2094 */ 2095static u32 get_wmid_devices(void) 2096{ 2097 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL}; 2098 union acpi_object *obj; 2099 acpi_status status; 2100 u32 devices = 0; 2101 2102 status = wmi_query_block(WMID_GUID2, 0, &out); 2103 if (ACPI_FAILURE(status)) 2104 return 0; 2105 2106 obj = (union acpi_object *) out.pointer; 2107 if (obj) { 2108 if (obj->type == ACPI_TYPE_BUFFER && 2109 (obj->buffer.length == sizeof(u32) || 2110 obj->buffer.length == sizeof(u64))) { 2111 devices = *((u32 *) obj->buffer.pointer); 2112 } else if (obj->type == ACPI_TYPE_INTEGER) { 2113 devices = (u32) obj->integer.value; 2114 } 2115 } 2116 2117 kfree(out.pointer); 2118 return devices; 2119} 2120 2121/* 2122 * Platform device 2123 */ 2124static int acer_platform_probe(struct platform_device *device) 2125{ 2126 int err; 2127 2128 if (has_cap(ACER_CAP_MAILLED)) { 2129 err = acer_led_init(&device->dev); 2130 if (err) 2131 goto error_mailled; 2132 } 2133 2134 if (has_cap(ACER_CAP_BRIGHTNESS)) { 2135 err = acer_backlight_init(&device->dev); 2136 if (err) 2137 goto error_brightness; 2138 } 2139 2140 err = acer_rfkill_init(&device->dev); 2141 if (err) 2142 goto error_rfkill; 2143 2144 return err; 2145 2146error_rfkill: 2147 if (has_cap(ACER_CAP_BRIGHTNESS)) 2148 acer_backlight_exit(); 2149error_brightness: 2150 if (has_cap(ACER_CAP_MAILLED)) 2151 acer_led_exit(); 2152error_mailled: 2153 return err; 2154} 2155 2156static int acer_platform_remove(struct platform_device *device) 2157{ 2158 if (has_cap(ACER_CAP_MAILLED)) 2159 acer_led_exit(); 2160 if (has_cap(ACER_CAP_BRIGHTNESS)) 2161 acer_backlight_exit(); 2162 2163 acer_rfkill_exit(); 2164 return 0; 2165} 2166 2167#ifdef CONFIG_PM_SLEEP 2168static int acer_suspend(struct device *dev) 2169{ 2170 u32 value; 2171 struct acer_data *data = &interface->data; 2172 2173 if (!data) 2174 return -ENOMEM; 2175 2176 if (has_cap(ACER_CAP_MAILLED)) { 2177 get_u32(&value, ACER_CAP_MAILLED); 2178 set_u32(LED_OFF, ACER_CAP_MAILLED); 2179 data->mailled = value; 2180 } 2181 2182 if (has_cap(ACER_CAP_BRIGHTNESS)) { 2183 get_u32(&value, ACER_CAP_BRIGHTNESS); 2184 data->brightness = value; 2185 } 2186 2187 return 0; 2188} 2189 2190static int acer_resume(struct device *dev) 2191{ 2192 struct acer_data *data = &interface->data; 2193 2194 if (!data) 2195 return -ENOMEM; 2196 2197 if (has_cap(ACER_CAP_MAILLED)) 2198 set_u32(data->mailled, ACER_CAP_MAILLED); 2199 2200 if (has_cap(ACER_CAP_BRIGHTNESS)) 2201 set_u32(data->brightness, ACER_CAP_BRIGHTNESS); 2202 2203 if (acer_wmi_accel_dev) 2204 acer_gsensor_init(); 2205 2206 return 0; 2207} 2208#else 2209#define acer_suspend NULL 2210#define acer_resume NULL 2211#endif 2212 2213static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume); 2214 2215static void acer_platform_shutdown(struct platform_device *device) 2216{ 2217 struct acer_data *data = &interface->data; 2218 2219 if (!data) 2220 return; 2221 2222 if (has_cap(ACER_CAP_MAILLED)) 2223 set_u32(LED_OFF, ACER_CAP_MAILLED); 2224} 2225 2226static struct platform_driver acer_platform_driver = { 2227 .driver = { 2228 .name = "acer-wmi", 2229 .pm = &acer_pm, 2230 }, 2231 .probe = acer_platform_probe, 2232 .remove = acer_platform_remove, 2233 .shutdown = acer_platform_shutdown, 2234}; 2235 2236static struct platform_device *acer_platform_device; 2237 2238static void remove_debugfs(void) 2239{ 2240 debugfs_remove_recursive(interface->debug.root); 2241} 2242 2243static void __init create_debugfs(void) 2244{ 2245 interface->debug.root = debugfs_create_dir("acer-wmi", NULL); 2246 2247 debugfs_create_u32("devices", S_IRUGO, interface->debug.root, 2248 &interface->debug.wmid_devices); 2249} 2250 2251static int __init acer_wmi_init(void) 2252{ 2253 int err; 2254 2255 pr_info("Acer Laptop ACPI-WMI Extras\n"); 2256 2257 if (dmi_check_system(acer_blacklist)) { 2258 pr_info("Blacklisted hardware detected - not loading\n"); 2259 return -ENODEV; 2260 } 2261 2262 find_quirks(); 2263 2264 /* 2265 * The AMW0_GUID1 wmi is not only found on Acer family but also other 2266 * machines like Lenovo, Fujitsu and Medion. In the past days, 2267 * acer-wmi driver handled those non-Acer machines by quirks list. 2268 * But actually acer-wmi driver was loaded on any machines that have 2269 * AMW0_GUID1. This behavior is strange because those machines should 2270 * be supported by appropriate wmi drivers. e.g. fujitsu-laptop, 2271 * ideapad-laptop. So, here checks the machine that has AMW0_GUID1 2272 * should be in Acer/Gateway/Packard Bell white list, or it's already 2273 * in the past quirk list. 2274 */ 2275 if (wmi_has_guid(AMW0_GUID1) && 2276 !dmi_check_system(amw0_whitelist) && 2277 quirks == &quirk_unknown) { 2278 pr_debug("Unsupported machine has AMW0_GUID1, unable to load\n"); 2279 return -ENODEV; 2280 } 2281 2282 /* 2283 * Detect which ACPI-WMI interface we're using. 2284 */ 2285 if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1)) 2286 interface = &AMW0_V2_interface; 2287 2288 if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1)) 2289 interface = &wmid_interface; 2290 2291 if (wmi_has_guid(WMID_GUID3)) 2292 interface = &wmid_v2_interface; 2293 2294 if (interface) 2295 dmi_walk(type_aa_dmi_decode, NULL); 2296 2297 if (wmi_has_guid(WMID_GUID2) && interface) { 2298 if (!has_type_aa && ACPI_FAILURE(WMID_set_capabilities())) { 2299 pr_err("Unable to detect available WMID devices\n"); 2300 return -ENODEV; 2301 } 2302 /* WMID always provides brightness methods */ 2303 interface->capability |= ACER_CAP_BRIGHTNESS; 2304 } else if (!wmi_has_guid(WMID_GUID2) && interface && !has_type_aa && force_caps == -1) { 2305 pr_err("No WMID device detection method found\n"); 2306 return -ENODEV; 2307 } 2308 2309 if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) { 2310 interface = &AMW0_interface; 2311 2312 if (ACPI_FAILURE(AMW0_set_capabilities())) { 2313 pr_err("Unable to detect available AMW0 devices\n"); 2314 return -ENODEV; 2315 } 2316 } 2317 2318 if (wmi_has_guid(AMW0_GUID1)) 2319 AMW0_find_mailled(); 2320 2321 if (!interface) { 2322 pr_err("No or unsupported WMI interface, unable to load\n"); 2323 return -ENODEV; 2324 } 2325 2326 set_quirks(); 2327 2328 if (dmi_check_system(video_vendor_dmi_table)) 2329 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 2330 2331 if (acpi_video_get_backlight_type() != acpi_backlight_vendor) 2332 interface->capability &= ~ACER_CAP_BRIGHTNESS; 2333 2334 if (wmi_has_guid(WMID_GUID3)) 2335 interface->capability |= ACER_CAP_SET_FUNCTION_MODE; 2336 2337 if (force_caps != -1) 2338 interface->capability = force_caps; 2339 2340 if (wmi_has_guid(WMID_GUID3) && 2341 (interface->capability & ACER_CAP_SET_FUNCTION_MODE)) { 2342 if (ACPI_FAILURE(acer_wmi_enable_rf_button())) 2343 pr_warn("Cannot enable RF Button Driver\n"); 2344 2345 if (ec_raw_mode) { 2346 if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) { 2347 pr_err("Cannot enable EC raw mode\n"); 2348 return -ENODEV; 2349 } 2350 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) { 2351 pr_err("Cannot enable Launch Manager mode\n"); 2352 return -ENODEV; 2353 } 2354 } else if (ec_raw_mode) { 2355 pr_info("No WMID EC raw mode enable method\n"); 2356 } 2357 2358 if (wmi_has_guid(ACERWMID_EVENT_GUID)) { 2359 err = acer_wmi_input_setup(); 2360 if (err) 2361 return err; 2362 err = acer_wmi_accel_setup(); 2363 if (err && err != -ENODEV) 2364 pr_warn("Cannot enable accelerometer\n"); 2365 } 2366 2367 err = platform_driver_register(&acer_platform_driver); 2368 if (err) { 2369 pr_err("Unable to register platform driver\n"); 2370 goto error_platform_register; 2371 } 2372 2373 acer_platform_device = platform_device_alloc("acer-wmi", -1); 2374 if (!acer_platform_device) { 2375 err = -ENOMEM; 2376 goto error_device_alloc; 2377 } 2378 2379 err = platform_device_add(acer_platform_device); 2380 if (err) 2381 goto error_device_add; 2382 2383 if (wmi_has_guid(WMID_GUID2)) { 2384 interface->debug.wmid_devices = get_wmid_devices(); 2385 create_debugfs(); 2386 } 2387 2388 /* Override any initial settings with values from the commandline */ 2389 acer_commandline_init(); 2390 2391 return 0; 2392 2393error_device_add: 2394 platform_device_put(acer_platform_device); 2395error_device_alloc: 2396 platform_driver_unregister(&acer_platform_driver); 2397error_platform_register: 2398 if (wmi_has_guid(ACERWMID_EVENT_GUID)) 2399 acer_wmi_input_destroy(); 2400 if (acer_wmi_accel_dev) 2401 input_unregister_device(acer_wmi_accel_dev); 2402 2403 return err; 2404} 2405 2406static void __exit acer_wmi_exit(void) 2407{ 2408 if (wmi_has_guid(ACERWMID_EVENT_GUID)) 2409 acer_wmi_input_destroy(); 2410 2411 if (acer_wmi_accel_dev) 2412 input_unregister_device(acer_wmi_accel_dev); 2413 2414 remove_debugfs(); 2415 platform_device_unregister(acer_platform_device); 2416 platform_driver_unregister(&acer_platform_driver); 2417 2418 pr_info("Acer Laptop WMI Extras unloaded\n"); 2419 return; 2420} 2421 2422module_init(acer_wmi_init); 2423module_exit(acer_wmi_exit); 2424