e60385df4af22fef9ff9b961c02b77eb252434f1
[linux-2.6.git] / drivers / platform / x86 / asus-wmi.c
1 /*
2  * Asus PC WMI hotkey driver
3  *
4  * Copyright(C) 2010 Intel Corporation.
5  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
6  *
7  * Portions based on wistron_btns.c:
8  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or
15  *  (at your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; if not, write to the Free Software
24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  */
26
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/types.h>
33 #include <linux/slab.h>
34 #include <linux/input.h>
35 #include <linux/input/sparse-keymap.h>
36 #include <linux/fb.h>
37 #include <linux/backlight.h>
38 #include <linux/leds.h>
39 #include <linux/rfkill.h>
40 #include <linux/pci.h>
41 #include <linux/pci_hotplug.h>
42 #include <linux/hwmon.h>
43 #include <linux/hwmon-sysfs.h>
44 #include <linux/debugfs.h>
45 #include <linux/seq_file.h>
46 #include <linux/platform_device.h>
47 #include <acpi/acpi_bus.h>
48 #include <acpi/acpi_drivers.h>
49
50 #include "asus-wmi.h"
51
52 MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
53               "Yong Wang <yong.y.wang@intel.com>");
54 MODULE_DESCRIPTION("Asus Generic WMI Driver");
55 MODULE_LICENSE("GPL");
56
57 #define to_platform_driver(drv)                                 \
58         (container_of((drv), struct platform_driver, driver))
59
60 #define to_asus_wmi_driver(pdrv)                                        \
61         (container_of((pdrv), struct asus_wmi_driver, platform_driver))
62
63 #define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
64
65 #define NOTIFY_BRNUP_MIN                0x11
66 #define NOTIFY_BRNUP_MAX                0x1f
67 #define NOTIFY_BRNDOWN_MIN              0x20
68 #define NOTIFY_BRNDOWN_MAX              0x2e
69 #define NOTIFY_KBD_BRTUP                0xc4
70 #define NOTIFY_KBD_BRTDWN               0xc5
71
72 /* WMI Methods */
73 #define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
74 #define ASUS_WMI_METHODID_SFBD          0x44424653 /* Set First Boot Device */
75 #define ASUS_WMI_METHODID_GLCD          0x44434C47 /* Get LCD status */
76 #define ASUS_WMI_METHODID_GPID          0x44495047 /* Get Panel ID?? (Resol) */
77 #define ASUS_WMI_METHODID_QMOD          0x444F4D51 /* Quiet MODe */
78 #define ASUS_WMI_METHODID_SPLV          0x4C425053 /* Set Panel Light Value */
79 #define ASUS_WMI_METHODID_SFUN          0x4E554653 /* FUNCtionalities */
80 #define ASUS_WMI_METHODID_SDSP          0x50534453 /* Set DiSPlay output */
81 #define ASUS_WMI_METHODID_GDSP          0x50534447 /* Get DiSPlay output */
82 #define ASUS_WMI_METHODID_DEVP          0x50564544 /* DEVice Policy */
83 #define ASUS_WMI_METHODID_OSVR          0x5256534F /* OS VeRsion */
84 #define ASUS_WMI_METHODID_DSTS          0x53544344 /* Device STatuS */
85 #define ASUS_WMI_METHODID_DSTS2         0x53545344 /* Device STatuS #2*/
86 #define ASUS_WMI_METHODID_BSTS          0x53545342 /* Bios STatuS ? */
87 #define ASUS_WMI_METHODID_DEVS          0x53564544 /* DEVice Set */
88 #define ASUS_WMI_METHODID_CFVS          0x53564643 /* CPU Frequency Volt Set */
89 #define ASUS_WMI_METHODID_KBFT          0x5446424B /* KeyBoard FilTer */
90 #define ASUS_WMI_METHODID_INIT          0x54494E49 /* INITialize */
91 #define ASUS_WMI_METHODID_HKEY          0x59454B48 /* Hot KEY ?? */
92
93 #define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
94
95 /* Wireless */
96 #define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
97 #define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
98 #define ASUS_WMI_DEVID_CWAP             0x00010003
99 #define ASUS_WMI_DEVID_WLAN             0x00010011
100 #define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
101 #define ASUS_WMI_DEVID_GPS              0x00010015
102 #define ASUS_WMI_DEVID_WIMAX            0x00010017
103 #define ASUS_WMI_DEVID_WWAN3G           0x00010019
104 #define ASUS_WMI_DEVID_UWB              0x00010021
105
106 /* Leds */
107 /* 0x000200XX and 0x000400XX */
108 #define ASUS_WMI_DEVID_LED1             0x00020011
109 #define ASUS_WMI_DEVID_LED2             0x00020012
110 #define ASUS_WMI_DEVID_LED3             0x00020013
111 #define ASUS_WMI_DEVID_LED4             0x00020014
112 #define ASUS_WMI_DEVID_LED5             0x00020015
113 #define ASUS_WMI_DEVID_LED6             0x00020016
114
115 /* Backlight and Brightness */
116 #define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
117 #define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
118 #define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
119 #define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022 /* ?? */
120
121 /* Misc */
122 #define ASUS_WMI_DEVID_CAMERA           0x00060013
123
124 /* Storage */
125 #define ASUS_WMI_DEVID_CARDREADER       0x00080013
126
127 /* Input */
128 #define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
129 #define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
130
131 /* Fan, Thermal */
132 #define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
133 #define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
134
135 /* Power */
136 #define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
137
138 /* DSTS masks */
139 #define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
140 #define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
141 #define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
142 #define ASUS_WMI_DSTS_USER_BIT          0x00020000
143 #define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
144 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
145 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
146
147 struct bios_args {
148         u32 arg0;
149         u32 arg1;
150 } __packed;
151
152 /*
153  * <platform>/    - debugfs root directory
154  *   dev_id      - current dev_id
155  *   ctrl_param  - current ctrl_param
156  *   method_id   - current method_id
157  *   devs        - call DEVS(dev_id, ctrl_param) and print result
158  *   dsts        - call DSTS(dev_id)  and print result
159  *   call        - call method_id(dev_id, ctrl_param) and print result
160  */
161 struct asus_wmi_debug {
162         struct dentry *root;
163         u32 method_id;
164         u32 dev_id;
165         u32 ctrl_param;
166 };
167
168 struct asus_rfkill {
169         struct asus_wmi *asus;
170         struct rfkill *rfkill;
171         u32 dev_id;
172 };
173
174 struct asus_wmi {
175         int dsts_id;
176         int spec;
177         int sfun;
178
179         struct input_dev *inputdev;
180         struct backlight_device *backlight_device;
181         struct device *hwmon_device;
182         struct platform_device *platform_device;
183
184         struct led_classdev tpd_led;
185         int tpd_led_wk;
186         struct led_classdev kbd_led;
187         int kbd_led_wk;
188         struct workqueue_struct *led_workqueue;
189         struct work_struct tpd_led_work;
190         struct work_struct kbd_led_work;
191
192         struct asus_rfkill wlan;
193         struct asus_rfkill bluetooth;
194         struct asus_rfkill wimax;
195         struct asus_rfkill wwan3g;
196
197         struct hotplug_slot *hotplug_slot;
198         struct mutex hotplug_lock;
199         struct mutex wmi_lock;
200         struct workqueue_struct *hotplug_workqueue;
201         struct work_struct hotplug_work;
202
203         struct asus_wmi_debug debug;
204
205         struct asus_wmi_driver *driver;
206 };
207
208 static int asus_wmi_input_init(struct asus_wmi *asus)
209 {
210         int err;
211
212         asus->inputdev = input_allocate_device();
213         if (!asus->inputdev)
214                 return -ENOMEM;
215
216         asus->inputdev->name = asus->driver->input_name;
217         asus->inputdev->phys = asus->driver->input_phys;
218         asus->inputdev->id.bustype = BUS_HOST;
219         asus->inputdev->dev.parent = &asus->platform_device->dev;
220         set_bit(EV_REP, asus->inputdev->evbit);
221
222         err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
223         if (err)
224                 goto err_free_dev;
225
226         err = input_register_device(asus->inputdev);
227         if (err)
228                 goto err_free_keymap;
229
230         return 0;
231
232 err_free_keymap:
233         sparse_keymap_free(asus->inputdev);
234 err_free_dev:
235         input_free_device(asus->inputdev);
236         return err;
237 }
238
239 static void asus_wmi_input_exit(struct asus_wmi *asus)
240 {
241         if (asus->inputdev) {
242                 sparse_keymap_free(asus->inputdev);
243                 input_unregister_device(asus->inputdev);
244         }
245
246         asus->inputdev = NULL;
247 }
248
249 static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
250                                     u32 *retval)
251 {
252         struct bios_args args = {
253                 .arg0 = arg0,
254                 .arg1 = arg1,
255         };
256         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
257         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
258         acpi_status status;
259         union acpi_object *obj;
260         u32 tmp;
261
262         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
263                                      &input, &output);
264
265         if (ACPI_FAILURE(status))
266                 goto exit;
267
268         obj = (union acpi_object *)output.pointer;
269         if (obj && obj->type == ACPI_TYPE_INTEGER)
270                 tmp = (u32) obj->integer.value;
271         else
272                 tmp = 0;
273
274         if (retval)
275                 *retval = tmp;
276
277         kfree(obj);
278
279 exit:
280         if (ACPI_FAILURE(status))
281                 return -EIO;
282
283         if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
284                 return -ENODEV;
285
286         return 0;
287 }
288
289 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
290 {
291         return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
292 }
293
294 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
295                                  u32 *retval)
296 {
297         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
298                                         ctrl_param, retval);
299 }
300
301 /* Helper for special devices with magic return codes */
302 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
303                                       u32 dev_id, u32 mask)
304 {
305         u32 retval = 0;
306         int err;
307
308         err = asus_wmi_get_devstate(asus, dev_id, &retval);
309
310         if (err < 0)
311                 return err;
312
313         if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
314                 return -ENODEV;
315
316         if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
317                 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
318                         return -ENODEV;
319         }
320
321         return retval & mask;
322 }
323
324 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
325 {
326         return asus_wmi_get_devstate_bits(asus, dev_id,
327                                           ASUS_WMI_DSTS_STATUS_BIT);
328 }
329
330 /*
331  * LEDs
332  */
333 /*
334  * These functions actually update the LED's, and are called from a
335  * workqueue. By doing this as separate work rather than when the LED
336  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
337  * potentially bad time, such as a timer interrupt.
338  */
339 static void tpd_led_update(struct work_struct *work)
340 {
341         int ctrl_param;
342         struct asus_wmi *asus;
343
344         asus = container_of(work, struct asus_wmi, tpd_led_work);
345
346         ctrl_param = asus->tpd_led_wk;
347         asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
348 }
349
350 static void tpd_led_set(struct led_classdev *led_cdev,
351                         enum led_brightness value)
352 {
353         struct asus_wmi *asus;
354
355         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
356
357         asus->tpd_led_wk = !!value;
358         queue_work(asus->led_workqueue, &asus->tpd_led_work);
359 }
360
361 static int read_tpd_led_state(struct asus_wmi *asus)
362 {
363         return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
364 }
365
366 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
367 {
368         struct asus_wmi *asus;
369
370         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
371
372         return read_tpd_led_state(asus);
373 }
374
375 static void kbd_led_update(struct work_struct *work)
376 {
377         int ctrl_param = 0;
378         struct asus_wmi *asus;
379
380         asus = container_of(work, struct asus_wmi, kbd_led_work);
381
382         /*
383          * bits 0-2: level
384          * bit 7: light on/off
385          */
386         if (asus->kbd_led_wk > 0)
387                 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
388
389         asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
390 }
391
392 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
393 {
394         int retval;
395
396         /*
397          * bits 0-2: level
398          * bit 7: light on/off
399          * bit 8-10: environment (0: dark, 1: normal, 2: light)
400          * bit 17: status unknown
401          */
402         retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
403                                             0xFFFF);
404
405         /* Unknown status is considered as off */
406         if (retval == 0x8000)
407                 retval = 0;
408
409         if (retval >= 0) {
410                 if (level)
411                         *level = retval & 0x80 ? retval & 0x7F : 0;
412                 if (env)
413                         *env = (retval >> 8) & 0x7F;
414                 retval = 0;
415         }
416
417         return retval;
418 }
419
420 static void kbd_led_set(struct led_classdev *led_cdev,
421                         enum led_brightness value)
422 {
423         struct asus_wmi *asus;
424
425         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
426
427         if (value > asus->kbd_led.max_brightness)
428                 value = asus->kbd_led.max_brightness;
429         else if (value < 0)
430                 value = 0;
431
432         asus->kbd_led_wk = value;
433         queue_work(asus->led_workqueue, &asus->kbd_led_work);
434 }
435
436 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
437 {
438         struct asus_wmi *asus;
439         int retval, value;
440
441         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
442
443         retval = kbd_led_read(asus, &value, NULL);
444
445         if (retval < 0)
446                 return retval;
447
448         return value;
449 }
450
451 static void asus_wmi_led_exit(struct asus_wmi *asus)
452 {
453         if (asus->tpd_led.dev)
454                 led_classdev_unregister(&asus->tpd_led);
455         if (asus->led_workqueue)
456                 destroy_workqueue(asus->led_workqueue);
457 }
458
459 static int asus_wmi_led_init(struct asus_wmi *asus)
460 {
461         int rv = 0;
462
463         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
464         if (!asus->led_workqueue)
465                 return -ENOMEM;
466
467         if (read_tpd_led_state(asus) >= 0) {
468                 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
469
470                 asus->tpd_led.name = "asus::touchpad";
471                 asus->tpd_led.brightness_set = tpd_led_set;
472                 asus->tpd_led.brightness_get = tpd_led_get;
473                 asus->tpd_led.max_brightness = 1;
474
475                 rv = led_classdev_register(&asus->platform_device->dev,
476                                            &asus->tpd_led);
477                 if (rv)
478                         goto error;
479         }
480
481         if (kbd_led_read(asus, NULL, NULL) >= 0) {
482                 INIT_WORK(&asus->kbd_led_work, kbd_led_update);
483
484                 asus->kbd_led.name = "asus::kbd_backlight";
485                 asus->kbd_led.brightness_set = kbd_led_set;
486                 asus->kbd_led.brightness_get = kbd_led_get;
487                 asus->kbd_led.max_brightness = 3;
488
489                 rv = led_classdev_register(&asus->platform_device->dev,
490                                            &asus->kbd_led);
491         }
492
493 error:
494         if (rv)
495                 asus_wmi_led_exit(asus);
496
497         return rv;
498 }
499
500
501 /*
502  * PCI hotplug (for wlan rfkill)
503  */
504 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
505 {
506         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
507
508         if (result < 0)
509                 return false;
510         return !result;
511 }
512
513 static void asus_rfkill_hotplug(struct asus_wmi *asus)
514 {
515         struct pci_dev *dev;
516         struct pci_bus *bus;
517         bool blocked;
518         bool absent;
519         u32 l;
520
521         mutex_lock(&asus->wmi_lock);
522         blocked = asus_wlan_rfkill_blocked(asus);
523         mutex_unlock(&asus->wmi_lock);
524
525         mutex_lock(&asus->hotplug_lock);
526
527         if (asus->wlan.rfkill)
528                 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
529
530         if (asus->hotplug_slot) {
531                 bus = pci_find_bus(0, 1);
532                 if (!bus) {
533                         pr_warn("Unable to find PCI bus 1?\n");
534                         goto out_unlock;
535                 }
536
537                 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
538                         pr_err("Unable to read PCI config space?\n");
539                         goto out_unlock;
540                 }
541                 absent = (l == 0xffffffff);
542
543                 if (blocked != absent) {
544                         pr_warn("BIOS says wireless lan is %s, "
545                                 "but the pci device is %s\n",
546                                 blocked ? "blocked" : "unblocked",
547                                 absent ? "absent" : "present");
548                         pr_warn("skipped wireless hotplug as probably "
549                                 "inappropriate for this model\n");
550                         goto out_unlock;
551                 }
552
553                 if (!blocked) {
554                         dev = pci_get_slot(bus, 0);
555                         if (dev) {
556                                 /* Device already present */
557                                 pci_dev_put(dev);
558                                 goto out_unlock;
559                         }
560                         dev = pci_scan_single_device(bus, 0);
561                         if (dev) {
562                                 pci_bus_assign_resources(bus);
563                                 if (pci_bus_add_device(dev))
564                                         pr_err("Unable to hotplug wifi\n");
565                         }
566                 } else {
567                         dev = pci_get_slot(bus, 0);
568                         if (dev) {
569                                 pci_remove_bus_device(dev);
570                                 pci_dev_put(dev);
571                         }
572                 }
573         }
574
575 out_unlock:
576         mutex_unlock(&asus->hotplug_lock);
577 }
578
579 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
580 {
581         struct asus_wmi *asus = data;
582
583         if (event != ACPI_NOTIFY_BUS_CHECK)
584                 return;
585
586         /*
587          * We can't call directly asus_rfkill_hotplug because most
588          * of the time WMBC is still being executed and not reetrant.
589          * There is currently no way to tell ACPICA that  we want this
590          * method to be serialized, we schedule a asus_rfkill_hotplug
591          * call later, in a safer context.
592          */
593         queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
594 }
595
596 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
597 {
598         acpi_status status;
599         acpi_handle handle;
600
601         status = acpi_get_handle(NULL, node, &handle);
602
603         if (ACPI_SUCCESS(status)) {
604                 status = acpi_install_notify_handler(handle,
605                                                      ACPI_SYSTEM_NOTIFY,
606                                                      asus_rfkill_notify, asus);
607                 if (ACPI_FAILURE(status))
608                         pr_warn("Failed to register notify on %s\n", node);
609         } else
610                 return -ENODEV;
611
612         return 0;
613 }
614
615 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
616 {
617         acpi_status status = AE_OK;
618         acpi_handle handle;
619
620         status = acpi_get_handle(NULL, node, &handle);
621
622         if (ACPI_SUCCESS(status)) {
623                 status = acpi_remove_notify_handler(handle,
624                                                     ACPI_SYSTEM_NOTIFY,
625                                                     asus_rfkill_notify);
626                 if (ACPI_FAILURE(status))
627                         pr_err("Error removing rfkill notify handler %s\n",
628                                node);
629         }
630 }
631
632 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
633                                    u8 *value)
634 {
635         struct asus_wmi *asus = hotplug_slot->private;
636         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
637
638         if (result < 0)
639                 return result;
640
641         *value = !!result;
642         return 0;
643 }
644
645 static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
646 {
647         kfree(hotplug_slot->info);
648         kfree(hotplug_slot);
649 }
650
651 static struct hotplug_slot_ops asus_hotplug_slot_ops = {
652         .owner = THIS_MODULE,
653         .get_adapter_status = asus_get_adapter_status,
654         .get_power_status = asus_get_adapter_status,
655 };
656
657 static void asus_hotplug_work(struct work_struct *work)
658 {
659         struct asus_wmi *asus;
660
661         asus = container_of(work, struct asus_wmi, hotplug_work);
662         asus_rfkill_hotplug(asus);
663 }
664
665 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
666 {
667         int ret = -ENOMEM;
668         struct pci_bus *bus = pci_find_bus(0, 1);
669
670         if (!bus) {
671                 pr_err("Unable to find wifi PCI bus\n");
672                 return -ENODEV;
673         }
674
675         asus->hotplug_workqueue =
676             create_singlethread_workqueue("hotplug_workqueue");
677         if (!asus->hotplug_workqueue)
678                 goto error_workqueue;
679
680         INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
681
682         asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
683         if (!asus->hotplug_slot)
684                 goto error_slot;
685
686         asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
687                                            GFP_KERNEL);
688         if (!asus->hotplug_slot->info)
689                 goto error_info;
690
691         asus->hotplug_slot->private = asus;
692         asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
693         asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
694         asus_get_adapter_status(asus->hotplug_slot,
695                                 &asus->hotplug_slot->info->adapter_status);
696
697         ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
698         if (ret) {
699                 pr_err("Unable to register hotplug slot - %d\n", ret);
700                 goto error_register;
701         }
702
703         return 0;
704
705 error_register:
706         kfree(asus->hotplug_slot->info);
707 error_info:
708         kfree(asus->hotplug_slot);
709         asus->hotplug_slot = NULL;
710 error_slot:
711         destroy_workqueue(asus->hotplug_workqueue);
712 error_workqueue:
713         return ret;
714 }
715
716 /*
717  * Rfkill devices
718  */
719 static int asus_rfkill_set(void *data, bool blocked)
720 {
721         struct asus_rfkill *priv = data;
722         u32 ctrl_param = !blocked;
723
724         return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
725 }
726
727 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
728 {
729         struct asus_rfkill *priv = data;
730         int result;
731
732         result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
733
734         if (result < 0)
735                 return;
736
737         rfkill_set_sw_state(priv->rfkill, !result);
738 }
739
740 static int asus_rfkill_wlan_set(void *data, bool blocked)
741 {
742         struct asus_rfkill *priv = data;
743         struct asus_wmi *asus = priv->asus;
744         int ret;
745
746         /*
747          * This handler is enabled only if hotplug is enabled.
748          * In this case, the asus_wmi_set_devstate() will
749          * trigger a wmi notification and we need to wait
750          * this call to finish before being able to call
751          * any wmi method
752          */
753         mutex_lock(&asus->wmi_lock);
754         ret = asus_rfkill_set(data, blocked);
755         mutex_unlock(&asus->wmi_lock);
756         return ret;
757 }
758
759 static const struct rfkill_ops asus_rfkill_wlan_ops = {
760         .set_block = asus_rfkill_wlan_set,
761         .query = asus_rfkill_query,
762 };
763
764 static const struct rfkill_ops asus_rfkill_ops = {
765         .set_block = asus_rfkill_set,
766         .query = asus_rfkill_query,
767 };
768
769 static int asus_new_rfkill(struct asus_wmi *asus,
770                            struct asus_rfkill *arfkill,
771                            const char *name, enum rfkill_type type, int dev_id)
772 {
773         int result = asus_wmi_get_devstate_simple(asus, dev_id);
774         struct rfkill **rfkill = &arfkill->rfkill;
775
776         if (result < 0)
777                 return result;
778
779         arfkill->dev_id = dev_id;
780         arfkill->asus = asus;
781
782         if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
783                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
784                                        &asus_rfkill_wlan_ops, arfkill);
785         else
786                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
787                                        &asus_rfkill_ops, arfkill);
788
789         if (!*rfkill)
790                 return -EINVAL;
791
792         rfkill_init_sw_state(*rfkill, !result);
793         result = rfkill_register(*rfkill);
794         if (result) {
795                 rfkill_destroy(*rfkill);
796                 *rfkill = NULL;
797                 return result;
798         }
799         return 0;
800 }
801
802 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
803 {
804         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
805         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
806         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
807         if (asus->wlan.rfkill) {
808                 rfkill_unregister(asus->wlan.rfkill);
809                 rfkill_destroy(asus->wlan.rfkill);
810                 asus->wlan.rfkill = NULL;
811         }
812         /*
813          * Refresh pci hotplug in case the rfkill state was changed after
814          * asus_unregister_rfkill_notifier()
815          */
816         asus_rfkill_hotplug(asus);
817         if (asus->hotplug_slot)
818                 pci_hp_deregister(asus->hotplug_slot);
819         if (asus->hotplug_workqueue)
820                 destroy_workqueue(asus->hotplug_workqueue);
821
822         if (asus->bluetooth.rfkill) {
823                 rfkill_unregister(asus->bluetooth.rfkill);
824                 rfkill_destroy(asus->bluetooth.rfkill);
825                 asus->bluetooth.rfkill = NULL;
826         }
827         if (asus->wimax.rfkill) {
828                 rfkill_unregister(asus->wimax.rfkill);
829                 rfkill_destroy(asus->wimax.rfkill);
830                 asus->wimax.rfkill = NULL;
831         }
832         if (asus->wwan3g.rfkill) {
833                 rfkill_unregister(asus->wwan3g.rfkill);
834                 rfkill_destroy(asus->wwan3g.rfkill);
835                 asus->wwan3g.rfkill = NULL;
836         }
837 }
838
839 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
840 {
841         int result = 0;
842
843         mutex_init(&asus->hotplug_lock);
844         mutex_init(&asus->wmi_lock);
845
846         result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
847                                  RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
848
849         if (result && result != -ENODEV)
850                 goto exit;
851
852         result = asus_new_rfkill(asus, &asus->bluetooth,
853                                  "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
854                                  ASUS_WMI_DEVID_BLUETOOTH);
855
856         if (result && result != -ENODEV)
857                 goto exit;
858
859         result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
860                                  RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
861
862         if (result && result != -ENODEV)
863                 goto exit;
864
865         result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
866                                  RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
867
868         if (result && result != -ENODEV)
869                 goto exit;
870
871         if (!asus->driver->hotplug_wireless)
872                 goto exit;
873
874         result = asus_setup_pci_hotplug(asus);
875         /*
876          * If we get -EBUSY then something else is handling the PCI hotplug -
877          * don't fail in this case
878          */
879         if (result == -EBUSY)
880                 result = 0;
881
882         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
883         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
884         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
885         /*
886          * Refresh pci hotplug in case the rfkill state was changed during
887          * setup.
888          */
889         asus_rfkill_hotplug(asus);
890
891 exit:
892         if (result && result != -ENODEV)
893                 asus_wmi_rfkill_exit(asus);
894
895         if (result == -ENODEV)
896                 result = 0;
897
898         return result;
899 }
900
901 /*
902  * Hwmon device
903  */
904 static ssize_t asus_hwmon_pwm1(struct device *dev,
905                                struct device_attribute *attr,
906                                char *buf)
907 {
908         struct asus_wmi *asus = dev_get_drvdata(dev);
909         u32 value;
910         int err;
911
912         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
913
914         if (err < 0)
915                 return err;
916
917         value &= 0xFF;
918
919         if (value == 1) /* Low Speed */
920                 value = 85;
921         else if (value == 2)
922                 value = 170;
923         else if (value == 3)
924                 value = 255;
925         else if (value != 0) {
926                 pr_err("Unknown fan speed %#x", value);
927                 value = -1;
928         }
929
930         return sprintf(buf, "%d\n", value);
931 }
932
933 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
934
935 static ssize_t
936 show_name(struct device *dev, struct device_attribute *attr, char *buf)
937 {
938         return sprintf(buf, "asus\n");
939 }
940 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
941
942 static struct attribute *hwmon_attributes[] = {
943         &sensor_dev_attr_pwm1.dev_attr.attr,
944         &sensor_dev_attr_name.dev_attr.attr,
945         NULL
946 };
947
948 static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
949                                     struct attribute *attr, int idx)
950 {
951         struct device *dev = container_of(kobj, struct device, kobj);
952         struct platform_device *pdev = to_platform_device(dev->parent);
953         struct asus_wmi *asus = platform_get_drvdata(pdev);
954         bool ok = true;
955         int dev_id = -1;
956         u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
957
958         if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
959                 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
960
961         if (dev_id != -1) {
962                 int err = asus_wmi_get_devstate(asus, dev_id, &value);
963
964                 if (err < 0)
965                         return 0; /* can't return negative here */
966         }
967
968         if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
969                 /*
970                  * We need to find a better way, probably using sfun,
971                  * bits or spec ...
972                  * Currently we disable it if:
973                  * - ASUS_WMI_UNSUPPORTED_METHOD is returned
974                  * - reverved bits are non-zero
975                  * - sfun and presence bit are not set
976                  */
977                 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
978                     || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
979                         ok = false;
980         }
981
982         return ok ? attr->mode : 0;
983 }
984
985 static struct attribute_group hwmon_attribute_group = {
986         .is_visible = asus_hwmon_sysfs_is_visible,
987         .attrs = hwmon_attributes
988 };
989
990 static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
991 {
992         struct device *hwmon;
993
994         hwmon = asus->hwmon_device;
995         if (!hwmon)
996                 return;
997         sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
998         hwmon_device_unregister(hwmon);
999         asus->hwmon_device = NULL;
1000 }
1001
1002 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1003 {
1004         struct device *hwmon;
1005         int result;
1006
1007         hwmon = hwmon_device_register(&asus->platform_device->dev);
1008         if (IS_ERR(hwmon)) {
1009                 pr_err("Could not register asus hwmon device\n");
1010                 return PTR_ERR(hwmon);
1011         }
1012         dev_set_drvdata(hwmon, asus);
1013         asus->hwmon_device = hwmon;
1014         result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
1015         if (result)
1016                 asus_wmi_hwmon_exit(asus);
1017         return result;
1018 }
1019
1020 /*
1021  * Backlight
1022  */
1023 static int read_backlight_power(struct asus_wmi *asus)
1024 {
1025         int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
1026
1027         if (ret < 0)
1028                 return ret;
1029
1030         return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1031 }
1032
1033 static int read_brightness_max(struct asus_wmi *asus)
1034 {
1035         u32 retval;
1036         int err;
1037
1038         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1039
1040         if (err < 0)
1041                 return err;
1042
1043         retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1044         retval >>= 8;
1045
1046         if (!retval)
1047                 return -ENODEV;
1048
1049         return retval;
1050 }
1051
1052 static int read_brightness(struct backlight_device *bd)
1053 {
1054         struct asus_wmi *asus = bl_get_data(bd);
1055         u32 retval;
1056         int err;
1057
1058         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1059
1060         if (err < 0)
1061                 return err;
1062
1063         return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1064 }
1065
1066 static int update_bl_status(struct backlight_device *bd)
1067 {
1068         struct asus_wmi *asus = bl_get_data(bd);
1069         u32 ctrl_param;
1070         int power, err;
1071
1072         ctrl_param = bd->props.brightness;
1073
1074         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1075                                     ctrl_param, NULL);
1076
1077         if (err < 0)
1078                 return err;
1079
1080         power = read_backlight_power(asus);
1081         if (power != -ENODEV && bd->props.power != power) {
1082                 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1083                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1084                                             ctrl_param, NULL);
1085         }
1086         return err;
1087 }
1088
1089 static const struct backlight_ops asus_wmi_bl_ops = {
1090         .get_brightness = read_brightness,
1091         .update_status = update_bl_status,
1092 };
1093
1094 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1095 {
1096         struct backlight_device *bd = asus->backlight_device;
1097         int old = bd->props.brightness;
1098         int new = old;
1099
1100         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1101                 new = code - NOTIFY_BRNUP_MIN + 1;
1102         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1103                 new = code - NOTIFY_BRNDOWN_MIN;
1104
1105         bd->props.brightness = new;
1106         backlight_update_status(bd);
1107         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1108
1109         return old;
1110 }
1111
1112 static int asus_wmi_backlight_init(struct asus_wmi *asus)
1113 {
1114         struct backlight_device *bd;
1115         struct backlight_properties props;
1116         int max;
1117         int power;
1118
1119         max = read_brightness_max(asus);
1120
1121         if (max == -ENODEV)
1122                 max = 0;
1123         else if (max < 0)
1124                 return max;
1125
1126         power = read_backlight_power(asus);
1127
1128         if (power == -ENODEV)
1129                 power = FB_BLANK_UNBLANK;
1130         else if (power < 0)
1131                 return power;
1132
1133         memset(&props, 0, sizeof(struct backlight_properties));
1134         props.type = BACKLIGHT_PLATFORM;
1135         props.max_brightness = max;
1136         bd = backlight_device_register(asus->driver->name,
1137                                        &asus->platform_device->dev, asus,
1138                                        &asus_wmi_bl_ops, &props);
1139         if (IS_ERR(bd)) {
1140                 pr_err("Could not register backlight device\n");
1141                 return PTR_ERR(bd);
1142         }
1143
1144         asus->backlight_device = bd;
1145
1146         bd->props.brightness = read_brightness(bd);
1147         bd->props.power = power;
1148         backlight_update_status(bd);
1149
1150         return 0;
1151 }
1152
1153 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
1154 {
1155         if (asus->backlight_device)
1156                 backlight_device_unregister(asus->backlight_device);
1157
1158         asus->backlight_device = NULL;
1159 }
1160
1161 static void asus_wmi_notify(u32 value, void *context)
1162 {
1163         struct asus_wmi *asus = context;
1164         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1165         union acpi_object *obj;
1166         acpi_status status;
1167         int code;
1168         int orig_code;
1169         unsigned int key_value = 1;
1170         bool autorelease = 1;
1171
1172         status = wmi_get_event_data(value, &response);
1173         if (status != AE_OK) {
1174                 pr_err("bad event status 0x%x\n", status);
1175                 return;
1176         }
1177
1178         obj = (union acpi_object *)response.pointer;
1179
1180         if (!obj || obj->type != ACPI_TYPE_INTEGER)
1181                 goto exit;
1182
1183         code = obj->integer.value;
1184         orig_code = code;
1185
1186         if (asus->driver->key_filter) {
1187                 asus->driver->key_filter(asus->driver, &code, &key_value,
1188                                          &autorelease);
1189                 if (code == ASUS_WMI_KEY_IGNORE)
1190                         goto exit;
1191         }
1192
1193         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1194                 code = NOTIFY_BRNUP_MIN;
1195         else if (code >= NOTIFY_BRNDOWN_MIN &&
1196                  code <= NOTIFY_BRNDOWN_MAX)
1197                 code = NOTIFY_BRNDOWN_MIN;
1198
1199         if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
1200                 if (!acpi_video_backlight_support())
1201                         asus_wmi_backlight_notify(asus, orig_code);
1202         } else if (!sparse_keymap_report_event(asus->inputdev, code,
1203                                                key_value, autorelease))
1204                 pr_info("Unknown key %x pressed\n", code);
1205
1206 exit:
1207         kfree(obj);
1208 }
1209
1210 /*
1211  * Sys helpers
1212  */
1213 static int parse_arg(const char *buf, unsigned long count, int *val)
1214 {
1215         if (!count)
1216                 return 0;
1217         if (sscanf(buf, "%i", val) != 1)
1218                 return -EINVAL;
1219         return count;
1220 }
1221
1222 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1223                              const char *buf, size_t count)
1224 {
1225         u32 retval;
1226         int rv, err, value;
1227
1228         value = asus_wmi_get_devstate_simple(asus, devid);
1229         if (value == -ENODEV)   /* Check device presence */
1230                 return value;
1231
1232         rv = parse_arg(buf, count, &value);
1233         err = asus_wmi_set_devstate(devid, value, &retval);
1234
1235         if (err < 0)
1236                 return err;
1237
1238         return rv;
1239 }
1240
1241 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
1242 {
1243         int value = asus_wmi_get_devstate_simple(asus, devid);
1244
1245         if (value < 0)
1246                 return value;
1247
1248         return sprintf(buf, "%d\n", value);
1249 }
1250
1251 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
1252         static ssize_t show_##_name(struct device *dev,                 \
1253                                     struct device_attribute *attr,      \
1254                                     char *buf)                          \
1255         {                                                               \
1256                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
1257                                                                         \
1258                 return show_sys_wmi(asus, _cm, buf);                    \
1259         }                                                               \
1260         static ssize_t store_##_name(struct device *dev,                \
1261                                      struct device_attribute *attr,     \
1262                                      const char *buf, size_t count)     \
1263         {                                                               \
1264                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
1265                                                                         \
1266                 return store_sys_wmi(asus, _cm, buf, count);            \
1267         }                                                               \
1268         static struct device_attribute dev_attr_##_name = {             \
1269                 .attr = {                                               \
1270                         .name = __stringify(_name),                     \
1271                         .mode = _mode },                                \
1272                 .show   = show_##_name,                                 \
1273                 .store  = store_##_name,                                \
1274         }
1275
1276 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1277 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1278 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
1279
1280 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1281                            const char *buf, size_t count)
1282 {
1283         int value;
1284
1285         if (!count || sscanf(buf, "%i", &value) != 1)
1286                 return -EINVAL;
1287         if (value < 0 || value > 2)
1288                 return -EINVAL;
1289
1290         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1291 }
1292
1293 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1294
1295 static struct attribute *platform_attributes[] = {
1296         &dev_attr_cpufv.attr,
1297         &dev_attr_camera.attr,
1298         &dev_attr_cardr.attr,
1299         &dev_attr_touchpad.attr,
1300         NULL
1301 };
1302
1303 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1304                                     struct attribute *attr, int idx)
1305 {
1306         struct device *dev = container_of(kobj, struct device, kobj);
1307         struct platform_device *pdev = to_platform_device(dev);
1308         struct asus_wmi *asus = platform_get_drvdata(pdev);
1309         bool ok = true;
1310         int devid = -1;
1311
1312         if (attr == &dev_attr_camera.attr)
1313                 devid = ASUS_WMI_DEVID_CAMERA;
1314         else if (attr == &dev_attr_cardr.attr)
1315                 devid = ASUS_WMI_DEVID_CARDREADER;
1316         else if (attr == &dev_attr_touchpad.attr)
1317                 devid = ASUS_WMI_DEVID_TOUCHPAD;
1318
1319         if (devid != -1)
1320                 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1321
1322         return ok ? attr->mode : 0;
1323 }
1324
1325 static struct attribute_group platform_attribute_group = {
1326         .is_visible = asus_sysfs_is_visible,
1327         .attrs = platform_attributes
1328 };
1329
1330 static void asus_wmi_sysfs_exit(struct platform_device *device)
1331 {
1332         sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1333 }
1334
1335 static int asus_wmi_sysfs_init(struct platform_device *device)
1336 {
1337         return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1338 }
1339
1340 /*
1341  * Platform device
1342  */
1343 static int asus_wmi_platform_init(struct asus_wmi *asus)
1344 {
1345         int rv;
1346
1347         /* INIT enable hotkeys on some models */
1348         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1349                 pr_info("Initialization: %#x", rv);
1350
1351         /* We don't know yet what to do with this version... */
1352         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
1353                 pr_info("BIOS WMI version: %d.%d", rv >> 16, rv & 0xFF);
1354                 asus->spec = rv;
1355         }
1356
1357         /*
1358          * The SFUN method probably allows the original driver to get the list
1359          * of features supported by a given model. For now, 0x0100 or 0x0800
1360          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1361          * The significance of others is yet to be found.
1362          */
1363         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1364                 pr_info("SFUN value: %#x", rv);
1365                 asus->sfun = rv;
1366         }
1367
1368         /*
1369          * Eee PC and Notebooks seems to have different method_id for DSTS,
1370          * but it may also be related to the BIOS's SPEC.
1371          * Note, on most Eeepc, there is no way to check if a method exist
1372          * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1373          * but once again, SPEC may probably be used for that kind of things.
1374          */
1375         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1376                 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1377         else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
1378                 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1379
1380         if (!asus->dsts_id) {
1381                 pr_err("Can't find DSTS");
1382                 return -ENODEV;
1383         }
1384
1385         return asus_wmi_sysfs_init(asus->platform_device);
1386 }
1387
1388 static void asus_wmi_platform_exit(struct asus_wmi *asus)
1389 {
1390         asus_wmi_sysfs_exit(asus->platform_device);
1391 }
1392
1393 /*
1394  * debugfs
1395  */
1396 struct asus_wmi_debugfs_node {
1397         struct asus_wmi *asus;
1398         char *name;
1399         int (*show) (struct seq_file *m, void *data);
1400 };
1401
1402 static int show_dsts(struct seq_file *m, void *data)
1403 {
1404         struct asus_wmi *asus = m->private;
1405         int err;
1406         u32 retval = -1;
1407
1408         err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1409
1410         if (err < 0)
1411                 return err;
1412
1413         seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
1414
1415         return 0;
1416 }
1417
1418 static int show_devs(struct seq_file *m, void *data)
1419 {
1420         struct asus_wmi *asus = m->private;
1421         int err;
1422         u32 retval = -1;
1423
1424         err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1425                                     &retval);
1426
1427         if (err < 0)
1428                 return err;
1429
1430         seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
1431                    asus->debug.ctrl_param, retval);
1432
1433         return 0;
1434 }
1435
1436 static int show_call(struct seq_file *m, void *data)
1437 {
1438         struct asus_wmi *asus = m->private;
1439         struct bios_args args = {
1440                 .arg0 = asus->debug.dev_id,
1441                 .arg1 = asus->debug.ctrl_param,
1442         };
1443         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1444         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1445         union acpi_object *obj;
1446         acpi_status status;
1447
1448         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1449                                      1, asus->debug.method_id,
1450                                      &input, &output);
1451
1452         if (ACPI_FAILURE(status))
1453                 return -EIO;
1454
1455         obj = (union acpi_object *)output.pointer;
1456         if (obj && obj->type == ACPI_TYPE_INTEGER)
1457                 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1458                            asus->debug.dev_id, asus->debug.ctrl_param,
1459                            (u32) obj->integer.value);
1460         else
1461                 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1462                            asus->debug.dev_id, asus->debug.ctrl_param,
1463                            obj ? obj->type : -1);
1464
1465         kfree(obj);
1466
1467         return 0;
1468 }
1469
1470 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1471         {NULL, "devs", show_devs},
1472         {NULL, "dsts", show_dsts},
1473         {NULL, "call", show_call},
1474 };
1475
1476 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1477 {
1478         struct asus_wmi_debugfs_node *node = inode->i_private;
1479
1480         return single_open(file, node->show, node->asus);
1481 }
1482
1483 static const struct file_operations asus_wmi_debugfs_io_ops = {
1484         .owner = THIS_MODULE,
1485         .open = asus_wmi_debugfs_open,
1486         .read = seq_read,
1487         .llseek = seq_lseek,
1488         .release = single_release,
1489 };
1490
1491 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1492 {
1493         debugfs_remove_recursive(asus->debug.root);
1494 }
1495
1496 static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1497 {
1498         struct dentry *dent;
1499         int i;
1500
1501         asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1502         if (!asus->debug.root) {
1503                 pr_err("failed to create debugfs directory");
1504                 goto error_debugfs;
1505         }
1506
1507         dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1508                                   asus->debug.root, &asus->debug.method_id);
1509         if (!dent)
1510                 goto error_debugfs;
1511
1512         dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1513                                   asus->debug.root, &asus->debug.dev_id);
1514         if (!dent)
1515                 goto error_debugfs;
1516
1517         dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1518                                   asus->debug.root, &asus->debug.ctrl_param);
1519         if (!dent)
1520                 goto error_debugfs;
1521
1522         for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1523                 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1524
1525                 node->asus = asus;
1526                 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1527                                            asus->debug.root, node,
1528                                            &asus_wmi_debugfs_io_ops);
1529                 if (!dent) {
1530                         pr_err("failed to create debug file: %s\n", node->name);
1531                         goto error_debugfs;
1532                 }
1533         }
1534
1535         return 0;
1536
1537 error_debugfs:
1538         asus_wmi_debugfs_exit(asus);
1539         return -ENOMEM;
1540 }
1541
1542 /*
1543  * WMI Driver
1544  */
1545 static int asus_wmi_add(struct platform_device *pdev)
1546 {
1547         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1548         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1549         struct asus_wmi *asus;
1550         acpi_status status;
1551         int err;
1552
1553         asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1554         if (!asus)
1555                 return -ENOMEM;
1556
1557         asus->driver = wdrv;
1558         asus->platform_device = pdev;
1559         wdrv->platform_device = pdev;
1560         platform_set_drvdata(asus->platform_device, asus);
1561
1562         if (wdrv->quirks)
1563                 wdrv->quirks(asus->driver);
1564
1565         err = asus_wmi_platform_init(asus);
1566         if (err)
1567                 goto fail_platform;
1568
1569         err = asus_wmi_input_init(asus);
1570         if (err)
1571                 goto fail_input;
1572
1573         err = asus_wmi_hwmon_init(asus);
1574         if (err)
1575                 goto fail_hwmon;
1576
1577         err = asus_wmi_led_init(asus);
1578         if (err)
1579                 goto fail_leds;
1580
1581         err = asus_wmi_rfkill_init(asus);
1582         if (err)
1583                 goto fail_rfkill;
1584
1585         if (!acpi_video_backlight_support()) {
1586                 err = asus_wmi_backlight_init(asus);
1587                 if (err && err != -ENODEV)
1588                         goto fail_backlight;
1589         } else
1590                 pr_info("Backlight controlled by ACPI video driver\n");
1591
1592         status = wmi_install_notify_handler(asus->driver->event_guid,
1593                                             asus_wmi_notify, asus);
1594         if (ACPI_FAILURE(status)) {
1595                 pr_err("Unable to register notify handler - %d\n", status);
1596                 err = -ENODEV;
1597                 goto fail_wmi_handler;
1598         }
1599
1600         err = asus_wmi_debugfs_init(asus);
1601         if (err)
1602                 goto fail_debugfs;
1603
1604         return 0;
1605
1606 fail_debugfs:
1607         wmi_remove_notify_handler(asus->driver->event_guid);
1608 fail_wmi_handler:
1609         asus_wmi_backlight_exit(asus);
1610 fail_backlight:
1611         asus_wmi_rfkill_exit(asus);
1612 fail_rfkill:
1613         asus_wmi_led_exit(asus);
1614 fail_leds:
1615         asus_wmi_hwmon_exit(asus);
1616 fail_hwmon:
1617         asus_wmi_input_exit(asus);
1618 fail_input:
1619         asus_wmi_platform_exit(asus);
1620 fail_platform:
1621         kfree(asus);
1622         return err;
1623 }
1624
1625 static int asus_wmi_remove(struct platform_device *device)
1626 {
1627         struct asus_wmi *asus;
1628
1629         asus = platform_get_drvdata(device);
1630         wmi_remove_notify_handler(asus->driver->event_guid);
1631         asus_wmi_backlight_exit(asus);
1632         asus_wmi_input_exit(asus);
1633         asus_wmi_hwmon_exit(asus);
1634         asus_wmi_led_exit(asus);
1635         asus_wmi_rfkill_exit(asus);
1636         asus_wmi_debugfs_exit(asus);
1637         asus_wmi_platform_exit(asus);
1638
1639         kfree(asus);
1640         return 0;
1641 }
1642
1643 /*
1644  * Platform driver - hibernate/resume callbacks
1645  */
1646 static int asus_hotk_thaw(struct device *device)
1647 {
1648         struct asus_wmi *asus = dev_get_drvdata(device);
1649
1650         if (asus->wlan.rfkill) {
1651                 bool wlan;
1652
1653                 /*
1654                  * Work around bios bug - acpi _PTS turns off the wireless led
1655                  * during suspend.  Normally it restores it on resume, but
1656                  * we should kick it ourselves in case hibernation is aborted.
1657                  */
1658                 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1659                 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
1660         }
1661
1662         return 0;
1663 }
1664
1665 static int asus_hotk_restore(struct device *device)
1666 {
1667         struct asus_wmi *asus = dev_get_drvdata(device);
1668         int bl;
1669
1670         /* Refresh both wlan rfkill state and pci hotplug */
1671         if (asus->wlan.rfkill)
1672                 asus_rfkill_hotplug(asus);
1673
1674         if (asus->bluetooth.rfkill) {
1675                 bl = !asus_wmi_get_devstate_simple(asus,
1676                                                    ASUS_WMI_DEVID_BLUETOOTH);
1677                 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
1678         }
1679         if (asus->wimax.rfkill) {
1680                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
1681                 rfkill_set_sw_state(asus->wimax.rfkill, bl);
1682         }
1683         if (asus->wwan3g.rfkill) {
1684                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
1685                 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
1686         }
1687
1688         return 0;
1689 }
1690
1691 static const struct dev_pm_ops asus_pm_ops = {
1692         .thaw = asus_hotk_thaw,
1693         .restore = asus_hotk_restore,
1694 };
1695
1696 static int asus_wmi_probe(struct platform_device *pdev)
1697 {
1698         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1699         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1700         int ret;
1701
1702         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1703                 pr_warn("Management GUID not found\n");
1704                 return -ENODEV;
1705         }
1706
1707         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
1708                 pr_warn("Event GUID not found\n");
1709                 return -ENODEV;
1710         }
1711
1712         if (wdrv->probe) {
1713                 ret = wdrv->probe(pdev);
1714                 if (ret)
1715                         return ret;
1716         }
1717
1718         return asus_wmi_add(pdev);
1719 }
1720
1721 static bool used;
1722
1723 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
1724 {
1725         struct platform_driver *platform_driver;
1726         struct platform_device *platform_device;
1727
1728         if (used)
1729                 return -EBUSY;
1730
1731         platform_driver = &driver->platform_driver;
1732         platform_driver->remove = asus_wmi_remove;
1733         platform_driver->driver.owner = driver->owner;
1734         platform_driver->driver.name = driver->name;
1735         platform_driver->driver.pm = &asus_pm_ops;
1736
1737         platform_device = platform_create_bundle(platform_driver,
1738                                                  asus_wmi_probe,
1739                                                  NULL, 0, NULL, 0);
1740         if (IS_ERR(platform_device))
1741                 return PTR_ERR(platform_device);
1742
1743         used = true;
1744         return 0;
1745 }
1746 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1747
1748 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1749 {
1750         platform_device_unregister(driver->platform_device);
1751         platform_driver_unregister(&driver->platform_driver);
1752         used = false;
1753 }
1754 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1755
1756 static int __init asus_wmi_init(void)
1757 {
1758         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1759                 pr_info("Asus Management GUID not found");
1760                 return -ENODEV;
1761         }
1762
1763         pr_info("ASUS WMI generic driver loaded");
1764         return 0;
1765 }
1766
1767 static void __exit asus_wmi_exit(void)
1768 {
1769         pr_info("ASUS WMI generic driver unloaded");
1770 }
1771
1772 module_init(asus_wmi_init);
1773 module_exit(asus_wmi_exit);