drivers/platform/x86/acer-wmi.c

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