drivers/platform/x86/acer-wmi.c

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