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 <[email protected]>
   6  *
   7  *  Based on acer_acpi:
   8  *    Copyright (C) 2005-2007   E.M. Smith
   9  *    Copyright (C) 2007-2008   Carlos Corbacho <[email protected]>
  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 = dmi_matched,
 602                 .ident = "Acer Predator PH18-71",
 603                 .matches = {
 604                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 605                         DMI_MATCH(DMI_PRODUCT_NAME, "Predator PH18-71"),
 606                 },
 607                 .driver_data = &quirk_acer_predator_v4,
 608         },
 609         {
 610                 .callback = set_force_caps,
 611                 .ident = "Acer Aspire Switch 10E SW3-016",
 612                 .matches = {
 613                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 614                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW3-016"),
 615                 },
 616                 .driver_data = (void *)ACER_CAP_KBD_DOCK,
 617         },
 618         {
 619                 .callback = set_force_caps,
 620                 .ident = "Acer Aspire Switch 10 SW5-012",
 621                 .matches = {
 622                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
 623                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"),
 624                 },
 625                 .driver_data = (void *)ACER_CAP_KBD_DOCK,
 626         },
 627         {
 628                 .callback = set_force_caps,
 629                 .ident = "Acer Aspire Switch V 10 SW5-017",
 630                 .matches = {
 631                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
 632                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "SW5-017"),
 633                 },
 634                 .driver_data = (void *)ACER_CAP_KBD_DOCK,
 635         },
 636         {
 637                 .callback = set_force_caps,
 638                 .ident = "Acer One 10 (S1003)",
 639                 .matches = {
 640                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Acer"),
 641                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "One S1003"),
 642                 },
 643                 .driver_data = (void *)ACER_CAP_KBD_DOCK,
 644         },
 645         {}
 646 };
 647
 648 /*
 649  * This quirk list is for those non-acer machines that have AMW0_GUID1
 650  * but supported by acer-wmi in past days. Keeping this quirk list here
 651  * is only for backward compatible. Please do not add new machine to
 652  * here anymore. Those non-acer machines should be supported by
 653  * appropriate wmi drivers.
 654  */
 655 static const struct dmi_system_id non_acer_quirks[] __initconst = {
 656         {
 657                 .callback = dmi_matched,
 658                 .ident = "Fujitsu Siemens Amilo Li 1718",
 659                 .matches = {
 660                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
 661                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Li 1718"),
 662                 },
 663                 .driver_data = &quirk_fujitsu_amilo_li_1718,
 664         },
 665         {
 666                 .callback = dmi_matched,
 667                 .ident = "Medion MD 98300",
 668                 .matches = {
 669                         DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
 670                         DMI_MATCH(DMI_PRODUCT_NAME, "WAM2030"),
 671                 },
 672                 .driver_data = &quirk_medion_md_98300,
 673         },
 674         {
 675                 .callback = dmi_matched,
 676                 .ident = "Lenovo Ideapad S205",
 677                 .matches = {
 678                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 679                         DMI_MATCH(DMI_PRODUCT_NAME, "10382LG"),
 680                 },
 681                 .driver_data = &quirk_lenovo_ideapad_s205,
 682         },
 683         {
 684                 .callback = dmi_matched,
 685                 .ident = "Lenovo Ideapad S205 (Brazos)",
 686                 .matches = {
 687                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 688                         DMI_MATCH(DMI_PRODUCT_NAME, "Brazos"),
 689                 },
 690                 .driver_data = &quirk_lenovo_ideapad_s205,
 691         },
 692         {
 693                 .callback = dmi_matched,
 694                 .ident = "Lenovo 3000 N200",
 695                 .matches = {
 696                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 697                         DMI_MATCH(DMI_PRODUCT_NAME, "0687A31"),
 698                 },
 699                 .driver_data = &quirk_fujitsu_amilo_li_1718,
 700         },
 701         {
 702                 .callback = dmi_matched,
 703                 .ident = "Lenovo Ideapad S205-10382JG",
 704                 .matches = {
 705                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 706                         DMI_MATCH(DMI_PRODUCT_NAME, "10382JG"),
 707                 },
 708                 .driver_data = &quirk_lenovo_ideapad_s205,
 709         },
 710         {
 711                 .callback = dmi_matched,
 712                 .ident = "Lenovo Ideapad S205-1038DPG",
 713                 .matches = {
 714                         DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 715                         DMI_MATCH(DMI_PRODUCT_NAME, "1038DPG"),
 716                 },
 717                 .driver_data = &quirk_lenovo_ideapad_s205,
 718         },
 719         {}
 720 };
 721
 722 static struct platform_profile_handler platform_profile_handler;
 723 static bool platform_profile_support;
 724
 725 /*
 726  * The profile used before turbo mode. This variable is needed for
 727  * returning from turbo mode when the mode key is in toggle mode.
 728  */
 729 static int last_non_turbo_profile;
 730
 731 enum acer_predator_v4_thermal_profile_ec {
 732         ACER_PREDATOR_V4_THERMAL_PROFILE_ECO = 0x04,
 733         ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO = 0x03,
 734         ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE = 0x02,
 735         ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET = 0x01,
 736         ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED = 0x00,
 737 };
 738
 739 enum acer_predator_v4_thermal_profile_wmi {
 740         ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI = 0x060B,
 741         ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI = 0x050B,
 742         ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI = 0x040B,
 743         ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI = 0x0B,
 744         ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI = 0x010B,
 745 };
 746
 747 /* Find which quirks are needed for a particular vendor/ model pair */
 748 static void __init find_quirks(void)
 749 {
 750         if (predator_v4) {
 751                 quirks = &quirk_acer_predator_v4;
 752         } else if (!force_series) {
 753                 dmi_check_system(acer_quirks);
 754                 dmi_check_system(non_acer_quirks);
 755         } else if (force_series == 2490) {
 756                 quirks = &quirk_acer_travelmate_2490;
 757         }
 758
 759         if (quirks == NULL)
 760                 quirks = &quirk_unknown;
 761 }
 762
 763 /*
 764  * General interface convenience methods
 765  */
 766
 767 static bool has_cap(u32 cap)
 768 {
 769         return interface->capability & cap;
 770 }
 771
 772 /*
 773  * AMW0 (V1) interface
 774  */
 775 struct wmab_args {
 776         u32 eax;
 777         u32 ebx;
 778         u32 ecx;
 779         u32 edx;
 780 };
 781
 782 struct wmab_ret {
 783         u32 eax;
 784         u32 ebx;
 785         u32 ecx;
 786         u32 edx;
 787         u32 eex;
 788 };
 789
 790 static acpi_status wmab_execute(struct wmab_args *regbuf,
 791 struct acpi_buffer *result)
 792 {
 793         struct acpi_buffer input;
 794         acpi_status status;
 795         input.length = sizeof(struct wmab_args);
 796         input.pointer = (u8 *)regbuf;
 797
 798         status = wmi_evaluate_method(AMW0_GUID1, 0, 1, &input, result);
 799
 800         return status;
 801 }
 802
 803 static acpi_status AMW0_get_u32(u32 *value, u32 cap)
 804 {
 805         int err;
 806         u8 result;
 807
 808         switch (cap) {
 809         case ACER_CAP_MAILLED:
 810                 switch (quirks->mailled) {
 811                 default:
 812                         err = ec_read(0xA, &result);
 813                         if (err)
 814                                 return AE_ERROR;
 815                         *value = (result >> 7) & 0x1;
 816                         return AE_OK;
 817                 }
 818                 break;
 819         case ACER_CAP_WIRELESS:
 820                 switch (quirks->wireless) {
 821                 case 1:
 822                         err = ec_read(0x7B, &result);
 823                         if (err)
 824                                 return AE_ERROR;
 825                         *value = result & 0x1;
 826                         return AE_OK;
 827                 case 2:
 828                         err = ec_read(0x71, &result);
 829                         if (err)
 830                                 return AE_ERROR;
 831                         *value = result & 0x1;
 832                         return AE_OK;
 833                 case 3:
 834                         err = ec_read(0x78, &result);
 835                         if (err)
 836                                 return AE_ERROR;
 837                         *value = result & 0x1;
 838                         return AE_OK;
 839                 default:
 840                         err = ec_read(0xA, &result);
 841                         if (err)
 842                                 return AE_ERROR;
 843                         *value = (result >> 2) & 0x1;
 844                         return AE_OK;
 845                 }
 846                 break;
 847         case ACER_CAP_BLUETOOTH:
 848                 switch (quirks->bluetooth) {
 849                 default:
 850                         err = ec_read(0xA, &result);
 851                         if (err)
 852                                 return AE_ERROR;
 853                         *value = (result >> 4) & 0x1;
 854                         return AE_OK;
 855                 }
 856                 break;
 857         case ACER_CAP_BRIGHTNESS:
 858                 switch (quirks->brightness) {
 859                 default:
 860                         err = ec_read(0x83, &result);
 861                         if (err)
 862                                 return AE_ERROR;
 863                         *value = result;
 864                         return AE_OK;
 865                 }
 866                 break;
 867         default:
 868                 return AE_ERROR;
 869         }
 870         return AE_OK;
 871 }
 872
 873 static acpi_status AMW0_set_u32(u32 value, u32 cap)
 874 {
 875         struct wmab_args args;
 876
 877         args.eax = ACER_AMW0_WRITE;
 878         args.ebx = value ? (1<<8) : 0;
 879         args.ecx = args.edx = 0;
 880
 881         switch (cap) {
 882         case ACER_CAP_MAILLED:
 883                 if (value > 1)
 884                         return AE_BAD_PARAMETER;
 885                 args.ebx |= ACER_AMW0_MAILLED_MASK;
 886                 break;
 887         case ACER_CAP_WIRELESS:
 888                 if (value > 1)
 889                         return AE_BAD_PARAMETER;
 890                 args.ebx |= ACER_AMW0_WIRELESS_MASK;
 891                 break;
 892         case ACER_CAP_BLUETOOTH:
 893                 if (value > 1)
 894                         return AE_BAD_PARAMETER;
 895                 args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
 896                 break;
 897         case ACER_CAP_BRIGHTNESS:
 898                 if (value > max_brightness)
 899                         return AE_BAD_PARAMETER;
 900                 switch (quirks->brightness) {
 901                 default:
 902                         return ec_write(0x83, value);
 903                 }
 904         default:
 905                 return AE_ERROR;
 906         }
 907
 908         /* Actually do the set */
 909         return wmab_execute(&args, NULL);
 910 }
 911
 912 static acpi_status __init AMW0_find_mailled(void)
 913 {
 914         struct wmab_args args;
 915         struct wmab_ret ret;
 916         acpi_status status = AE_OK;
 917         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 918         union acpi_object *obj;
 919
 920         args.eax = 0x86;
 921         args.ebx = args.ecx = args.edx = 0;
 922
 923         status = wmab_execute(&args, &out);
 924         if (ACPI_FAILURE(status))
 925                 return status;
 926
 927         obj = (union acpi_object *) out.pointer;
 928         if (obj && obj->type == ACPI_TYPE_BUFFER &&
 929         obj->buffer.length == sizeof(struct wmab_ret)) {
 930                 ret = *((struct wmab_ret *) obj->buffer.pointer);
 931         } else {
 932                 kfree(out.pointer);
 933                 return AE_ERROR;
 934         }
 935
 936         if (ret.eex & 0x1)
 937                 interface->capability |= ACER_CAP_MAILLED;
 938
 939         kfree(out.pointer);
 940
 941         return AE_OK;
 942 }
 943
 944 static const struct acpi_device_id norfkill_ids[] __initconst = {
 945         { "VPC2004", 0},
 946         { "IBM0068", 0},
 947         { "LEN0068", 0},
 948         { "SNY5001", 0},        /* sony-laptop in charge */
 949         { "HPQ6601", 0},
 950         { "", 0},
 951 };
 952
 953 static int __init AMW0_set_cap_acpi_check_device(void)
 954 {
 955         const struct acpi_device_id *id;
 956
 957         for (id = norfkill_ids; id->id[0]; id++)
 958                 if (acpi_dev_found(id->id))
 959                         return true;
 960
 961         return false;
 962 }
 963
 964 static acpi_status __init AMW0_set_capabilities(void)
 965 {
 966         struct wmab_args args;
 967         struct wmab_ret ret;
 968         acpi_status status;
 969         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
 970         union acpi_object *obj;
 971
 972         /*
 973          * On laptops with this strange GUID (non Acer), normal probing doesn't
 974          * work.
 975          */
 976         if (wmi_has_guid(AMW0_GUID2)) {
 977                 if ((quirks != &quirk_unknown) ||
 978                     !AMW0_set_cap_acpi_check_device())
 979                         interface->capability |= ACER_CAP_WIRELESS;
 980                 return AE_OK;
 981         }
 982
 983         args.eax = ACER_AMW0_WRITE;
 984         args.ecx = args.edx = 0;
 985
 986         args.ebx = 0xa2 << 8;
 987         args.ebx |= ACER_AMW0_WIRELESS_MASK;
 988
 989         status = wmab_execute(&args, &out);
 990         if (ACPI_FAILURE(status))
 991                 return status;
 992
 993         obj = out.pointer;
 994         if (obj && obj->type == ACPI_TYPE_BUFFER &&
 995         obj->buffer.length == sizeof(struct wmab_ret)) {
 996                 ret = *((struct wmab_ret *) obj->buffer.pointer);
 997         } else {
 998                 status = AE_ERROR;
 999                 goto out;
1000         }
1001
1002         if (ret.eax & 0x1)
1003                 interface->capability |= ACER_CAP_WIRELESS;
1004
1005         args.ebx = 2 << 8;
1006         args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
1007
1008         /*
1009          * It's ok to use existing buffer for next wmab_execute call.
1010          * But we need to kfree(out.pointer) if next wmab_execute fail.
1011          */
1012         status = wmab_execute(&args, &out);
1013         if (ACPI_FAILURE(status))
1014                 goto out;
1015
1016         obj = (union acpi_object *) out.pointer;
1017         if (obj && obj->type == ACPI_TYPE_BUFFER
1018         && obj->buffer.length == sizeof(struct wmab_ret)) {
1019                 ret = *((struct wmab_ret *) obj->buffer.pointer);
1020         } else {
1021                 status = AE_ERROR;
1022                 goto out;
1023         }
1024
1025         if (ret.eax & 0x1)
1026                 interface->capability |= ACER_CAP_BLUETOOTH;
1027
1028         /*
1029          * This appears to be safe to enable, since all Wistron based laptops
1030          * appear to use the same EC register for brightness, even if they
1031          * differ for wireless, etc
1032          */
1033         if (quirks->brightness >= 0)
1034                 interface->capability |= ACER_CAP_BRIGHTNESS;
1035
1036         status = AE_OK;
1037 out:
1038         kfree(out.pointer);
1039         return status;
1040 }
1041
1042 static struct wmi_interface AMW0_interface = {
1043         .type = ACER_AMW0,
1044 };
1045
1046 static struct wmi_interface AMW0_V2_interface = {
1047         .type = ACER_AMW0_V2,
1048 };
1049
1050 /*
1051  * New interface (The WMID interface)
1052  */
1053 static acpi_status
1054 WMI_execute_u32(u32 method_id, u32 in, u32 *out)
1055 {
1056         struct acpi_buffer input = { (acpi_size) sizeof(u32), (void *)(&in) };
1057         struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
1058         union acpi_object *obj;
1059         u32 tmp = 0;
1060         acpi_status status;
1061
1062         status = wmi_evaluate_method(WMID_GUID1, 0, method_id, &input, &result);
1063
1064         if (ACPI_FAILURE(status))
1065                 return status;
1066
1067         obj = (union acpi_object *) result.pointer;
1068         if (obj) {
1069                 if (obj->type == ACPI_TYPE_BUFFER &&
1070                         (obj->buffer.length == sizeof(u32) ||
1071                         obj->buffer.length == sizeof(u64))) {
1072                         tmp = *((u32 *) obj->buffer.pointer);
1073                 } else if (obj->type == ACPI_TYPE_INTEGER) {
1074                         tmp = (u32) obj->integer.value;
1075                 }
1076         }
1077
1078         if (out)
1079                 *out = tmp;
1080
1081         kfree(result.pointer);
1082
1083         return status;
1084 }
1085
1086 static acpi_status WMID_get_u32(u32 *value, u32 cap)
1087 {
1088         acpi_status status;
1089         u8 tmp;
1090         u32 result, method_id = 0;
1091
1092         switch (cap) {
1093         case ACER_CAP_WIRELESS:
1094                 method_id = ACER_WMID_GET_WIRELESS_METHODID;
1095                 break;
1096         case ACER_CAP_BLUETOOTH:
1097                 method_id = ACER_WMID_GET_BLUETOOTH_METHODID;
1098                 break;
1099         case ACER_CAP_BRIGHTNESS:
1100                 method_id = ACER_WMID_GET_BRIGHTNESS_METHODID;
1101                 break;
1102         case ACER_CAP_THREEG:
1103                 method_id = ACER_WMID_GET_THREEG_METHODID;
1104                 break;
1105         case ACER_CAP_MAILLED:
1106                 if (quirks->mailled == 1) {
1107                         ec_read(0x9f, &tmp);
1108                         *value = tmp & 0x1;
1109                         return 0;
1110                 }
1111                 fallthrough;
1112         default:
1113                 return AE_ERROR;
1114         }
1115         status = WMI_execute_u32(method_id, 0, &result);
1116
1117         if (ACPI_SUCCESS(status))
1118                 *value = (u8)result;
1119
1120         return status;
1121 }
1122
1123 static acpi_status WMID_set_u32(u32 value, u32 cap)
1124 {
1125         u32 method_id = 0;
1126         char param;
1127
1128         switch (cap) {
1129         case ACER_CAP_BRIGHTNESS:
1130                 if (value > max_brightness)
1131                         return AE_BAD_PARAMETER;
1132                 method_id = ACER_WMID_SET_BRIGHTNESS_METHODID;
1133                 break;
1134         case ACER_CAP_WIRELESS:
1135                 if (value > 1)
1136                         return AE_BAD_PARAMETER;
1137                 method_id = ACER_WMID_SET_WIRELESS_METHODID;
1138                 break;
1139         case ACER_CAP_BLUETOOTH:
1140                 if (value > 1)
1141                         return AE_BAD_PARAMETER;
1142                 method_id = ACER_WMID_SET_BLUETOOTH_METHODID;
1143                 break;
1144         case ACER_CAP_THREEG:
1145                 if (value > 1)
1146                         return AE_BAD_PARAMETER;
1147                 method_id = ACER_WMID_SET_THREEG_METHODID;
1148                 break;
1149         case ACER_CAP_MAILLED:
1150                 if (value > 1)
1151                         return AE_BAD_PARAMETER;
1152                 if (quirks->mailled == 1) {
1153                         param = value ? 0x92 : 0x93;
1154                         i8042_lock_chip();
1155                         i8042_command(&param, 0x1059);
1156                         i8042_unlock_chip();
1157                         return 0;
1158                 }
1159                 break;
1160         default:
1161                 return AE_ERROR;
1162         }
1163         return WMI_execute_u32(method_id, (u32)value, NULL);
1164 }
1165
1166 static acpi_status wmid3_get_device_status(u32 *value, u16 device)
1167 {
1168         struct wmid3_gds_return_value return_value;
1169         acpi_status status;
1170         union acpi_object *obj;
1171         struct wmid3_gds_get_input_param params = {
1172                 .function_num = 0x1,
1173                 .hotkey_number = commun_fn_key_number,
1174                 .devices = device,
1175         };
1176         struct acpi_buffer input = {
1177                 sizeof(struct wmid3_gds_get_input_param),
1178                 &params
1179         };
1180         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1181
1182         status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output);
1183         if (ACPI_FAILURE(status))
1184                 return status;
1185
1186         obj = output.pointer;
1187
1188         if (!obj)
1189                 return AE_ERROR;
1190         else if (obj->type != ACPI_TYPE_BUFFER) {
1191                 kfree(obj);
1192                 return AE_ERROR;
1193         }
1194         if (obj->buffer.length != 8) {
1195                 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1196                 kfree(obj);
1197                 return AE_ERROR;
1198         }
1199
1200         return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1201         kfree(obj);
1202
1203         if (return_value.error_code || return_value.ec_return_value)
1204                 pr_warn("Get 0x%x Device Status failed: 0x%x - 0x%x\n",
1205                         device,
1206                         return_value.error_code,
1207                         return_value.ec_return_value);
1208         else
1209                 *value = !!(return_value.devices & device);
1210
1211         return status;
1212 }
1213
1214 static acpi_status wmid_v2_get_u32(u32 *value, u32 cap)
1215 {
1216         u16 device;
1217
1218         switch (cap) {
1219         case ACER_CAP_WIRELESS:
1220                 device = ACER_WMID3_GDS_WIRELESS;
1221                 break;
1222         case ACER_CAP_BLUETOOTH:
1223                 device = ACER_WMID3_GDS_BLUETOOTH;
1224                 break;
1225         case ACER_CAP_THREEG:
1226                 device = ACER_WMID3_GDS_THREEG;
1227                 break;
1228         default:
1229                 return AE_ERROR;
1230         }
1231         return wmid3_get_device_status(value, device);
1232 }
1233
1234 static acpi_status wmid3_set_device_status(u32 value, u16 device)
1235 {
1236         struct wmid3_gds_return_value return_value;
1237         acpi_status status;
1238         union acpi_object *obj;
1239         u16 devices;
1240         struct wmid3_gds_get_input_param get_params = {
1241                 .function_num = 0x1,
1242                 .hotkey_number = commun_fn_key_number,
1243                 .devices = commun_func_bitmap,
1244         };
1245         struct acpi_buffer get_input = {
1246                 sizeof(struct wmid3_gds_get_input_param),
1247                 &get_params
1248         };
1249         struct wmid3_gds_set_input_param set_params = {
1250                 .function_num = 0x2,
1251                 .hotkey_number = commun_fn_key_number,
1252                 .devices = commun_func_bitmap,
1253         };
1254         struct acpi_buffer set_input = {
1255                 sizeof(struct wmid3_gds_set_input_param),
1256                 &set_params
1257         };
1258         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1259         struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
1260
1261         status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &get_input, &output);
1262         if (ACPI_FAILURE(status))
1263                 return status;
1264
1265         obj = output.pointer;
1266
1267         if (!obj)
1268                 return AE_ERROR;
1269         else if (obj->type != ACPI_TYPE_BUFFER) {
1270                 kfree(obj);
1271                 return AE_ERROR;
1272         }
1273         if (obj->buffer.length != 8) {
1274                 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1275                 kfree(obj);
1276                 return AE_ERROR;
1277         }
1278
1279         return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1280         kfree(obj);
1281
1282         if (return_value.error_code || return_value.ec_return_value) {
1283                 pr_warn("Get Current Device Status failed: 0x%x - 0x%x\n",
1284                         return_value.error_code,
1285                         return_value.ec_return_value);
1286                 return status;
1287         }
1288
1289         devices = return_value.devices;
1290         set_params.devices = (value) ? (devices | device) : (devices & ~device);
1291
1292         status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &set_input, &output2);
1293         if (ACPI_FAILURE(status))
1294                 return status;
1295
1296         obj = output2.pointer;
1297
1298         if (!obj)
1299                 return AE_ERROR;
1300         else if (obj->type != ACPI_TYPE_BUFFER) {
1301                 kfree(obj);
1302                 return AE_ERROR;
1303         }
1304         if (obj->buffer.length != 4) {
1305                 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
1306                 kfree(obj);
1307                 return AE_ERROR;
1308         }
1309
1310         return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
1311         kfree(obj);
1312
1313         if (return_value.error_code || return_value.ec_return_value)
1314                 pr_warn("Set Device Status failed: 0x%x - 0x%x\n",
1315                         return_value.error_code,
1316                         return_value.ec_return_value);
1317
1318         return status;
1319 }
1320
1321 static acpi_status wmid_v2_set_u32(u32 value, u32 cap)
1322 {
1323         u16 device;
1324
1325         switch (cap) {
1326         case ACER_CAP_WIRELESS:
1327                 device = ACER_WMID3_GDS_WIRELESS;
1328                 break;
1329         case ACER_CAP_BLUETOOTH:
1330                 device = ACER_WMID3_GDS_BLUETOOTH;
1331                 break;
1332         case ACER_CAP_THREEG:
1333                 device = ACER_WMID3_GDS_THREEG;
1334                 break;
1335         default:
1336                 return AE_ERROR;
1337         }
1338         return wmid3_set_device_status(value, device);
1339 }
1340
1341 static void __init type_aa_dmi_decode(const struct dmi_header *header, void *d)
1342 {
1343         struct hotkey_function_type_aa *type_aa;
1344
1345         /* We are looking for OEM-specific Type AAh */
1346         if (header->type != 0xAA)
1347                 return;
1348
1349         has_type_aa = true;
1350         type_aa = (struct hotkey_function_type_aa *) header;
1351
1352         pr_info("Function bitmap for Communication Button: 0x%x\n",
1353                 type_aa->commun_func_bitmap);
1354         commun_func_bitmap = type_aa->commun_func_bitmap;
1355
1356         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS)
1357                 interface->capability |= ACER_CAP_WIRELESS;
1358         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_THREEG)
1359                 interface->capability |= ACER_CAP_THREEG;
1360         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_BLUETOOTH)
1361                 interface->capability |= ACER_CAP_BLUETOOTH;
1362         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_RFBTN)
1363                 commun_func_bitmap &= ~ACER_WMID3_GDS_RFBTN;
1364
1365         commun_fn_key_number = type_aa->commun_fn_key_number;
1366 }
1367
1368 static acpi_status __init WMID_set_capabilities(void)
1369 {
1370         struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1371         union acpi_object *obj;
1372         acpi_status status;
1373         u32 devices;
1374
1375         status = wmi_query_block(WMID_GUID2, 0, &out);
1376         if (ACPI_FAILURE(status))
1377                 return status;
1378
1379         obj = (union acpi_object *) out.pointer;
1380         if (obj) {
1381                 if (obj->type == ACPI_TYPE_BUFFER &&
1382                         (obj->buffer.length == sizeof(u32) ||
1383                         obj->buffer.length == sizeof(u64))) {
1384                         devices = *((u32 *) obj->buffer.pointer);
1385                 } else if (obj->type == ACPI_TYPE_INTEGER) {
1386                         devices = (u32) obj->integer.value;
1387                 } else {
1388                         kfree(out.pointer);
1389                         return AE_ERROR;
1390                 }
1391         } else {
1392                 kfree(out.pointer);
1393                 return AE_ERROR;
1394         }
1395
1396         pr_info("Function bitmap for Communication Device: 0x%x\n", devices);
1397         if (devices & 0x07)
1398                 interface->capability |= ACER_CAP_WIRELESS;
1399         if (devices & 0x40)
1400                 interface->capability |= ACER_CAP_THREEG;
1401         if (devices & 0x10)
1402                 interface->capability |= ACER_CAP_BLUETOOTH;
1403
1404         if (!(devices & 0x20))
1405                 max_brightness = 0x9;
1406
1407         kfree(out.pointer);
1408         return status;
1409 }
1410
1411 static struct wmi_interface wmid_interface = {
1412         .type = ACER_WMID,
1413 };
1414
1415 static struct wmi_interface wmid_v2_interface = {
1416         .type = ACER_WMID_v2,
1417 };
1418
1419 /*
1420  * WMID Gaming interface
1421  */
1422
1423 static acpi_status
1424 WMI_gaming_execute_u64(u32 method_id, u64 in, u64 *out)
1425 {
1426         struct acpi_buffer input = { (acpi_size) sizeof(u64), (void *)(&in) };
1427         struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
1428         union acpi_object *obj;
1429         u64 tmp = 0;
1430         acpi_status status;
1431
1432         status = wmi_evaluate_method(WMID_GUID4, 0, method_id, &input, &result);
1433
1434         if (ACPI_FAILURE(status))
1435                 return status;
1436         obj = (union acpi_object *) result.pointer;
1437
1438         if (obj) {
1439                 if (obj->type == ACPI_TYPE_BUFFER) {
1440                         if (obj->buffer.length == sizeof(u32))
1441                                 tmp = *((u32 *) obj->buffer.pointer);
1442                         else if (obj->buffer.length == sizeof(u64))
1443                                 tmp = *((u64 *) obj->buffer.pointer);
1444                 } else if (obj->type == ACPI_TYPE_INTEGER) {
1445                         tmp = (u64) obj->integer.value;
1446                 }
1447         }
1448
1449         if (out)
1450                 *out = tmp;
1451
1452         kfree(result.pointer);
1453
1454         return status;
1455 }
1456
1457 static acpi_status WMID_gaming_set_u64(u64 value, u32 cap)
1458 {
1459         u32 method_id = 0;
1460
1461         if (!(interface->capability & cap))
1462                 return AE_BAD_PARAMETER;
1463
1464         switch (cap) {
1465         case ACER_CAP_TURBO_LED:
1466                 method_id = ACER_WMID_SET_GAMING_LED_METHODID;
1467                 break;
1468         case ACER_CAP_TURBO_FAN:
1469                 method_id = ACER_WMID_SET_GAMING_FAN_BEHAVIOR;
1470                 break;
1471         case ACER_CAP_TURBO_OC:
1472                 method_id = ACER_WMID_SET_GAMING_MISC_SETTING_METHODID;
1473                 break;
1474         default:
1475                 return AE_BAD_PARAMETER;
1476         }
1477
1478         return WMI_gaming_execute_u64(method_id, value, NULL);
1479 }
1480
1481 static acpi_status WMID_gaming_get_u64(u64 *value, u32 cap)
1482 {
1483         acpi_status status;
1484         u64 result;
1485         u64 input;
1486         u32 method_id;
1487
1488         if (!(interface->capability & cap))
1489                 return AE_BAD_PARAMETER;
1490
1491         switch (cap) {
1492         case ACER_CAP_TURBO_LED:
1493                 method_id = ACER_WMID_GET_GAMING_LED_METHODID;
1494                 input = 0x1;
1495                 break;
1496         default:
1497                 return AE_BAD_PARAMETER;
1498         }
1499         status = WMI_gaming_execute_u64(method_id, input, &result);
1500         if (ACPI_SUCCESS(status))
1501                 *value = (u64) result;
1502
1503         return status;
1504 }
1505
1506 static void WMID_gaming_set_fan_mode(u8 fan_mode)
1507 {
1508         /* fan_mode = 1 is used for auto, fan_mode = 2 used for turbo*/
1509         u64 gpu_fan_config1 = 0, gpu_fan_config2 = 0;
1510         int i;
1511
1512         if (quirks->cpu_fans > 0)
1513                 gpu_fan_config2 |= 1;
1514         for (i = 0; i < (quirks->cpu_fans + quirks->gpu_fans); ++i)
1515                 gpu_fan_config2 |= 1 << (i + 1);
1516         for (i = 0; i < quirks->gpu_fans; ++i)
1517                 gpu_fan_config2 |= 1 << (i + 3);
1518         if (quirks->cpu_fans > 0)
1519                 gpu_fan_config1 |= fan_mode;
1520         for (i = 0; i < (quirks->cpu_fans + quirks->gpu_fans); ++i)
1521                 gpu_fan_config1 |= fan_mode << (2 * i + 2);
1522         for (i = 0; i < quirks->gpu_fans; ++i)
1523                 gpu_fan_config1 |= fan_mode << (2 * i + 6);
1524         WMID_gaming_set_u64(gpu_fan_config2 | gpu_fan_config1 << 16, ACER_CAP_TURBO_FAN);
1525 }
1526
1527 /*
1528  * Generic Device (interface-independent)
1529  */
1530
1531 static acpi_status get_u32(u32 *value, u32 cap)
1532 {
1533         acpi_status status = AE_ERROR;
1534
1535         switch (interface->type) {
1536         case ACER_AMW0:
1537                 status = AMW0_get_u32(value, cap);
1538                 break;
1539         case ACER_AMW0_V2:
1540                 if (cap == ACER_CAP_MAILLED) {
1541                         status = AMW0_get_u32(value, cap);
1542                         break;
1543                 }
1544                 fallthrough;
1545         case ACER_WMID:
1546                 status = WMID_get_u32(value, cap);
1547                 break;
1548         case ACER_WMID_v2:
1549                 if (cap & (ACER_CAP_WIRELESS |
1550                            ACER_CAP_BLUETOOTH |
1551                            ACER_CAP_THREEG))
1552                         status = wmid_v2_get_u32(value, cap);
1553                 else if (wmi_has_guid(WMID_GUID2))
1554                         status = WMID_get_u32(value, cap);
1555                 break;
1556         }
1557
1558         return status;
1559 }
1560
1561 static acpi_status set_u32(u32 value, u32 cap)
1562 {
1563         acpi_status status;
1564
1565         if (interface->capability & cap) {
1566                 switch (interface->type) {
1567                 case ACER_AMW0:
1568                         return AMW0_set_u32(value, cap);
1569                 case ACER_AMW0_V2:
1570                         if (cap == ACER_CAP_MAILLED)
1571                                 return AMW0_set_u32(value, cap);
1572
1573                         /*
1574                          * On some models, some WMID methods don't toggle
1575                          * properly. For those cases, we want to run the AMW0
1576                          * method afterwards to be certain we've really toggled
1577                          * the device state.
1578                          */
1579                         if (cap == ACER_CAP_WIRELESS ||
1580                                 cap == ACER_CAP_BLUETOOTH) {
1581                                 status = WMID_set_u32(value, cap);
1582                                 if (ACPI_FAILURE(status))
1583                                         return status;
1584
1585                                 return AMW0_set_u32(value, cap);
1586                         }
1587                         fallthrough;
1588                 case ACER_WMID:
1589                         return WMID_set_u32(value, cap);
1590                 case ACER_WMID_v2:
1591                         if (cap & (ACER_CAP_WIRELESS |
1592                                    ACER_CAP_BLUETOOTH |
1593                                    ACER_CAP_THREEG))
1594                                 return wmid_v2_set_u32(value, cap);
1595                         else if (wmi_has_guid(WMID_GUID2))
1596                                 return WMID_set_u32(value, cap);
1597                         fallthrough;
1598                 default:
1599                         return AE_BAD_PARAMETER;
1600                 }
1601         }
1602         return AE_BAD_PARAMETER;
1603 }
1604
1605 static void __init acer_commandline_init(void)
1606 {
1607         /*
1608          * These will all fail silently if the value given is invalid, or the
1609          * capability isn't available on the given interface
1610          */
1611         if (mailled >= 0)
1612                 set_u32(mailled, ACER_CAP_MAILLED);
1613         if (!has_type_aa && threeg >= 0)
1614                 set_u32(threeg, ACER_CAP_THREEG);
1615         if (brightness >= 0)
1616                 set_u32(brightness, ACER_CAP_BRIGHTNESS);
1617 }
1618
1619 /*
1620  * LED device (Mail LED only, no other LEDs known yet)
1621  */
1622 static void mail_led_set(struct led_classdev *led_cdev,
1623 enum led_brightness value)
1624 {
1625         set_u32(value, ACER_CAP_MAILLED);
1626 }
1627
1628 static struct led_classdev mail_led = {
1629         .name = "acer-wmi::mail",
1630         .brightness_set = mail_led_set,
1631 };
1632
1633 static int acer_led_init(struct device *dev)
1634 {
1635         return led_classdev_register(dev, &mail_led);
1636 }
1637
1638 static void acer_led_exit(void)
1639 {
1640         set_u32(LED_OFF, ACER_CAP_MAILLED);
1641         led_classdev_unregister(&mail_led);
1642 }
1643
1644 /*
1645  * Backlight device
1646  */
1647 static struct backlight_device *acer_backlight_device;
1648
1649 static int read_brightness(struct backlight_device *bd)
1650 {
1651         u32 value;
1652         get_u32(&value, ACER_CAP_BRIGHTNESS);
1653         return value;
1654 }
1655
1656 static int update_bl_status(struct backlight_device *bd)
1657 {
1658         int intensity = backlight_get_brightness(bd);
1659
1660         set_u32(intensity, ACER_CAP_BRIGHTNESS);
1661
1662         return 0;
1663 }
1664
1665 static const struct backlight_ops acer_bl_ops = {
1666         .get_brightness = read_brightness,
1667         .update_status = update_bl_status,
1668 };
1669
1670 static int acer_backlight_init(struct device *dev)
1671 {
1672         struct backlight_properties props;
1673         struct backlight_device *bd;
1674
1675         memset(&props, 0, sizeof(struct backlight_properties));
1676         props.type = BACKLIGHT_PLATFORM;
1677         props.max_brightness = max_brightness;
1678         bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops,
1679                                        &props);
1680         if (IS_ERR(bd)) {
1681                 pr_err("Could not register Acer backlight device\n");
1682                 acer_backlight_device = NULL;
1683                 return PTR_ERR(bd);
1684         }
1685
1686         acer_backlight_device = bd;
1687
1688         bd->props.power = FB_BLANK_UNBLANK;
1689         bd->props.brightness = read_brightness(bd);
1690         backlight_update_status(bd);
1691         return 0;
1692 }
1693
1694 static void acer_backlight_exit(void)
1695 {
1696         backlight_device_unregister(acer_backlight_device);
1697 }
1698
1699 /*
1700  * Accelerometer device
1701  */
1702 static acpi_handle gsensor_handle;
1703
1704 static int acer_gsensor_init(void)
1705 {
1706         acpi_status status;
1707         struct acpi_buffer output;
1708         union acpi_object out_obj;
1709
1710         output.length = sizeof(out_obj);
1711         output.pointer = &out_obj;
1712         status = acpi_evaluate_object(gsensor_handle, "_INI", NULL, &output);
1713         if (ACPI_FAILURE(status))
1714                 return -1;
1715
1716         return 0;
1717 }
1718
1719 static int acer_gsensor_open(struct input_dev *input)
1720 {
1721         return acer_gsensor_init();
1722 }
1723
1724 static int acer_gsensor_event(void)
1725 {
1726         acpi_status status;
1727         struct acpi_buffer output;
1728         union acpi_object out_obj[5];
1729
1730         if (!acer_wmi_accel_dev)
1731                 return -1;
1732
1733         output.length = sizeof(out_obj);
1734         output.pointer = out_obj;
1735
1736         status = acpi_evaluate_object(gsensor_handle, "RDVL", NULL, &output);
1737         if (ACPI_FAILURE(status))
1738                 return -1;
1739
1740         if (out_obj->package.count != 4)
1741                 return -1;
1742
1743         input_report_abs(acer_wmi_accel_dev, ABS_X,
1744                 (s16)out_obj->package.elements[0].integer.value);
1745         input_report_abs(acer_wmi_accel_dev, ABS_Y,
1746                 (s16)out_obj->package.elements[1].integer.value);
1747         input_report_abs(acer_wmi_accel_dev, ABS_Z,
1748                 (s16)out_obj->package.elements[2].integer.value);
1749         input_sync(acer_wmi_accel_dev);
1750         return 0;
1751 }
1752
1753 static int acer_get_fan_speed(int fan)
1754 {
1755         if (quirks->predator_v4) {
1756                 acpi_status status;
1757                 u64 fanspeed;
1758
1759                 status = WMI_gaming_execute_u64(
1760                         ACER_WMID_GET_GAMING_SYS_INFO_METHODID,
1761                         fan == 0 ? ACER_WMID_CMD_GET_PREDATOR_V4_CPU_FAN_SPEED :
1762                                    ACER_WMID_CMD_GET_PREDATOR_V4_GPU_FAN_SPEED,
1763                         &fanspeed);
1764
1765                 if (ACPI_FAILURE(status))
1766                         return -EIO;
1767
1768                 return FIELD_GET(ACER_PREDATOR_V4_FAN_SPEED_READ_BIT_MASK, fanspeed);
1769         }
1770         return -EOPNOTSUPP;
1771 }
1772
1773 /*
1774  *  Predator series turbo button
1775  */
1776 static int acer_toggle_turbo(void)
1777 {
1778         u64 turbo_led_state;
1779
1780         /* Get current state from turbo button */
1781         if (ACPI_FAILURE(WMID_gaming_get_u64(&turbo_led_state, ACER_CAP_TURBO_LED)))
1782                 return -1;
1783
1784         if (turbo_led_state) {
1785                 /* Turn off turbo led */
1786                 WMID_gaming_set_u64(0x1, ACER_CAP_TURBO_LED);
1787
1788                 /* Set FAN mode to auto */
1789                 WMID_gaming_set_fan_mode(0x1);
1790
1791                 /* Set OC to normal */
1792                 WMID_gaming_set_u64(0x5, ACER_CAP_TURBO_OC);
1793                 WMID_gaming_set_u64(0x7, ACER_CAP_TURBO_OC);
1794         } else {
1795                 /* Turn on turbo led */
1796                 WMID_gaming_set_u64(0x10001, ACER_CAP_TURBO_LED);
1797
1798                 /* Set FAN mode to turbo */
1799                 WMID_gaming_set_fan_mode(0x2);
1800
1801                 /* Set OC to turbo mode */
1802                 WMID_gaming_set_u64(0x205, ACER_CAP_TURBO_OC);
1803                 WMID_gaming_set_u64(0x207, ACER_CAP_TURBO_OC);
1804         }
1805         return turbo_led_state;
1806 }
1807
1808 static int
1809 acer_predator_v4_platform_profile_get(struct platform_profile_handler *pprof,
1810                                       enum platform_profile_option *profile)
1811 {
1812         u8 tp;
1813         int err;
1814
1815         err = ec_read(ACER_PREDATOR_V4_THERMAL_PROFILE_EC_OFFSET, &tp);
1816
1817         if (err < 0)
1818                 return err;
1819
1820         switch (tp) {
1821         case ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO:
1822                 *profile = PLATFORM_PROFILE_PERFORMANCE;
1823                 break;
1824         case ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE:
1825                 *profile = PLATFORM_PROFILE_BALANCED_PERFORMANCE;
1826                 break;
1827         case ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED:
1828                 *profile = PLATFORM_PROFILE_BALANCED;
1829                 break;
1830         case ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET:
1831                 *profile = PLATFORM_PROFILE_QUIET;
1832                 break;
1833         case ACER_PREDATOR_V4_THERMAL_PROFILE_ECO:
1834                 *profile = PLATFORM_PROFILE_LOW_POWER;
1835                 break;
1836         default:
1837                 return -EOPNOTSUPP;
1838         }
1839
1840         return 0;
1841 }
1842
1843 static int
1844 acer_predator_v4_platform_profile_set(struct platform_profile_handler *pprof,
1845                                       enum platform_profile_option profile)
1846 {
1847         int tp;
1848         acpi_status status;
1849
1850         switch (profile) {
1851         case PLATFORM_PROFILE_PERFORMANCE:
1852                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1853                 break;
1854         case PLATFORM_PROFILE_BALANCED_PERFORMANCE:
1855                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI;
1856                 break;
1857         case PLATFORM_PROFILE_BALANCED:
1858                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1859                 break;
1860         case PLATFORM_PROFILE_QUIET:
1861                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI;
1862                 break;
1863         case PLATFORM_PROFILE_LOW_POWER:
1864                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1865                 break;
1866         default:
1867                 return -EOPNOTSUPP;
1868         }
1869
1870         status = WMI_gaming_execute_u64(
1871                 ACER_WMID_SET_GAMING_MISC_SETTING_METHODID, tp, NULL);
1872
1873         if (ACPI_FAILURE(status))
1874                 return -EIO;
1875
1876         if (tp != ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI)
1877                 last_non_turbo_profile = tp;
1878
1879         return 0;
1880 }
1881
1882 static int acer_platform_profile_setup(void)
1883 {
1884         if (quirks->predator_v4) {
1885                 int err;
1886
1887                 platform_profile_handler.profile_get =
1888                         acer_predator_v4_platform_profile_get;
1889                 platform_profile_handler.profile_set =
1890                         acer_predator_v4_platform_profile_set;
1891
1892                 set_bit(PLATFORM_PROFILE_PERFORMANCE,
1893                         platform_profile_handler.choices);
1894                 set_bit(PLATFORM_PROFILE_BALANCED_PERFORMANCE,
1895                         platform_profile_handler.choices);
1896                 set_bit(PLATFORM_PROFILE_BALANCED,
1897                         platform_profile_handler.choices);
1898                 set_bit(PLATFORM_PROFILE_QUIET,
1899                         platform_profile_handler.choices);
1900                 set_bit(PLATFORM_PROFILE_LOW_POWER,
1901                         platform_profile_handler.choices);
1902
1903                 err = platform_profile_register(&platform_profile_handler);
1904                 if (err)
1905                         return err;
1906
1907                 platform_profile_support = true;
1908
1909                 /* Set default non-turbo profile  */
1910                 last_non_turbo_profile =
1911                         ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1912         }
1913         return 0;
1914 }
1915
1916 static int acer_thermal_profile_change(void)
1917 {
1918         /*
1919          * This mode key can rotate each mode or toggle turbo mode.
1920          * On battery, only ECO and BALANCED mode are available.
1921          */
1922         if (quirks->predator_v4) {
1923                 u8 current_tp;
1924                 int tp, err;
1925                 u64 on_AC;
1926                 acpi_status status;
1927
1928                 err = ec_read(ACER_PREDATOR_V4_THERMAL_PROFILE_EC_OFFSET,
1929                               &current_tp);
1930
1931                 if (err < 0)
1932                         return err;
1933
1934                 /* Check power source */
1935                 status = WMI_gaming_execute_u64(
1936                         ACER_WMID_GET_GAMING_SYS_INFO_METHODID,
1937                         ACER_WMID_CMD_GET_PREDATOR_V4_BAT_STATUS, &on_AC);
1938
1939                 if (ACPI_FAILURE(status))
1940                         return -EIO;
1941
1942                 switch (current_tp) {
1943                 case ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO:
1944                         if (!on_AC)
1945                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1946                         else if (cycle_gaming_thermal_profile)
1947                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1948                         else
1949                                 tp = last_non_turbo_profile;
1950                         break;
1951                 case ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE:
1952                         if (!on_AC)
1953                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1954                         else
1955                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1956                         break;
1957                 case ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED:
1958                         if (!on_AC)
1959                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_ECO_WMI;
1960                         else if (cycle_gaming_thermal_profile)
1961                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_PERFORMANCE_WMI;
1962                         else
1963                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1964                         break;
1965                 case ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET:
1966                         if (!on_AC)
1967                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1968                         else if (cycle_gaming_thermal_profile)
1969                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1970                         else
1971                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1972                         break;
1973                 case ACER_PREDATOR_V4_THERMAL_PROFILE_ECO:
1974                         if (!on_AC)
1975                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_BALANCED_WMI;
1976                         else if (cycle_gaming_thermal_profile)
1977                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_QUIET_WMI;
1978                         else
1979                                 tp = ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI;
1980                         break;
1981                 default:
1982                         return -EOPNOTSUPP;
1983                 }
1984
1985                 status = WMI_gaming_execute_u64(
1986                         ACER_WMID_SET_GAMING_MISC_SETTING_METHODID, tp, NULL);
1987
1988                 if (ACPI_FAILURE(status))
1989                         return -EIO;
1990
1991                 /* Store non-turbo profile for turbo mode toggle*/
1992                 if (tp != ACER_PREDATOR_V4_THERMAL_PROFILE_TURBO_WMI)
1993                         last_non_turbo_profile = tp;
1994
1995                 platform_profile_notify();
1996         }
1997
1998         return 0;
1999 }
2000
2001 /*
2002  * Switch series keyboard dock status
2003  */
2004 static int acer_kbd_dock_state_to_sw_tablet_mode(u8 kbd_dock_state)
2005 {
2006         switch (kbd_dock_state) {
2007         case 0x01: /* Docked, traditional clamshell laptop mode */
2008                 return 0;
2009         case 0x04: /* Stand-alone tablet */
2010         case 0x40: /* Docked, tent mode, keyboard not usable */
2011                 return 1;
2012         default:
2013                 pr_warn("Unknown kbd_dock_state 0x%02x\n", kbd_dock_state);
2014         }
2015
2016         return 0;
2017 }
2018
2019 static void acer_kbd_dock_get_initial_state(void)
2020 {
2021         u8 *output, input[8] = { 0x05, 0x00, };
2022         struct acpi_buffer input_buf = { sizeof(input), input };
2023         struct acpi_buffer output_buf = { ACPI_ALLOCATE_BUFFER, NULL };
2024         union acpi_object *obj;
2025         acpi_status status;
2026         int sw_tablet_mode;
2027
2028         status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input_buf, &output_buf);
2029         if (ACPI_FAILURE(status)) {
2030                 pr_err("Error getting keyboard-dock initial status: %s\n",
2031                        acpi_format_exception(status));
2032                 return;
2033         }
2034
2035         obj = output_buf.pointer;
2036         if (!obj || obj->type != ACPI_TYPE_BUFFER || obj->buffer.length != 8) {
2037                 pr_err("Unexpected output format getting keyboard-dock initial status\n");
2038                 goto out_free_obj;
2039         }
2040
2041         output = obj->buffer.pointer;
2042         if (output[0] != 0x00 || (output[3] != 0x05 && output[3] != 0x45)) {
2043                 pr_err("Unexpected output [0]=0x%02x [3]=0x%02x getting keyboard-dock initial status\n",
2044                        output[0], output[3]);
2045                 goto out_free_obj;
2046         }
2047
2048         sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(output[4]);
2049         input_report_switch(acer_wmi_input_dev, SW_TABLET_MODE, sw_tablet_mode);
2050
2051 out_free_obj:
2052         kfree(obj);
2053 }
2054
2055 static void acer_kbd_dock_event(const struct event_return_value *event)
2056 {
2057         int sw_tablet_mode;
2058
2059         if (!has_cap(ACER_CAP_KBD_DOCK))
2060                 return;
2061
2062         sw_tablet_mode = acer_kbd_dock_state_to_sw_tablet_mode(event->kbd_dock_state);
2063         input_report_switch(acer_wmi_input_dev, SW_TABLET_MODE, sw_tablet_mode);
2064         input_sync(acer_wmi_input_dev);
2065 }
2066
2067 /*
2068  * Rfkill devices
2069  */
2070 static void acer_rfkill_update(struct work_struct *ignored);
2071 static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update);
2072 static void acer_rfkill_update(struct work_struct *ignored)
2073 {
2074         u32 state;
2075         acpi_status status;
2076
2077         if (has_cap(ACER_CAP_WIRELESS)) {
2078                 status = get_u32(&state, ACER_CAP_WIRELESS);
2079                 if (ACPI_SUCCESS(status)) {
2080                         if (quirks->wireless == 3)
2081                                 rfkill_set_hw_state(wireless_rfkill, !state);
2082                         else
2083                                 rfkill_set_sw_state(wireless_rfkill, !state);
2084                 }
2085         }
2086
2087         if (has_cap(ACER_CAP_BLUETOOTH)) {
2088                 status = get_u32(&state, ACER_CAP_BLUETOOTH);
2089                 if (ACPI_SUCCESS(status))
2090                         rfkill_set_sw_state(bluetooth_rfkill, !state);
2091         }
2092
2093         if (has_cap(ACER_CAP_THREEG) && wmi_has_guid(WMID_GUID3)) {
2094                 status = get_u32(&state, ACER_WMID3_GDS_THREEG);
2095                 if (ACPI_SUCCESS(status))
2096                         rfkill_set_sw_state(threeg_rfkill, !state);
2097         }
2098
2099         schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
2100 }
2101
2102 static int acer_rfkill_set(void *data, bool blocked)
2103 {
2104         acpi_status status;
2105         u32 cap = (unsigned long)data;
2106
2107         if (rfkill_inited) {
2108                 status = set_u32(!blocked, cap);
2109                 if (ACPI_FAILURE(status))
2110                         return -ENODEV;
2111         }
2112
2113         return 0;
2114 }
2115
2116 static const struct rfkill_ops acer_rfkill_ops = {
2117         .set_block = acer_rfkill_set,
2118 };
2119
2120 static struct rfkill *acer_rfkill_register(struct device *dev,
2121                                            enum rfkill_type type,
2122                                            char *name, u32 cap)
2123 {
2124         int err;
2125         struct rfkill *rfkill_dev;
2126         u32 state;
2127         acpi_status status;
2128
2129         rfkill_dev = rfkill_alloc(name, dev, type,
2130                                   &acer_rfkill_ops,
2131                                   (void *)(unsigned long)cap);
2132         if (!rfkill_dev)
2133                 return ERR_PTR(-ENOMEM);
2134
2135         status = get_u32(&state, cap);
2136
2137         err = rfkill_register(rfkill_dev);
2138         if (err) {
2139                 rfkill_destroy(rfkill_dev);
2140                 return ERR_PTR(err);
2141         }
2142
2143         if (ACPI_SUCCESS(status))
2144                 rfkill_set_sw_state(rfkill_dev, !state);
2145
2146         return rfkill_dev;
2147 }
2148
2149 static int acer_rfkill_init(struct device *dev)
2150 {
2151         int err;
2152
2153         if (has_cap(ACER_CAP_WIRELESS)) {
2154                 wireless_rfkill = acer_rfkill_register(dev, RFKILL_TYPE_WLAN,
2155                         "acer-wireless", ACER_CAP_WIRELESS);
2156                 if (IS_ERR(wireless_rfkill)) {
2157                         err = PTR_ERR(wireless_rfkill);
2158                         goto error_wireless;
2159                 }
2160         }
2161
2162         if (has_cap(ACER_CAP_BLUETOOTH)) {
2163                 bluetooth_rfkill = acer_rfkill_register(dev,
2164                         RFKILL_TYPE_BLUETOOTH, "acer-bluetooth",
2165                         ACER_CAP_BLUETOOTH);
2166                 if (IS_ERR(bluetooth_rfkill)) {
2167                         err = PTR_ERR(bluetooth_rfkill);
2168                         goto error_bluetooth;
2169                 }
2170         }
2171
2172         if (has_cap(ACER_CAP_THREEG)) {
2173                 threeg_rfkill = acer_rfkill_register(dev,
2174                         RFKILL_TYPE_WWAN, "acer-threeg",
2175                         ACER_CAP_THREEG);
2176                 if (IS_ERR(threeg_rfkill)) {
2177                         err = PTR_ERR(threeg_rfkill);
2178                         goto error_threeg;
2179                 }
2180         }
2181
2182         rfkill_inited = true;
2183
2184         if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
2185             has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
2186                 schedule_delayed_work(&acer_rfkill_work,
2187                         round_jiffies_relative(HZ));
2188
2189         return 0;
2190
2191 error_threeg:
2192         if (has_cap(ACER_CAP_BLUETOOTH)) {
2193                 rfkill_unregister(bluetooth_rfkill);
2194                 rfkill_destroy(bluetooth_rfkill);
2195         }
2196 error_bluetooth:
2197         if (has_cap(ACER_CAP_WIRELESS)) {
2198                 rfkill_unregister(wireless_rfkill);
2199                 rfkill_destroy(wireless_rfkill);
2200         }
2201 error_wireless:
2202         return err;
2203 }
2204
2205 static void acer_rfkill_exit(void)
2206 {
2207         if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
2208             has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
2209                 cancel_delayed_work_sync(&acer_rfkill_work);
2210
2211         if (has_cap(ACER_CAP_WIRELESS)) {
2212                 rfkill_unregister(wireless_rfkill);
2213                 rfkill_destroy(wireless_rfkill);
2214         }
2215
2216         if (has_cap(ACER_CAP_BLUETOOTH)) {
2217                 rfkill_unregister(bluetooth_rfkill);
2218                 rfkill_destroy(bluetooth_rfkill);
2219         }
2220
2221         if (has_cap(ACER_CAP_THREEG)) {
2222                 rfkill_unregister(threeg_rfkill);
2223                 rfkill_destroy(threeg_rfkill);
2224         }
2225 }
2226
2227 static void acer_wmi_notify(u32 value, void *context)
2228 {
2229         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
2230         union acpi_object *obj;
2231         struct event_return_value return_value;
2232         acpi_status status;
2233         u16 device_state;
2234         const struct key_entry *key;
2235         u32 scancode;
2236
2237         status = wmi_get_event_data(value, &response);
2238         if (status != AE_OK) {
2239                 pr_warn("bad event status 0x%x\n", status);
2240                 return;
2241         }
2242
2243         obj = (union acpi_object *)response.pointer;
2244
2245         if (!obj)
2246                 return;
2247         if (obj->type != ACPI_TYPE_BUFFER) {
2248                 pr_warn("Unknown response received %d\n", obj->type);
2249                 kfree(obj);
2250                 return;
2251         }
2252         if (obj->buffer.length != 8) {
2253                 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
2254                 kfree(obj);
2255                 return;
2256         }
2257
2258         return_value = *((struct event_return_value *)obj->buffer.pointer);
2259         kfree(obj);
2260
2261         switch (return_value.function) {
2262         case WMID_HOTKEY_EVENT:
2263                 device_state = return_value.device_state;
2264                 pr_debug("device state: 0x%x\n", device_state);
2265
2266                 key = sparse_keymap_entry_from_scancode(acer_wmi_input_dev,
2267                                                         return_value.key_num);
2268                 if (!key) {
2269                         pr_warn("Unknown key number - 0x%x\n",
2270                                 return_value.key_num);
2271                 } else {
2272                         scancode = return_value.key_num;
2273                         switch (key->keycode) {
2274                         case KEY_WLAN:
2275                         case KEY_BLUETOOTH:
2276                                 if (has_cap(ACER_CAP_WIRELESS))
2277                                         rfkill_set_sw_state(wireless_rfkill,
2278                                                 !(device_state & ACER_WMID3_GDS_WIRELESS));
2279                                 if (has_cap(ACER_CAP_THREEG))
2280                                         rfkill_set_sw_state(threeg_rfkill,
2281                                                 !(device_state & ACER_WMID3_GDS_THREEG));
2282                                 if (has_cap(ACER_CAP_BLUETOOTH))
2283                                         rfkill_set_sw_state(bluetooth_rfkill,
2284                                                 !(device_state & ACER_WMID3_GDS_BLUETOOTH));
2285                                 break;
2286                         case KEY_TOUCHPAD_TOGGLE:
2287                                 scancode = (device_state & ACER_WMID3_GDS_TOUCHPAD) ?
2288                                                 KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF;
2289                         }
2290                         sparse_keymap_report_event(acer_wmi_input_dev, scancode, 1, true);
2291                 }
2292                 break;
2293         case WMID_ACCEL_OR_KBD_DOCK_EVENT:
2294                 acer_gsensor_event();
2295                 acer_kbd_dock_event(&return_value);
2296                 break;
2297         case WMID_GAMING_TURBO_KEY_EVENT:
2298                 if (return_value.key_num == 0x4)
2299                         acer_toggle_turbo();
2300                 if (return_value.key_num == 0x5 && has_cap(ACER_CAP_PLATFORM_PROFILE))
2301                         acer_thermal_profile_change();
2302                 break;
2303         default:
2304                 pr_warn("Unknown function number - %d - %d\n",
2305                         return_value.function, return_value.key_num);
2306                 break;
2307         }
2308 }
2309
2310 static acpi_status __init
2311 wmid3_set_function_mode(struct func_input_params *params,
2312                         struct func_return_value *return_value)
2313 {
2314         acpi_status status;
2315         union acpi_object *obj;
2316
2317         struct acpi_buffer input = { sizeof(struct func_input_params), params };
2318         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
2319
2320         status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output);
2321         if (ACPI_FAILURE(status))
2322                 return status;
2323
2324         obj = output.pointer;
2325
2326         if (!obj)
2327                 return AE_ERROR;
2328         else if (obj->type != ACPI_TYPE_BUFFER) {
2329                 kfree(obj);
2330                 return AE_ERROR;
2331         }
2332         if (obj->buffer.length != 4) {
2333                 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
2334                 kfree(obj);
2335                 return AE_ERROR;
2336         }
2337
2338         *return_value = *((struct func_return_value *)obj->buffer.pointer);
2339         kfree(obj);
2340
2341         return status;
2342 }
2343
2344 static int __init acer_wmi_enable_ec_raw(void)
2345 {
2346         struct func_return_value return_value;
2347         acpi_status status;
2348         struct func_input_params params = {
2349                 .function_num = 0x1,
2350                 .commun_devices = 0xFFFF,
2351                 .devices = 0xFFFF,
2352                 .app_status = 0x00,             /* Launch Manager Deactive */
2353                 .app_mask = 0x01,
2354         };
2355
2356         status = wmid3_set_function_mode(&params, &return_value);
2357
2358         if (return_value.error_code || return_value.ec_return_value)
2359                 pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
2360                         return_value.error_code,
2361                         return_value.ec_return_value);
2362         else
2363                 pr_info("Enabled EC raw mode\n");
2364
2365         return status;
2366 }
2367
2368 static int __init acer_wmi_enable_lm(void)
2369 {
2370         struct func_return_value return_value;
2371         acpi_status status;
2372         struct func_input_params params = {
2373                 .function_num = 0x1,
2374                 .commun_devices = 0xFFFF,
2375                 .devices = 0xFFFF,
2376                 .app_status = 0x01,            /* Launch Manager Active */
2377                 .app_mask = 0x01,
2378         };
2379
2380         status = wmid3_set_function_mode(&params, &return_value);
2381
2382         if (return_value.error_code || return_value.ec_return_value)
2383                 pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
2384                         return_value.error_code,
2385                         return_value.ec_return_value);
2386
2387         return status;
2388 }
2389
2390 static int __init acer_wmi_enable_rf_button(void)
2391 {
2392         struct func_return_value return_value;
2393         acpi_status status;
2394         struct func_input_params params = {
2395                 .function_num = 0x1,
2396                 .commun_devices = 0xFFFF,
2397                 .devices = 0xFFFF,
2398                 .app_status = 0x10,            /* RF Button Active */
2399                 .app_mask = 0x10,
2400         };
2401
2402         status = wmid3_set_function_mode(&params, &return_value);
2403
2404         if (return_value.error_code || return_value.ec_return_value)
2405                 pr_warn("Enabling RF Button failed: 0x%x - 0x%x\n",
2406                         return_value.error_code,
2407                         return_value.ec_return_value);
2408
2409         return status;
2410 }
2411
2412 static int __init acer_wmi_accel_setup(void)
2413 {
2414         struct acpi_device *adev;
2415         int err;
2416
2417         adev = acpi_dev_get_first_match_dev("BST0001", NULL, -1);
2418         if (!adev)
2419                 return -ENODEV;
2420
2421         gsensor_handle = acpi_device_handle(adev);
2422         acpi_dev_put(adev);
2423
2424         acer_wmi_accel_dev = input_allocate_device();
2425         if (!acer_wmi_accel_dev)
2426                 return -ENOMEM;
2427
2428         acer_wmi_accel_dev->open = acer_gsensor_open;
2429
2430         acer_wmi_accel_dev->name = "Acer BMA150 accelerometer";
2431         acer_wmi_accel_dev->phys = "wmi/input1";
2432         acer_wmi_accel_dev->id.bustype = BUS_HOST;
2433         acer_wmi_accel_dev->evbit[0] = BIT_MASK(EV_ABS);
2434         input_set_abs_params(acer_wmi_accel_dev, ABS_X, -16384, 16384, 0, 0);
2435         input_set_abs_params(acer_wmi_accel_dev, ABS_Y, -16384, 16384, 0, 0);
2436         input_set_abs_params(acer_wmi_accel_dev, ABS_Z, -16384, 16384, 0, 0);
2437
2438         err = input_register_device(acer_wmi_accel_dev);
2439         if (err)
2440                 goto err_free_dev;
2441
2442         return 0;
2443
2444 err_free_dev:
2445         input_free_device(acer_wmi_accel_dev);
2446         return err;
2447 }
2448
2449 static int __init acer_wmi_input_setup(void)
2450 {
2451         acpi_status status;
2452         int err;
2453
2454         acer_wmi_input_dev = input_allocate_device();
2455         if (!acer_wmi_input_dev)
2456                 return -ENOMEM;
2457
2458         acer_wmi_input_dev->name = "Acer WMI hotkeys";
2459         acer_wmi_input_dev->phys = "wmi/input0";
2460         acer_wmi_input_dev->id.bustype = BUS_HOST;
2461
2462         err = sparse_keymap_setup(acer_wmi_input_dev, acer_wmi_keymap, NULL);
2463         if (err)
2464                 goto err_free_dev;
2465
2466         if (has_cap(ACER_CAP_KBD_DOCK))
2467                 input_set_capability(acer_wmi_input_dev, EV_SW, SW_TABLET_MODE);
2468
2469         status = wmi_install_notify_handler(ACERWMID_EVENT_GUID,
2470                                                 acer_wmi_notify, NULL);
2471         if (ACPI_FAILURE(status)) {
2472                 err = -EIO;
2473                 goto err_free_dev;
2474         }
2475
2476         if (has_cap(ACER_CAP_KBD_DOCK))
2477                 acer_kbd_dock_get_initial_state();
2478
2479         err = input_register_device(acer_wmi_input_dev);
2480         if (err)
2481                 goto err_uninstall_notifier;
2482
2483         return 0;
2484
2485 err_uninstall_notifier:
2486         wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
2487 err_free_dev:
2488         input_free_device(acer_wmi_input_dev);
2489         return err;
2490 }
2491
2492 static void acer_wmi_input_destroy(void)
2493 {
2494         wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
2495         input_unregister_device(acer_wmi_input_dev);
2496 }
2497
2498 /*
2499  * debugfs functions
2500  */
2501 static u32 get_wmid_devices(void)
2502 {
2503         struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
2504         union acpi_object *obj;
2505         acpi_status status;
2506         u32 devices = 0;
2507
2508         status = wmi_query_block(WMID_GUID2, 0, &out);
2509         if (ACPI_FAILURE(status))
2510                 return 0;
2511
2512         obj = (union acpi_object *) out.pointer;
2513         if (obj) {
2514                 if (obj->type == ACPI_TYPE_BUFFER &&
2515                         (obj->buffer.length == sizeof(u32) ||
2516                         obj->buffer.length == sizeof(u64))) {
2517                         devices = *((u32 *) obj->buffer.pointer);
2518                 } else if (obj->type == ACPI_TYPE_INTEGER) {
2519                         devices = (u32) obj->integer.value;
2520                 }
2521         }
2522
2523         kfree(out.pointer);
2524         return devices;
2525 }
2526
2527 static int acer_wmi_hwmon_init(void);
2528
2529 /*
2530  * Platform device
2531  */
2532 static int acer_platform_probe(struct platform_device *device)
2533 {
2534         int err;
2535
2536         if (has_cap(ACER_CAP_MAILLED)) {
2537                 err = acer_led_init(&device->dev);
2538                 if (err)
2539                         goto error_mailled;
2540         }
2541
2542         if (has_cap(ACER_CAP_BRIGHTNESS)) {
2543                 err = acer_backlight_init(&device->dev);
2544                 if (err)
2545                         goto error_brightness;
2546         }
2547
2548         err = acer_rfkill_init(&device->dev);
2549         if (err)
2550                 goto error_rfkill;
2551
2552         if (has_cap(ACER_CAP_PLATFORM_PROFILE)) {
2553                 err = acer_platform_profile_setup();
2554                 if (err)
2555                         goto error_platform_profile;
2556         }
2557
2558         if (has_cap(ACER_CAP_FAN_SPEED_READ)) {
2559                 err = acer_wmi_hwmon_init();
2560                 if (err)
2561                         goto error_hwmon;
2562         }
2563
2564         return 0;
2565
2566 error_hwmon:
2567         if (platform_profile_support)
2568                 platform_profile_remove();
2569 error_platform_profile:
2570         acer_rfkill_exit();
2571 error_rfkill:
2572         if (has_cap(ACER_CAP_BRIGHTNESS))
2573                 acer_backlight_exit();
2574 error_brightness:
2575         if (has_cap(ACER_CAP_MAILLED))
2576                 acer_led_exit();
2577 error_mailled:
2578         return err;
2579 }
2580
2581 static void acer_platform_remove(struct platform_device *device)
2582 {
2583         if (has_cap(ACER_CAP_MAILLED))
2584                 acer_led_exit();
2585         if (has_cap(ACER_CAP_BRIGHTNESS))
2586                 acer_backlight_exit();
2587
2588         acer_rfkill_exit();
2589
2590         if (platform_profile_support)
2591                 platform_profile_remove();
2592 }
2593
2594 #ifdef CONFIG_PM_SLEEP
2595 static int acer_suspend(struct device *dev)
2596 {
2597         u32 value;
2598         struct acer_data *data = &interface->data;
2599
2600         if (!data)
2601                 return -ENOMEM;
2602
2603         if (has_cap(ACER_CAP_MAILLED)) {
2604                 get_u32(&value, ACER_CAP_MAILLED);
2605                 set_u32(LED_OFF, ACER_CAP_MAILLED);
2606                 data->mailled = value;
2607         }
2608
2609         if (has_cap(ACER_CAP_BRIGHTNESS)) {
2610                 get_u32(&value, ACER_CAP_BRIGHTNESS);
2611                 data->brightness = value;
2612         }
2613
2614         return 0;
2615 }
2616
2617 static int acer_resume(struct device *dev)
2618 {
2619         struct acer_data *data = &interface->data;
2620
2621         if (!data)
2622                 return -ENOMEM;
2623
2624         if (has_cap(ACER_CAP_MAILLED))
2625                 set_u32(data->mailled, ACER_CAP_MAILLED);
2626
2627         if (has_cap(ACER_CAP_BRIGHTNESS))
2628                 set_u32(data->brightness, ACER_CAP_BRIGHTNESS);
2629
2630         if (acer_wmi_accel_dev)
2631                 acer_gsensor_init();
2632
2633         return 0;
2634 }
2635 #else
2636 #define acer_suspend    NULL
2637 #define acer_resume     NULL
2638 #endif
2639
2640 static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume);
2641
2642 static void acer_platform_shutdown(struct platform_device *device)
2643 {
2644         struct acer_data *data = &interface->data;
2645
2646         if (!data)
2647                 return;
2648
2649         if (has_cap(ACER_CAP_MAILLED))
2650                 set_u32(LED_OFF, ACER_CAP_MAILLED);
2651 }
2652
2653 static struct platform_driver acer_platform_driver = {
2654         .driver = {
2655                 .name = "acer-wmi",
2656                 .pm = &acer_pm,
2657         },
2658         .probe = acer_platform_probe,
2659         .remove_new = acer_platform_remove,
2660         .shutdown = acer_platform_shutdown,
2661 };
2662
2663 static struct platform_device *acer_platform_device;
2664
2665 static void remove_debugfs(void)
2666 {
2667         debugfs_remove_recursive(interface->debug.root);
2668 }
2669
2670 static void __init create_debugfs(void)
2671 {
2672         interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
2673
2674         debugfs_create_u32("devices", S_IRUGO, interface->debug.root,
2675                            &interface->debug.wmid_devices);
2676 }
2677
2678 static umode_t acer_wmi_hwmon_is_visible(const void *data,
2679                                          enum hwmon_sensor_types type, u32 attr,
2680                                          int channel)
2681 {
2682         switch (type) {
2683         case hwmon_fan:
2684                 if (acer_get_fan_speed(channel) >= 0)
2685                         return 0444;
2686                 break;
2687         default:
2688                 return 0;
2689         }
2690
2691         return 0;
2692 }
2693
2694 static int acer_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
2695                                u32 attr, int channel, long *val)
2696 {
2697         int ret;
2698
2699         switch (type) {
2700         case hwmon_fan:
2701                 ret = acer_get_fan_speed(channel);
2702                 if (ret < 0)
2703                         return ret;
2704                 *val = ret;
2705                 break;
2706         default:
2707                 return -EOPNOTSUPP;
2708         }
2709
2710         return 0;
2711 }
2712
2713 static const struct hwmon_channel_info *const acer_wmi_hwmon_info[] = {
2714         HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT, HWMON_F_INPUT), NULL
2715 };
2716
2717 static const struct hwmon_ops acer_wmi_hwmon_ops = {
2718         .read = acer_wmi_hwmon_read,
2719         .is_visible = acer_wmi_hwmon_is_visible,
2720 };
2721
2722 static const struct hwmon_chip_info acer_wmi_hwmon_chip_info = {
2723         .ops = &acer_wmi_hwmon_ops,
2724         .info = acer_wmi_hwmon_info,
2725 };
2726
2727 static int acer_wmi_hwmon_init(void)
2728 {
2729         struct device *dev = &acer_platform_device->dev;
2730         struct device *hwmon;
2731
2732         hwmon = devm_hwmon_device_register_with_info(dev, "acer",
2733                                                      &acer_platform_driver,
2734                                                      &acer_wmi_hwmon_chip_info,
2735                                                      NULL);
2736
2737         if (IS_ERR(hwmon)) {
2738                 dev_err(dev, "Could not register acer hwmon device\n");
2739                 return PTR_ERR(hwmon);
2740         }
2741
2742         return 0;
2743 }
2744
2745 static int __init acer_wmi_init(void)
2746 {
2747         int err;
2748
2749         pr_info("Acer Laptop ACPI-WMI Extras\n");
2750
2751         if (dmi_check_system(acer_blacklist)) {
2752                 pr_info("Blacklisted hardware detected - not loading\n");
2753                 return -ENODEV;
2754         }
2755
2756         find_quirks();
2757
2758         /*
2759          * The AMW0_GUID1 wmi is not only found on Acer family but also other
2760          * machines like Lenovo, Fujitsu and Medion. In the past days,
2761          * acer-wmi driver handled those non-Acer machines by quirks list.
2762          * But actually acer-wmi driver was loaded on any machines that have
2763          * AMW0_GUID1. This behavior is strange because those machines should
2764          * be supported by appropriate wmi drivers. e.g. fujitsu-laptop,
2765          * ideapad-laptop. So, here checks the machine that has AMW0_GUID1
2766          * should be in Acer/Gateway/Packard Bell white list, or it's already
2767          * in the past quirk list.
2768          */
2769         if (wmi_has_guid(AMW0_GUID1) &&
2770             !dmi_check_system(amw0_whitelist) &&
2771             quirks == &quirk_unknown) {
2772                 pr_debug("Unsupported machine has AMW0_GUID1, unable to load\n");
2773                 return -ENODEV;
2774         }
2775
2776         /*
2777          * Detect which ACPI-WMI interface we're using.
2778          */
2779         if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2780                 interface = &AMW0_V2_interface;
2781
2782         if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2783                 interface = &wmid_interface;
2784
2785         if (wmi_has_guid(WMID_GUID3))
2786                 interface = &wmid_v2_interface;
2787
2788         if (interface)
2789                 dmi_walk(type_aa_dmi_decode, NULL);
2790
2791         if (wmi_has_guid(WMID_GUID2) && interface) {
2792                 if (!has_type_aa && ACPI_FAILURE(WMID_set_capabilities())) {
2793                         pr_err("Unable to detect available WMID devices\n");
2794                         return -ENODEV;
2795                 }
2796                 /* WMID always provides brightness methods */
2797                 interface->capability |= ACER_CAP_BRIGHTNESS;
2798         } else if (!wmi_has_guid(WMID_GUID2) && interface && !has_type_aa && force_caps == -1) {
2799                 pr_err("No WMID device detection method found\n");
2800                 return -ENODEV;
2801         }
2802
2803         if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) {
2804                 interface = &AMW0_interface;
2805
2806                 if (ACPI_FAILURE(AMW0_set_capabilities())) {
2807                         pr_err("Unable to detect available AMW0 devices\n");
2808                         return -ENODEV;
2809                 }
2810         }
2811
2812         if (wmi_has_guid(AMW0_GUID1))
2813                 AMW0_find_mailled();
2814
2815         if (!interface) {
2816                 pr_err("No or unsupported WMI interface, unable to load\n");
2817                 return -ENODEV;
2818         }
2819
2820         set_quirks();
2821
2822         if (acpi_video_get_backlight_type() != acpi_backlight_vendor)
2823                 interface->capability &= ~ACER_CAP_BRIGHTNESS;
2824
2825         if (wmi_has_guid(WMID_GUID3))
2826                 interface->capability |= ACER_CAP_SET_FUNCTION_MODE;
2827
2828         if (force_caps != -1)
2829                 interface->capability = force_caps;
2830
2831         if (wmi_has_guid(WMID_GUID3) &&
2832             (interface->capability & ACER_CAP_SET_FUNCTION_MODE)) {
2833                 if (ACPI_FAILURE(acer_wmi_enable_rf_button()))
2834                         pr_warn("Cannot enable RF Button Driver\n");
2835
2836                 if (ec_raw_mode) {
2837                         if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
2838                                 pr_err("Cannot enable EC raw mode\n");
2839                                 return -ENODEV;
2840                         }
2841                 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
2842                         pr_err("Cannot enable Launch Manager mode\n");
2843                         return -ENODEV;
2844                 }
2845         } else if (ec_raw_mode) {
2846                 pr_info("No WMID EC raw mode enable method\n");
2847         }
2848
2849         if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
2850                 err = acer_wmi_input_setup();
2851                 if (err)
2852                         return err;
2853                 err = acer_wmi_accel_setup();
2854                 if (err && err != -ENODEV)
2855                         pr_warn("Cannot enable accelerometer\n");
2856         }
2857
2858         err = platform_driver_register(&acer_platform_driver);
2859         if (err) {
2860                 pr_err("Unable to register platform driver\n");
2861                 goto error_platform_register;
2862         }
2863
2864         acer_platform_device = platform_device_alloc("acer-wmi", PLATFORM_DEVID_NONE);
2865         if (!acer_platform_device) {
2866                 err = -ENOMEM;
2867                 goto error_device_alloc;
2868         }
2869
2870         err = platform_device_add(acer_platform_device);
2871         if (err)
2872                 goto error_device_add;
2873
2874         if (wmi_has_guid(WMID_GUID2)) {
2875                 interface->debug.wmid_devices = get_wmid_devices();
2876                 create_debugfs();
2877         }
2878
2879         /* Override any initial settings with values from the commandline */
2880         acer_commandline_init();
2881
2882         return 0;
2883
2884 error_device_add:
2885         platform_device_put(acer_platform_device);
2886 error_device_alloc:
2887         platform_driver_unregister(&acer_platform_driver);
2888 error_platform_register:
2889         if (wmi_has_guid(ACERWMID_EVENT_GUID))
2890                 acer_wmi_input_destroy();
2891         if (acer_wmi_accel_dev)
2892                 input_unregister_device(acer_wmi_accel_dev);
2893
2894         return err;
2895 }
2896
2897 static void __exit acer_wmi_exit(void)
2898 {
2899         if (wmi_has_guid(ACERWMID_EVENT_GUID))
2900                 acer_wmi_input_destroy();
2901
2902         if (acer_wmi_accel_dev)
2903                 input_unregister_device(acer_wmi_accel_dev);
2904
2905         remove_debugfs();
2906         platform_device_unregister(acer_platform_device);
2907         platform_driver_unregister(&acer_platform_driver);
2908
2909         pr_info("Acer Laptop WMI Extras unloaded\n");
2910 }
2911
2912 module_init(acer_wmi_init);
2913 module_exit(acer_wmi_exit);