2 * Acer WMI Laptop Extras
4 * Copyright (C) 2007-2009 Carlos Corbacho <carlos@strangeworlds.co.uk>
7 * Copyright (C) 2005-2007 E.M. Smith
8 * Copyright (C) 2007-2008 Carlos Corbacho <cathectic@gmail.com>
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.
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.
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
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
33 #include <linux/backlight.h>
34 #include <linux/leds.h>
35 #include <linux/platform_device.h>
36 #include <linux/acpi.h>
37 #include <linux/i8042.h>
38 #include <linux/rfkill.h>
39 #include <linux/workqueue.h>
40 #include <linux/debugfs.h>
41 #include <linux/slab.h>
42 #include <linux/input.h>
43 #include <linux/input/sparse-keymap.h>
44 #include <acpi/video.h>
46 MODULE_AUTHOR("Carlos Corbacho");
47 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
48 MODULE_LICENSE("GPL");
52 * Meaning is unknown - this number is required for writing to ACPI for AMW0
53 * (it's also used in acerhk when directly accessing the BIOS)
55 #define ACER_AMW0_WRITE 0x9610
58 * Bit masks for the AMW0 interface
60 #define ACER_AMW0_WIRELESS_MASK 0x35
61 #define ACER_AMW0_BLUETOOTH_MASK 0x34
62 #define ACER_AMW0_MAILLED_MASK 0x31
65 * Method IDs for WMID interface
67 #define ACER_WMID_GET_WIRELESS_METHODID 1
68 #define ACER_WMID_GET_BLUETOOTH_METHODID 2
69 #define ACER_WMID_GET_BRIGHTNESS_METHODID 3
70 #define ACER_WMID_SET_WIRELESS_METHODID 4
71 #define ACER_WMID_SET_BLUETOOTH_METHODID 5
72 #define ACER_WMID_SET_BRIGHTNESS_METHODID 6
73 #define ACER_WMID_GET_THREEG_METHODID 10
74 #define ACER_WMID_SET_THREEG_METHODID 11
77 * Acer ACPI method GUIDs
79 #define AMW0_GUID1 "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
80 #define AMW0_GUID2 "431F16ED-0C2B-444C-B267-27DEB140CF9C"
81 #define WMID_GUID1 "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
82 #define WMID_GUID2 "95764E09-FB56-4E83-B31A-37761F60994A"
83 #define WMID_GUID3 "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
86 * Acer ACPI event GUIDs
88 #define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
90 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
91 MODULE_ALIAS("wmi:6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3");
92 MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
94 enum acer_wmi_event_ids
{
95 WMID_HOTKEY_EVENT
= 0x1,
96 WMID_ACCEL_EVENT
= 0x5,
99 static const struct key_entry acer_wmi_keymap
[] __initconst
= {
100 {KE_KEY
, 0x01, {KEY_WLAN
} }, /* WiFi */
101 {KE_KEY
, 0x03, {KEY_WLAN
} }, /* WiFi */
102 {KE_KEY
, 0x04, {KEY_WLAN
} }, /* WiFi */
103 {KE_KEY
, 0x12, {KEY_BLUETOOTH
} }, /* BT */
104 {KE_KEY
, 0x21, {KEY_PROG1
} }, /* Backup */
105 {KE_KEY
, 0x22, {KEY_PROG2
} }, /* Arcade */
106 {KE_KEY
, 0x23, {KEY_PROG3
} }, /* P_Key */
107 {KE_KEY
, 0x24, {KEY_PROG4
} }, /* Social networking_Key */
108 {KE_KEY
, 0x29, {KEY_PROG3
} }, /* P_Key for TM8372 */
109 {KE_IGNORE
, 0x41, {KEY_MUTE
} },
110 {KE_IGNORE
, 0x42, {KEY_PREVIOUSSONG
} },
111 {KE_IGNORE
, 0x4d, {KEY_PREVIOUSSONG
} },
112 {KE_IGNORE
, 0x43, {KEY_NEXTSONG
} },
113 {KE_IGNORE
, 0x4e, {KEY_NEXTSONG
} },
114 {KE_IGNORE
, 0x44, {KEY_PLAYPAUSE
} },
115 {KE_IGNORE
, 0x4f, {KEY_PLAYPAUSE
} },
116 {KE_IGNORE
, 0x45, {KEY_STOP
} },
117 {KE_IGNORE
, 0x50, {KEY_STOP
} },
118 {KE_IGNORE
, 0x48, {KEY_VOLUMEUP
} },
119 {KE_IGNORE
, 0x49, {KEY_VOLUMEDOWN
} },
120 {KE_IGNORE
, 0x4a, {KEY_VOLUMEDOWN
} },
121 {KE_IGNORE
, 0x61, {KEY_SWITCHVIDEOMODE
} },
122 {KE_IGNORE
, 0x62, {KEY_BRIGHTNESSUP
} },
123 {KE_IGNORE
, 0x63, {KEY_BRIGHTNESSDOWN
} },
124 {KE_KEY
, 0x64, {KEY_SWITCHVIDEOMODE
} }, /* Display Switch */
125 {KE_IGNORE
, 0x81, {KEY_SLEEP
} },
126 {KE_KEY
, 0x82, {KEY_TOUCHPAD_TOGGLE
} }, /* Touch Pad Toggle */
127 {KE_KEY
, KEY_TOUCHPAD_ON
, {KEY_TOUCHPAD_ON
} },
128 {KE_KEY
, KEY_TOUCHPAD_OFF
, {KEY_TOUCHPAD_OFF
} },
129 {KE_IGNORE
, 0x83, {KEY_TOUCHPAD_TOGGLE
} },
130 {KE_KEY
, 0x85, {KEY_TOUCHPAD_TOGGLE
} },
131 {KE_KEY
, 0x86, {KEY_WLAN
} },
132 {KE_KEY
, 0x87, {KEY_POWER
} },
136 static struct input_dev
*acer_wmi_input_dev
;
137 static struct input_dev
*acer_wmi_accel_dev
;
139 struct event_return_value
{
144 } __attribute__((packed
));
147 * GUID3 Get Device Status device flags
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_RFBTN (1<<14) /* RF Button */
155 #define ACER_WMID3_GDS_TOUCHPAD (1<<1) /* Touchpad */
157 /* Hotkey Customized Setting and Acer Application Status.
158 * Set Device Default Value and Report Acer Application Status.
159 * When Acer Application starts, it will run this method to inform
160 * BIOS/EC that Acer Application is on.
162 * Bit[0]: Launch Manager Status
164 * Bit[2]: Device Control Status
165 * Bit[3]: Acer Power Button Utility Status
166 * Bit[4]: RF Button Status
167 * Bit[5]: ODD PM Status
168 * Bit[6]: Device Default Value Control
169 * Bit[7]: Hall Sensor Application Status
171 struct func_input_params
{
172 u8 function_num
; /* Function Number */
173 u16 commun_devices
; /* Communication type devices default status */
174 u16 devices
; /* Other type devices default status */
175 u8 app_status
; /* Acer Device Status. LM, ePM, RF Button... */
176 u8 app_mask
; /* Bit mask to app_status */
178 } __attribute__((packed
));
180 struct func_return_value
{
181 u8 error_code
; /* Error Code */
182 u8 ec_return_value
; /* EC Return Value */
184 } __attribute__((packed
));
186 struct wmid3_gds_set_input_param
{ /* Set Device Status input parameter */
187 u8 function_num
; /* Function Number */
188 u8 hotkey_number
; /* Hotkey Number */
189 u16 devices
; /* Set Device */
190 u8 volume_value
; /* Volume Value */
191 } __attribute__((packed
));
193 struct wmid3_gds_get_input_param
{ /* Get Device Status input parameter */
194 u8 function_num
; /* Function Number */
195 u8 hotkey_number
; /* Hotkey Number */
196 u16 devices
; /* Get Device */
197 } __attribute__((packed
));
199 struct wmid3_gds_return_value
{ /* Get Device Status return value*/
200 u8 error_code
; /* Error Code */
201 u8 ec_return_value
; /* EC Return Value */
202 u16 devices
; /* Current Device Status */
204 } __attribute__((packed
));
206 struct hotkey_function_type_aa
{
210 u16 commun_func_bitmap
;
211 u16 application_func_bitmap
;
212 u16 media_func_bitmap
;
213 u16 display_func_bitmap
;
214 u16 others_func_bitmap
;
215 u8 commun_fn_key_number
;
216 } __attribute__((packed
));
219 * Interface capability flags
221 #define ACER_CAP_MAILLED (1<<0)
222 #define ACER_CAP_WIRELESS (1<<1)
223 #define ACER_CAP_BLUETOOTH (1<<2)
224 #define ACER_CAP_BRIGHTNESS (1<<3)
225 #define ACER_CAP_THREEG (1<<4)
226 #define ACER_CAP_ACCEL (1<<5)
227 #define ACER_CAP_RFBTN (1<<6)
228 #define ACER_CAP_ANY (0xFFFFFFFF)
231 * Interface type flags
233 enum interface_flags
{
240 #define ACER_DEFAULT_WIRELESS 0
241 #define ACER_DEFAULT_BLUETOOTH 0
242 #define ACER_DEFAULT_MAILLED 0
243 #define ACER_DEFAULT_THREEG 0
245 static int max_brightness
= 0xF;
247 static int mailled
= -1;
248 static int brightness
= -1;
249 static int threeg
= -1;
250 static int force_series
;
251 static bool ec_raw_mode
;
252 static bool has_type_aa
;
253 static u16 commun_func_bitmap
;
254 static u8 commun_fn_key_number
;
256 module_param(mailled
, int, 0444);
257 module_param(brightness
, int, 0444);
258 module_param(threeg
, int, 0444);
259 module_param(force_series
, int, 0444);
260 module_param(ec_raw_mode
, bool, 0444);
261 MODULE_PARM_DESC(mailled
, "Set initial state of Mail LED");
262 MODULE_PARM_DESC(brightness
, "Set initial LCD backlight brightness");
263 MODULE_PARM_DESC(threeg
, "Set initial state of 3G hardware");
264 MODULE_PARM_DESC(force_series
, "Force a different laptop series");
265 MODULE_PARM_DESC(ec_raw_mode
, "Enable EC raw mode");
275 struct dentry
*devices
;
279 static struct rfkill
*wireless_rfkill
;
280 static struct rfkill
*bluetooth_rfkill
;
281 static struct rfkill
*threeg_rfkill
;
282 static bool rfkill_inited
;
284 /* Each low-level interface must define at least some of the following */
285 struct wmi_interface
{
286 /* The WMI device type */
289 /* The capabilities this interface provides */
292 /* Private data for the current interface */
293 struct acer_data data
;
295 /* debugfs entries associated with this interface */
296 struct acer_debug debug
;
299 /* The static interface pointer, points to the currently detected interface */
300 static struct wmi_interface
*interface
;
303 * Embedded Controller quirks
304 * Some laptops require us to directly access the EC to either enable or query
305 * features that are not available through WMI.
315 static struct quirk_entry
*quirks
;
317 static void __init
set_quirks(void)
323 interface
->capability
|= ACER_CAP_MAILLED
;
325 if (quirks
->brightness
)
326 interface
->capability
|= ACER_CAP_BRIGHTNESS
;
329 static int __init
dmi_matched(const struct dmi_system_id
*dmi
)
331 quirks
= dmi
->driver_data
;
335 static struct quirk_entry quirk_unknown
= {
338 static struct quirk_entry quirk_acer_aspire_1520
= {
342 static struct quirk_entry quirk_acer_travelmate_2490
= {
346 /* This AMW0 laptop has no bluetooth */
347 static struct quirk_entry quirk_medion_md_98300
= {
351 static struct quirk_entry quirk_fujitsu_amilo_li_1718
= {
355 static struct quirk_entry quirk_lenovo_ideapad_s205
= {
359 /* The Aspire One has a dummy ACPI-WMI interface - disable it */
360 static const struct dmi_system_id acer_blacklist
[] __initconst
= {
362 .ident
= "Acer Aspire One (SSD)",
364 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
365 DMI_MATCH(DMI_PRODUCT_NAME
, "AOA110"),
369 .ident
= "Acer Aspire One (HDD)",
371 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
372 DMI_MATCH(DMI_PRODUCT_NAME
, "AOA150"),
378 static const struct dmi_system_id amw0_whitelist
[] __initconst
= {
382 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
388 DMI_MATCH(DMI_SYS_VENDOR
, "Gateway"),
392 .ident
= "Packard Bell",
394 DMI_MATCH(DMI_SYS_VENDOR
, "Packard Bell"),
401 * This quirk table is only for Acer/Gateway/Packard Bell family
402 * that those machines are supported by acer-wmi driver.
404 static const struct dmi_system_id acer_quirks
[] __initconst
= {
406 .callback
= dmi_matched
,
407 .ident
= "Acer Aspire 1360",
409 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
410 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 1360"),
412 .driver_data
= &quirk_acer_aspire_1520
,
415 .callback
= dmi_matched
,
416 .ident
= "Acer Aspire 1520",
418 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
419 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 1520"),
421 .driver_data
= &quirk_acer_aspire_1520
,
424 .callback
= dmi_matched
,
425 .ident
= "Acer Aspire 3100",
427 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
428 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 3100"),
430 .driver_data
= &quirk_acer_travelmate_2490
,
433 .callback
= dmi_matched
,
434 .ident
= "Acer Aspire 3610",
436 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
437 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 3610"),
439 .driver_data
= &quirk_acer_travelmate_2490
,
442 .callback
= dmi_matched
,
443 .ident
= "Acer Aspire 5100",
445 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
446 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5100"),
448 .driver_data
= &quirk_acer_travelmate_2490
,
451 .callback
= dmi_matched
,
452 .ident
= "Acer Aspire 5610",
454 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
455 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5610"),
457 .driver_data
= &quirk_acer_travelmate_2490
,
460 .callback
= dmi_matched
,
461 .ident
= "Acer Aspire 5630",
463 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
464 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5630"),
466 .driver_data
= &quirk_acer_travelmate_2490
,
469 .callback
= dmi_matched
,
470 .ident
= "Acer Aspire 5650",
472 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
473 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5650"),
475 .driver_data
= &quirk_acer_travelmate_2490
,
478 .callback
= dmi_matched
,
479 .ident
= "Acer Aspire 5680",
481 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
482 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5680"),
484 .driver_data
= &quirk_acer_travelmate_2490
,
487 .callback
= dmi_matched
,
488 .ident
= "Acer Aspire 9110",
490 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
491 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 9110"),
493 .driver_data
= &quirk_acer_travelmate_2490
,
496 .callback
= dmi_matched
,
497 .ident
= "Acer TravelMate 2490",
499 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
500 DMI_MATCH(DMI_PRODUCT_NAME
, "TravelMate 2490"),
502 .driver_data
= &quirk_acer_travelmate_2490
,
505 .callback
= dmi_matched
,
506 .ident
= "Acer TravelMate 4200",
508 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
509 DMI_MATCH(DMI_PRODUCT_NAME
, "TravelMate 4200"),
511 .driver_data
= &quirk_acer_travelmate_2490
,
517 * This quirk list is for those non-acer machines that have AMW0_GUID1
518 * but supported by acer-wmi in past days. Keeping this quirk list here
519 * is only for backward compatible. Please do not add new machine to
520 * here anymore. Those non-acer machines should be supported by
521 * appropriate wmi drivers.
523 static const struct dmi_system_id non_acer_quirks
[] __initconst
= {
525 .callback
= dmi_matched
,
526 .ident
= "Fujitsu Siemens Amilo Li 1718",
528 DMI_MATCH(DMI_SYS_VENDOR
, "FUJITSU SIEMENS"),
529 DMI_MATCH(DMI_PRODUCT_NAME
, "AMILO Li 1718"),
531 .driver_data
= &quirk_fujitsu_amilo_li_1718
,
534 .callback
= dmi_matched
,
535 .ident
= "Medion MD 98300",
537 DMI_MATCH(DMI_SYS_VENDOR
, "MEDION"),
538 DMI_MATCH(DMI_PRODUCT_NAME
, "WAM2030"),
540 .driver_data
= &quirk_medion_md_98300
,
543 .callback
= dmi_matched
,
544 .ident
= "Lenovo Ideapad S205",
546 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
547 DMI_MATCH(DMI_PRODUCT_NAME
, "10382LG"),
549 .driver_data
= &quirk_lenovo_ideapad_s205
,
552 .callback
= dmi_matched
,
553 .ident
= "Lenovo Ideapad S205 (Brazos)",
555 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
556 DMI_MATCH(DMI_PRODUCT_NAME
, "Brazos"),
558 .driver_data
= &quirk_lenovo_ideapad_s205
,
561 .callback
= dmi_matched
,
562 .ident
= "Lenovo 3000 N200",
564 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
565 DMI_MATCH(DMI_PRODUCT_NAME
, "0687A31"),
567 .driver_data
= &quirk_fujitsu_amilo_li_1718
,
570 .callback
= dmi_matched
,
571 .ident
= "Lenovo Ideapad S205-10382JG",
573 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
574 DMI_MATCH(DMI_PRODUCT_NAME
, "10382JG"),
576 .driver_data
= &quirk_lenovo_ideapad_s205
,
579 .callback
= dmi_matched
,
580 .ident
= "Lenovo Ideapad S205-1038DPG",
582 DMI_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
583 DMI_MATCH(DMI_PRODUCT_NAME
, "1038DPG"),
585 .driver_data
= &quirk_lenovo_ideapad_s205
,
591 video_set_backlight_video_vendor(const struct dmi_system_id
*d
)
593 interface
->capability
&= ~ACER_CAP_BRIGHTNESS
;
594 pr_info("Brightness must be controlled by generic video driver\n");
598 static const struct dmi_system_id video_vendor_dmi_table
[] __initconst
= {
600 .callback
= video_set_backlight_video_vendor
,
601 .ident
= "Acer TravelMate 4750",
603 DMI_MATCH(DMI_BOARD_VENDOR
, "Acer"),
604 DMI_MATCH(DMI_PRODUCT_NAME
, "TravelMate 4750"),
608 .callback
= video_set_backlight_video_vendor
,
609 .ident
= "Acer Extensa 5235",
611 DMI_MATCH(DMI_BOARD_VENDOR
, "Acer"),
612 DMI_MATCH(DMI_PRODUCT_NAME
, "Extensa 5235"),
616 .callback
= video_set_backlight_video_vendor
,
617 .ident
= "Acer TravelMate 5760",
619 DMI_MATCH(DMI_BOARD_VENDOR
, "Acer"),
620 DMI_MATCH(DMI_PRODUCT_NAME
, "TravelMate 5760"),
624 .callback
= video_set_backlight_video_vendor
,
625 .ident
= "Acer Aspire 5750",
627 DMI_MATCH(DMI_BOARD_VENDOR
, "Acer"),
628 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5750"),
632 .callback
= video_set_backlight_video_vendor
,
633 .ident
= "Acer Aspire 5741",
635 DMI_MATCH(DMI_BOARD_VENDOR
, "Acer"),
636 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 5741"),
641 * Note no video_set_backlight_video_vendor, we must use the
642 * acer interface, as there is no native backlight interface.
644 .ident
= "Acer KAV80",
646 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
647 DMI_MATCH(DMI_PRODUCT_NAME
, "KAV80"),
653 /* Find which quirks are needed for a particular vendor/ model pair */
654 static void __init
find_quirks(void)
657 dmi_check_system(acer_quirks
);
658 dmi_check_system(non_acer_quirks
);
659 } else if (force_series
== 2490) {
660 quirks
= &quirk_acer_travelmate_2490
;
664 quirks
= &quirk_unknown
;
670 * General interface convenience methods
673 static bool has_cap(u32 cap
)
675 if ((interface
->capability
& cap
) != 0)
682 * AMW0 (V1) interface
699 static acpi_status
wmab_execute(struct wmab_args
*regbuf
,
700 struct acpi_buffer
*result
)
702 struct acpi_buffer input
;
704 input
.length
= sizeof(struct wmab_args
);
705 input
.pointer
= (u8
*)regbuf
;
707 status
= wmi_evaluate_method(AMW0_GUID1
, 0, 1, &input
, result
);
712 static acpi_status
AMW0_get_u32(u32
*value
, u32 cap
)
718 case ACER_CAP_MAILLED
:
719 switch (quirks
->mailled
) {
721 err
= ec_read(0xA, &result
);
724 *value
= (result
>> 7) & 0x1;
728 case ACER_CAP_WIRELESS
:
729 switch (quirks
->wireless
) {
731 err
= ec_read(0x7B, &result
);
734 *value
= result
& 0x1;
737 err
= ec_read(0x71, &result
);
740 *value
= result
& 0x1;
743 err
= ec_read(0x78, &result
);
746 *value
= result
& 0x1;
749 err
= ec_read(0xA, &result
);
752 *value
= (result
>> 2) & 0x1;
756 case ACER_CAP_BLUETOOTH
:
757 switch (quirks
->bluetooth
) {
759 err
= ec_read(0xA, &result
);
762 *value
= (result
>> 4) & 0x1;
766 case ACER_CAP_BRIGHTNESS
:
767 switch (quirks
->brightness
) {
769 err
= ec_read(0x83, &result
);
782 static acpi_status
AMW0_set_u32(u32 value
, u32 cap
)
784 struct wmab_args args
;
786 args
.eax
= ACER_AMW0_WRITE
;
787 args
.ebx
= value
? (1<<8) : 0;
788 args
.ecx
= args
.edx
= 0;
791 case ACER_CAP_MAILLED
:
793 return AE_BAD_PARAMETER
;
794 args
.ebx
|= ACER_AMW0_MAILLED_MASK
;
796 case ACER_CAP_WIRELESS
:
798 return AE_BAD_PARAMETER
;
799 args
.ebx
|= ACER_AMW0_WIRELESS_MASK
;
801 case ACER_CAP_BLUETOOTH
:
803 return AE_BAD_PARAMETER
;
804 args
.ebx
|= ACER_AMW0_BLUETOOTH_MASK
;
806 case ACER_CAP_BRIGHTNESS
:
807 if (value
> max_brightness
)
808 return AE_BAD_PARAMETER
;
809 switch (quirks
->brightness
) {
811 return ec_write(0x83, value
);
818 /* Actually do the set */
819 return wmab_execute(&args
, NULL
);
822 static acpi_status __init
AMW0_find_mailled(void)
824 struct wmab_args args
;
826 acpi_status status
= AE_OK
;
827 struct acpi_buffer out
= { ACPI_ALLOCATE_BUFFER
, NULL
};
828 union acpi_object
*obj
;
831 args
.ebx
= args
.ecx
= args
.edx
= 0;
833 status
= wmab_execute(&args
, &out
);
834 if (ACPI_FAILURE(status
))
837 obj
= (union acpi_object
*) out
.pointer
;
838 if (obj
&& obj
->type
== ACPI_TYPE_BUFFER
&&
839 obj
->buffer
.length
== sizeof(struct wmab_ret
)) {
840 ret
= *((struct wmab_ret
*) obj
->buffer
.pointer
);
847 interface
->capability
|= ACER_CAP_MAILLED
;
854 static const struct acpi_device_id norfkill_ids
[] __initconst
= {
858 { "SNY5001", 0}, /* sony-laptop in charge */
863 static int __init
AMW0_set_cap_acpi_check_device(void)
865 const struct acpi_device_id
*id
;
867 for (id
= norfkill_ids
; id
->id
[0]; id
++)
868 if (acpi_dev_found(id
->id
))
874 static acpi_status __init
AMW0_set_capabilities(void)
876 struct wmab_args args
;
879 struct acpi_buffer out
= { ACPI_ALLOCATE_BUFFER
, NULL
};
880 union acpi_object
*obj
;
883 * On laptops with this strange GUID (non Acer), normal probing doesn't
886 if (wmi_has_guid(AMW0_GUID2
)) {
887 if ((quirks
!= &quirk_unknown
) ||
888 !AMW0_set_cap_acpi_check_device())
889 interface
->capability
|= ACER_CAP_WIRELESS
;
893 args
.eax
= ACER_AMW0_WRITE
;
894 args
.ecx
= args
.edx
= 0;
896 args
.ebx
= 0xa2 << 8;
897 args
.ebx
|= ACER_AMW0_WIRELESS_MASK
;
899 status
= wmab_execute(&args
, &out
);
900 if (ACPI_FAILURE(status
))
904 if (obj
&& obj
->type
== ACPI_TYPE_BUFFER
&&
905 obj
->buffer
.length
== sizeof(struct wmab_ret
)) {
906 ret
= *((struct wmab_ret
*) obj
->buffer
.pointer
);
913 interface
->capability
|= ACER_CAP_WIRELESS
;
916 args
.ebx
|= ACER_AMW0_BLUETOOTH_MASK
;
919 * It's ok to use existing buffer for next wmab_execute call.
920 * But we need to kfree(out.pointer) if next wmab_execute fail.
922 status
= wmab_execute(&args
, &out
);
923 if (ACPI_FAILURE(status
))
926 obj
= (union acpi_object
*) out
.pointer
;
927 if (obj
&& obj
->type
== ACPI_TYPE_BUFFER
928 && obj
->buffer
.length
== sizeof(struct wmab_ret
)) {
929 ret
= *((struct wmab_ret
*) obj
->buffer
.pointer
);
936 interface
->capability
|= ACER_CAP_BLUETOOTH
;
939 * This appears to be safe to enable, since all Wistron based laptops
940 * appear to use the same EC register for brightness, even if they
941 * differ for wireless, etc
943 if (quirks
->brightness
>= 0)
944 interface
->capability
|= ACER_CAP_BRIGHTNESS
;
952 static struct wmi_interface AMW0_interface
= {
956 static struct wmi_interface AMW0_V2_interface
= {
957 .type
= ACER_AMW0_V2
,
961 * New interface (The WMID interface)
964 WMI_execute_u32(u32 method_id
, u32 in
, u32
*out
)
966 struct acpi_buffer input
= { (acpi_size
) sizeof(u32
), (void *)(&in
) };
967 struct acpi_buffer result
= { ACPI_ALLOCATE_BUFFER
, NULL
};
968 union acpi_object
*obj
;
972 status
= wmi_evaluate_method(WMID_GUID1
, 0, method_id
, &input
, &result
);
974 if (ACPI_FAILURE(status
))
977 obj
= (union acpi_object
*) result
.pointer
;
979 if (obj
->type
== ACPI_TYPE_BUFFER
&&
980 (obj
->buffer
.length
== sizeof(u32
) ||
981 obj
->buffer
.length
== sizeof(u64
))) {
982 tmp
= *((u32
*) obj
->buffer
.pointer
);
983 } else if (obj
->type
== ACPI_TYPE_INTEGER
) {
984 tmp
= (u32
) obj
->integer
.value
;
991 kfree(result
.pointer
);
996 static acpi_status
WMID_get_u32(u32
*value
, u32 cap
)
1000 u32 result
, method_id
= 0;
1003 case ACER_CAP_WIRELESS
:
1004 method_id
= ACER_WMID_GET_WIRELESS_METHODID
;
1006 case ACER_CAP_BLUETOOTH
:
1007 method_id
= ACER_WMID_GET_BLUETOOTH_METHODID
;
1009 case ACER_CAP_BRIGHTNESS
:
1010 method_id
= ACER_WMID_GET_BRIGHTNESS_METHODID
;
1012 case ACER_CAP_THREEG
:
1013 method_id
= ACER_WMID_GET_THREEG_METHODID
;
1015 case ACER_CAP_MAILLED
:
1016 if (quirks
->mailled
== 1) {
1017 ec_read(0x9f, &tmp
);
1024 status
= WMI_execute_u32(method_id
, 0, &result
);
1026 if (ACPI_SUCCESS(status
))
1027 *value
= (u8
)result
;
1032 static acpi_status
WMID_set_u32(u32 value
, u32 cap
)
1038 case ACER_CAP_BRIGHTNESS
:
1039 if (value
> max_brightness
)
1040 return AE_BAD_PARAMETER
;
1041 method_id
= ACER_WMID_SET_BRIGHTNESS_METHODID
;
1043 case ACER_CAP_WIRELESS
:
1045 return AE_BAD_PARAMETER
;
1046 method_id
= ACER_WMID_SET_WIRELESS_METHODID
;
1048 case ACER_CAP_BLUETOOTH
:
1050 return AE_BAD_PARAMETER
;
1051 method_id
= ACER_WMID_SET_BLUETOOTH_METHODID
;
1053 case ACER_CAP_THREEG
:
1055 return AE_BAD_PARAMETER
;
1056 method_id
= ACER_WMID_SET_THREEG_METHODID
;
1058 case ACER_CAP_MAILLED
:
1060 return AE_BAD_PARAMETER
;
1061 if (quirks
->mailled
== 1) {
1062 param
= value
? 0x92 : 0x93;
1064 i8042_command(¶m
, 0x1059);
1065 i8042_unlock_chip();
1072 return WMI_execute_u32(method_id
, (u32
)value
, NULL
);
1075 static acpi_status
wmid3_get_device_status(u32
*value
, u16 device
)
1077 struct wmid3_gds_return_value return_value
;
1079 union acpi_object
*obj
;
1080 struct wmid3_gds_get_input_param params
= {
1081 .function_num
= 0x1,
1082 .hotkey_number
= commun_fn_key_number
,
1085 struct acpi_buffer input
= {
1086 sizeof(struct wmid3_gds_get_input_param
),
1089 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1091 status
= wmi_evaluate_method(WMID_GUID3
, 0, 0x2, &input
, &output
);
1092 if (ACPI_FAILURE(status
))
1095 obj
= output
.pointer
;
1099 else if (obj
->type
!= ACPI_TYPE_BUFFER
) {
1103 if (obj
->buffer
.length
!= 8) {
1104 pr_warn("Unknown buffer length %d\n", obj
->buffer
.length
);
1109 return_value
= *((struct wmid3_gds_return_value
*)obj
->buffer
.pointer
);
1112 if (return_value
.error_code
|| return_value
.ec_return_value
)
1113 pr_warn("Get 0x%x Device Status failed: 0x%x - 0x%x\n",
1115 return_value
.error_code
,
1116 return_value
.ec_return_value
);
1118 *value
= !!(return_value
.devices
& device
);
1123 static acpi_status
wmid_v2_get_u32(u32
*value
, u32 cap
)
1128 case ACER_CAP_WIRELESS
:
1129 device
= ACER_WMID3_GDS_WIRELESS
;
1131 case ACER_CAP_BLUETOOTH
:
1132 device
= ACER_WMID3_GDS_BLUETOOTH
;
1134 case ACER_CAP_THREEG
:
1135 device
= ACER_WMID3_GDS_THREEG
;
1140 return wmid3_get_device_status(value
, device
);
1143 static acpi_status
wmid3_set_device_status(u32 value
, u16 device
)
1145 struct wmid3_gds_return_value return_value
;
1147 union acpi_object
*obj
;
1149 struct wmid3_gds_get_input_param get_params
= {
1150 .function_num
= 0x1,
1151 .hotkey_number
= commun_fn_key_number
,
1152 .devices
= commun_func_bitmap
,
1154 struct acpi_buffer get_input
= {
1155 sizeof(struct wmid3_gds_get_input_param
),
1158 struct wmid3_gds_set_input_param set_params
= {
1159 .function_num
= 0x2,
1160 .hotkey_number
= commun_fn_key_number
,
1161 .devices
= commun_func_bitmap
,
1163 struct acpi_buffer set_input
= {
1164 sizeof(struct wmid3_gds_set_input_param
),
1167 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1168 struct acpi_buffer output2
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1170 status
= wmi_evaluate_method(WMID_GUID3
, 0, 0x2, &get_input
, &output
);
1171 if (ACPI_FAILURE(status
))
1174 obj
= output
.pointer
;
1178 else if (obj
->type
!= ACPI_TYPE_BUFFER
) {
1182 if (obj
->buffer
.length
!= 8) {
1183 pr_warn("Unknown buffer length %d\n", obj
->buffer
.length
);
1188 return_value
= *((struct wmid3_gds_return_value
*)obj
->buffer
.pointer
);
1191 if (return_value
.error_code
|| return_value
.ec_return_value
) {
1192 pr_warn("Get Current Device Status failed: 0x%x - 0x%x\n",
1193 return_value
.error_code
,
1194 return_value
.ec_return_value
);
1198 devices
= return_value
.devices
;
1199 set_params
.devices
= (value
) ? (devices
| device
) : (devices
& ~device
);
1201 status
= wmi_evaluate_method(WMID_GUID3
, 0, 0x1, &set_input
, &output2
);
1202 if (ACPI_FAILURE(status
))
1205 obj
= output2
.pointer
;
1209 else if (obj
->type
!= ACPI_TYPE_BUFFER
) {
1213 if (obj
->buffer
.length
!= 4) {
1214 pr_warn("Unknown buffer length %d\n", obj
->buffer
.length
);
1219 return_value
= *((struct wmid3_gds_return_value
*)obj
->buffer
.pointer
);
1222 if (return_value
.error_code
|| return_value
.ec_return_value
)
1223 pr_warn("Set Device Status failed: 0x%x - 0x%x\n",
1224 return_value
.error_code
,
1225 return_value
.ec_return_value
);
1230 static acpi_status
wmid_v2_set_u32(u32 value
, u32 cap
)
1235 case ACER_CAP_WIRELESS
:
1236 device
= ACER_WMID3_GDS_WIRELESS
;
1238 case ACER_CAP_BLUETOOTH
:
1239 device
= ACER_WMID3_GDS_BLUETOOTH
;
1241 case ACER_CAP_THREEG
:
1242 device
= ACER_WMID3_GDS_THREEG
;
1247 return wmid3_set_device_status(value
, device
);
1250 static void __init
type_aa_dmi_decode(const struct dmi_header
*header
, void *d
)
1252 struct hotkey_function_type_aa
*type_aa
;
1254 /* We are looking for OEM-specific Type AAh */
1255 if (header
->type
!= 0xAA)
1259 type_aa
= (struct hotkey_function_type_aa
*) header
;
1261 pr_info("Function bitmap for Communication Button: 0x%x\n",
1262 type_aa
->commun_func_bitmap
);
1263 commun_func_bitmap
= type_aa
->commun_func_bitmap
;
1265 if (type_aa
->commun_func_bitmap
& ACER_WMID3_GDS_WIRELESS
)
1266 interface
->capability
|= ACER_CAP_WIRELESS
;
1267 if (type_aa
->commun_func_bitmap
& ACER_WMID3_GDS_THREEG
)
1268 interface
->capability
|= ACER_CAP_THREEG
;
1269 if (type_aa
->commun_func_bitmap
& ACER_WMID3_GDS_BLUETOOTH
)
1270 interface
->capability
|= ACER_CAP_BLUETOOTH
;
1271 if (type_aa
->commun_func_bitmap
& ACER_WMID3_GDS_RFBTN
) {
1272 interface
->capability
|= ACER_CAP_RFBTN
;
1273 commun_func_bitmap
&= ~ACER_WMID3_GDS_RFBTN
;
1276 commun_fn_key_number
= type_aa
->commun_fn_key_number
;
1279 static acpi_status __init
WMID_set_capabilities(void)
1281 struct acpi_buffer out
= {ACPI_ALLOCATE_BUFFER
, NULL
};
1282 union acpi_object
*obj
;
1286 status
= wmi_query_block(WMID_GUID2
, 0, &out
);
1287 if (ACPI_FAILURE(status
))
1290 obj
= (union acpi_object
*) out
.pointer
;
1292 if (obj
->type
== ACPI_TYPE_BUFFER
&&
1293 (obj
->buffer
.length
== sizeof(u32
) ||
1294 obj
->buffer
.length
== sizeof(u64
))) {
1295 devices
= *((u32
*) obj
->buffer
.pointer
);
1296 } else if (obj
->type
== ACPI_TYPE_INTEGER
) {
1297 devices
= (u32
) obj
->integer
.value
;
1307 pr_info("Function bitmap for Communication Device: 0x%x\n", devices
);
1309 interface
->capability
|= ACER_CAP_WIRELESS
;
1311 interface
->capability
|= ACER_CAP_THREEG
;
1313 interface
->capability
|= ACER_CAP_BLUETOOTH
;
1315 if (!(devices
& 0x20))
1316 max_brightness
= 0x9;
1322 static struct wmi_interface wmid_interface
= {
1326 static struct wmi_interface wmid_v2_interface
= {
1327 .type
= ACER_WMID_v2
,
1331 * Generic Device (interface-independent)
1334 static acpi_status
get_u32(u32
*value
, u32 cap
)
1336 acpi_status status
= AE_ERROR
;
1338 switch (interface
->type
) {
1340 status
= AMW0_get_u32(value
, cap
);
1343 if (cap
== ACER_CAP_MAILLED
) {
1344 status
= AMW0_get_u32(value
, cap
);
1348 status
= WMID_get_u32(value
, cap
);
1351 if (cap
& (ACER_CAP_WIRELESS
|
1352 ACER_CAP_BLUETOOTH
|
1354 status
= wmid_v2_get_u32(value
, cap
);
1355 else if (wmi_has_guid(WMID_GUID2
))
1356 status
= WMID_get_u32(value
, cap
);
1363 static acpi_status
set_u32(u32 value
, u32 cap
)
1367 if (interface
->capability
& cap
) {
1368 switch (interface
->type
) {
1370 return AMW0_set_u32(value
, cap
);
1372 if (cap
== ACER_CAP_MAILLED
)
1373 return AMW0_set_u32(value
, cap
);
1376 * On some models, some WMID methods don't toggle
1377 * properly. For those cases, we want to run the AMW0
1378 * method afterwards to be certain we've really toggled
1381 if (cap
== ACER_CAP_WIRELESS
||
1382 cap
== ACER_CAP_BLUETOOTH
) {
1383 status
= WMID_set_u32(value
, cap
);
1384 if (ACPI_FAILURE(status
))
1387 return AMW0_set_u32(value
, cap
);
1390 return WMID_set_u32(value
, cap
);
1392 if (cap
& (ACER_CAP_WIRELESS
|
1393 ACER_CAP_BLUETOOTH
|
1395 return wmid_v2_set_u32(value
, cap
);
1396 else if (wmi_has_guid(WMID_GUID2
))
1397 return WMID_set_u32(value
, cap
);
1399 return AE_BAD_PARAMETER
;
1402 return AE_BAD_PARAMETER
;
1405 static void __init
acer_commandline_init(void)
1408 * These will all fail silently if the value given is invalid, or the
1409 * capability isn't available on the given interface
1412 set_u32(mailled
, ACER_CAP_MAILLED
);
1413 if (!has_type_aa
&& threeg
>= 0)
1414 set_u32(threeg
, ACER_CAP_THREEG
);
1415 if (brightness
>= 0)
1416 set_u32(brightness
, ACER_CAP_BRIGHTNESS
);
1420 * LED device (Mail LED only, no other LEDs known yet)
1422 static void mail_led_set(struct led_classdev
*led_cdev
,
1423 enum led_brightness value
)
1425 set_u32(value
, ACER_CAP_MAILLED
);
1428 static struct led_classdev mail_led
= {
1429 .name
= "acer-wmi::mail",
1430 .brightness_set
= mail_led_set
,
1433 static int acer_led_init(struct device
*dev
)
1435 return led_classdev_register(dev
, &mail_led
);
1438 static void acer_led_exit(void)
1440 set_u32(LED_OFF
, ACER_CAP_MAILLED
);
1441 led_classdev_unregister(&mail_led
);
1447 static struct backlight_device
*acer_backlight_device
;
1449 static int read_brightness(struct backlight_device
*bd
)
1452 get_u32(&value
, ACER_CAP_BRIGHTNESS
);
1456 static int update_bl_status(struct backlight_device
*bd
)
1458 int intensity
= bd
->props
.brightness
;
1460 if (bd
->props
.power
!= FB_BLANK_UNBLANK
)
1462 if (bd
->props
.fb_blank
!= FB_BLANK_UNBLANK
)
1465 set_u32(intensity
, ACER_CAP_BRIGHTNESS
);
1470 static const struct backlight_ops acer_bl_ops
= {
1471 .get_brightness
= read_brightness
,
1472 .update_status
= update_bl_status
,
1475 static int acer_backlight_init(struct device
*dev
)
1477 struct backlight_properties props
;
1478 struct backlight_device
*bd
;
1480 memset(&props
, 0, sizeof(struct backlight_properties
));
1481 props
.type
= BACKLIGHT_PLATFORM
;
1482 props
.max_brightness
= max_brightness
;
1483 bd
= backlight_device_register("acer-wmi", dev
, NULL
, &acer_bl_ops
,
1486 pr_err("Could not register Acer backlight device\n");
1487 acer_backlight_device
= NULL
;
1491 acer_backlight_device
= bd
;
1493 bd
->props
.power
= FB_BLANK_UNBLANK
;
1494 bd
->props
.brightness
= read_brightness(bd
);
1495 backlight_update_status(bd
);
1499 static void acer_backlight_exit(void)
1501 backlight_device_unregister(acer_backlight_device
);
1505 * Accelerometer device
1507 static acpi_handle gsensor_handle
;
1509 static int acer_gsensor_init(void)
1512 struct acpi_buffer output
;
1513 union acpi_object out_obj
;
1515 output
.length
= sizeof(out_obj
);
1516 output
.pointer
= &out_obj
;
1517 status
= acpi_evaluate_object(gsensor_handle
, "_INI", NULL
, &output
);
1518 if (ACPI_FAILURE(status
))
1524 static int acer_gsensor_open(struct input_dev
*input
)
1526 return acer_gsensor_init();
1529 static int acer_gsensor_event(void)
1532 struct acpi_buffer output
;
1533 union acpi_object out_obj
[5];
1535 if (!has_cap(ACER_CAP_ACCEL
))
1538 output
.length
= sizeof(out_obj
);
1539 output
.pointer
= out_obj
;
1541 status
= acpi_evaluate_object(gsensor_handle
, "RDVL", NULL
, &output
);
1542 if (ACPI_FAILURE(status
))
1545 if (out_obj
->package
.count
!= 4)
1548 input_report_abs(acer_wmi_accel_dev
, ABS_X
,
1549 (s16
)out_obj
->package
.elements
[0].integer
.value
);
1550 input_report_abs(acer_wmi_accel_dev
, ABS_Y
,
1551 (s16
)out_obj
->package
.elements
[1].integer
.value
);
1552 input_report_abs(acer_wmi_accel_dev
, ABS_Z
,
1553 (s16
)out_obj
->package
.elements
[2].integer
.value
);
1554 input_sync(acer_wmi_accel_dev
);
1561 static void acer_rfkill_update(struct work_struct
*ignored
);
1562 static DECLARE_DELAYED_WORK(acer_rfkill_work
, acer_rfkill_update
);
1563 static void acer_rfkill_update(struct work_struct
*ignored
)
1568 if (has_cap(ACER_CAP_WIRELESS
)) {
1569 status
= get_u32(&state
, ACER_CAP_WIRELESS
);
1570 if (ACPI_SUCCESS(status
)) {
1571 if (quirks
->wireless
== 3)
1572 rfkill_set_hw_state(wireless_rfkill
, !state
);
1574 rfkill_set_sw_state(wireless_rfkill
, !state
);
1578 if (has_cap(ACER_CAP_BLUETOOTH
)) {
1579 status
= get_u32(&state
, ACER_CAP_BLUETOOTH
);
1580 if (ACPI_SUCCESS(status
))
1581 rfkill_set_sw_state(bluetooth_rfkill
, !state
);
1584 if (has_cap(ACER_CAP_THREEG
) && wmi_has_guid(WMID_GUID3
)) {
1585 status
= get_u32(&state
, ACER_WMID3_GDS_THREEG
);
1586 if (ACPI_SUCCESS(status
))
1587 rfkill_set_sw_state(threeg_rfkill
, !state
);
1590 schedule_delayed_work(&acer_rfkill_work
, round_jiffies_relative(HZ
));
1593 static int acer_rfkill_set(void *data
, bool blocked
)
1596 u32 cap
= (unsigned long)data
;
1598 if (rfkill_inited
) {
1599 status
= set_u32(!blocked
, cap
);
1600 if (ACPI_FAILURE(status
))
1607 static const struct rfkill_ops acer_rfkill_ops
= {
1608 .set_block
= acer_rfkill_set
,
1611 static struct rfkill
*acer_rfkill_register(struct device
*dev
,
1612 enum rfkill_type type
,
1613 char *name
, u32 cap
)
1616 struct rfkill
*rfkill_dev
;
1620 rfkill_dev
= rfkill_alloc(name
, dev
, type
,
1622 (void *)(unsigned long)cap
);
1624 return ERR_PTR(-ENOMEM
);
1626 status
= get_u32(&state
, cap
);
1628 err
= rfkill_register(rfkill_dev
);
1630 rfkill_destroy(rfkill_dev
);
1631 return ERR_PTR(err
);
1634 if (ACPI_SUCCESS(status
))
1635 rfkill_set_sw_state(rfkill_dev
, !state
);
1640 static int acer_rfkill_init(struct device
*dev
)
1644 if (has_cap(ACER_CAP_WIRELESS
)) {
1645 wireless_rfkill
= acer_rfkill_register(dev
, RFKILL_TYPE_WLAN
,
1646 "acer-wireless", ACER_CAP_WIRELESS
);
1647 if (IS_ERR(wireless_rfkill
)) {
1648 err
= PTR_ERR(wireless_rfkill
);
1649 goto error_wireless
;
1653 if (has_cap(ACER_CAP_BLUETOOTH
)) {
1654 bluetooth_rfkill
= acer_rfkill_register(dev
,
1655 RFKILL_TYPE_BLUETOOTH
, "acer-bluetooth",
1656 ACER_CAP_BLUETOOTH
);
1657 if (IS_ERR(bluetooth_rfkill
)) {
1658 err
= PTR_ERR(bluetooth_rfkill
);
1659 goto error_bluetooth
;
1663 if (has_cap(ACER_CAP_THREEG
)) {
1664 threeg_rfkill
= acer_rfkill_register(dev
,
1665 RFKILL_TYPE_WWAN
, "acer-threeg",
1667 if (IS_ERR(threeg_rfkill
)) {
1668 err
= PTR_ERR(threeg_rfkill
);
1673 rfkill_inited
= true;
1675 if ((ec_raw_mode
|| !wmi_has_guid(ACERWMID_EVENT_GUID
)) &&
1676 has_cap(ACER_CAP_WIRELESS
| ACER_CAP_BLUETOOTH
| ACER_CAP_THREEG
))
1677 schedule_delayed_work(&acer_rfkill_work
,
1678 round_jiffies_relative(HZ
));
1683 if (has_cap(ACER_CAP_BLUETOOTH
)) {
1684 rfkill_unregister(bluetooth_rfkill
);
1685 rfkill_destroy(bluetooth_rfkill
);
1688 if (has_cap(ACER_CAP_WIRELESS
)) {
1689 rfkill_unregister(wireless_rfkill
);
1690 rfkill_destroy(wireless_rfkill
);
1696 static void acer_rfkill_exit(void)
1698 if ((ec_raw_mode
|| !wmi_has_guid(ACERWMID_EVENT_GUID
)) &&
1699 has_cap(ACER_CAP_WIRELESS
| ACER_CAP_BLUETOOTH
| ACER_CAP_THREEG
))
1700 cancel_delayed_work_sync(&acer_rfkill_work
);
1702 if (has_cap(ACER_CAP_WIRELESS
)) {
1703 rfkill_unregister(wireless_rfkill
);
1704 rfkill_destroy(wireless_rfkill
);
1707 if (has_cap(ACER_CAP_BLUETOOTH
)) {
1708 rfkill_unregister(bluetooth_rfkill
);
1709 rfkill_destroy(bluetooth_rfkill
);
1712 if (has_cap(ACER_CAP_THREEG
)) {
1713 rfkill_unregister(threeg_rfkill
);
1714 rfkill_destroy(threeg_rfkill
);
1719 static void acer_wmi_notify(u32 value
, void *context
)
1721 struct acpi_buffer response
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1722 union acpi_object
*obj
;
1723 struct event_return_value return_value
;
1726 const struct key_entry
*key
;
1729 status
= wmi_get_event_data(value
, &response
);
1730 if (status
!= AE_OK
) {
1731 pr_warn("bad event status 0x%x\n", status
);
1735 obj
= (union acpi_object
*)response
.pointer
;
1739 if (obj
->type
!= ACPI_TYPE_BUFFER
) {
1740 pr_warn("Unknown response received %d\n", obj
->type
);
1744 if (obj
->buffer
.length
!= 8) {
1745 pr_warn("Unknown buffer length %d\n", obj
->buffer
.length
);
1750 return_value
= *((struct event_return_value
*)obj
->buffer
.pointer
);
1753 switch (return_value
.function
) {
1754 case WMID_HOTKEY_EVENT
:
1755 device_state
= return_value
.device_state
;
1756 pr_debug("device state: 0x%x\n", device_state
);
1758 key
= sparse_keymap_entry_from_scancode(acer_wmi_input_dev
,
1759 return_value
.key_num
);
1761 pr_warn("Unknown key number - 0x%x\n",
1762 return_value
.key_num
);
1764 scancode
= return_value
.key_num
;
1765 switch (key
->keycode
) {
1768 if (has_cap(ACER_CAP_WIRELESS
))
1769 rfkill_set_sw_state(wireless_rfkill
,
1770 !(device_state
& ACER_WMID3_GDS_WIRELESS
));
1771 if (has_cap(ACER_CAP_THREEG
))
1772 rfkill_set_sw_state(threeg_rfkill
,
1773 !(device_state
& ACER_WMID3_GDS_THREEG
));
1774 if (has_cap(ACER_CAP_BLUETOOTH
))
1775 rfkill_set_sw_state(bluetooth_rfkill
,
1776 !(device_state
& ACER_WMID3_GDS_BLUETOOTH
));
1778 case KEY_TOUCHPAD_TOGGLE
:
1779 scancode
= (device_state
& ACER_WMID3_GDS_TOUCHPAD
) ?
1780 KEY_TOUCHPAD_ON
: KEY_TOUCHPAD_OFF
;
1782 sparse_keymap_report_event(acer_wmi_input_dev
, scancode
, 1, true);
1785 case WMID_ACCEL_EVENT
:
1786 acer_gsensor_event();
1789 pr_warn("Unknown function number - %d - %d\n",
1790 return_value
.function
, return_value
.key_num
);
1795 static acpi_status __init
1796 wmid3_set_function_mode(struct func_input_params
*params
,
1797 struct func_return_value
*return_value
)
1800 union acpi_object
*obj
;
1802 struct acpi_buffer input
= { sizeof(struct func_input_params
), params
};
1803 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1805 status
= wmi_evaluate_method(WMID_GUID3
, 0, 0x1, &input
, &output
);
1806 if (ACPI_FAILURE(status
))
1809 obj
= output
.pointer
;
1813 else if (obj
->type
!= ACPI_TYPE_BUFFER
) {
1817 if (obj
->buffer
.length
!= 4) {
1818 pr_warn("Unknown buffer length %d\n", obj
->buffer
.length
);
1823 *return_value
= *((struct func_return_value
*)obj
->buffer
.pointer
);
1829 static int __init
acer_wmi_enable_ec_raw(void)
1831 struct func_return_value return_value
;
1833 struct func_input_params params
= {
1834 .function_num
= 0x1,
1835 .commun_devices
= 0xFFFF,
1837 .app_status
= 0x00, /* Launch Manager Deactive */
1841 status
= wmid3_set_function_mode(¶ms
, &return_value
);
1843 if (return_value
.error_code
|| return_value
.ec_return_value
)
1844 pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
1845 return_value
.error_code
,
1846 return_value
.ec_return_value
);
1848 pr_info("Enabled EC raw mode\n");
1853 static int __init
acer_wmi_enable_lm(void)
1855 struct func_return_value return_value
;
1857 struct func_input_params params
= {
1858 .function_num
= 0x1,
1859 .commun_devices
= 0xFFFF,
1861 .app_status
= 0x01, /* Launch Manager Active */
1865 status
= wmid3_set_function_mode(¶ms
, &return_value
);
1867 if (return_value
.error_code
|| return_value
.ec_return_value
)
1868 pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
1869 return_value
.error_code
,
1870 return_value
.ec_return_value
);
1875 static int __init
acer_wmi_enable_rf_button(void)
1877 struct func_return_value return_value
;
1879 struct func_input_params params
= {
1880 .function_num
= 0x1,
1881 .commun_devices
= 0xFFFF,
1883 .app_status
= 0x10, /* RF Button Active */
1887 status
= wmid3_set_function_mode(¶ms
, &return_value
);
1889 if (return_value
.error_code
|| return_value
.ec_return_value
)
1890 pr_warn("Enabling RF Button failed: 0x%x - 0x%x\n",
1891 return_value
.error_code
,
1892 return_value
.ec_return_value
);
1897 #define ACER_WMID_ACCEL_HID "BST0001"
1899 static acpi_status __init
acer_wmi_get_handle_cb(acpi_handle ah
, u32 level
,
1900 void *ctx
, void **retval
)
1902 struct acpi_device
*dev
;
1904 if (!strcmp(ctx
, "SENR")) {
1905 if (acpi_bus_get_device(ah
, &dev
))
1907 if (strcmp(ACER_WMID_ACCEL_HID
, acpi_device_hid(dev
)))
1912 *(acpi_handle
*)retval
= ah
;
1914 return AE_CTRL_TERMINATE
;
1917 static int __init
acer_wmi_get_handle(const char *name
, const char *prop
,
1923 BUG_ON(!name
|| !ah
);
1926 status
= acpi_get_devices(prop
, acer_wmi_get_handle_cb
,
1927 (void *)name
, &handle
);
1928 if (ACPI_SUCCESS(status
) && handle
) {
1936 static int __init
acer_wmi_accel_setup(void)
1940 err
= acer_wmi_get_handle("SENR", ACER_WMID_ACCEL_HID
, &gsensor_handle
);
1944 interface
->capability
|= ACER_CAP_ACCEL
;
1946 acer_wmi_accel_dev
= input_allocate_device();
1947 if (!acer_wmi_accel_dev
)
1950 acer_wmi_accel_dev
->open
= acer_gsensor_open
;
1952 acer_wmi_accel_dev
->name
= "Acer BMA150 accelerometer";
1953 acer_wmi_accel_dev
->phys
= "wmi/input1";
1954 acer_wmi_accel_dev
->id
.bustype
= BUS_HOST
;
1955 acer_wmi_accel_dev
->evbit
[0] = BIT_MASK(EV_ABS
);
1956 input_set_abs_params(acer_wmi_accel_dev
, ABS_X
, -16384, 16384, 0, 0);
1957 input_set_abs_params(acer_wmi_accel_dev
, ABS_Y
, -16384, 16384, 0, 0);
1958 input_set_abs_params(acer_wmi_accel_dev
, ABS_Z
, -16384, 16384, 0, 0);
1960 err
= input_register_device(acer_wmi_accel_dev
);
1967 input_free_device(acer_wmi_accel_dev
);
1971 static void acer_wmi_accel_destroy(void)
1973 input_unregister_device(acer_wmi_accel_dev
);
1976 static int __init
acer_wmi_input_setup(void)
1981 acer_wmi_input_dev
= input_allocate_device();
1982 if (!acer_wmi_input_dev
)
1985 acer_wmi_input_dev
->name
= "Acer WMI hotkeys";
1986 acer_wmi_input_dev
->phys
= "wmi/input0";
1987 acer_wmi_input_dev
->id
.bustype
= BUS_HOST
;
1989 err
= sparse_keymap_setup(acer_wmi_input_dev
, acer_wmi_keymap
, NULL
);
1993 status
= wmi_install_notify_handler(ACERWMID_EVENT_GUID
,
1994 acer_wmi_notify
, NULL
);
1995 if (ACPI_FAILURE(status
)) {
2000 err
= input_register_device(acer_wmi_input_dev
);
2002 goto err_uninstall_notifier
;
2006 err_uninstall_notifier
:
2007 wmi_remove_notify_handler(ACERWMID_EVENT_GUID
);
2009 input_free_device(acer_wmi_input_dev
);
2013 static void acer_wmi_input_destroy(void)
2015 wmi_remove_notify_handler(ACERWMID_EVENT_GUID
);
2016 input_unregister_device(acer_wmi_input_dev
);
2022 static u32
get_wmid_devices(void)
2024 struct acpi_buffer out
= {ACPI_ALLOCATE_BUFFER
, NULL
};
2025 union acpi_object
*obj
;
2029 status
= wmi_query_block(WMID_GUID2
, 0, &out
);
2030 if (ACPI_FAILURE(status
))
2033 obj
= (union acpi_object
*) out
.pointer
;
2035 if (obj
->type
== ACPI_TYPE_BUFFER
&&
2036 (obj
->buffer
.length
== sizeof(u32
) ||
2037 obj
->buffer
.length
== sizeof(u64
))) {
2038 devices
= *((u32
*) obj
->buffer
.pointer
);
2039 } else if (obj
->type
== ACPI_TYPE_INTEGER
) {
2040 devices
= (u32
) obj
->integer
.value
;
2051 static int acer_platform_probe(struct platform_device
*device
)
2055 if (has_cap(ACER_CAP_MAILLED
)) {
2056 err
= acer_led_init(&device
->dev
);
2061 if (has_cap(ACER_CAP_BRIGHTNESS
)) {
2062 err
= acer_backlight_init(&device
->dev
);
2064 goto error_brightness
;
2067 err
= acer_rfkill_init(&device
->dev
);
2074 if (has_cap(ACER_CAP_BRIGHTNESS
))
2075 acer_backlight_exit();
2077 if (has_cap(ACER_CAP_MAILLED
))
2083 static int acer_platform_remove(struct platform_device
*device
)
2085 if (has_cap(ACER_CAP_MAILLED
))
2087 if (has_cap(ACER_CAP_BRIGHTNESS
))
2088 acer_backlight_exit();
2094 #ifdef CONFIG_PM_SLEEP
2095 static int acer_suspend(struct device
*dev
)
2098 struct acer_data
*data
= &interface
->data
;
2103 if (has_cap(ACER_CAP_MAILLED
)) {
2104 get_u32(&value
, ACER_CAP_MAILLED
);
2105 set_u32(LED_OFF
, ACER_CAP_MAILLED
);
2106 data
->mailled
= value
;
2109 if (has_cap(ACER_CAP_BRIGHTNESS
)) {
2110 get_u32(&value
, ACER_CAP_BRIGHTNESS
);
2111 data
->brightness
= value
;
2117 static int acer_resume(struct device
*dev
)
2119 struct acer_data
*data
= &interface
->data
;
2124 if (has_cap(ACER_CAP_MAILLED
))
2125 set_u32(data
->mailled
, ACER_CAP_MAILLED
);
2127 if (has_cap(ACER_CAP_BRIGHTNESS
))
2128 set_u32(data
->brightness
, ACER_CAP_BRIGHTNESS
);
2130 if (has_cap(ACER_CAP_ACCEL
))
2131 acer_gsensor_init();
2136 #define acer_suspend NULL
2137 #define acer_resume NULL
2140 static SIMPLE_DEV_PM_OPS(acer_pm
, acer_suspend
, acer_resume
);
2142 static void acer_platform_shutdown(struct platform_device
*device
)
2144 struct acer_data
*data
= &interface
->data
;
2149 if (has_cap(ACER_CAP_MAILLED
))
2150 set_u32(LED_OFF
, ACER_CAP_MAILLED
);
2153 static struct platform_driver acer_platform_driver
= {
2158 .probe
= acer_platform_probe
,
2159 .remove
= acer_platform_remove
,
2160 .shutdown
= acer_platform_shutdown
,
2163 static struct platform_device
*acer_platform_device
;
2165 static void remove_debugfs(void)
2167 debugfs_remove(interface
->debug
.devices
);
2168 debugfs_remove(interface
->debug
.root
);
2171 static int __init
create_debugfs(void)
2173 interface
->debug
.root
= debugfs_create_dir("acer-wmi", NULL
);
2174 if (!interface
->debug
.root
) {
2175 pr_err("Failed to create debugfs directory");
2179 interface
->debug
.devices
= debugfs_create_u32("devices", S_IRUGO
,
2180 interface
->debug
.root
,
2181 &interface
->debug
.wmid_devices
);
2182 if (!interface
->debug
.devices
)
2192 static int __init
acer_wmi_init(void)
2196 pr_info("Acer Laptop ACPI-WMI Extras\n");
2198 if (dmi_check_system(acer_blacklist
)) {
2199 pr_info("Blacklisted hardware detected - not loading\n");
2206 * The AMW0_GUID1 wmi is not only found on Acer family but also other
2207 * machines like Lenovo, Fujitsu and Medion. In the past days,
2208 * acer-wmi driver handled those non-Acer machines by quirks list.
2209 * But actually acer-wmi driver was loaded on any machines that have
2210 * AMW0_GUID1. This behavior is strange because those machines should
2211 * be supported by appropriate wmi drivers. e.g. fujitsu-laptop,
2212 * ideapad-laptop. So, here checks the machine that has AMW0_GUID1
2213 * should be in Acer/Gateway/Packard Bell white list, or it's already
2214 * in the past quirk list.
2216 if (wmi_has_guid(AMW0_GUID1
) &&
2217 !dmi_check_system(amw0_whitelist
) &&
2218 quirks
== &quirk_unknown
) {
2219 pr_err("Unsupported machine has AMW0_GUID1, unable to load\n");
2224 * Detect which ACPI-WMI interface we're using.
2226 if (wmi_has_guid(AMW0_GUID1
) && wmi_has_guid(WMID_GUID1
))
2227 interface
= &AMW0_V2_interface
;
2229 if (!wmi_has_guid(AMW0_GUID1
) && wmi_has_guid(WMID_GUID1
))
2230 interface
= &wmid_interface
;
2232 if (wmi_has_guid(WMID_GUID3
))
2233 interface
= &wmid_v2_interface
;
2236 dmi_walk(type_aa_dmi_decode
, NULL
);
2238 if (wmi_has_guid(WMID_GUID2
) && interface
) {
2239 if (!has_type_aa
&& ACPI_FAILURE(WMID_set_capabilities())) {
2240 pr_err("Unable to detect available WMID devices\n");
2243 /* WMID always provides brightness methods */
2244 interface
->capability
|= ACER_CAP_BRIGHTNESS
;
2245 } else if (!wmi_has_guid(WMID_GUID2
) && interface
&& !has_type_aa
) {
2246 pr_err("No WMID device detection method found\n");
2250 if (wmi_has_guid(AMW0_GUID1
) && !wmi_has_guid(WMID_GUID1
)) {
2251 interface
= &AMW0_interface
;
2253 if (ACPI_FAILURE(AMW0_set_capabilities())) {
2254 pr_err("Unable to detect available AMW0 devices\n");
2259 if (wmi_has_guid(AMW0_GUID1
))
2260 AMW0_find_mailled();
2263 pr_err("No or unsupported WMI interface, unable to load\n");
2269 if (dmi_check_system(video_vendor_dmi_table
))
2270 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor
);
2272 if (acpi_video_get_backlight_type() != acpi_backlight_vendor
)
2273 interface
->capability
&= ~ACER_CAP_BRIGHTNESS
;
2275 if (wmi_has_guid(WMID_GUID3
)) {
2276 if (ACPI_FAILURE(acer_wmi_enable_rf_button()))
2277 pr_warn("Cannot enable RF Button Driver\n");
2280 if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
2281 pr_err("Cannot enable EC raw mode\n");
2284 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
2285 pr_err("Cannot enable Launch Manager mode\n");
2288 } else if (ec_raw_mode
) {
2289 pr_info("No WMID EC raw mode enable method\n");
2292 if (wmi_has_guid(ACERWMID_EVENT_GUID
)) {
2293 err
= acer_wmi_input_setup();
2296 err
= acer_wmi_accel_setup();
2297 if (err
&& err
!= -ENODEV
)
2298 pr_warn("Cannot enable accelerometer\n");
2301 err
= platform_driver_register(&acer_platform_driver
);
2303 pr_err("Unable to register platform driver\n");
2304 goto error_platform_register
;
2307 acer_platform_device
= platform_device_alloc("acer-wmi", -1);
2308 if (!acer_platform_device
) {
2310 goto error_device_alloc
;
2313 err
= platform_device_add(acer_platform_device
);
2315 goto error_device_add
;
2317 if (wmi_has_guid(WMID_GUID2
)) {
2318 interface
->debug
.wmid_devices
= get_wmid_devices();
2319 err
= create_debugfs();
2321 goto error_create_debugfs
;
2324 /* Override any initial settings with values from the commandline */
2325 acer_commandline_init();
2329 error_create_debugfs
:
2330 platform_device_del(acer_platform_device
);
2332 platform_device_put(acer_platform_device
);
2334 platform_driver_unregister(&acer_platform_driver
);
2335 error_platform_register
:
2336 if (wmi_has_guid(ACERWMID_EVENT_GUID
))
2337 acer_wmi_input_destroy();
2338 if (has_cap(ACER_CAP_ACCEL
))
2339 acer_wmi_accel_destroy();
2344 static void __exit
acer_wmi_exit(void)
2346 if (wmi_has_guid(ACERWMID_EVENT_GUID
))
2347 acer_wmi_input_destroy();
2349 if (has_cap(ACER_CAP_ACCEL
))
2350 acer_wmi_accel_destroy();
2353 platform_device_unregister(acer_platform_device
);
2354 platform_driver_unregister(&acer_platform_driver
);
2356 pr_info("Acer Laptop WMI Extras unloaded\n");
2360 module_init(acer_wmi_init
);
2361 module_exit(acer_wmi_exit
);