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