Merge branch 'r6040' of git://git.kernel.org/pub/scm/linux/kernel/git/romieu/netdev...
[linux-2.6] / drivers / misc / acer-wmi.c
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
25 #define ACER_WMI_VERSION        "0.1"
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/backlight.h>
33 #include <linux/leds.h>
34 #include <linux/platform_device.h>
35 #include <linux/acpi.h>
36 #include <linux/i8042.h>
37
38 #include <acpi/acpi_drivers.h>
39
40 MODULE_AUTHOR("Carlos Corbacho");
41 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
42 MODULE_LICENSE("GPL");
43
44 #define ACER_LOGPREFIX "acer-wmi: "
45 #define ACER_ERR KERN_ERR ACER_LOGPREFIX
46 #define ACER_NOTICE KERN_NOTICE ACER_LOGPREFIX
47 #define ACER_INFO KERN_INFO ACER_LOGPREFIX
48
49 /*
50  * The following defines quirks to get some specific functions to work
51  * which are known to not be supported over ACPI-WMI (such as the mail LED
52  * on WMID based Acer's)
53  */
54 struct acer_quirks {
55         const char *vendor;
56         const char *model;
57         u16 quirks;
58 };
59
60 /*
61  * Magic Number
62  * Meaning is unknown - this number is required for writing to ACPI for AMW0
63  * (it's also used in acerhk when directly accessing the BIOS)
64  */
65 #define ACER_AMW0_WRITE 0x9610
66
67 /*
68  * Bit masks for the AMW0 interface
69  */
70 #define ACER_AMW0_WIRELESS_MASK  0x35
71 #define ACER_AMW0_BLUETOOTH_MASK 0x34
72 #define ACER_AMW0_MAILLED_MASK   0x31
73
74 /*
75  * Method IDs for WMID interface
76  */
77 #define ACER_WMID_GET_WIRELESS_METHODID         1
78 #define ACER_WMID_GET_BLUETOOTH_METHODID        2
79 #define ACER_WMID_GET_BRIGHTNESS_METHODID       3
80 #define ACER_WMID_SET_WIRELESS_METHODID         4
81 #define ACER_WMID_SET_BLUETOOTH_METHODID        5
82 #define ACER_WMID_SET_BRIGHTNESS_METHODID       6
83 #define ACER_WMID_GET_THREEG_METHODID           10
84 #define ACER_WMID_SET_THREEG_METHODID           11
85
86 /*
87  * Acer ACPI method GUIDs
88  */
89 #define AMW0_GUID1              "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
90 #define WMID_GUID1              "6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3"
91 #define WMID_GUID2              "95764E09-FB56-4e83-B31A-37761F60994A"
92
93 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
94 MODULE_ALIAS("wmi:6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3");
95
96 /* Temporary workaround until the WMI sysfs interface goes in */
97 MODULE_ALIAS("dmi:*:*Acer*:*:");
98
99 /*
100  * Interface capability flags
101  */
102 #define ACER_CAP_MAILLED                (1<<0)
103 #define ACER_CAP_WIRELESS               (1<<1)
104 #define ACER_CAP_BLUETOOTH              (1<<2)
105 #define ACER_CAP_BRIGHTNESS             (1<<3)
106 #define ACER_CAP_THREEG                 (1<<4)
107 #define ACER_CAP_ANY                    (0xFFFFFFFF)
108
109 /*
110  * Interface type flags
111  */
112 enum interface_flags {
113         ACER_AMW0,
114         ACER_AMW0_V2,
115         ACER_WMID,
116 };
117
118 #define ACER_DEFAULT_WIRELESS  0
119 #define ACER_DEFAULT_BLUETOOTH 0
120 #define ACER_DEFAULT_MAILLED   0
121 #define ACER_DEFAULT_THREEG    0
122
123 static int max_brightness = 0xF;
124
125 static int wireless = -1;
126 static int bluetooth = -1;
127 static int mailled = -1;
128 static int brightness = -1;
129 static int threeg = -1;
130 static int force_series;
131
132 module_param(mailled, int, 0444);
133 module_param(wireless, int, 0444);
134 module_param(bluetooth, int, 0444);
135 module_param(brightness, int, 0444);
136 module_param(threeg, int, 0444);
137 module_param(force_series, int, 0444);
138 MODULE_PARM_DESC(wireless, "Set initial state of Wireless hardware");
139 MODULE_PARM_DESC(bluetooth, "Set initial state of Bluetooth hardware");
140 MODULE_PARM_DESC(mailled, "Set initial state of Mail LED");
141 MODULE_PARM_DESC(brightness, "Set initial LCD backlight brightness");
142 MODULE_PARM_DESC(threeg, "Set initial state of 3G hardware");
143 MODULE_PARM_DESC(force_series, "Force a different laptop series");
144
145 struct acer_data {
146         int mailled;
147         int wireless;
148         int bluetooth;
149         int threeg;
150         int brightness;
151 };
152
153 /* Each low-level interface must define at least some of the following */
154 struct wmi_interface {
155         /* The WMI device type */
156         u32 type;
157
158         /* The capabilities this interface provides */
159         u32 capability;
160
161         /* Private data for the current interface */
162         struct acer_data data;
163 };
164
165 /* The static interface pointer, points to the currently detected interface */
166 static struct wmi_interface *interface;
167
168 /*
169  * Embedded Controller quirks
170  * Some laptops require us to directly access the EC to either enable or query
171  * features that are not available through WMI.
172  */
173
174 struct quirk_entry {
175         u8 wireless;
176         u8 mailled;
177         u8 brightness;
178         u8 bluetooth;
179 };
180
181 static struct quirk_entry *quirks;
182
183 static void set_quirks(void)
184 {
185         if (quirks->mailled)
186                 interface->capability |= ACER_CAP_MAILLED;
187
188         if (quirks->brightness)
189                 interface->capability |= ACER_CAP_BRIGHTNESS;
190 }
191
192 static int dmi_matched(const struct dmi_system_id *dmi)
193 {
194         quirks = dmi->driver_data;
195         return 0;
196 }
197
198 static struct quirk_entry quirk_unknown = {
199 };
200
201 static struct quirk_entry quirk_acer_travelmate_2490 = {
202         .mailled = 1,
203 };
204
205 /* This AMW0 laptop has no bluetooth */
206 static struct quirk_entry quirk_medion_md_98300 = {
207         .wireless = 1,
208 };
209
210 static struct dmi_system_id acer_quirks[] = {
211         {
212                 .callback = dmi_matched,
213                 .ident = "Acer Aspire 3100",
214                 .matches = {
215                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
216                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3100"),
217                 },
218                 .driver_data = &quirk_acer_travelmate_2490,
219         },
220         {
221                 .callback = dmi_matched,
222                 .ident = "Acer Aspire 5100",
223                 .matches = {
224                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
225                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"),
226                 },
227                 .driver_data = &quirk_acer_travelmate_2490,
228         },
229         {
230                 .callback = dmi_matched,
231                 .ident = "Acer Aspire 5630",
232                 .matches = {
233                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
234                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"),
235                 },
236                 .driver_data = &quirk_acer_travelmate_2490,
237         },
238         {
239                 .callback = dmi_matched,
240                 .ident = "Acer Aspire 5650",
241                 .matches = {
242                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
243                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"),
244                 },
245                 .driver_data = &quirk_acer_travelmate_2490,
246         },
247         {
248                 .callback = dmi_matched,
249                 .ident = "Acer Aspire 5680",
250                 .matches = {
251                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
252                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"),
253                 },
254                 .driver_data = &quirk_acer_travelmate_2490,
255         },
256         {
257                 .callback = dmi_matched,
258                 .ident = "Acer Aspire 9110",
259                 .matches = {
260                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
261                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"),
262                 },
263                 .driver_data = &quirk_acer_travelmate_2490,
264         },
265         {
266                 .callback = dmi_matched,
267                 .ident = "Acer TravelMate 2490",
268                 .matches = {
269                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
270                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
271                 },
272                 .driver_data = &quirk_acer_travelmate_2490,
273         },
274         {
275                 .callback = dmi_matched,
276                 .ident = "Medion MD 98300",
277                 .matches = {
278                         DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
279                         DMI_MATCH(DMI_PRODUCT_NAME, "WAM2030"),
280                 },
281                 .driver_data = &quirk_medion_md_98300,
282         },
283         {}
284 };
285
286 /* Find which quirks are needed for a particular vendor/ model pair */
287 static void find_quirks(void)
288 {
289         if (!force_series) {
290                 dmi_check_system(acer_quirks);
291         } else if (force_series == 2490) {
292                 quirks = &quirk_acer_travelmate_2490;
293         }
294
295         if (quirks == NULL)
296                 quirks = &quirk_unknown;
297
298         set_quirks();
299 }
300
301 /*
302  * General interface convenience methods
303  */
304
305 static bool has_cap(u32 cap)
306 {
307         if ((interface->capability & cap) != 0)
308                 return 1;
309
310         return 0;
311 }
312
313 /*
314  * AMW0 (V1) interface
315  */
316 struct wmab_args {
317         u32 eax;
318         u32 ebx;
319         u32 ecx;
320         u32 edx;
321 };
322
323 struct wmab_ret {
324         u32 eax;
325         u32 ebx;
326         u32 ecx;
327         u32 edx;
328         u32 eex;
329 };
330
331 static acpi_status wmab_execute(struct wmab_args *regbuf,
332 struct acpi_buffer *result)
333 {
334         struct acpi_buffer input;
335         acpi_status status;
336         input.length = sizeof(struct wmab_args);
337         input.pointer = (u8 *)regbuf;
338
339         status = wmi_evaluate_method(AMW0_GUID1, 1, 1, &input, result);
340
341         return status;
342 }
343
344 static acpi_status AMW0_get_u32(u32 *value, u32 cap,
345 struct wmi_interface *iface)
346 {
347         int err;
348         u8 result;
349
350         switch (cap) {
351         case ACER_CAP_MAILLED:
352                 switch (quirks->mailled) {
353                 default:
354                         err = ec_read(0xA, &result);
355                         if (err)
356                                 return AE_ERROR;
357                         *value = (result >> 7) & 0x1;
358                         return AE_OK;
359                 }
360                 break;
361         case ACER_CAP_WIRELESS:
362                 switch (quirks->wireless) {
363                 case 1:
364                         err = ec_read(0x7B, &result);
365                         if (err)
366                                 return AE_ERROR;
367                         *value = result & 0x1;
368                         return AE_OK;
369                 default:
370                         err = ec_read(0xA, &result);
371                         if (err)
372                                 return AE_ERROR;
373                         *value = (result >> 2) & 0x1;
374                         return AE_OK;
375                 }
376                 break;
377         case ACER_CAP_BLUETOOTH:
378                 switch (quirks->bluetooth) {
379                 default:
380                         err = ec_read(0xA, &result);
381                         if (err)
382                                 return AE_ERROR;
383                         *value = (result >> 4) & 0x1;
384                         return AE_OK;
385                 }
386                 break;
387         case ACER_CAP_BRIGHTNESS:
388                 switch (quirks->brightness) {
389                 default:
390                         err = ec_read(0x83, &result);
391                         if (err)
392                                 return AE_ERROR;
393                         *value = result;
394                         return AE_OK;
395                 }
396                 break;
397         default:
398                 return AE_BAD_ADDRESS;
399         }
400         return AE_OK;
401 }
402
403 static acpi_status AMW0_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
404 {
405         struct wmab_args args;
406
407         args.eax = ACER_AMW0_WRITE;
408         args.ebx = value ? (1<<8) : 0;
409         args.ecx = args.edx = 0;
410
411         switch (cap) {
412         case ACER_CAP_MAILLED:
413                 if (value > 1)
414                         return AE_BAD_PARAMETER;
415                 args.ebx |= ACER_AMW0_MAILLED_MASK;
416                 break;
417         case ACER_CAP_WIRELESS:
418                 if (value > 1)
419                         return AE_BAD_PARAMETER;
420                 args.ebx |= ACER_AMW0_WIRELESS_MASK;
421                 break;
422         case ACER_CAP_BLUETOOTH:
423                 if (value > 1)
424                         return AE_BAD_PARAMETER;
425                 args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
426                 break;
427         case ACER_CAP_BRIGHTNESS:
428                 if (value > max_brightness)
429                         return AE_BAD_PARAMETER;
430                 switch (quirks->brightness) {
431                 default:
432                         return ec_write(0x83, value);
433                         break;
434                 }
435         default:
436                 return AE_BAD_ADDRESS;
437         }
438
439         /* Actually do the set */
440         return wmab_execute(&args, NULL);
441 }
442
443 static acpi_status AMW0_find_mailled(void)
444 {
445         struct wmab_args args;
446         struct wmab_ret ret;
447         acpi_status status = AE_OK;
448         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
449         union acpi_object *obj;
450
451         args.eax = 0x86;
452         args.ebx = args.ecx = args.edx = 0;
453
454         status = wmab_execute(&args, &out);
455         if (ACPI_FAILURE(status))
456                 return status;
457
458         obj = (union acpi_object *) out.pointer;
459         if (obj && obj->type == ACPI_TYPE_BUFFER &&
460         obj->buffer.length == sizeof(struct wmab_ret)) {
461                 ret = *((struct wmab_ret *) obj->buffer.pointer);
462         } else {
463                 return AE_ERROR;
464         }
465
466         if (ret.eex & 0x1)
467                 interface->capability |= ACER_CAP_MAILLED;
468
469         kfree(out.pointer);
470
471         return AE_OK;
472 }
473
474 static acpi_status AMW0_set_capabilities(void)
475 {
476         struct wmab_args args;
477         struct wmab_ret ret;
478         acpi_status status = AE_OK;
479         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
480         union acpi_object *obj;
481
482         args.eax = ACER_AMW0_WRITE;
483         args.ecx = args.edx = 0;
484
485         args.ebx = 0xa2 << 8;
486         args.ebx |= ACER_AMW0_WIRELESS_MASK;
487
488         status = wmab_execute(&args, &out);
489         if (ACPI_FAILURE(status))
490                 return status;
491
492         obj = (union acpi_object *) out.pointer;
493         if (obj && obj->type == ACPI_TYPE_BUFFER &&
494         obj->buffer.length == sizeof(struct wmab_ret)) {
495                 ret = *((struct wmab_ret *) obj->buffer.pointer);
496         } else {
497                 return AE_ERROR;
498         }
499
500         if (ret.eax & 0x1)
501                 interface->capability |= ACER_CAP_WIRELESS;
502
503         args.ebx = 2 << 8;
504         args.ebx |= ACER_AMW0_BLUETOOTH_MASK;
505
506         status = wmab_execute(&args, &out);
507         if (ACPI_FAILURE(status))
508                 return status;
509
510         obj = (union acpi_object *) out.pointer;
511         if (obj && obj->type == ACPI_TYPE_BUFFER
512         && obj->buffer.length == sizeof(struct wmab_ret)) {
513                 ret = *((struct wmab_ret *) obj->buffer.pointer);
514         } else {
515                 return AE_ERROR;
516         }
517
518         if (ret.eax & 0x1)
519                 interface->capability |= ACER_CAP_BLUETOOTH;
520
521         kfree(out.pointer);
522
523         /*
524          * This appears to be safe to enable, since all Wistron based laptops
525          * appear to use the same EC register for brightness, even if they
526          * differ for wireless, etc
527          */
528         interface->capability |= ACER_CAP_BRIGHTNESS;
529
530         return AE_OK;
531 }
532
533 static struct wmi_interface AMW0_interface = {
534         .type = ACER_AMW0,
535 };
536
537 static struct wmi_interface AMW0_V2_interface = {
538         .type = ACER_AMW0_V2,
539 };
540
541 /*
542  * New interface (The WMID interface)
543  */
544 static acpi_status
545 WMI_execute_u32(u32 method_id, u32 in, u32 *out)
546 {
547         struct acpi_buffer input = { (acpi_size) sizeof(u32), (void *)(&in) };
548         struct acpi_buffer result = { ACPI_ALLOCATE_BUFFER, NULL };
549         union acpi_object *obj;
550         u32 tmp;
551         acpi_status status;
552
553         status = wmi_evaluate_method(WMID_GUID1, 1, method_id, &input, &result);
554
555         if (ACPI_FAILURE(status))
556                 return status;
557
558         obj = (union acpi_object *) result.pointer;
559         if (obj && obj->type == ACPI_TYPE_BUFFER &&
560                 obj->buffer.length == sizeof(u32)) {
561                 tmp = *((u32 *) obj->buffer.pointer);
562         } else {
563                 tmp = 0;
564         }
565
566         if (out)
567                 *out = tmp;
568
569         kfree(result.pointer);
570
571         return status;
572 }
573
574 static acpi_status WMID_get_u32(u32 *value, u32 cap,
575 struct wmi_interface *iface)
576 {
577         acpi_status status;
578         u8 tmp;
579         u32 result, method_id = 0;
580
581         switch (cap) {
582         case ACER_CAP_WIRELESS:
583                 method_id = ACER_WMID_GET_WIRELESS_METHODID;
584                 break;
585         case ACER_CAP_BLUETOOTH:
586                 method_id = ACER_WMID_GET_BLUETOOTH_METHODID;
587                 break;
588         case ACER_CAP_BRIGHTNESS:
589                 method_id = ACER_WMID_GET_BRIGHTNESS_METHODID;
590                 break;
591         case ACER_CAP_THREEG:
592                 method_id = ACER_WMID_GET_THREEG_METHODID;
593                 break;
594         case ACER_CAP_MAILLED:
595                 if (quirks->mailled == 1) {
596                         ec_read(0x9f, &tmp);
597                         *value = tmp & 0x1;
598                         return 0;
599                 }
600         default:
601                 return AE_BAD_ADDRESS;
602         }
603         status = WMI_execute_u32(method_id, 0, &result);
604
605         if (ACPI_SUCCESS(status))
606                 *value = (u8)result;
607
608         return status;
609 }
610
611 static acpi_status WMID_set_u32(u32 value, u32 cap, struct wmi_interface *iface)
612 {
613         u32 method_id = 0;
614         char param;
615
616         switch (cap) {
617         case ACER_CAP_BRIGHTNESS:
618                 if (value > max_brightness)
619                         return AE_BAD_PARAMETER;
620                 method_id = ACER_WMID_SET_BRIGHTNESS_METHODID;
621                 break;
622         case ACER_CAP_WIRELESS:
623                 if (value > 1)
624                         return AE_BAD_PARAMETER;
625                 method_id = ACER_WMID_SET_WIRELESS_METHODID;
626                 break;
627         case ACER_CAP_BLUETOOTH:
628                 if (value > 1)
629                         return AE_BAD_PARAMETER;
630                 method_id = ACER_WMID_SET_BLUETOOTH_METHODID;
631                 break;
632         case ACER_CAP_THREEG:
633                 if (value > 1)
634                         return AE_BAD_PARAMETER;
635                 method_id = ACER_WMID_SET_THREEG_METHODID;
636                 break;
637         case ACER_CAP_MAILLED:
638                 if (value > 1)
639                         return AE_BAD_PARAMETER;
640                 if (quirks->mailled == 1) {
641                         param = value ? 0x92 : 0x93;
642                         i8042_command(&param, 0x1059);
643                         return 0;
644                 }
645                 break;
646         default:
647                 return AE_BAD_ADDRESS;
648         }
649         return WMI_execute_u32(method_id, (u32)value, NULL);
650 }
651
652 static acpi_status WMID_set_capabilities(void)
653 {
654         struct acpi_buffer out = {ACPI_ALLOCATE_BUFFER, NULL};
655         union acpi_object *obj;
656         acpi_status status;
657         u32 devices;
658
659         status = wmi_query_block(WMID_GUID2, 1, &out);
660         if (ACPI_FAILURE(status))
661                 return status;
662
663         obj = (union acpi_object *) out.pointer;
664         if (obj && obj->type == ACPI_TYPE_BUFFER &&
665                 obj->buffer.length == sizeof(u32)) {
666                 devices = *((u32 *) obj->buffer.pointer);
667         } else {
668                 return AE_ERROR;
669         }
670
671         /* Not sure on the meaning of the relevant bits yet to detect these */
672         interface->capability |= ACER_CAP_WIRELESS;
673         interface->capability |= ACER_CAP_THREEG;
674
675         /* WMID always provides brightness methods */
676         interface->capability |= ACER_CAP_BRIGHTNESS;
677
678         if (devices & 0x10)
679                 interface->capability |= ACER_CAP_BLUETOOTH;
680
681         if (!(devices & 0x20))
682                 max_brightness = 0x9;
683
684         return status;
685 }
686
687 static struct wmi_interface wmid_interface = {
688         .type = ACER_WMID,
689 };
690
691 /*
692  * Generic Device (interface-independent)
693  */
694
695 static acpi_status get_u32(u32 *value, u32 cap)
696 {
697         acpi_status status = AE_BAD_ADDRESS;
698
699         switch (interface->type) {
700         case ACER_AMW0:
701                 status = AMW0_get_u32(value, cap, interface);
702                 break;
703         case ACER_AMW0_V2:
704                 if (cap == ACER_CAP_MAILLED) {
705                         status = AMW0_get_u32(value, cap, interface);
706                         break;
707                 }
708         case ACER_WMID:
709                 status = WMID_get_u32(value, cap, interface);
710                 break;
711         }
712
713         return status;
714 }
715
716 static acpi_status set_u32(u32 value, u32 cap)
717 {
718         if (interface->capability & cap) {
719                 switch (interface->type) {
720                 case ACER_AMW0:
721                         return AMW0_set_u32(value, cap, interface);
722                 case ACER_AMW0_V2:
723                 case ACER_WMID:
724                         return WMID_set_u32(value, cap, interface);
725                 default:
726                         return AE_BAD_PARAMETER;
727                 }
728         }
729         return AE_BAD_PARAMETER;
730 }
731
732 static void __init acer_commandline_init(void)
733 {
734         /*
735          * These will all fail silently if the value given is invalid, or the
736          * capability isn't available on the given interface
737          */
738         set_u32(mailled, ACER_CAP_MAILLED);
739         set_u32(wireless, ACER_CAP_WIRELESS);
740         set_u32(bluetooth, ACER_CAP_BLUETOOTH);
741         set_u32(threeg, ACER_CAP_THREEG);
742         set_u32(brightness, ACER_CAP_BRIGHTNESS);
743 }
744
745 /*
746  * LED device (Mail LED only, no other LEDs known yet)
747  */
748 static void mail_led_set(struct led_classdev *led_cdev,
749 enum led_brightness value)
750 {
751         set_u32(value, ACER_CAP_MAILLED);
752 }
753
754 static struct led_classdev mail_led = {
755         .name = "acer-mail:green",
756         .brightness_set = mail_led_set,
757 };
758
759 static int __init acer_led_init(struct device *dev)
760 {
761         return led_classdev_register(dev, &mail_led);
762 }
763
764 static void acer_led_exit(void)
765 {
766         led_classdev_unregister(&mail_led);
767 }
768
769 /*
770  * Backlight device
771  */
772 static struct backlight_device *acer_backlight_device;
773
774 static int read_brightness(struct backlight_device *bd)
775 {
776         u32 value;
777         get_u32(&value, ACER_CAP_BRIGHTNESS);
778         return value;
779 }
780
781 static int update_bl_status(struct backlight_device *bd)
782 {
783         set_u32(bd->props.brightness, ACER_CAP_BRIGHTNESS);
784         return 0;
785 }
786
787 static struct backlight_ops acer_bl_ops = {
788         .get_brightness = read_brightness,
789         .update_status = update_bl_status,
790 };
791
792 static int __init acer_backlight_init(struct device *dev)
793 {
794         struct backlight_device *bd;
795
796         bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops);
797         if (IS_ERR(bd)) {
798                 printk(ACER_ERR "Could not register Acer backlight device\n");
799                 acer_backlight_device = NULL;
800                 return PTR_ERR(bd);
801         }
802
803         acer_backlight_device = bd;
804
805         bd->props.max_brightness = max_brightness;
806         bd->props.brightness = read_brightness(NULL);
807         backlight_update_status(bd);
808         return 0;
809 }
810
811 static void __exit acer_backlight_exit(void)
812 {
813         backlight_device_unregister(acer_backlight_device);
814 }
815
816 /*
817  * Read/ write bool sysfs macro
818  */
819 #define show_set_bool(value, cap) \
820 static ssize_t \
821 show_bool_##value(struct device *dev, struct device_attribute *attr, \
822         char *buf) \
823 { \
824         u32 result; \
825         acpi_status status = get_u32(&result, cap); \
826         if (ACPI_SUCCESS(status)) \
827                 return sprintf(buf, "%u\n", result); \
828         return sprintf(buf, "Read error\n"); \
829 } \
830 \
831 static ssize_t \
832 set_bool_##value(struct device *dev, struct device_attribute *attr, \
833         const char *buf, size_t count) \
834 { \
835         u32 tmp = simple_strtoul(buf, NULL, 10); \
836         acpi_status status = set_u32(tmp, cap); \
837                 if (ACPI_FAILURE(status)) \
838                         return -EINVAL; \
839         return count; \
840 } \
841 static DEVICE_ATTR(value, S_IWUGO | S_IRUGO | S_IWUSR, \
842         show_bool_##value, set_bool_##value);
843
844 show_set_bool(wireless, ACER_CAP_WIRELESS);
845 show_set_bool(bluetooth, ACER_CAP_BLUETOOTH);
846 show_set_bool(threeg, ACER_CAP_THREEG);
847
848 /*
849  * Read interface sysfs macro
850  */
851 static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
852         char *buf)
853 {
854         switch (interface->type) {
855         case ACER_AMW0:
856                 return sprintf(buf, "AMW0\n");
857         case ACER_AMW0_V2:
858                 return sprintf(buf, "AMW0 v2\n");
859         case ACER_WMID:
860                 return sprintf(buf, "WMID\n");
861         default:
862                 return sprintf(buf, "Error!\n");
863         }
864 }
865
866 static DEVICE_ATTR(interface, S_IWUGO | S_IRUGO | S_IWUSR,
867         show_interface, NULL);
868
869 /*
870  * Platform device
871  */
872 static int __devinit acer_platform_probe(struct platform_device *device)
873 {
874         int err;
875
876         if (has_cap(ACER_CAP_MAILLED)) {
877                 err = acer_led_init(&device->dev);
878                 if (err)
879                         goto error_mailled;
880         }
881
882         if (has_cap(ACER_CAP_BRIGHTNESS)) {
883                 err = acer_backlight_init(&device->dev);
884                 if (err)
885                         goto error_brightness;
886         }
887
888         return 0;
889
890 error_brightness:
891         acer_led_exit();
892 error_mailled:
893         return err;
894 }
895
896 static int acer_platform_remove(struct platform_device *device)
897 {
898         if (has_cap(ACER_CAP_MAILLED))
899                 acer_led_exit();
900         if (has_cap(ACER_CAP_BRIGHTNESS))
901                 acer_backlight_exit();
902         return 0;
903 }
904
905 static int acer_platform_suspend(struct platform_device *dev,
906 pm_message_t state)
907 {
908         u32 value;
909         struct acer_data *data = &interface->data;
910
911         if (!data)
912                 return -ENOMEM;
913
914         if (has_cap(ACER_CAP_WIRELESS)) {
915                 get_u32(&value, ACER_CAP_WIRELESS);
916                 data->wireless = value;
917         }
918
919         if (has_cap(ACER_CAP_BLUETOOTH)) {
920                 get_u32(&value, ACER_CAP_BLUETOOTH);
921                 data->bluetooth = value;
922         }
923
924         if (has_cap(ACER_CAP_MAILLED)) {
925                 get_u32(&value, ACER_CAP_MAILLED);
926                 data->mailled = value;
927         }
928
929         if (has_cap(ACER_CAP_BRIGHTNESS)) {
930                 get_u32(&value, ACER_CAP_BRIGHTNESS);
931                 data->brightness = value;
932         }
933
934         return 0;
935 }
936
937 static int acer_platform_resume(struct platform_device *device)
938 {
939         struct acer_data *data = &interface->data;
940
941         if (!data)
942                 return -ENOMEM;
943
944         if (has_cap(ACER_CAP_WIRELESS))
945                 set_u32(data->wireless, ACER_CAP_WIRELESS);
946
947         if (has_cap(ACER_CAP_BLUETOOTH))
948                 set_u32(data->bluetooth, ACER_CAP_BLUETOOTH);
949
950         if (has_cap(ACER_CAP_THREEG))
951                 set_u32(data->threeg, ACER_CAP_THREEG);
952
953         if (has_cap(ACER_CAP_MAILLED))
954                 set_u32(data->mailled, ACER_CAP_MAILLED);
955
956         if (has_cap(ACER_CAP_BRIGHTNESS))
957                 set_u32(data->brightness, ACER_CAP_BRIGHTNESS);
958
959         return 0;
960 }
961
962 static struct platform_driver acer_platform_driver = {
963         .driver = {
964                 .name = "acer-wmi",
965                 .owner = THIS_MODULE,
966         },
967         .probe = acer_platform_probe,
968         .remove = acer_platform_remove,
969         .suspend = acer_platform_suspend,
970         .resume = acer_platform_resume,
971 };
972
973 static struct platform_device *acer_platform_device;
974
975 static int remove_sysfs(struct platform_device *device)
976 {
977         if (has_cap(ACER_CAP_WIRELESS))
978                 device_remove_file(&device->dev, &dev_attr_wireless);
979
980         if (has_cap(ACER_CAP_BLUETOOTH))
981                 device_remove_file(&device->dev, &dev_attr_bluetooth);
982
983         if (has_cap(ACER_CAP_THREEG))
984                 device_remove_file(&device->dev, &dev_attr_threeg);
985
986         device_remove_file(&device->dev, &dev_attr_interface);
987
988         return 0;
989 }
990
991 static int create_sysfs(void)
992 {
993         int retval = -ENOMEM;
994
995         if (has_cap(ACER_CAP_WIRELESS)) {
996                 retval = device_create_file(&acer_platform_device->dev,
997                         &dev_attr_wireless);
998                 if (retval)
999                         goto error_sysfs;
1000         }
1001
1002         if (has_cap(ACER_CAP_BLUETOOTH)) {
1003                 retval = device_create_file(&acer_platform_device->dev,
1004                         &dev_attr_bluetooth);
1005                 if (retval)
1006                         goto error_sysfs;
1007         }
1008
1009         if (has_cap(ACER_CAP_THREEG)) {
1010                 retval = device_create_file(&acer_platform_device->dev,
1011                         &dev_attr_threeg);
1012                 if (retval)
1013                         goto error_sysfs;
1014         }
1015
1016         retval = device_create_file(&acer_platform_device->dev,
1017                 &dev_attr_interface);
1018         if (retval)
1019                 goto error_sysfs;
1020
1021         return 0;
1022
1023 error_sysfs:
1024                 remove_sysfs(acer_platform_device);
1025         return retval;
1026 }
1027
1028 static int __init acer_wmi_init(void)
1029 {
1030         int err;
1031
1032         printk(ACER_INFO "Acer Laptop ACPI-WMI Extras version %s\n",
1033                         ACER_WMI_VERSION);
1034
1035         /*
1036          * Detect which ACPI-WMI interface we're using.
1037          */
1038         if (wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
1039                 interface = &AMW0_V2_interface;
1040
1041         if (!wmi_has_guid(AMW0_GUID1) && wmi_has_guid(WMID_GUID1))
1042                 interface = &wmid_interface;
1043
1044         if (wmi_has_guid(WMID_GUID2) && interface) {
1045                 if (ACPI_FAILURE(WMID_set_capabilities())) {
1046                         printk(ACER_ERR "Unable to detect available devices\n");
1047                         return -ENODEV;
1048                 }
1049         } else if (!wmi_has_guid(WMID_GUID2) && interface) {
1050                 printk(ACER_ERR "Unable to detect available devices\n");
1051                 return -ENODEV;
1052         }
1053
1054         if (wmi_has_guid(AMW0_GUID1) && !wmi_has_guid(WMID_GUID1)) {
1055                 interface = &AMW0_interface;
1056
1057                 if (ACPI_FAILURE(AMW0_set_capabilities())) {
1058                         printk(ACER_ERR "Unable to detect available devices\n");
1059                         return -ENODEV;
1060                 }
1061         }
1062
1063         if (wmi_has_guid(AMW0_GUID1)) {
1064                 if (ACPI_FAILURE(AMW0_find_mailled()))
1065                         printk(ACER_ERR "Unable to detect mail LED\n");
1066         }
1067
1068         find_quirks();
1069
1070         if (!interface) {
1071                 printk(ACER_ERR "No or unsupported WMI interface, unable to ");
1072                 printk(KERN_CONT "load.\n");
1073                 return -ENODEV;
1074         }
1075
1076         if (platform_driver_register(&acer_platform_driver)) {
1077                 printk(ACER_ERR "Unable to register platform driver.\n");
1078                 goto error_platform_register;
1079         }
1080         acer_platform_device = platform_device_alloc("acer-wmi", -1);
1081         platform_device_add(acer_platform_device);
1082
1083         err = create_sysfs();
1084         if (err)
1085                 return err;
1086
1087         /* Override any initial settings with values from the commandline */
1088         acer_commandline_init();
1089
1090         return 0;
1091
1092 error_platform_register:
1093         return -ENODEV;
1094 }
1095
1096 static void __exit acer_wmi_exit(void)
1097 {
1098         remove_sysfs(acer_platform_device);
1099         platform_device_del(acer_platform_device);
1100         platform_driver_unregister(&acer_platform_driver);
1101
1102         printk(ACER_INFO "Acer Laptop WMI Extras unloaded\n");
1103         return;
1104 }
1105
1106 module_init(acer_wmi_init);
1107 module_exit(acer_wmi_exit);