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