drivers/platform/x86/acer-wmi.c

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