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