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