projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-airlied' of git://people.freedesktop.org/~danvet/drm-intel into...
[deliverable/linux.git] / drivers / platform / x86 / acer-wmi.c
1 /*
2 * Acer WMI Laptop Extras
3 *
4 * Copyright (C) 2007-2009 Carlos Corbacho <carlos@strangeworlds.co.uk>
5 *
6 * Based on acer_acpi:
7 * Copyright (C) 2005-2007 E.M. Smith
8 * Copyright (C) 2007-2008 Carlos Corbacho <cathectic@gmail.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/types.h>
31 #include <linux/dmi.h>
32 #include <linux/fb.h>
33 #include <linux/backlight.h>
34 #include <linux/leds.h>
35 #include <linux/platform_device.h>
36 #include <linux/acpi.h>
37 #include <linux/i8042.h>
38 #include <linux/rfkill.h>
39 #include <linux/workqueue.h>
40 #include <linux/debugfs.h>
41 #include <linux/slab.h>
42 #include <linux/input.h>
43 #include <linux/input/sparse-keymap.h>
44
45 #include <acpi/acpi_drivers.h>
46 #include <acpi/video.h>
47
48 MODULE_AUTHOR("Carlos Corbacho");
49 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
50 MODULE_LICENSE("GPL");
51
52 /*
53 * Magic Number
54 * Meaning is unknown - this number is required for writing to ACPI for AMW0
55 * (it's also used in acerhk when directly accessing the BIOS)
56 */
57 #define ACER_AMW0_WRITE 0x9610
58
59 /*
60 * Bit masks for the AMW0 interface
61 */
62 #define ACER_AMW0_WIRELESS_MASK 0x35
63 #define ACER_AMW0_BLUETOOTH_MASK 0x34
64 #define ACER_AMW0_MAILLED_MASK 0x31
65
66 /*
67 * Method IDs for WMID interface
68 */
69 #define ACER_WMID_GET_WIRELESS_METHODID 1
70 #define ACER_WMID_GET_BLUETOOTH_METHODID 2
71 #define ACER_WMID_GET_BRIGHTNESS_METHODID 3
72 #define ACER_WMID_SET_WIRELESS_METHODID 4
73 #define ACER_WMID_SET_BLUETOOTH_METHODID 5
74 #define ACER_WMID_SET_BRIGHTNESS_METHODID 6
75 #define ACER_WMID_GET_THREEG_METHODID 10
76 #define ACER_WMID_SET_THREEG_METHODID 11
77
78 /*
79 * Acer ACPI method GUIDs
80 */
81 #define AMW0_GUID1 "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
82 #define AMW0_GUID2 "431F16ED-0C2B-444C-B267-27DEB140CF9C"
83 #define WMID_GUID1 "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
84 #define WMID_GUID2 "95764E09-FB56-4E83-B31A-37761F60994A"
85 #define WMID_GUID3 "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
86
87 /*
88 * Acer ACPI event GUIDs
89 */
90 #define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
91
92 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
93 MODULE_ALIAS("wmi:6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3");
94 MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
95
96 enum acer_wmi_event_ids {
97 WMID_HOTKEY_EVENT = 0x1,
98 WMID_ACCEL_EVENT = 0x5,
99 };
100
101 static const struct key_entry acer_wmi_keymap[] = {
102 {KE_KEY, 0x01, {KEY_WLAN} }, /* WiFi */
103 {KE_KEY, 0x03, {KEY_WLAN} }, /* WiFi */
104 {KE_KEY, 0x04, {KEY_WLAN} }, /* WiFi */
105 {KE_KEY, 0x12, {KEY_BLUETOOTH} }, /* BT */
106 {KE_KEY, 0x21, {KEY_PROG1} }, /* Backup */
107 {KE_KEY, 0x22, {KEY_PROG2} }, /* Arcade */
108 {KE_KEY, 0x23, {KEY_PROG3} }, /* P_Key */
109 {KE_KEY, 0x24, {KEY_PROG4} }, /* Social networking_Key */
110 {KE_KEY, 0x29, {KEY_PROG3} }, /* P_Key for TM8372 */
111 {KE_IGNORE, 0x41, {KEY_MUTE} },
112 {KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} },
113 {KE_IGNORE, 0x4d, {KEY_PREVIOUSSONG} },
114 {KE_IGNORE, 0x43, {KEY_NEXTSONG} },
115 {KE_IGNORE, 0x4e, {KEY_NEXTSONG} },
116 {KE_IGNORE, 0x44, {KEY_PLAYPAUSE} },
117 {KE_IGNORE, 0x4f, {KEY_PLAYPAUSE} },
118 {KE_IGNORE, 0x45, {KEY_STOP} },
119 {KE_IGNORE, 0x50, {KEY_STOP} },
120 {KE_IGNORE, 0x48, {KEY_VOLUMEUP} },
121 {KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} },
122 {KE_IGNORE, 0x4a, {KEY_VOLUMEDOWN} },
123 {KE_IGNORE, 0x61, {KEY_SWITCHVIDEOMODE} },
124 {KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} },
125 {KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} },
126 {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
127 {KE_IGNORE, 0x81, {KEY_SLEEP} },
128 {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
129 {KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} },
130 {KE_END, 0}
131 };
132
133 static struct input_dev *acer_wmi_input_dev;
134 static struct input_dev *acer_wmi_accel_dev;
135
136 struct event_return_value {
137 u8 function;
138 u8 key_num;
139 u16 device_state;
140 u32 reserved;
141 } __attribute__((packed));
142
143 /*
144 * GUID3 Get Device Status device flags
145 */
146 #define ACER_WMID3_GDS_WIRELESS (1<<0) /* WiFi */
147 #define ACER_WMID3_GDS_THREEG (1<<6) /* 3G */
148 #define ACER_WMID3_GDS_WIMAX (1<<7) /* WiMAX */
149 #define ACER_WMID3_GDS_BLUETOOTH (1<<11) /* BT */
150
151 struct 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
159 struct lm_return_value {
160 u8 error_code; /* Error Code */
161 u8 ec_return_value; /* EC Return Value */
162 u16 reserved;
163 } __attribute__((packed));
164
165 struct 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
172 struct wmid3_gds_get_input_param { /* Get Device Status input parameter */
173 u8 function_num; /* Function Number */
174 u8 hotkey_number; /* Hotkey Number */
175 u16 devices; /* Get Device */
176 } __attribute__((packed));
177
178 struct 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
185 struct hotkey_function_type_aa {
186 u8 type;
187 u8 length;
188 u16 handle;
189 u16 commun_func_bitmap;
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;
195 } __attribute__((packed));
196
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)
205 #define ACER_CAP_ACCEL (1<<5)
206 #define ACER_CAP_ANY (0xFFFFFFFF)
207
208 /*
209 * Interface type flags
210 */
211 enum interface_flags {
212 ACER_AMW0,
213 ACER_AMW0_V2,
214 ACER_WMID,
215 ACER_WMID_v2,
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
223 static int max_brightness = 0xF;
224
225 static int mailled = -1;
226 static int brightness = -1;
227 static int threeg = -1;
228 static int force_series;
229 static bool ec_raw_mode;
230 static bool has_type_aa;
231 static u16 commun_func_bitmap;
232 static u8 commun_fn_key_number;
233
234 module_param(mailled, int, 0444);
235 module_param(brightness, int, 0444);
236 module_param(threeg, int, 0444);
237 module_param(force_series, int, 0444);
238 module_param(ec_raw_mode, bool, 0444);
239 MODULE_PARM_DESC(mailled, "Set initial state of Mail LED");
240 MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness");
241 MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware");
242 MODULE_PARM_DESC(force_series, "Force a different laptop series");
243 MODULE_PARM_DESC(ec_raw_mode, "Enable EC raw mode");
244
245 struct acer_data {
246 int mailled;
247 int threeg;
248 int brightness;
249 };
250
251 struct acer_debug {
252 struct dentry *root;
253 struct dentry *devices;
254 u32 wmid_devices;
255 };
256
257 static struct rfkill *wireless_rfkill;
258 static struct rfkill *bluetooth_rfkill;
259 static struct rfkill *threeg_rfkill;
260 static bool rfkill_inited;
261
262 /* Each low-level interface must define at least some of the following */
263 struct 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;
272
273 /* debugfs entries associated with this interface */
274 struct acer_debug debug;
275 };
276
277 /* The static interface pointer, points to the currently detected interface */
278 static 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
286 struct quirk_entry {
287 u8 wireless;
288 u8 mailled;
289 s8 brightness;
290 u8 bluetooth;
291 };
292
293 static struct quirk_entry *quirks;
294
295 static void set_quirks(void)
296 {
297 if (!interface)
298 return;
299
300 if (quirks->mailled)
301 interface->capability |= ACER_CAP_MAILLED;
302
303 if (quirks->brightness)
304 interface->capability |= ACER_CAP_BRIGHTNESS;
305 }
306
307 static int dmi_matched(const struct dmi_system_id *dmi)
308 {
309 quirks = dmi->driver_data;
310 return 1;
311 }
312
313 static struct quirk_entry quirk_unknown = {
314 };
315
316 static struct quirk_entry quirk_acer_aspire_1520 = {
317 .brightness = -1,
318 };
319
320 static struct quirk_entry quirk_acer_travelmate_2490 = {
321 .mailled = 1,
322 };
323
324 /* This AMW0 laptop has no bluetooth */
325 static struct quirk_entry quirk_medion_md_98300 = {
326 .wireless = 1,
327 };
328
329 static struct quirk_entry quirk_fujitsu_amilo_li_1718 = {
330 .wireless = 2,
331 };
332
333 static struct quirk_entry quirk_lenovo_ideapad_s205 = {
334 .wireless = 3,
335 };
336
337 /* The Aspire One has a dummy ACPI-WMI interface - disable it */
338 static 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
356 static struct dmi_system_id acer_quirks[] = {
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
510 {}
511 };
512
513 static 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
520 static 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 },
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 },
553 {}
554 };
555
556 /* Find which quirks are needed for a particular vendor/ model pair */
557 static 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
575 static 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 */
586 struct wmab_args {
587 u32 eax;
588 u32 ebx;
589 u32 ecx;
590 u32 edx;
591 };
592
593 struct wmab_ret {
594 u32 eax;
595 u32 ebx;
596 u32 ecx;
597 u32 edx;
598 u32 eex;
599 };
600
601 static acpi_status wmab_execute(struct wmab_args *regbuf,
602 struct 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
614 static acpi_status AMW0_get_u32(u32 *value, u32 cap)
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;
638 case 2:
639 err = ec_read(0x71, &result);
640 if (err)
641 return AE_ERROR;
642 *value = result & 0x1;
643 return AE_OK;
644 case 3:
645 err = ec_read(0x78, &result);
646 if (err)
647 return AE_ERROR;
648 *value = result & 0x1;
649 return AE_OK;
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:
679 return AE_ERROR;
680 }
681 return AE_OK;
682 }
683
684 static acpi_status AMW0_set_u32(u32 value, u32 cap)
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) {
712 default:
713 return ec_write(0x83, value);
714 break;
715 }
716 default:
717 return AE_ERROR;
718 }
719
720 /* Actually do the set */
721 return wmab_execute(&args, NULL);
722 }
723
724 static 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 {
744 kfree(out.pointer);
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
756 static int AMW0_set_cap_acpi_check_device_found;
757
758 static 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
765 static const struct acpi_device_id norfkill_ids[] = {
766 { "VPC2004", 0},
767 { "IBM0068", 0},
768 { "LEN0068", 0},
769 { "SNY5001", 0}, /* sony-laptop in charge */
770 { "", 0},
771 };
772
773 static 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
783 static acpi_status AMW0_set_capabilities(void)
784 {
785 struct wmab_args args;
786 struct wmab_ret ret;
787 acpi_status status;
788 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
789 union acpi_object *obj;
790
791 /*
792 * On laptops with this strange GUID (non Acer), normal probing doesn't
793 * work.
794 */
795 if (wmi_has_guid(AMW0_GUID2)) {
796 if ((quirks != &quirk_unknown) ||
797 !AMW0_set_cap_acpi_check_device())
798 interface->capability |= ACER_CAP_WIRELESS;
799 return AE_OK;
800 }
801
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
812 obj = out.pointer;
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 {
817 status = AE_ERROR;
818 goto out;
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
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 */
831 status = wmab_execute(&args, &out);
832 if (ACPI_FAILURE(status))
833 goto out;
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 {
840 status = AE_ERROR;
841 goto out;
842 }
843
844 if (ret.eax & 0x1)
845 interface->capability |= ACER_CAP_BLUETOOTH;
846
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 */
852 if (quirks->brightness >= 0)
853 interface->capability |= ACER_CAP_BRIGHTNESS;
854
855 status = AE_OK;
856 out:
857 kfree(out.pointer);
858 return status;
859 }
860
861 static struct wmi_interface AMW0_interface = {
862 .type = ACER_AMW0,
863 };
864
865 static struct wmi_interface AMW0_V2_interface = {
866 .type = ACER_AMW0_V2,
867 };
868
869 /*
870 * New interface (The WMID interface)
871 */
872 static acpi_status
873 WMI_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 &&
888 (obj->buffer.length == sizeof(u32) ||
889 obj->buffer.length == sizeof(u64))) {
890 tmp = *((u32 *) obj->buffer.pointer);
891 } else if (obj->type == ACPI_TYPE_INTEGER) {
892 tmp = (u32) obj->integer.value;
893 } else {
894 tmp = 0;
895 }
896
897 if (out)
898 *out = tmp;
899
900 kfree(result.pointer);
901
902 return status;
903 }
904
905 static acpi_status WMID_get_u32(u32 *value, u32 cap)
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:
931 return AE_ERROR;
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
941 static acpi_status WMID_set_u32(u32 value, u32 cap)
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;
972 i8042_lock_chip();
973 i8042_command(&param, 0x1059);
974 i8042_unlock_chip();
975 return 0;
976 }
977 break;
978 default:
979 return AE_ERROR;
980 }
981 return WMI_execute_u32(method_id, (u32)value, NULL);
982 }
983
984 static 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;
989 struct wmid3_gds_get_input_param params = {
990 .function_num = 0x1,
991 .hotkey_number = commun_fn_key_number,
992 .devices = device,
993 };
994 struct acpi_buffer input = {
995 sizeof(struct wmid3_gds_get_input_param),
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
1032 static 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
1052 static 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;
1058 struct wmid3_gds_get_input_param get_params = {
1059 .function_num = 0x1,
1060 .hotkey_number = commun_fn_key_number,
1061 .devices = commun_func_bitmap,
1062 };
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
1075 };
1076 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1077 struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
1078
1079 status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &get_input, &output);
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) {
1092 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
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) {
1101 pr_warn("Get Current Device Status failed: 0x%x - 0x%x\n",
1102 return_value.error_code,
1103 return_value.ec_return_value);
1104 return status;
1105 }
1106
1107 devices = return_value.devices;
1108 set_params.devices = (value) ? (devices | device) : (devices & ~device);
1109
1110 status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &set_input, &output2);
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) {
1123 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
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)
1132 pr_warn("Set Device Status failed: 0x%x - 0x%x\n",
1133 return_value.error_code,
1134 return_value.ec_return_value);
1135
1136 return status;
1137 }
1138
1139 static 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
1159 static 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
1170 pr_info("Function bitmap for Communication Button: 0x%x\n",
1171 type_aa->commun_func_bitmap);
1172 commun_func_bitmap = type_aa->commun_func_bitmap;
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;
1180
1181 commun_fn_key_number = type_aa->commun_fn_key_number;
1182 }
1183
1184 static 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 &&
1197 (obj->buffer.length == sizeof(u32) ||
1198 obj->buffer.length == sizeof(u64))) {
1199 devices = *((u32 *) obj->buffer.pointer);
1200 } else if (obj->type == ACPI_TYPE_INTEGER) {
1201 devices = (u32) obj->integer.value;
1202 } else {
1203 kfree(out.pointer);
1204 return AE_ERROR;
1205 }
1206
1207 pr_info("Function bitmap for Communication Device: 0x%x\n", devices);
1208 if (devices & 0x07)
1209 interface->capability |= ACER_CAP_WIRELESS;
1210 if (devices & 0x40)
1211 interface->capability |= ACER_CAP_THREEG;
1212 if (devices & 0x10)
1213 interface->capability |= ACER_CAP_BLUETOOTH;
1214
1215 if (!(devices & 0x20))
1216 max_brightness = 0x9;
1217
1218 kfree(out.pointer);
1219 return status;
1220 }
1221
1222 static struct wmi_interface wmid_interface = {
1223 .type = ACER_WMID,
1224 };
1225
1226 static struct wmi_interface wmid_v2_interface = {
1227 .type = ACER_WMID_v2,
1228 };
1229
1230 /*
1231 * Generic Device (interface-independent)
1232 */
1233
1234 static acpi_status get_u32(u32 *value, u32 cap)
1235 {
1236 acpi_status status = AE_ERROR;
1237
1238 switch (interface->type) {
1239 case ACER_AMW0:
1240 status = AMW0_get_u32(value, cap);
1241 break;
1242 case ACER_AMW0_V2:
1243 if (cap == ACER_CAP_MAILLED) {
1244 status = AMW0_get_u32(value, cap);
1245 break;
1246 }
1247 case ACER_WMID:
1248 status = WMID_get_u32(value, cap);
1249 break;
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))
1256 status = WMID_get_u32(value, cap);
1257 break;
1258 }
1259
1260 return status;
1261 }
1262
1263 static acpi_status set_u32(u32 value, u32 cap)
1264 {
1265 acpi_status status;
1266
1267 if (interface->capability & cap) {
1268 switch (interface->type) {
1269 case ACER_AMW0:
1270 return AMW0_set_u32(value, cap);
1271 case ACER_AMW0_V2:
1272 if (cap == ACER_CAP_MAILLED)
1273 return AMW0_set_u32(value, cap);
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) {
1283 status = WMID_set_u32(value, cap);
1284 if (ACPI_FAILURE(status))
1285 return status;
1286
1287 return AMW0_set_u32(value, cap);
1288 }
1289 case ACER_WMID:
1290 return WMID_set_u32(value, cap);
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))
1297 return WMID_set_u32(value, cap);
1298 default:
1299 return AE_BAD_PARAMETER;
1300 }
1301 }
1302 return AE_BAD_PARAMETER;
1303 }
1304
1305 static 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 */
1311 if (mailled >= 0)
1312 set_u32(mailled, ACER_CAP_MAILLED);
1313 if (!has_type_aa && threeg >= 0)
1314 set_u32(threeg, ACER_CAP_THREEG);
1315 if (brightness >= 0)
1316 set_u32(brightness, ACER_CAP_BRIGHTNESS);
1317 }
1318
1319 /*
1320 * LED device (Mail LED only, no other LEDs known yet)
1321 */
1322 static void mail_led_set(struct led_classdev *led_cdev,
1323 enum led_brightness value)
1324 {
1325 set_u32(value, ACER_CAP_MAILLED);
1326 }
1327
1328 static struct led_classdev mail_led = {
1329 .name = "acer-wmi::mail",
1330 .brightness_set = mail_led_set,
1331 };
1332
1333 static int __devinit acer_led_init(struct device *dev)
1334 {
1335 return led_classdev_register(dev, &mail_led);
1336 }
1337
1338 static void acer_led_exit(void)
1339 {
1340 set_u32(LED_OFF, ACER_CAP_MAILLED);
1341 led_classdev_unregister(&mail_led);
1342 }
1343
1344 /*
1345 * Backlight device
1346 */
1347 static struct backlight_device *acer_backlight_device;
1348
1349 static int read_brightness(struct backlight_device *bd)
1350 {
1351 u32 value;
1352 get_u32(&value, ACER_CAP_BRIGHTNESS);
1353 return value;
1354 }
1355
1356 static int update_bl_status(struct backlight_device *bd)
1357 {
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
1367 return 0;
1368 }
1369
1370 static const struct backlight_ops acer_bl_ops = {
1371 .get_brightness = read_brightness,
1372 .update_status = update_bl_status,
1373 };
1374
1375 static int __devinit acer_backlight_init(struct device *dev)
1376 {
1377 struct backlight_properties props;
1378 struct backlight_device *bd;
1379
1380 memset(&props, 0, sizeof(struct backlight_properties));
1381 props.type = BACKLIGHT_PLATFORM;
1382 props.max_brightness = max_brightness;
1383 bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops,
1384 &props);
1385 if (IS_ERR(bd)) {
1386 pr_err("Could not register Acer backlight device\n");
1387 acer_backlight_device = NULL;
1388 return PTR_ERR(bd);
1389 }
1390
1391 acer_backlight_device = bd;
1392
1393 bd->props.power = FB_BLANK_UNBLANK;
1394 bd->props.brightness = read_brightness(bd);
1395 backlight_update_status(bd);
1396 return 0;
1397 }
1398
1399 static void acer_backlight_exit(void)
1400 {
1401 backlight_device_unregister(acer_backlight_device);
1402 }
1403
1404 /*
1405 * Accelerometer device
1406 */
1407 static acpi_handle gsensor_handle;
1408
1409 static 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
1424 static int acer_gsensor_open(struct input_dev *input)
1425 {
1426 return acer_gsensor_init();
1427 }
1428
1429 static 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
1458 /*
1459 * Rfkill devices
1460 */
1461 static void acer_rfkill_update(struct work_struct *ignored);
1462 static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update);
1463 static void acer_rfkill_update(struct work_struct *ignored)
1464 {
1465 u32 state;
1466 acpi_status status;
1467
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);
1475 }
1476 }
1477
1478 if (has_cap(ACER_CAP_BLUETOOTH)) {
1479 status = get_u32(&state, ACER_CAP_BLUETOOTH);
1480 if (ACPI_SUCCESS(status))
1481 rfkill_set_sw_state(bluetooth_rfkill, !state);
1482 }
1483
1484 if (has_cap(ACER_CAP_THREEG) && wmi_has_guid(WMID_GUID3)) {
1485 status = get_u32(&state, ACER_WMID3_GDS_THREEG);
1486 if (ACPI_SUCCESS(status))
1487 rfkill_set_sw_state(threeg_rfkill, !state);
1488 }
1489
1490 schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
1491 }
1492
1493 static int acer_rfkill_set(void *data, bool blocked)
1494 {
1495 acpi_status status;
1496 u32 cap = (unsigned long)data;
1497
1498 if (rfkill_inited) {
1499 status = set_u32(!blocked, cap);
1500 if (ACPI_FAILURE(status))
1501 return -ENODEV;
1502 }
1503
1504 return 0;
1505 }
1506
1507 static const struct rfkill_ops acer_rfkill_ops = {
1508 .set_block = acer_rfkill_set,
1509 };
1510
1511 static struct rfkill *acer_rfkill_register(struct device *dev,
1512 enum rfkill_type type,
1513 char *name, u32 cap)
1514 {
1515 int err;
1516 struct rfkill *rfkill_dev;
1517 u32 state;
1518 acpi_status status;
1519
1520 rfkill_dev = rfkill_alloc(name, dev, type,
1521 &acer_rfkill_ops,
1522 (void *)(unsigned long)cap);
1523 if (!rfkill_dev)
1524 return ERR_PTR(-ENOMEM);
1525
1526 status = get_u32(&state, cap);
1527
1528 err = rfkill_register(rfkill_dev);
1529 if (err) {
1530 rfkill_destroy(rfkill_dev);
1531 return ERR_PTR(err);
1532 }
1533
1534 if (ACPI_SUCCESS(status))
1535 rfkill_set_sw_state(rfkill_dev, !state);
1536
1537 return rfkill_dev;
1538 }
1539
1540 static int acer_rfkill_init(struct device *dev)
1541 {
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 }
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)) {
1558 err = PTR_ERR(bluetooth_rfkill);
1559 goto error_bluetooth;
1560 }
1561 }
1562
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)) {
1568 err = PTR_ERR(threeg_rfkill);
1569 goto error_threeg;
1570 }
1571 }
1572
1573 rfkill_inited = true;
1574
1575 if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
1576 has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
1577 schedule_delayed_work(&acer_rfkill_work,
1578 round_jiffies_relative(HZ));
1579
1580 return 0;
1581
1582 error_threeg:
1583 if (has_cap(ACER_CAP_BLUETOOTH)) {
1584 rfkill_unregister(bluetooth_rfkill);
1585 rfkill_destroy(bluetooth_rfkill);
1586 }
1587 error_bluetooth:
1588 if (has_cap(ACER_CAP_WIRELESS)) {
1589 rfkill_unregister(wireless_rfkill);
1590 rfkill_destroy(wireless_rfkill);
1591 }
1592 error_wireless:
1593 return err;
1594 }
1595
1596 static void acer_rfkill_exit(void)
1597 {
1598 if ((ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID)) &&
1599 has_cap(ACER_CAP_WIRELESS | ACER_CAP_BLUETOOTH | ACER_CAP_THREEG))
1600 cancel_delayed_work_sync(&acer_rfkill_work);
1601
1602 if (has_cap(ACER_CAP_WIRELESS)) {
1603 rfkill_unregister(wireless_rfkill);
1604 rfkill_destroy(wireless_rfkill);
1605 }
1606
1607 if (has_cap(ACER_CAP_BLUETOOTH)) {
1608 rfkill_unregister(bluetooth_rfkill);
1609 rfkill_destroy(bluetooth_rfkill);
1610 }
1611
1612 if (has_cap(ACER_CAP_THREEG)) {
1613 rfkill_unregister(threeg_rfkill);
1614 rfkill_destroy(threeg_rfkill);
1615 }
1616 return;
1617 }
1618
1619 /*
1620 * sysfs interface
1621 */
1622 static ssize_t show_bool_threeg(struct device *dev,
1623 struct device_attribute *attr, char *buf)
1624 {
1625 u32 result; \
1626 acpi_status status;
1627
1628 pr_info("This threeg sysfs will be removed in 2012 - used by: %s\n",
1629 current->comm);
1630 status = get_u32(&result, ACER_CAP_THREEG);
1631 if (ACPI_SUCCESS(status))
1632 return sprintf(buf, "%u\n", result);
1633 return sprintf(buf, "Read error\n");
1634 }
1635
1636 static 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);
1641 pr_info("This threeg sysfs will be removed in 2012 - used by: %s\n",
1642 current->comm);
1643 if (ACPI_FAILURE(status))
1644 return -EINVAL;
1645 return count;
1646 }
1647 static DEVICE_ATTR(threeg, S_IRUGO | S_IWUSR, show_bool_threeg,
1648 set_bool_threeg);
1649
1650 static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
1651 char *buf)
1652 {
1653 pr_info("This interface sysfs will be removed in 2012 - used by: %s\n",
1654 current->comm);
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");
1662 case ACER_WMID_v2:
1663 return sprintf(buf, "WMID v2\n");
1664 default:
1665 return sprintf(buf, "Error!\n");
1666 }
1667 }
1668
1669 static DEVICE_ATTR(interface, S_IRUGO, show_interface, NULL);
1670
1671 static 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;
1677 u16 device_state;
1678 const struct key_entry *key;
1679
1680 status = wmi_get_event_data(value, &response);
1681 if (status != AE_OK) {
1682 pr_warn("bad event status 0x%x\n", status);
1683 return;
1684 }
1685
1686 obj = (union acpi_object *)response.pointer;
1687
1688 if (!obj)
1689 return;
1690 if (obj->type != ACPI_TYPE_BUFFER) {
1691 pr_warn("Unknown response received %d\n", obj->type);
1692 kfree(obj);
1693 return;
1694 }
1695 if (obj->buffer.length != 8) {
1696 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
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:
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) {
1712 pr_warn("Unknown key number - 0x%x\n",
1713 return_value.key_num);
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 }
1732 break;
1733 case WMID_ACCEL_EVENT:
1734 acer_gsensor_event();
1735 break;
1736 default:
1737 pr_warn("Unknown function number - %d - %d\n",
1738 return_value.function, return_value.key_num);
1739 break;
1740 }
1741 }
1742
1743 static acpi_status
1744 wmid3_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) {
1766 pr_warn("Unknown buffer length %d\n", obj->buffer.length);
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
1777 static 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)
1791 pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
1792 return_value.error_code,
1793 return_value.ec_return_value);
1794 else
1795 pr_info("Enabled EC raw mode\n");
1796
1797 return status;
1798 }
1799
1800 static 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)
1814 pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
1815 return_value.error_code,
1816 return_value.ec_return_value);
1817
1818 return status;
1819 }
1820
1821 static 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
1828 static 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 = NULL;
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
1848 static 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
1878 err_free_dev:
1879 input_free_device(acer_wmi_accel_dev);
1880 return err;
1881 }
1882
1883 static void acer_wmi_accel_destroy(void)
1884 {
1885 input_unregister_device(acer_wmi_accel_dev);
1886 }
1887
1888 static int __init acer_wmi_input_setup(void)
1889 {
1890 acpi_status status;
1891 int err;
1892
1893 acer_wmi_input_dev = input_allocate_device();
1894 if (!acer_wmi_input_dev)
1895 return -ENOMEM;
1896
1897 acer_wmi_input_dev->name = "Acer WMI hotkeys";
1898 acer_wmi_input_dev->phys = "wmi/input0";
1899 acer_wmi_input_dev->id.bustype = BUS_HOST;
1900
1901 err = sparse_keymap_setup(acer_wmi_input_dev, acer_wmi_keymap, NULL);
1902 if (err)
1903 goto err_free_dev;
1904
1905 status = wmi_install_notify_handler(ACERWMID_EVENT_GUID,
1906 acer_wmi_notify, NULL);
1907 if (ACPI_FAILURE(status)) {
1908 err = -EIO;
1909 goto err_free_keymap;
1910 }
1911
1912 err = input_register_device(acer_wmi_input_dev);
1913 if (err)
1914 goto err_uninstall_notifier;
1915
1916 return 0;
1917
1918 err_uninstall_notifier:
1919 wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
1920 err_free_keymap:
1921 sparse_keymap_free(acer_wmi_input_dev);
1922 err_free_dev:
1923 input_free_device(acer_wmi_input_dev);
1924 return err;
1925 }
1926
1927 static void acer_wmi_input_destroy(void)
1928 {
1929 wmi_remove_notify_handler(ACERWMID_EVENT_GUID);
1930 sparse_keymap_free(acer_wmi_input_dev);
1931 input_unregister_device(acer_wmi_input_dev);
1932 }
1933
1934 /*
1935 * debugfs functions
1936 */
1937 static u32 get_wmid_devices(void)
1938 {
1939 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1940 union acpi_object *obj;
1941 acpi_status status;
1942 u32 devices = 0;
1943
1944 status = wmi_query_block(WMID_GUID2, 1, &out);
1945 if (ACPI_FAILURE(status))
1946 return 0;
1947
1948 obj = (union acpi_object *) out.pointer;
1949 if (obj && obj->type == ACPI_TYPE_BUFFER &&
1950 (obj->buffer.length == sizeof(u32) ||
1951 obj->buffer.length == sizeof(u64))) {
1952 devices = *((u32 *) obj->buffer.pointer);
1953 } else if (obj->type == ACPI_TYPE_INTEGER) {
1954 devices = (u32) obj->integer.value;
1955 }
1956
1957 kfree(out.pointer);
1958 return devices;
1959 }
1960
1961 /*
1962 * Platform device
1963 */
1964 static int __devinit acer_platform_probe(struct platform_device *device)
1965 {
1966 int err;
1967
1968 if (has_cap(ACER_CAP_MAILLED)) {
1969 err = acer_led_init(&device->dev);
1970 if (err)
1971 goto error_mailled;
1972 }
1973
1974 if (has_cap(ACER_CAP_BRIGHTNESS)) {
1975 err = acer_backlight_init(&device->dev);
1976 if (err)
1977 goto error_brightness;
1978 }
1979
1980 err = acer_rfkill_init(&device->dev);
1981 if (err)
1982 goto error_rfkill;
1983
1984 return err;
1985
1986 error_rfkill:
1987 if (has_cap(ACER_CAP_BRIGHTNESS))
1988 acer_backlight_exit();
1989 error_brightness:
1990 if (has_cap(ACER_CAP_MAILLED))
1991 acer_led_exit();
1992 error_mailled:
1993 return err;
1994 }
1995
1996 static int acer_platform_remove(struct platform_device *device)
1997 {
1998 if (has_cap(ACER_CAP_MAILLED))
1999 acer_led_exit();
2000 if (has_cap(ACER_CAP_BRIGHTNESS))
2001 acer_backlight_exit();
2002
2003 acer_rfkill_exit();
2004 return 0;
2005 }
2006
2007 static int acer_suspend(struct device *dev)
2008 {
2009 u32 value;
2010 struct acer_data *data = &interface->data;
2011
2012 if (!data)
2013 return -ENOMEM;
2014
2015 if (has_cap(ACER_CAP_MAILLED)) {
2016 get_u32(&value, ACER_CAP_MAILLED);
2017 set_u32(LED_OFF, ACER_CAP_MAILLED);
2018 data->mailled = value;
2019 }
2020
2021 if (has_cap(ACER_CAP_BRIGHTNESS)) {
2022 get_u32(&value, ACER_CAP_BRIGHTNESS);
2023 data->brightness = value;
2024 }
2025
2026 return 0;
2027 }
2028
2029 static int acer_resume(struct device *dev)
2030 {
2031 struct acer_data *data = &interface->data;
2032
2033 if (!data)
2034 return -ENOMEM;
2035
2036 if (has_cap(ACER_CAP_MAILLED))
2037 set_u32(data->mailled, ACER_CAP_MAILLED);
2038
2039 if (has_cap(ACER_CAP_BRIGHTNESS))
2040 set_u32(data->brightness, ACER_CAP_BRIGHTNESS);
2041
2042 if (has_cap(ACER_CAP_ACCEL))
2043 acer_gsensor_init();
2044
2045 return 0;
2046 }
2047
2048 static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume);
2049
2050 static void acer_platform_shutdown(struct platform_device *device)
2051 {
2052 struct acer_data *data = &interface->data;
2053
2054 if (!data)
2055 return;
2056
2057 if (has_cap(ACER_CAP_MAILLED))
2058 set_u32(LED_OFF, ACER_CAP_MAILLED);
2059 }
2060
2061 static struct platform_driver acer_platform_driver = {
2062 .driver = {
2063 .name = "acer-wmi",
2064 .owner = THIS_MODULE,
2065 .pm = &acer_pm,
2066 },
2067 .probe = acer_platform_probe,
2068 .remove = acer_platform_remove,
2069 .shutdown = acer_platform_shutdown,
2070 };
2071
2072 static struct platform_device *acer_platform_device;
2073
2074 static int remove_sysfs(struct platform_device *device)
2075 {
2076 if (has_cap(ACER_CAP_THREEG))
2077 device_remove_file(&device->dev, &dev_attr_threeg);
2078
2079 device_remove_file(&device->dev, &dev_attr_interface);
2080
2081 return 0;
2082 }
2083
2084 static int create_sysfs(void)
2085 {
2086 int retval = -ENOMEM;
2087
2088 if (has_cap(ACER_CAP_THREEG)) {
2089 retval = device_create_file(&acer_platform_device->dev,
2090 &dev_attr_threeg);
2091 if (retval)
2092 goto error_sysfs;
2093 }
2094
2095 retval = device_create_file(&acer_platform_device->dev,
2096 &dev_attr_interface);
2097 if (retval)
2098 goto error_sysfs;
2099
2100 return 0;
2101
2102 error_sysfs:
2103 remove_sysfs(acer_platform_device);
2104 return retval;
2105 }
2106
2107 static void remove_debugfs(void)
2108 {
2109 debugfs_remove(interface->debug.devices);
2110 debugfs_remove(interface->debug.root);
2111 }
2112
2113 static int create_debugfs(void)
2114 {
2115 interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
2116 if (!interface->debug.root) {
2117 pr_err("Failed to create debugfs directory");
2118 return -ENOMEM;
2119 }
2120
2121 interface->debug.devices = debugfs_create_u32("devices", S_IRUGO,
2122 interface->debug.root,
2123 &interface->debug.wmid_devices);
2124 if (!interface->debug.devices)
2125 goto error_debugfs;
2126
2127 return 0;
2128
2129 error_debugfs:
2130 remove_debugfs();
2131 return -ENOMEM;
2132 }
2133
2134 static int __init acer_wmi_init(void)
2135 {
2136 int err;
2137
2138 pr_info("Acer Laptop ACPI-WMI Extras\n");
2139
2140 if (dmi_check_system(acer_blacklist)) {
2141 pr_info("Blacklisted hardware detected - not loading\n");
2142 return -ENODEV;
2143 }
2144
2145 find_quirks();
2146
2147 /*
2148 * Detect which ACPI-WMI interface we're using.
2149 */
2150 if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2151 interface = &AMW0_V2_interface;
2152
2153 if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
2154 interface = &wmid_interface;
2155
2156 if (wmi_has_guid(WMID_GUID3))
2157 interface = &wmid_v2_interface;
2158
2159 if (interface)
2160 dmi_walk(type_aa_dmi_decode, NULL);
2161
2162 if (wmi_has_guid(WMID_GUID2) && interface) {
2163 if (!has_type_aa && ACPI_FAILURE(WMID_set_capabilities())) {
2164 pr_err("Unable to detect available WMID devices\n");
2165 return -ENODEV;
2166 }
2167 /* WMID always provides brightness methods */
2168 interface->capability |= ACER_CAP_BRIGHTNESS;
2169 } else if (!wmi_has_guid(WMID_GUID2) && interface && !has_type_aa) {
2170 pr_err("No WMID device detection method found\n");
2171 return -ENODEV;
2172 }
2173
2174 if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) {
2175 interface = &AMW0_interface;
2176
2177 if (ACPI_FAILURE(AMW0_set_capabilities())) {
2178 pr_err("Unable to detect available AMW0 devices\n");
2179 return -ENODEV;
2180 }
2181 }
2182
2183 if (wmi_has_guid(AMW0_GUID1))
2184 AMW0_find_mailled();
2185
2186 if (!interface) {
2187 pr_err("No or unsupported WMI interface, unable to load\n");
2188 return -ENODEV;
2189 }
2190
2191 set_quirks();
2192
2193 if (dmi_check_system(video_vendor_dmi_table))
2194 acpi_video_dmi_promote_vendor();
2195 if (acpi_video_backlight_support()) {
2196 interface->capability &= ~ACER_CAP_BRIGHTNESS;
2197 pr_info("Brightness must be controlled by acpi video driver\n");
2198 } else {
2199 #ifdef CONFIG_ACPI_VIDEO
2200 pr_info("Disabling ACPI video driver\n");
2201 acpi_video_unregister();
2202 #endif
2203 }
2204
2205 if (wmi_has_guid(WMID_GUID3)) {
2206 if (ec_raw_mode) {
2207 if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
2208 pr_err("Cannot enable EC raw mode\n");
2209 return -ENODEV;
2210 }
2211 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
2212 pr_err("Cannot enable Launch Manager mode\n");
2213 return -ENODEV;
2214 }
2215 } else if (ec_raw_mode) {
2216 pr_info("No WMID EC raw mode enable method\n");
2217 }
2218
2219 if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
2220 err = acer_wmi_input_setup();
2221 if (err)
2222 return err;
2223 }
2224
2225 acer_wmi_accel_setup();
2226
2227 err = platform_driver_register(&acer_platform_driver);
2228 if (err) {
2229 pr_err("Unable to register platform driver\n");
2230 goto error_platform_register;
2231 }
2232
2233 acer_platform_device = platform_device_alloc("acer-wmi", -1);
2234 if (!acer_platform_device) {
2235 err = -ENOMEM;
2236 goto error_device_alloc;
2237 }
2238
2239 err = platform_device_add(acer_platform_device);
2240 if (err)
2241 goto error_device_add;
2242
2243 err = create_sysfs();
2244 if (err)
2245 goto error_create_sys;
2246
2247 if (wmi_has_guid(WMID_GUID2)) {
2248 interface->debug.wmid_devices = get_wmid_devices();
2249 err = create_debugfs();
2250 if (err)
2251 goto error_create_debugfs;
2252 }
2253
2254 /* Override any initial settings with values from the commandline */
2255 acer_commandline_init();
2256
2257 return 0;
2258
2259 error_create_debugfs:
2260 remove_sysfs(acer_platform_device);
2261 error_create_sys:
2262 platform_device_del(acer_platform_device);
2263 error_device_add:
2264 platform_device_put(acer_platform_device);
2265 error_device_alloc:
2266 platform_driver_unregister(&acer_platform_driver);
2267 error_platform_register:
2268 if (wmi_has_guid(ACERWMID_EVENT_GUID))
2269 acer_wmi_input_destroy();
2270 if (has_cap(ACER_CAP_ACCEL))
2271 acer_wmi_accel_destroy();
2272
2273 return err;
2274 }
2275
2276 static void __exit acer_wmi_exit(void)
2277 {
2278 if (wmi_has_guid(ACERWMID_EVENT_GUID))
2279 acer_wmi_input_destroy();
2280
2281 if (has_cap(ACER_CAP_ACCEL))
2282 acer_wmi_accel_destroy();
2283
2284 remove_sysfs(acer_platform_device);
2285 remove_debugfs();
2286 platform_device_unregister(acer_platform_device);
2287 platform_driver_unregister(&acer_platform_driver);
2288
2289 pr_info("Acer Laptop WMI Extras unloaded\n");
2290 return;
2291 }
2292
2293 module_init(acer_wmi_init);
2294 module_exit(acer_wmi_exit);
Linux kernel - Deliverables
This page took 0.10653 seconds and 5 git commands to generate.