projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ACPI: WMI: Enable event methods when registering notifiers
[deliverable/linux.git] / drivers / misc / acer-wmi.c
CommitLineData
745a5d21
CC		 1/*
2 * Acer WMI Laptop Extras
3 *
4 * Copyright (C) 2007-2008 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
745a5d21
CC		 25#include <linux/kernel.h>
26#include <linux/module.h>
27#include <linux/init.h>
28#include <linux/types.h>
29#include <linux/dmi.h>
f2b585b4 30#include <linux/fb.h>
745a5d21
CC		 31#include <linux/backlight.h>
32#include <linux/leds.h>
33#include <linux/platform_device.h>
34#include <linux/acpi.h>
35#include <linux/i8042.h>
0606e1ab
CC		 36#include <linux/rfkill.h>
37#include <linux/workqueue.h>
81143522 38#include <linux/debugfs.h>
745a5d21
CC		 39
40#include <acpi/acpi_drivers.h>
41
42MODULE_AUTHOR("Carlos Corbacho");
43MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
44MODULE_LICENSE("GPL");
45
46#define ACER_LOGPREFIX "acer-wmi: "
47#define ACER_ERR KERN_ERR ACER_LOGPREFIX
48#define ACER_NOTICE KERN_NOTICE ACER_LOGPREFIX
49#define ACER_INFO KERN_INFO ACER_LOGPREFIX
50
51/*
52 * The following defines quirks to get some specific functions to work
53 * which are known to not be supported over ACPI-WMI (such as the mail LED
54 * on WMID based Acer's)
55 */
56struct acer_quirks {
57 const char *vendor;
58 const char *model;
59 u16 quirks;
60};
61
62/*
63 * Magic Number
64 * Meaning is unknown - this number is required for writing to ACPI for AMW0
65 * (it's also used in acerhk when directly accessing the BIOS)
66 */
67#define ACER_AMW0_WRITE 0x9610
68
69/*
70 * Bit masks for the AMW0 interface
71 */
72#define ACER_AMW0_WIRELESS_MASK 0x35
73#define ACER_AMW0_BLUETOOTH_MASK 0x34
74#define ACER_AMW0_MAILLED_MASK 0x31
75
76/*
77 * Method IDs for WMID interface
78 */
79#define ACER_WMID_GET_WIRELESS_METHODID 1
80#define ACER_WMID_GET_BLUETOOTH_METHODID 2
81#define ACER_WMID_GET_BRIGHTNESS_METHODID 3
82#define ACER_WMID_SET_WIRELESS_METHODID 4
83#define ACER_WMID_SET_BLUETOOTH_METHODID 5
84#define ACER_WMID_SET_BRIGHTNESS_METHODID 6
85#define ACER_WMID_GET_THREEG_METHODID 10
86#define ACER_WMID_SET_THREEG_METHODID 11
87
88/*
89 * Acer ACPI method GUIDs
90 */
91#define AMW0_GUID1 "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
5753dd53 92#define AMW0_GUID2 "431F16ED-0C2B-444C-B267-27DEB140CF9C"
745a5d21
CC		 93#define WMID_GUID1 "6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3"
94#define WMID_GUID2 "95764E09-FB56-4e83-B31A-37761F60994A"
95
96MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
97MODULE_ALIAS("wmi:6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3");
98
99/* Temporary workaround until the WMI sysfs interface goes in */
100MODULE_ALIAS("dmi:*:*Acer*:*:");
101
102/*
103 * Interface capability flags
104 */
105#define ACER_CAP_MAILLED (1<<0)
106#define ACER_CAP_WIRELESS (1<<1)
107#define ACER_CAP_BLUETOOTH (1<<2)
108#define ACER_CAP_BRIGHTNESS (1<<3)
109#define ACER_CAP_THREEG (1<<4)
110#define ACER_CAP_ANY (0xFFFFFFFF)
111
112/*
113 * Interface type flags
114 */
115enum interface_flags {
116 ACER_AMW0,
117 ACER_AMW0_V2,
118 ACER_WMID,
119};
120
121#define ACER_DEFAULT_WIRELESS 0
122#define ACER_DEFAULT_BLUETOOTH 0
123#define ACER_DEFAULT_MAILLED 0
124#define ACER_DEFAULT_THREEG 0
125
126static int max_brightness = 0xF;
127
745a5d21
CC		 128static int mailled = -1;
129static int brightness = -1;
130static int threeg = -1;
131static int force_series;
132
133module_param(mailled, int, 0444);
745a5d21
CC		 134module_param(brightness, int, 0444);
135module_param(threeg, int, 0444);
136module_param(force_series, int, 0444);
745a5d21
CC		 137MODULE_PARM_DESC(mailled, "Set initial state of Mail LED");
138MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness");
139MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware");
140MODULE_PARM_DESC(force_series, "Force a different laptop series");
141
142struct acer_data {
143 int mailled;
745a5d21
CC		 144 int threeg;
145 int brightness;
146};
147
81143522
CC		 148struct acer_debug {
149 struct dentry *root;
150 struct dentry *devices;
151 u32 wmid_devices;
152};
153
0606e1ab
CC		 154static struct rfkill *wireless_rfkill;
155static struct rfkill *bluetooth_rfkill;
156
745a5d21
CC		 157/* Each low-level interface must define at least some of the following */
158struct wmi_interface {
159 /* The WMI device type */
160 u32 type;
161
162 /* The capabilities this interface provides */
163 u32 capability;
164
165 /* Private data for the current interface */
166 struct acer_data data;
81143522
CC		 167
168 /* debugfs entries associated with this interface */
169 struct acer_debug debug;
745a5d21
CC		 170};
171
172/* The static interface pointer, points to the currently detected interface */
173static struct wmi_interface *interface;
174
175/*
176 * Embedded Controller quirks
177 * Some laptops require us to directly access the EC to either enable or query
178 * features that are not available through WMI.
179 */
180
181struct quirk_entry {
182 u8 wireless;
183 u8 mailled;
9991d9f2 184 s8 brightness;
745a5d21
CC		 185 u8 bluetooth;
186};
187
188static struct quirk_entry *quirks;
189
190static void set_quirks(void)
191{
83097aca
AV		 192 if (!interface)
193 return;
194
745a5d21
CC		 195 if (quirks->mailled)
196 interface->capability |= ACER_CAP_MAILLED;
197
198 if (quirks->brightness)
199 interface->capability |= ACER_CAP_BRIGHTNESS;
200}
201
202static int dmi_matched(const struct dmi_system_id *dmi)
203{
204 quirks = dmi->driver_data;
205 return 0;
206}
207
208static struct quirk_entry quirk_unknown = {
209};
210
9991d9f2
CC		 211static struct quirk_entry quirk_acer_aspire_1520 = {
212 .brightness = -1,
213};
214
745a5d21
CC		 215static struct quirk_entry quirk_acer_travelmate_2490 = {
216 .mailled = 1,
217};
218
219/* This AMW0 laptop has no bluetooth */
220static struct quirk_entry quirk_medion_md_98300 = {
221 .wireless = 1,
222};
223
6f061ab5
CC		 224static struct quirk_entry quirk_fujitsu_amilo_li_1718 = {
225 .wireless = 2,
226};
227
745a5d21 228static struct dmi_system_id acer_quirks[] = {
9991d9f2
CC		 229 {
230 .callback = dmi_matched,
231 .ident = "Acer Aspire 1360",
232 .matches = {
233 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
234 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"),
235 },
236 .driver_data = &quirk_acer_aspire_1520,
237 },
238 {
239 .callback = dmi_matched,
240 .ident = "Acer Aspire 1520",
241 .matches = {
242 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
243 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1520"),
244 },
245 .driver_data = &quirk_acer_aspire_1520,
246 },
745a5d21
CC		 247 {
248 .callback = dmi_matched,
249 .ident = "Acer Aspire 3100",
250 .matches = {
251 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
252 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3100"),
253 },
254 .driver_data = &quirk_acer_travelmate_2490,
255 },
ed9cfe98
CC		 256 {
257 .callback = dmi_matched,
258 .ident = "Acer Aspire 3610",
259 .matches = {
260 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
261 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3610"),
262 },
263 .driver_data = &quirk_acer_travelmate_2490,
264 },
745a5d21
CC		 265 {
266 .callback = dmi_matched,
267 .ident = "Acer Aspire 5100",
268 .matches = {
269 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
270 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"),
271 },
272 .driver_data = &quirk_acer_travelmate_2490,
273 },
ed9cfe98
CC		 274 {
275 .callback = dmi_matched,
276 .ident = "Acer Aspire 5610",
277 .matches = {
278 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
279 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5610"),
280 },
281 .driver_data = &quirk_acer_travelmate_2490,
282 },
745a5d21
CC		 283 {
284 .callback = dmi_matched,
285 .ident = "Acer Aspire 5630",
286 .matches = {
287 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
288 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"),
289 },
290 .driver_data = &quirk_acer_travelmate_2490,
291 },
292 {
293 .callback = dmi_matched,
294 .ident = "Acer Aspire 5650",
295 .matches = {
296 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
297 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"),
298 },
299 .driver_data = &quirk_acer_travelmate_2490,
300 },
301 {
302 .callback = dmi_matched,
303 .ident = "Acer Aspire 5680",
304 .matches = {
305 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
306 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"),
307 },
308 .driver_data = &quirk_acer_travelmate_2490,
309 },
310 {
311 .callback = dmi_matched,
312 .ident = "Acer Aspire 9110",
313 .matches = {
314 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
315 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"),
316 },
317 .driver_data = &quirk_acer_travelmate_2490,
318 },
319 {
320 .callback = dmi_matched,
321 .ident = "Acer TravelMate 2490",
322 .matches = {
323 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
324 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
325 },
326 .driver_data = &quirk_acer_travelmate_2490,
327 },
262ee35b
CC		 328 {
329 .callback = dmi_matched,
330 .ident = "Acer TravelMate 4200",
331 .matches = {
332 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
333 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4200"),
334 },
335 .driver_data = &quirk_acer_travelmate_2490,
336 },
6f061ab5
CC		 337 {
338 .callback = dmi_matched,
339 .ident = "Fujitsu Siemens Amilo Li 1718",
340 .matches = {
341 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
342 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Li 1718"),
343 },
344 .driver_data = &quirk_fujitsu_amilo_li_1718,
345 },
745a5d21
CC		 346 {
347 .callback = dmi_matched,
348 .ident = "Medion MD 98300",
349 .matches = {
350 DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
351 DMI_MATCH(DMI_PRODUCT_NAME, "WAM2030"),
352 },
353 .driver_data = &quirk_medion_md_98300,
354 },
355 {}
356};
357
358/* Find which quirks are needed for a particular vendor/ model pair */
359static void find_quirks(void)
360{
361 if (!force_series) {
362 dmi_check_system(acer_quirks);
363 } else if (force_series == 2490) {
364 quirks = &quirk_acer_travelmate_2490;
365 }
366
367 if (quirks == NULL)
368 quirks = &quirk_unknown;
369
370 set_quirks();
371}
372
373/*
374 * General interface convenience methods
375 */
376
377static bool has_cap(u32 cap)
378{
379 if ((interface->capability & cap) != 0)
380 return 1;
381
382 return 0;
383}
384
385/*
386 * AMW0 (V1) interface
387 */
388struct wmab_args {
389 u32 eax;
390 u32 ebx;
391 u32 ecx;
392 u32 edx;
393};
394
395struct wmab_ret {
396 u32 eax;
397 u32 ebx;
398 u32 ecx;
399 u32 edx;
400 u32 eex;
401};
402
403static acpi_status wmab_execute(struct wmab_args *regbuf,
404struct acpi_buffer *result)
405{
406 struct acpi_buffer input;
407 acpi_status status;
408 input.length = sizeof(struct wmab_args);
409 input.pointer = (u8 *)regbuf;
410
411 status = wmi_evaluate_method(AMW0_GUID1, 1, 1, &input, result);
412
413 return status;
414}
415
416static acpi_status AMW0_get_u32(u32 *value, u32 cap,
417struct wmi_interface *iface)
418{
419 int err;
420 u8 result;
421
422 switch (cap) {
423 case ACER_CAP_MAILLED:
424 switch (quirks->mailled) {
425 default:
426 err = ec_read(0xA, &result);
427 if (err)
428 return AE_ERROR;
429 *value = (result >> 7) & 0x1;
430 return AE_OK;
431 }
432 break;
433 case ACER_CAP_WIRELESS:
434 switch (quirks->wireless) {
435 case 1:
436 err = ec_read(0x7B, &result);
437 if (err)
438 return AE_ERROR;
439 *value = result & 0x1;
440 return AE_OK;
6f061ab5
CC		 441 case 2:
442 err = ec_read(0x71, &result);
443 if (err)
444 return AE_ERROR;
445 *value = result & 0x1;
446 return AE_OK;
745a5d21
CC		 447 default:
448 err = ec_read(0xA, &result);
449 if (err)
450 return AE_ERROR;
451 *value = (result >> 2) & 0x1;
452 return AE_OK;
453 }
454 break;
455 case ACER_CAP_BLUETOOTH:
456 switch (quirks->bluetooth) {
457 default:
458 err = ec_read(0xA, &result);
459 if (err)
460 return AE_ERROR;
461 *value = (result >> 4) & 0x1;
462 return AE_OK;
463 }
464 break;
465 case ACER_CAP_BRIGHTNESS:
466 switch (quirks->brightness) {
467 default:
468 err = ec_read(0x83, &result);
469 if (err)
470 return AE_ERROR;
471 *value = result;
472 return AE_OK;
473 }
474 break;
475 default:
476 return AE_BAD_ADDRESS;
477 }
478 return AE_OK;
479}
480
481static acpi_status AMW0_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
482{
483 struct wmab_args args;
484
485 args.eax = ACER_AMW0_WRITE;
486 args.ebx = value ? (1<<8) : 0;
487 args.ecx = args.edx = 0;
488
489 switch (cap) {
490 case ACER_CAP_MAILLED:
491 if (value > 1)
492 return AE_BAD_PARAMETER;
493 args.ebx |= ACER_AMW0_MAILLED_MASK;
494 break;
495 case ACER_CAP_WIRELESS:
496 if (value > 1)
497 return AE_BAD_PARAMETER;
498 args.ebx |= ACER_AMW0_WIRELESS_MASK;
499 break;
500 case ACER_CAP_BLUETOOTH:
501 if (value > 1)
502 return AE_BAD_PARAMETER;
503 args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
504 break;
505 case ACER_CAP_BRIGHTNESS:
506 if (value > max_brightness)
507 return AE_BAD_PARAMETER;
508 switch (quirks->brightness) {
745a5d21 509 default:
4609d029
CC		 510 return ec_write(0x83, value);
511 break;
745a5d21
CC		 512 }
513 default:
514 return AE_BAD_ADDRESS;
515 }
516
517 /* Actually do the set */
518 return wmab_execute(&args, NULL);
519}
520
521static acpi_status AMW0_find_mailled(void)
522{
523 struct wmab_args args;
524 struct wmab_ret ret;
525 acpi_status status = AE_OK;
526 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
527 union acpi_object *obj;
528
529 args.eax = 0x86;
530 args.ebx = args.ecx = args.edx = 0;
531
532 status = wmab_execute(&args, &out);
533 if (ACPI_FAILURE(status))
534 return status;
535
536 obj = (union acpi_object *) out.pointer;
537 if (obj && obj->type == ACPI_TYPE_BUFFER &&
538 obj->buffer.length == sizeof(struct wmab_ret)) {
539 ret = *((struct wmab_ret *) obj->buffer.pointer);
540 } else {
541 return AE_ERROR;
542 }
543
544 if (ret.eex & 0x1)
545 interface->capability |= ACER_CAP_MAILLED;
546
547 kfree(out.pointer);
548
549 return AE_OK;
550}
551
552static acpi_status AMW0_set_capabilities(void)
553{
554 struct wmab_args args;
555 struct wmab_ret ret;
556 acpi_status status = AE_OK;
557 struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
558 union acpi_object *obj;
559
5753dd53
CC		 560 /*
561 * On laptops with this strange GUID (non Acer), normal probing doesn't
562 * work.
563 */
564 if (wmi_has_guid(AMW0_GUID2)) {
565 interface->capability |= ACER_CAP_WIRELESS;
566 return AE_OK;
567 }
568
745a5d21
CC		 569 args.eax = ACER_AMW0_WRITE;
570 args.ecx = args.edx = 0;
571
572 args.ebx = 0xa2 << 8;
573 args.ebx |= ACER_AMW0_WIRELESS_MASK;
574
575 status = wmab_execute(&args, &out);
576 if (ACPI_FAILURE(status))
577 return status;
578
579 obj = (union acpi_object *) out.pointer;
580 if (obj && obj->type == ACPI_TYPE_BUFFER &&
581 obj->buffer.length == sizeof(struct wmab_ret)) {
582 ret = *((struct wmab_ret *) obj->buffer.pointer);
583 } else {
584 return AE_ERROR;
585 }
586
587 if (ret.eax & 0x1)
588 interface->capability |= ACER_CAP_WIRELESS;
589
590 args.ebx = 2 << 8;
591 args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
592
593 status = wmab_execute(&args, &out);
594 if (ACPI_FAILURE(status))
595 return status;
596
597 obj = (union acpi_object *) out.pointer;
598 if (obj && obj->type == ACPI_TYPE_BUFFER
599 && obj->buffer.length == sizeof(struct wmab_ret)) {
600 ret = *((struct wmab_ret *) obj->buffer.pointer);
601 } else {
602 return AE_ERROR;
603 }
604
605 if (ret.eax & 0x1)
606 interface->capability |= ACER_CAP_BLUETOOTH;
607
608 kfree(out.pointer);
609
610 /*
611 * This appears to be safe to enable, since all Wistron based laptops
612 * appear to use the same EC register for brightness, even if they
613 * differ for wireless, etc
614 */
9991d9f2
CC		 615 if (quirks->brightness >= 0)
616 interface->capability |= ACER_CAP_BRIGHTNESS;
745a5d21
CC		 617
618 return AE_OK;
619}
620
621static struct wmi_interface AMW0_interface = {
622 .type = ACER_AMW0,
623};
624
625static struct wmi_interface AMW0_V2_interface = {
626 .type = ACER_AMW0_V2,
627};
628
629/*
630 * New interface (The WMID interface)
631 */
632static acpi_status
633WMI_execute_u32(u32 method_id, u32 in, u32 *out)
634{
635 struct acpi_buffer input = { (acpi_size) sizeof(u32), (void *)(&in) };
636 struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
637 union acpi_object *obj;
638 u32 tmp;
639 acpi_status status;
640
641 status = wmi_evaluate_method(WMID_GUID1, 1, method_id, &input, &result);
642
643 if (ACPI_FAILURE(status))
644 return status;
645
646 obj = (union acpi_object *) result.pointer;
647 if (obj && obj->type == ACPI_TYPE_BUFFER &&
648 obj->buffer.length == sizeof(u32)) {
649 tmp = *((u32 *) obj->buffer.pointer);
650 } else {
651 tmp = 0;
652 }
653
654 if (out)
655 *out = tmp;
656
657 kfree(result.pointer);
658
659 return status;
660}
661
662static acpi_status WMID_get_u32(u32 *value, u32 cap,
663struct wmi_interface *iface)
664{
665 acpi_status status;
666 u8 tmp;
667 u32 result, method_id = 0;
668
669 switch (cap) {
670 case ACER_CAP_WIRELESS:
671 method_id = ACER_WMID_GET_WIRELESS_METHODID;
672 break;
673 case ACER_CAP_BLUETOOTH:
674 method_id = ACER_WMID_GET_BLUETOOTH_METHODID;
675 break;
676 case ACER_CAP_BRIGHTNESS:
677 method_id = ACER_WMID_GET_BRIGHTNESS_METHODID;
678 break;
679 case ACER_CAP_THREEG:
680 method_id = ACER_WMID_GET_THREEG_METHODID;
681 break;
682 case ACER_CAP_MAILLED:
683 if (quirks->mailled == 1) {
684 ec_read(0x9f, &tmp);
685 *value = tmp & 0x1;
686 return 0;
687 }
688 default:
689 return AE_BAD_ADDRESS;
690 }
691 status = WMI_execute_u32(method_id, 0, &result);
692
693 if (ACPI_SUCCESS(status))
694 *value = (u8)result;
695
696 return status;
697}
698
699static acpi_status WMID_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
700{
701 u32 method_id = 0;
702 char param;
703
704 switch (cap) {
705 case ACER_CAP_BRIGHTNESS:
706 if (value > max_brightness)
707 return AE_BAD_PARAMETER;
708 method_id = ACER_WMID_SET_BRIGHTNESS_METHODID;
709 break;
710 case ACER_CAP_WIRELESS:
711 if (value > 1)
712 return AE_BAD_PARAMETER;
713 method_id = ACER_WMID_SET_WIRELESS_METHODID;
714 break;
715 case ACER_CAP_BLUETOOTH:
716 if (value > 1)
717 return AE_BAD_PARAMETER;
718 method_id = ACER_WMID_SET_BLUETOOTH_METHODID;
719 break;
720 case ACER_CAP_THREEG:
721 if (value > 1)
722 return AE_BAD_PARAMETER;
723 method_id = ACER_WMID_SET_THREEG_METHODID;
724 break;
725 case ACER_CAP_MAILLED:
726 if (value > 1)
727 return AE_BAD_PARAMETER;
728 if (quirks->mailled == 1) {
729 param = value ? 0x92 : 0x93;
730 i8042_command(&param, 0x1059);
731 return 0;
732 }
733 break;
734 default:
735 return AE_BAD_ADDRESS;
736 }
737 return WMI_execute_u32(method_id, (u32)value, NULL);
738}
739
740static acpi_status WMID_set_capabilities(void)
741{
742 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
743 union acpi_object *obj;
744 acpi_status status;
745 u32 devices;
746
747 status = wmi_query_block(WMID_GUID2, 1, &out);
748 if (ACPI_FAILURE(status))
749 return status;
750
751 obj = (union acpi_object *) out.pointer;
752 if (obj && obj->type == ACPI_TYPE_BUFFER &&
753 obj->buffer.length == sizeof(u32)) {
754 devices = *((u32 *) obj->buffer.pointer);
755 } else {
756 return AE_ERROR;
757 }
758
759 /* Not sure on the meaning of the relevant bits yet to detect these */
760 interface->capability |= ACER_CAP_WIRELESS;
761 interface->capability |= ACER_CAP_THREEG;
762
763 /* WMID always provides brightness methods */
764 interface->capability |= ACER_CAP_BRIGHTNESS;
765
766 if (devices & 0x10)
767 interface->capability |= ACER_CAP_BLUETOOTH;
768
769 if (!(devices & 0x20))
770 max_brightness = 0x9;
771
772 return status;
773}
774
775static struct wmi_interface wmid_interface = {
776 .type = ACER_WMID,
777};
778
779/*
780 * Generic Device (interface-independent)
781 */
782
783static acpi_status get_u32(u32 *value, u32 cap)
784{
785 acpi_status status = AE_BAD_ADDRESS;
786
787 switch (interface->type) {
788 case ACER_AMW0:
789 status = AMW0_get_u32(value, cap, interface);
790 break;
791 case ACER_AMW0_V2:
792 if (cap == ACER_CAP_MAILLED) {
793 status = AMW0_get_u32(value, cap, interface);
794 break;
795 }
796 case ACER_WMID:
797 status = WMID_get_u32(value, cap, interface);
798 break;
799 }
800
801 return status;
802}
803
804static acpi_status set_u32(u32 value, u32 cap)
805{
5c742b45
CC		 806 acpi_status status;
807
745a5d21
CC		 808 if (interface->capability & cap) {
809 switch (interface->type) {
810 case ACER_AMW0:
811 return AMW0_set_u32(value, cap, interface);
812 case ACER_AMW0_V2:
5c742b45
CC		 813 if (cap == ACER_CAP_MAILLED)
814 return AMW0_set_u32(value, cap, interface);
815
816 /*
817 * On some models, some WMID methods don't toggle
818 * properly. For those cases, we want to run the AMW0
819 * method afterwards to be certain we've really toggled
820 * the device state.
821 */
822 if (cap == ACER_CAP_WIRELESS ||
823 cap == ACER_CAP_BLUETOOTH) {
824 status = WMID_set_u32(value, cap, interface);
825 if (ACPI_FAILURE(status))
826 return status;
827
828 return AMW0_set_u32(value, cap, interface);
829 }
745a5d21
CC		 830 case ACER_WMID:
831 return WMID_set_u32(value, cap, interface);
832 default:
833 return AE_BAD_PARAMETER;
834 }
835 }
836 return AE_BAD_PARAMETER;
837}
838
839static void __init acer_commandline_init(void)
840{
841 /*
842 * These will all fail silently if the value given is invalid, or the
843 * capability isn't available on the given interface
844 */
845 set_u32(mailled, ACER_CAP_MAILLED);
745a5d21
CC		 846 set_u32(threeg, ACER_CAP_THREEG);
847 set_u32(brightness, ACER_CAP_BRIGHTNESS);
848}
849
850/*
851 * LED device (Mail LED only, no other LEDs known yet)
852 */
853static void mail_led_set(struct led_classdev *led_cdev,
854enum led_brightness value)
855{
856 set_u32(value, ACER_CAP_MAILLED);
857}
858
859static struct led_classdev mail_led = {
343c0042 860 .name = "acer-wmi::mail",
745a5d21
CC		 861 .brightness_set = mail_led_set,
862};
863
7560e385 864static int __devinit acer_led_init(struct device *dev)
745a5d21
CC		 865{
866 return led_classdev_register(dev, &mail_led);
867}
868
869static void acer_led_exit(void)
870{
871 led_classdev_unregister(&mail_led);
872}
873
874/*
875 * Backlight device
876 */
877static struct backlight_device *acer_backlight_device;
878
879static int read_brightness(struct backlight_device *bd)
880{
881 u32 value;
882 get_u32(&value, ACER_CAP_BRIGHTNESS);
883 return value;
884}
885
886static int update_bl_status(struct backlight_device *bd)
887{
f2b585b4
CC		 888 int intensity = bd->props.brightness;
889
890 if (bd->props.power != FB_BLANK_UNBLANK)
891 intensity = 0;
892 if (bd->props.fb_blank != FB_BLANK_UNBLANK)
893 intensity = 0;
894
895 set_u32(intensity, ACER_CAP_BRIGHTNESS);
896
745a5d21
CC		 897 return 0;
898}
899
900static struct backlight_ops acer_bl_ops = {
901 .get_brightness = read_brightness,
902 .update_status = update_bl_status,
903};
904
7560e385 905static int __devinit acer_backlight_init(struct device *dev)
745a5d21
CC		 906{
907 struct backlight_device *bd;
908
909 bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops);
910 if (IS_ERR(bd)) {
911 printk(ACER_ERR "Could not register Acer backlight device\n");
912 acer_backlight_device = NULL;
913 return PTR_ERR(bd);
914 }
915
916 acer_backlight_device = bd;
917
f2b585b4
CC		 918 bd->props.power = FB_BLANK_UNBLANK;
919 bd->props.brightness = max_brightness;
745a5d21 920 bd->props.max_brightness = max_brightness;
745a5d21
CC		 921 backlight_update_status(bd);
922 return 0;
923}
924
7560e385 925static void acer_backlight_exit(void)
745a5d21
CC		 926{
927 backlight_device_unregister(acer_backlight_device);
928}
929
0606e1ab
CC		 930/*
931 * Rfkill devices
932 */
933static struct workqueue_struct *rfkill_workqueue;
934
935static void acer_rfkill_update(struct work_struct *ignored);
936static DECLARE_DELAYED_WORK(acer_rfkill_work, acer_rfkill_update);
937static void acer_rfkill_update(struct work_struct *ignored)
938{
939 u32 state;
940 acpi_status status;
941
942 status = get_u32(&state, ACER_CAP_WIRELESS);
943 if (ACPI_SUCCESS(status))
944 rfkill_force_state(wireless_rfkill, state ?
945 RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED);
946
947 if (has_cap(ACER_CAP_BLUETOOTH)) {
948 status = get_u32(&state, ACER_CAP_BLUETOOTH);
949 if (ACPI_SUCCESS(status))
950 rfkill_force_state(bluetooth_rfkill, state ?
951 RFKILL_STATE_UNBLOCKED :
952 RFKILL_STATE_SOFT_BLOCKED);
953 }
954
955 queue_delayed_work(rfkill_workqueue, &acer_rfkill_work,
956 round_jiffies_relative(HZ));
957}
958
959static int acer_rfkill_set(void *data, enum rfkill_state state)
960{
961 acpi_status status;
962 u32 *cap = data;
963 status = set_u32((u32) (state == RFKILL_STATE_UNBLOCKED), *cap);
964 if (ACPI_FAILURE(status))
965 return -ENODEV;
966 return 0;
967}
968
969static struct rfkill * acer_rfkill_register(struct device *dev,
970enum rfkill_type type, char *name, u32 cap)
971{
972 int err;
973 u32 state;
974 u32 *data;
975 struct rfkill *rfkill_dev;
976
977 rfkill_dev = rfkill_allocate(dev, type);
978 if (!rfkill_dev)
979 return ERR_PTR(-ENOMEM);
980 rfkill_dev->name = name;
981 get_u32(&state, cap);
982 rfkill_dev->state = state ? RFKILL_STATE_UNBLOCKED :
983 RFKILL_STATE_SOFT_BLOCKED;
984 data = kzalloc(sizeof(u32), GFP_KERNEL);
985 if (!data) {
986 rfkill_free(rfkill_dev);
987 return ERR_PTR(-ENOMEM);
988 }
989 *data = cap;
990 rfkill_dev->data = data;
991 rfkill_dev->toggle_radio = acer_rfkill_set;
992 rfkill_dev->user_claim_unsupported = 1;
993
994 err = rfkill_register(rfkill_dev);
995 if (err) {
996 kfree(rfkill_dev->data);
997 rfkill_free(rfkill_dev);
998 return ERR_PTR(err);
999 }
1000 return rfkill_dev;
1001}
1002
1003static int acer_rfkill_init(struct device *dev)
1004{
1005 wireless_rfkill = acer_rfkill_register(dev, RFKILL_TYPE_WLAN,
1006 "acer-wireless", ACER_CAP_WIRELESS);
1007 if (IS_ERR(wireless_rfkill))
1008 return PTR_ERR(wireless_rfkill);
1009
1010 if (has_cap(ACER_CAP_BLUETOOTH)) {
1011 bluetooth_rfkill = acer_rfkill_register(dev,
1012 RFKILL_TYPE_BLUETOOTH, "acer-bluetooth",
1013 ACER_CAP_BLUETOOTH);
1014 if (IS_ERR(bluetooth_rfkill)) {
1015 kfree(wireless_rfkill->data);
1016 rfkill_unregister(wireless_rfkill);
1017 return PTR_ERR(bluetooth_rfkill);
1018 }
1019 }
1020
1021 rfkill_workqueue = create_singlethread_workqueue("rfkill_workqueue");
1022 if (!rfkill_workqueue) {
1023 if (has_cap(ACER_CAP_BLUETOOTH)) {
1024 kfree(bluetooth_rfkill->data);
1025 rfkill_unregister(bluetooth_rfkill);
1026 }
1027 kfree(wireless_rfkill->data);
1028 rfkill_unregister(wireless_rfkill);
1029 return -ENOMEM;
1030 }
1031 queue_delayed_work(rfkill_workqueue, &acer_rfkill_work, HZ);
1032
1033 return 0;
1034}
1035
1036static void acer_rfkill_exit(void)
1037{
1038 cancel_delayed_work_sync(&acer_rfkill_work);
1039 destroy_workqueue(rfkill_workqueue);
1040 kfree(wireless_rfkill->data);
1041 rfkill_unregister(wireless_rfkill);
1042 if (has_cap(ACER_CAP_BLUETOOTH)) {
1043 kfree(wireless_rfkill->data);
1044 rfkill_unregister(bluetooth_rfkill);
1045 }
1046 return;
1047}
1048
745a5d21 1049/*
7d9a06de 1050 * sysfs interface
745a5d21 1051 */
7d9a06de
CC		 1052static ssize_t show_bool_threeg(struct device *dev,
1053 struct device_attribute *attr, char *buf)
1054{
745a5d21 1055 u32 result; \
7d9a06de
CC		 1056 acpi_status status = get_u32(&result, ACER_CAP_THREEG);
1057 if (ACPI_SUCCESS(status))
1058 return sprintf(buf, "%u\n", result);
1059 return sprintf(buf, "Read error\n");
1060}
1061
1062static ssize_t set_bool_threeg(struct device *dev,
1063 struct device_attribute *attr, const char *buf, size_t count)
1064{
1065 u32 tmp = simple_strtoul(buf, NULL, 10);
1066 acpi_status status = set_u32(tmp, ACER_CAP_THREEG);
1067 if (ACPI_FAILURE(status))
1068 return -EINVAL;
1069 return count;
1070}
1071static DEVICE_ATTR(threeg, S_IWUGO | S_IRUGO | S_IWUSR, show_bool_threeg,
1072 set_bool_threeg);
745a5d21 1073
745a5d21
CC		 1074static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
1075 char *buf)
1076{
1077 switch (interface->type) {
1078 case ACER_AMW0:
1079 return sprintf(buf, "AMW0\n");
1080 case ACER_AMW0_V2:
1081 return sprintf(buf, "AMW0 v2\n");
1082 case ACER_WMID:
1083 return sprintf(buf, "WMID\n");
1084 default:
1085 return sprintf(buf, "Error!\n");
1086 }
1087}
1088
1089static DEVICE_ATTR(interface, S_IWUGO | S_IRUGO | S_IWUSR,
1090 show_interface, NULL);
1091
81143522
CC		 1092/*
1093 * debugfs functions
1094 */
1095static u32 get_wmid_devices(void)
1096{
1097 struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
1098 union acpi_object *obj;
1099 acpi_status status;
1100
1101 status = wmi_query_block(WMID_GUID2, 1, &out);
1102 if (ACPI_FAILURE(status))
1103 return 0;
1104
1105 obj = (union acpi_object *) out.pointer;
1106 if (obj && obj->type == ACPI_TYPE_BUFFER &&
1107 obj->buffer.length == sizeof(u32)) {
1108 return *((u32 *) obj->buffer.pointer);
1109 } else {
1110 return 0;
1111 }
1112}
1113
745a5d21
CC		 1114/*
1115 * Platform device
1116 */
1117static int __devinit acer_platform_probe(struct platform_device *device)
1118{
1119 int err;
1120
1121 if (has_cap(ACER_CAP_MAILLED)) {
1122 err = acer_led_init(&device->dev);
1123 if (err)
1124 goto error_mailled;
1125 }
1126
1127 if (has_cap(ACER_CAP_BRIGHTNESS)) {
1128 err = acer_backlight_init(&device->dev);
1129 if (err)
1130 goto error_brightness;
1131 }
1132
0606e1ab
CC		 1133 err = acer_rfkill_init(&device->dev);
1134
1135 return err;
745a5d21
CC		 1136
1137error_brightness:
1138 acer_led_exit();
1139error_mailled:
1140 return err;
1141}
1142
1143static int acer_platform_remove(struct platform_device *device)
1144{
1145 if (has_cap(ACER_CAP_MAILLED))
1146 acer_led_exit();
1147 if (has_cap(ACER_CAP_BRIGHTNESS))
1148 acer_backlight_exit();
0606e1ab
CC		 1149
1150 acer_rfkill_exit();
745a5d21
CC		 1151 return 0;
1152}
1153
1154static int acer_platform_suspend(struct platform_device *dev,
1155pm_message_t state)
1156{
1157 u32 value;
1158 struct acer_data *data = &interface->data;
1159
1160 if (!data)
1161 return -ENOMEM;
1162
745a5d21
CC		 1163 if (has_cap(ACER_CAP_MAILLED)) {
1164 get_u32(&value, ACER_CAP_MAILLED);
1165 data->mailled = value;
1166 }
1167
1168 if (has_cap(ACER_CAP_BRIGHTNESS)) {
1169 get_u32(&value, ACER_CAP_BRIGHTNESS);
1170 data->brightness = value;
1171 }
1172
1173 return 0;
1174}
1175
1176static int acer_platform_resume(struct platform_device *device)
1177{
1178 struct acer_data *data = &interface->data;
1179
1180 if (!data)
1181 return -ENOMEM;
1182
745a5d21
CC		 1183 if (has_cap(ACER_CAP_MAILLED))
1184 set_u32(data->mailled, ACER_CAP_MAILLED);
1185
1186 if (has_cap(ACER_CAP_BRIGHTNESS))
1187 set_u32(data->brightness, ACER_CAP_BRIGHTNESS);
1188
1189 return 0;
1190}
1191
1192static struct platform_driver acer_platform_driver = {
1193 .driver = {
1194 .name = "acer-wmi",
1195 .owner = THIS_MODULE,
1196 },
1197 .probe = acer_platform_probe,
1198 .remove = acer_platform_remove,
1199 .suspend = acer_platform_suspend,
1200 .resume = acer_platform_resume,
1201};
1202
1203static struct platform_device *acer_platform_device;
1204
1205static int remove_sysfs(struct platform_device *device)
1206{
745a5d21
CC		 1207 if (has_cap(ACER_CAP_THREEG))
1208 device_remove_file(&device->dev, &dev_attr_threeg);
1209
1210 device_remove_file(&device->dev, &dev_attr_interface);
1211
1212 return 0;
1213}
1214
1215static int create_sysfs(void)
1216{
1217 int retval = -ENOMEM;
1218
745a5d21
CC		 1219 if (has_cap(ACER_CAP_THREEG)) {
1220 retval = device_create_file(&acer_platform_device->dev,
1221 &dev_attr_threeg);
1222 if (retval)
1223 goto error_sysfs;
1224 }
1225
1226 retval = device_create_file(&acer_platform_device->dev,
1227 &dev_attr_interface);
1228 if (retval)
1229 goto error_sysfs;
1230
1231 return 0;
1232
1233error_sysfs:
1234 remove_sysfs(acer_platform_device);
1235 return retval;
1236}
1237
81143522
CC		 1238static void remove_debugfs(void)
1239{
1240 debugfs_remove(interface->debug.devices);
1241 debugfs_remove(interface->debug.root);
1242}
1243
1244static int create_debugfs(void)
1245{
1246 interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
1247 if (!interface->debug.root) {
1248 printk(ACER_ERR "Failed to create debugfs directory");
1249 return -ENOMEM;
1250 }
1251
1252 interface->debug.devices = debugfs_create_u32("devices", S_IRUGO,
1253 interface->debug.root,
1254 &interface->debug.wmid_devices);
1255 if (!interface->debug.devices)
1256 goto error_debugfs;
1257
1258 return 0;
1259
1260error_debugfs:
39dbbb45 1261 remove_debugfs();
81143522
CC		 1262 return -ENOMEM;
1263}
1264
745a5d21
CC		 1265static int __init acer_wmi_init(void)
1266{
1267 int err;
1268
860f0c6b 1269 printk(ACER_INFO "Acer Laptop ACPI-WMI Extras\n");
745a5d21 1270
9991d9f2
CC		 1271 find_quirks();
1272
745a5d21
CC		 1273 /*
1274 * Detect which ACPI-WMI interface we're using.
1275 */
1276 if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
1277 interface = &AMW0_V2_interface;
1278
1279 if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
1280 interface = &wmid_interface;
1281
1282 if (wmi_has_guid(WMID_GUID2) && interface) {
1283 if (ACPI_FAILURE(WMID_set_capabilities())) {
8d039bc7
CC		 1284 printk(ACER_ERR "Unable to detect available WMID "
1285 "devices\n");
745a5d21
CC		 1286 return -ENODEV;
1287 }
1288 } else if (!wmi_has_guid(WMID_GUID2) && interface) {
8d039bc7 1289 printk(ACER_ERR "No WMID device detection method found\n");
745a5d21
CC		 1290 return -ENODEV;
1291 }
1292
1293 if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) {
1294 interface = &AMW0_interface;
1295
1296 if (ACPI_FAILURE(AMW0_set_capabilities())) {
8d039bc7
CC		 1297 printk(ACER_ERR "Unable to detect available AMW0 "
1298 "devices\n");
745a5d21
CC		 1299 return -ENODEV;
1300 }
1301 }
1302
9b963c40
CC		 1303 if (wmi_has_guid(AMW0_GUID1))
1304 AMW0_find_mailled();
745a5d21 1305
745a5d21 1306 if (!interface) {
8d039bc7
CC		 1307 printk(ACER_ERR "No or unsupported WMI interface, unable to "
1308 "load\n");
745a5d21
CC		 1309 return -ENODEV;
1310 }
1311
83097aca
AV		 1312 set_quirks();
1313
745a5d21
CC		 1314 if (platform_driver_register(&acer_platform_driver)) {
1315 printk(ACER_ERR "Unable to register platform driver.\n");
1316 goto error_platform_register;
1317 }
1318 acer_platform_device = platform_device_alloc("acer-wmi", -1);
1319 platform_device_add(acer_platform_device);
1320
1321 err = create_sysfs();
1322 if (err)
1323 return err;
1324
81143522
CC		 1325 if (wmi_has_guid(WMID_GUID2)) {
1326 interface->debug.wmid_devices = get_wmid_devices();
1327 err = create_debugfs();
1328 if (err)
1329 return err;
1330 }
1331
745a5d21
CC		 1332 /* Override any initial settings with values from the commandline */
1333 acer_commandline_init();
1334
1335 return 0;
1336
1337error_platform_register:
1338 return -ENODEV;
1339}
1340
1341static void __exit acer_wmi_exit(void)
1342{
1343 remove_sysfs(acer_platform_device);
39dbbb45 1344 remove_debugfs();
745a5d21
CC		 1345 platform_device_del(acer_platform_device);
1346 platform_driver_unregister(&acer_platform_driver);
1347
1348 printk(ACER_INFO "Acer Laptop WMI Extras unloaded\n");
1349 return;
1350}
1351
1352module_init(acer_wmi_init);
1353module_exit(acer_wmi_exit);
Linux kernel - Deliverables
This page took 0.192576 seconds and 5 git commands to generate.