projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-linus-20160523' of git://git.infradead.org/linux-mtd
[deliverable/linux.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 <linux/thermal.h>
48 #include <linux/acpi.h>
49 #include <linux/dmi.h>
50 #include <acpi/video.h>
51
52 #include "asus-wmi.h"
53
54 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
55 "Yong Wang <yong.y.wang@intel.com>");
56 MODULE_DESCRIPTION("Asus Generic WMI Driver");
57 MODULE_LICENSE("GPL");
58
59 #define to_asus_wmi_driver(pdrv) \
60 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
61
62 #define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
63
64 #define NOTIFY_BRNUP_MIN 0x11
65 #define NOTIFY_BRNUP_MAX 0x1f
66 #define NOTIFY_BRNDOWN_MIN 0x20
67 #define NOTIFY_BRNDOWN_MAX 0x2e
68 #define NOTIFY_KBD_BRTUP 0xc4
69 #define NOTIFY_KBD_BRTDWN 0xc5
70
71 /* WMI Methods */
72 #define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
73 #define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
74 #define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
75 #define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
76 #define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
77 #define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
78 #define ASUS_WMI_METHODID_AGFN 0x4E464741 /* FaN? */
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_WLAN_LED 0x00010012
101 #define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
102 #define ASUS_WMI_DEVID_GPS 0x00010015
103 #define ASUS_WMI_DEVID_WIMAX 0x00010017
104 #define ASUS_WMI_DEVID_WWAN3G 0x00010019
105 #define ASUS_WMI_DEVID_UWB 0x00010021
106
107 /* Leds */
108 /* 0x000200XX and 0x000400XX */
109 #define ASUS_WMI_DEVID_LED1 0x00020011
110 #define ASUS_WMI_DEVID_LED2 0x00020012
111 #define ASUS_WMI_DEVID_LED3 0x00020013
112 #define ASUS_WMI_DEVID_LED4 0x00020014
113 #define ASUS_WMI_DEVID_LED5 0x00020015
114 #define ASUS_WMI_DEVID_LED6 0x00020016
115
116 /* Backlight and Brightness */
117 #define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
118 #define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
119 #define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
120 #define ASUS_WMI_DEVID_LIGHT_SENSOR 0x00050022 /* ?? */
121
122 /* Misc */
123 #define ASUS_WMI_DEVID_CAMERA 0x00060013
124
125 /* Storage */
126 #define ASUS_WMI_DEVID_CARDREADER 0x00080013
127
128 /* Input */
129 #define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
130 #define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
131
132 /* Fan, Thermal */
133 #define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011
134 #define ASUS_WMI_DEVID_FAN_CTRL 0x00110012
135
136 /* Power */
137 #define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012
138
139 /* Deep S3 / Resume on LID open */
140 #define ASUS_WMI_DEVID_LID_RESUME 0x00120031
141
142 /* DSTS masks */
143 #define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
144 #define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
145 #define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
146 #define ASUS_WMI_DSTS_USER_BIT 0x00020000
147 #define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
148 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
149 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
150
151 #define ASUS_FAN_DESC "cpu_fan"
152 #define ASUS_FAN_MFUN 0x13
153 #define ASUS_FAN_SFUN_READ 0x06
154 #define ASUS_FAN_SFUN_WRITE 0x07
155 #define ASUS_FAN_CTRL_MANUAL 1
156 #define ASUS_FAN_CTRL_AUTO 2
157
158 struct bios_args {
159 u32 arg0;
160 u32 arg1;
161 } __packed;
162
163 /*
164 * Struct that's used for all methods called via AGFN. Naming is
165 * identically to the AML code.
166 */
167 struct agfn_args {
168 u16 mfun; /* probably "Multi-function" to be called */
169 u16 sfun; /* probably "Sub-function" to be called */
170 u16 len; /* size of the hole struct, including subfunction fields */
171 u8 stas; /* not used by now */
172 u8 err; /* zero on success */
173 } __packed;
174
175 /* struct used for calling fan read and write methods */
176 struct fan_args {
177 struct agfn_args agfn; /* common fields */
178 u8 fan; /* fan number: 0: set auto mode 1: 1st fan */
179 u32 speed; /* read: RPM/100 - write: 0-255 */
180 } __packed;
181
182 /*
183 * <platform>/ - debugfs root directory
184 * dev_id - current dev_id
185 * ctrl_param - current ctrl_param
186 * method_id - current method_id
187 * devs - call DEVS(dev_id, ctrl_param) and print result
188 * dsts - call DSTS(dev_id) and print result
189 * call - call method_id(dev_id, ctrl_param) and print result
190 */
191 struct asus_wmi_debug {
192 struct dentry *root;
193 u32 method_id;
194 u32 dev_id;
195 u32 ctrl_param;
196 };
197
198 struct asus_rfkill {
199 struct asus_wmi *asus;
200 struct rfkill *rfkill;
201 u32 dev_id;
202 };
203
204 struct asus_wmi {
205 int dsts_id;
206 int spec;
207 int sfun;
208
209 struct input_dev *inputdev;
210 struct backlight_device *backlight_device;
211 struct platform_device *platform_device;
212
213 struct led_classdev wlan_led;
214 int wlan_led_wk;
215 struct led_classdev tpd_led;
216 int tpd_led_wk;
217 struct led_classdev kbd_led;
218 int kbd_led_wk;
219 struct workqueue_struct *led_workqueue;
220 struct work_struct tpd_led_work;
221 struct work_struct kbd_led_work;
222 struct work_struct wlan_led_work;
223
224 struct asus_rfkill wlan;
225 struct asus_rfkill bluetooth;
226 struct asus_rfkill wimax;
227 struct asus_rfkill wwan3g;
228 struct asus_rfkill gps;
229 struct asus_rfkill uwb;
230
231 bool asus_hwmon_fan_manual_mode;
232 int asus_hwmon_num_fans;
233 int asus_hwmon_pwm;
234
235 struct hotplug_slot *hotplug_slot;
236 struct mutex hotplug_lock;
237 struct mutex wmi_lock;
238 struct workqueue_struct *hotplug_workqueue;
239 struct work_struct hotplug_work;
240
241 struct asus_wmi_debug debug;
242
243 struct asus_wmi_driver *driver;
244 };
245
246 static int asus_wmi_input_init(struct asus_wmi *asus)
247 {
248 int err;
249
250 asus->inputdev = input_allocate_device();
251 if (!asus->inputdev)
252 return -ENOMEM;
253
254 asus->inputdev->name = asus->driver->input_name;
255 asus->inputdev->phys = asus->driver->input_phys;
256 asus->inputdev->id.bustype = BUS_HOST;
257 asus->inputdev->dev.parent = &asus->platform_device->dev;
258 set_bit(EV_REP, asus->inputdev->evbit);
259
260 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
261 if (err)
262 goto err_free_dev;
263
264 err = input_register_device(asus->inputdev);
265 if (err)
266 goto err_free_keymap;
267
268 return 0;
269
270 err_free_keymap:
271 sparse_keymap_free(asus->inputdev);
272 err_free_dev:
273 input_free_device(asus->inputdev);
274 return err;
275 }
276
277 static void asus_wmi_input_exit(struct asus_wmi *asus)
278 {
279 if (asus->inputdev) {
280 sparse_keymap_free(asus->inputdev);
281 input_unregister_device(asus->inputdev);
282 }
283
284 asus->inputdev = NULL;
285 }
286
287 static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
288 u32 *retval)
289 {
290 struct bios_args args = {
291 .arg0 = arg0,
292 .arg1 = arg1,
293 };
294 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
295 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
296 acpi_status status;
297 union acpi_object *obj;
298 u32 tmp = 0;
299
300 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
301 &input, &output);
302
303 if (ACPI_FAILURE(status))
304 goto exit;
305
306 obj = (union acpi_object *)output.pointer;
307 if (obj && obj->type == ACPI_TYPE_INTEGER)
308 tmp = (u32) obj->integer.value;
309
310 if (retval)
311 *retval = tmp;
312
313 kfree(obj);
314
315 exit:
316 if (ACPI_FAILURE(status))
317 return -EIO;
318
319 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
320 return -ENODEV;
321
322 return 0;
323 }
324
325 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
326 {
327 struct acpi_buffer input;
328 u64 phys_addr;
329 u32 retval;
330 u32 status = -1;
331
332 /*
333 * Copy to dma capable address otherwise memory corruption occurs as
334 * bios has to be able to access it.
335 */
336 input.pointer = kzalloc(args.length, GFP_DMA | GFP_KERNEL);
337 input.length = args.length;
338 if (!input.pointer)
339 return -ENOMEM;
340 phys_addr = virt_to_phys(input.pointer);
341 memcpy(input.pointer, args.pointer, args.length);
342
343 status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
344 phys_addr, 0, &retval);
345 if (!status)
346 memcpy(args.pointer, input.pointer, args.length);
347
348 kfree(input.pointer);
349 if (status)
350 return -ENXIO;
351
352 return retval;
353 }
354
355 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
356 {
357 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
358 }
359
360 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
361 u32 *retval)
362 {
363 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
364 ctrl_param, retval);
365 }
366
367 /* Helper for special devices with magic return codes */
368 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
369 u32 dev_id, u32 mask)
370 {
371 u32 retval = 0;
372 int err;
373
374 err = asus_wmi_get_devstate(asus, dev_id, &retval);
375
376 if (err < 0)
377 return err;
378
379 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
380 return -ENODEV;
381
382 if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
383 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
384 return -ENODEV;
385 }
386
387 return retval & mask;
388 }
389
390 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
391 {
392 return asus_wmi_get_devstate_bits(asus, dev_id,
393 ASUS_WMI_DSTS_STATUS_BIT);
394 }
395
396 /*
397 * LEDs
398 */
399 /*
400 * These functions actually update the LED's, and are called from a
401 * workqueue. By doing this as separate work rather than when the LED
402 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
403 * potentially bad time, such as a timer interrupt.
404 */
405 static void tpd_led_update(struct work_struct *work)
406 {
407 int ctrl_param;
408 struct asus_wmi *asus;
409
410 asus = container_of(work, struct asus_wmi, tpd_led_work);
411
412 ctrl_param = asus->tpd_led_wk;
413 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
414 }
415
416 static void tpd_led_set(struct led_classdev *led_cdev,
417 enum led_brightness value)
418 {
419 struct asus_wmi *asus;
420
421 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
422
423 asus->tpd_led_wk = !!value;
424 queue_work(asus->led_workqueue, &asus->tpd_led_work);
425 }
426
427 static int read_tpd_led_state(struct asus_wmi *asus)
428 {
429 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
430 }
431
432 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
433 {
434 struct asus_wmi *asus;
435
436 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
437
438 return read_tpd_led_state(asus);
439 }
440
441 static void kbd_led_update(struct work_struct *work)
442 {
443 int ctrl_param = 0;
444 struct asus_wmi *asus;
445
446 asus = container_of(work, struct asus_wmi, kbd_led_work);
447
448 /*
449 * bits 0-2: level
450 * bit 7: light on/off
451 */
452 if (asus->kbd_led_wk > 0)
453 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
454
455 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
456 }
457
458 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
459 {
460 int retval;
461
462 /*
463 * bits 0-2: level
464 * bit 7: light on/off
465 * bit 8-10: environment (0: dark, 1: normal, 2: light)
466 * bit 17: status unknown
467 */
468 retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
469 0xFFFF);
470
471 /* Unknown status is considered as off */
472 if (retval == 0x8000)
473 retval = 0;
474
475 if (retval >= 0) {
476 if (level)
477 *level = retval & 0x7F;
478 if (env)
479 *env = (retval >> 8) & 0x7F;
480 retval = 0;
481 }
482
483 return retval;
484 }
485
486 static void kbd_led_set(struct led_classdev *led_cdev,
487 enum led_brightness value)
488 {
489 struct asus_wmi *asus;
490
491 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
492
493 if (value > asus->kbd_led.max_brightness)
494 value = asus->kbd_led.max_brightness;
495 else if (value < 0)
496 value = 0;
497
498 asus->kbd_led_wk = value;
499 queue_work(asus->led_workqueue, &asus->kbd_led_work);
500 }
501
502 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
503 {
504 struct asus_wmi *asus;
505 int retval, value;
506
507 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
508
509 retval = kbd_led_read(asus, &value, NULL);
510
511 if (retval < 0)
512 return retval;
513
514 return value;
515 }
516
517 static int wlan_led_unknown_state(struct asus_wmi *asus)
518 {
519 u32 result;
520
521 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
522
523 return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
524 }
525
526 static int wlan_led_presence(struct asus_wmi *asus)
527 {
528 u32 result;
529
530 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
531
532 return result & ASUS_WMI_DSTS_PRESENCE_BIT;
533 }
534
535 static void wlan_led_update(struct work_struct *work)
536 {
537 int ctrl_param;
538 struct asus_wmi *asus;
539
540 asus = container_of(work, struct asus_wmi, wlan_led_work);
541
542 ctrl_param = asus->wlan_led_wk;
543 asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
544 }
545
546 static void wlan_led_set(struct led_classdev *led_cdev,
547 enum led_brightness value)
548 {
549 struct asus_wmi *asus;
550
551 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
552
553 asus->wlan_led_wk = !!value;
554 queue_work(asus->led_workqueue, &asus->wlan_led_work);
555 }
556
557 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
558 {
559 struct asus_wmi *asus;
560 u32 result;
561
562 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
563 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
564
565 return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
566 }
567
568 static void asus_wmi_led_exit(struct asus_wmi *asus)
569 {
570 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
571 led_classdev_unregister(&asus->kbd_led);
572 if (!IS_ERR_OR_NULL(asus->tpd_led.dev))
573 led_classdev_unregister(&asus->tpd_led);
574 if (!IS_ERR_OR_NULL(asus->wlan_led.dev))
575 led_classdev_unregister(&asus->wlan_led);
576 if (asus->led_workqueue)
577 destroy_workqueue(asus->led_workqueue);
578 }
579
580 static int asus_wmi_led_init(struct asus_wmi *asus)
581 {
582 int rv = 0, led_val;
583
584 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
585 if (!asus->led_workqueue)
586 return -ENOMEM;
587
588 if (read_tpd_led_state(asus) >= 0) {
589 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
590
591 asus->tpd_led.name = "asus::touchpad";
592 asus->tpd_led.brightness_set = tpd_led_set;
593 asus->tpd_led.brightness_get = tpd_led_get;
594 asus->tpd_led.max_brightness = 1;
595
596 rv = led_classdev_register(&asus->platform_device->dev,
597 &asus->tpd_led);
598 if (rv)
599 goto error;
600 }
601
602 led_val = kbd_led_read(asus, NULL, NULL);
603 if (led_val >= 0) {
604 INIT_WORK(&asus->kbd_led_work, kbd_led_update);
605
606 asus->kbd_led_wk = led_val;
607 asus->kbd_led.name = "asus::kbd_backlight";
608 asus->kbd_led.brightness_set = kbd_led_set;
609 asus->kbd_led.brightness_get = kbd_led_get;
610 asus->kbd_led.max_brightness = 3;
611
612 rv = led_classdev_register(&asus->platform_device->dev,
613 &asus->kbd_led);
614 if (rv)
615 goto error;
616 }
617
618 if (wlan_led_presence(asus) && (asus->driver->quirks->wapf > 0)) {
619 INIT_WORK(&asus->wlan_led_work, wlan_led_update);
620
621 asus->wlan_led.name = "asus::wlan";
622 asus->wlan_led.brightness_set = wlan_led_set;
623 if (!wlan_led_unknown_state(asus))
624 asus->wlan_led.brightness_get = wlan_led_get;
625 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
626 asus->wlan_led.max_brightness = 1;
627 asus->wlan_led.default_trigger = "asus-wlan";
628
629 rv = led_classdev_register(&asus->platform_device->dev,
630 &asus->wlan_led);
631 }
632
633 error:
634 if (rv)
635 asus_wmi_led_exit(asus);
636
637 return rv;
638 }
639
640
641 /*
642 * PCI hotplug (for wlan rfkill)
643 */
644 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
645 {
646 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
647
648 if (result < 0)
649 return false;
650 return !result;
651 }
652
653 static void asus_rfkill_hotplug(struct asus_wmi *asus)
654 {
655 struct pci_dev *dev;
656 struct pci_bus *bus;
657 bool blocked;
658 bool absent;
659 u32 l;
660
661 mutex_lock(&asus->wmi_lock);
662 blocked = asus_wlan_rfkill_blocked(asus);
663 mutex_unlock(&asus->wmi_lock);
664
665 mutex_lock(&asus->hotplug_lock);
666 pci_lock_rescan_remove();
667
668 if (asus->wlan.rfkill)
669 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
670
671 if (asus->hotplug_slot) {
672 bus = pci_find_bus(0, 1);
673 if (!bus) {
674 pr_warn("Unable to find PCI bus 1?\n");
675 goto out_unlock;
676 }
677
678 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
679 pr_err("Unable to read PCI config space?\n");
680 goto out_unlock;
681 }
682 absent = (l == 0xffffffff);
683
684 if (blocked != absent) {
685 pr_warn("BIOS says wireless lan is %s, "
686 "but the pci device is %s\n",
687 blocked ? "blocked" : "unblocked",
688 absent ? "absent" : "present");
689 pr_warn("skipped wireless hotplug as probably "
690 "inappropriate for this model\n");
691 goto out_unlock;
692 }
693
694 if (!blocked) {
695 dev = pci_get_slot(bus, 0);
696 if (dev) {
697 /* Device already present */
698 pci_dev_put(dev);
699 goto out_unlock;
700 }
701 dev = pci_scan_single_device(bus, 0);
702 if (dev) {
703 pci_bus_assign_resources(bus);
704 pci_bus_add_device(dev);
705 }
706 } else {
707 dev = pci_get_slot(bus, 0);
708 if (dev) {
709 pci_stop_and_remove_bus_device(dev);
710 pci_dev_put(dev);
711 }
712 }
713 }
714
715 out_unlock:
716 pci_unlock_rescan_remove();
717 mutex_unlock(&asus->hotplug_lock);
718 }
719
720 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
721 {
722 struct asus_wmi *asus = data;
723
724 if (event != ACPI_NOTIFY_BUS_CHECK)
725 return;
726
727 /*
728 * We can't call directly asus_rfkill_hotplug because most
729 * of the time WMBC is still being executed and not reetrant.
730 * There is currently no way to tell ACPICA that we want this
731 * method to be serialized, we schedule a asus_rfkill_hotplug
732 * call later, in a safer context.
733 */
734 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
735 }
736
737 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
738 {
739 acpi_status status;
740 acpi_handle handle;
741
742 status = acpi_get_handle(NULL, node, &handle);
743
744 if (ACPI_SUCCESS(status)) {
745 status = acpi_install_notify_handler(handle,
746 ACPI_SYSTEM_NOTIFY,
747 asus_rfkill_notify, asus);
748 if (ACPI_FAILURE(status))
749 pr_warn("Failed to register notify on %s\n", node);
750 } else
751 return -ENODEV;
752
753 return 0;
754 }
755
756 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
757 {
758 acpi_status status = AE_OK;
759 acpi_handle handle;
760
761 status = acpi_get_handle(NULL, node, &handle);
762
763 if (ACPI_SUCCESS(status)) {
764 status = acpi_remove_notify_handler(handle,
765 ACPI_SYSTEM_NOTIFY,
766 asus_rfkill_notify);
767 if (ACPI_FAILURE(status))
768 pr_err("Error removing rfkill notify handler %s\n",
769 node);
770 }
771 }
772
773 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
774 u8 *value)
775 {
776 struct asus_wmi *asus = hotplug_slot->private;
777 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
778
779 if (result < 0)
780 return result;
781
782 *value = !!result;
783 return 0;
784 }
785
786 static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
787 {
788 kfree(hotplug_slot->info);
789 kfree(hotplug_slot);
790 }
791
792 static struct hotplug_slot_ops asus_hotplug_slot_ops = {
793 .owner = THIS_MODULE,
794 .get_adapter_status = asus_get_adapter_status,
795 .get_power_status = asus_get_adapter_status,
796 };
797
798 static void asus_hotplug_work(struct work_struct *work)
799 {
800 struct asus_wmi *asus;
801
802 asus = container_of(work, struct asus_wmi, hotplug_work);
803 asus_rfkill_hotplug(asus);
804 }
805
806 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
807 {
808 int ret = -ENOMEM;
809 struct pci_bus *bus = pci_find_bus(0, 1);
810
811 if (!bus) {
812 pr_err("Unable to find wifi PCI bus\n");
813 return -ENODEV;
814 }
815
816 asus->hotplug_workqueue =
817 create_singlethread_workqueue("hotplug_workqueue");
818 if (!asus->hotplug_workqueue)
819 goto error_workqueue;
820
821 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
822
823 asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
824 if (!asus->hotplug_slot)
825 goto error_slot;
826
827 asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
828 GFP_KERNEL);
829 if (!asus->hotplug_slot->info)
830 goto error_info;
831
832 asus->hotplug_slot->private = asus;
833 asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
834 asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
835 asus_get_adapter_status(asus->hotplug_slot,
836 &asus->hotplug_slot->info->adapter_status);
837
838 ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
839 if (ret) {
840 pr_err("Unable to register hotplug slot - %d\n", ret);
841 goto error_register;
842 }
843
844 return 0;
845
846 error_register:
847 kfree(asus->hotplug_slot->info);
848 error_info:
849 kfree(asus->hotplug_slot);
850 asus->hotplug_slot = NULL;
851 error_slot:
852 destroy_workqueue(asus->hotplug_workqueue);
853 error_workqueue:
854 return ret;
855 }
856
857 /*
858 * Rfkill devices
859 */
860 static int asus_rfkill_set(void *data, bool blocked)
861 {
862 struct asus_rfkill *priv = data;
863 u32 ctrl_param = !blocked;
864 u32 dev_id = priv->dev_id;
865
866 /*
867 * If the user bit is set, BIOS can't set and record the wlan status,
868 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
869 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
870 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
871 * while setting the wlan status through WMI.
872 * This is also the behavior that windows app will do.
873 */
874 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
875 priv->asus->driver->wlan_ctrl_by_user)
876 dev_id = ASUS_WMI_DEVID_WLAN_LED;
877
878 return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
879 }
880
881 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
882 {
883 struct asus_rfkill *priv = data;
884 int result;
885
886 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
887
888 if (result < 0)
889 return;
890
891 rfkill_set_sw_state(priv->rfkill, !result);
892 }
893
894 static int asus_rfkill_wlan_set(void *data, bool blocked)
895 {
896 struct asus_rfkill *priv = data;
897 struct asus_wmi *asus = priv->asus;
898 int ret;
899
900 /*
901 * This handler is enabled only if hotplug is enabled.
902 * In this case, the asus_wmi_set_devstate() will
903 * trigger a wmi notification and we need to wait
904 * this call to finish before being able to call
905 * any wmi method
906 */
907 mutex_lock(&asus->wmi_lock);
908 ret = asus_rfkill_set(data, blocked);
909 mutex_unlock(&asus->wmi_lock);
910 return ret;
911 }
912
913 static const struct rfkill_ops asus_rfkill_wlan_ops = {
914 .set_block = asus_rfkill_wlan_set,
915 .query = asus_rfkill_query,
916 };
917
918 static const struct rfkill_ops asus_rfkill_ops = {
919 .set_block = asus_rfkill_set,
920 .query = asus_rfkill_query,
921 };
922
923 static int asus_new_rfkill(struct asus_wmi *asus,
924 struct asus_rfkill *arfkill,
925 const char *name, enum rfkill_type type, int dev_id)
926 {
927 int result = asus_wmi_get_devstate_simple(asus, dev_id);
928 struct rfkill **rfkill = &arfkill->rfkill;
929
930 if (result < 0)
931 return result;
932
933 arfkill->dev_id = dev_id;
934 arfkill->asus = asus;
935
936 if (dev_id == ASUS_WMI_DEVID_WLAN &&
937 asus->driver->quirks->hotplug_wireless)
938 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
939 &asus_rfkill_wlan_ops, arfkill);
940 else
941 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
942 &asus_rfkill_ops, arfkill);
943
944 if (!*rfkill)
945 return -EINVAL;
946
947 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
948 (asus->driver->quirks->wapf > 0))
949 rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
950
951 rfkill_init_sw_state(*rfkill, !result);
952 result = rfkill_register(*rfkill);
953 if (result) {
954 rfkill_destroy(*rfkill);
955 *rfkill = NULL;
956 return result;
957 }
958 return 0;
959 }
960
961 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
962 {
963 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
964 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
965 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
966 if (asus->wlan.rfkill) {
967 rfkill_unregister(asus->wlan.rfkill);
968 rfkill_destroy(asus->wlan.rfkill);
969 asus->wlan.rfkill = NULL;
970 }
971 /*
972 * Refresh pci hotplug in case the rfkill state was changed after
973 * asus_unregister_rfkill_notifier()
974 */
975 asus_rfkill_hotplug(asus);
976 if (asus->hotplug_slot)
977 pci_hp_deregister(asus->hotplug_slot);
978 if (asus->hotplug_workqueue)
979 destroy_workqueue(asus->hotplug_workqueue);
980
981 if (asus->bluetooth.rfkill) {
982 rfkill_unregister(asus->bluetooth.rfkill);
983 rfkill_destroy(asus->bluetooth.rfkill);
984 asus->bluetooth.rfkill = NULL;
985 }
986 if (asus->wimax.rfkill) {
987 rfkill_unregister(asus->wimax.rfkill);
988 rfkill_destroy(asus->wimax.rfkill);
989 asus->wimax.rfkill = NULL;
990 }
991 if (asus->wwan3g.rfkill) {
992 rfkill_unregister(asus->wwan3g.rfkill);
993 rfkill_destroy(asus->wwan3g.rfkill);
994 asus->wwan3g.rfkill = NULL;
995 }
996 if (asus->gps.rfkill) {
997 rfkill_unregister(asus->gps.rfkill);
998 rfkill_destroy(asus->gps.rfkill);
999 asus->gps.rfkill = NULL;
1000 }
1001 if (asus->uwb.rfkill) {
1002 rfkill_unregister(asus->uwb.rfkill);
1003 rfkill_destroy(asus->uwb.rfkill);
1004 asus->uwb.rfkill = NULL;
1005 }
1006 }
1007
1008 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1009 {
1010 int result = 0;
1011
1012 mutex_init(&asus->hotplug_lock);
1013 mutex_init(&asus->wmi_lock);
1014
1015 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1016 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1017
1018 if (result && result != -ENODEV)
1019 goto exit;
1020
1021 result = asus_new_rfkill(asus, &asus->bluetooth,
1022 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1023 ASUS_WMI_DEVID_BLUETOOTH);
1024
1025 if (result && result != -ENODEV)
1026 goto exit;
1027
1028 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1029 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1030
1031 if (result && result != -ENODEV)
1032 goto exit;
1033
1034 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1035 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1036
1037 if (result && result != -ENODEV)
1038 goto exit;
1039
1040 result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1041 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1042
1043 if (result && result != -ENODEV)
1044 goto exit;
1045
1046 result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1047 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1048
1049 if (result && result != -ENODEV)
1050 goto exit;
1051
1052 if (!asus->driver->quirks->hotplug_wireless)
1053 goto exit;
1054
1055 result = asus_setup_pci_hotplug(asus);
1056 /*
1057 * If we get -EBUSY then something else is handling the PCI hotplug -
1058 * don't fail in this case
1059 */
1060 if (result == -EBUSY)
1061 result = 0;
1062
1063 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1064 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1065 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1066 /*
1067 * Refresh pci hotplug in case the rfkill state was changed during
1068 * setup.
1069 */
1070 asus_rfkill_hotplug(asus);
1071
1072 exit:
1073 if (result && result != -ENODEV)
1074 asus_wmi_rfkill_exit(asus);
1075
1076 if (result == -ENODEV)
1077 result = 0;
1078
1079 return result;
1080 }
1081
1082 /*
1083 * Hwmon device
1084 */
1085 static int asus_hwmon_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1086 int *speed)
1087 {
1088 struct fan_args args = {
1089 .agfn.len = sizeof(args),
1090 .agfn.mfun = ASUS_FAN_MFUN,
1091 .agfn.sfun = ASUS_FAN_SFUN_READ,
1092 .fan = fan,
1093 .speed = 0,
1094 };
1095 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1096 int status;
1097
1098 if (fan != 1)
1099 return -EINVAL;
1100
1101 status = asus_wmi_evaluate_method_agfn(input);
1102
1103 if (status || args.agfn.err)
1104 return -ENXIO;
1105
1106 if (speed)
1107 *speed = args.speed;
1108
1109 return 0;
1110 }
1111
1112 static int asus_hwmon_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1113 int *speed)
1114 {
1115 struct fan_args args = {
1116 .agfn.len = sizeof(args),
1117 .agfn.mfun = ASUS_FAN_MFUN,
1118 .agfn.sfun = ASUS_FAN_SFUN_WRITE,
1119 .fan = fan,
1120 .speed = speed ? *speed : 0,
1121 };
1122 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1123 int status;
1124
1125 /* 1: for setting 1st fan's speed 0: setting auto mode */
1126 if (fan != 1 && fan != 0)
1127 return -EINVAL;
1128
1129 status = asus_wmi_evaluate_method_agfn(input);
1130
1131 if (status || args.agfn.err)
1132 return -ENXIO;
1133
1134 if (speed && fan == 1)
1135 asus->asus_hwmon_pwm = *speed;
1136
1137 return 0;
1138 }
1139
1140 /*
1141 * Check if we can read the speed of one fan. If true we assume we can also
1142 * control it.
1143 */
1144 static int asus_hwmon_get_fan_number(struct asus_wmi *asus, int *num_fans)
1145 {
1146 int status;
1147 int speed = 0;
1148
1149 *num_fans = 0;
1150
1151 status = asus_hwmon_agfn_fan_speed_read(asus, 1, &speed);
1152 if (!status)
1153 *num_fans = 1;
1154
1155 return 0;
1156 }
1157
1158 static int asus_hwmon_fan_set_auto(struct asus_wmi *asus)
1159 {
1160 int status;
1161
1162 status = asus_hwmon_agfn_fan_speed_write(asus, 0, NULL);
1163 if (status)
1164 return -ENXIO;
1165
1166 asus->asus_hwmon_fan_manual_mode = false;
1167
1168 return 0;
1169 }
1170
1171 static int asus_hwmon_fan_rpm_show(struct device *dev, int fan)
1172 {
1173 struct asus_wmi *asus = dev_get_drvdata(dev);
1174 int value;
1175 int ret;
1176
1177 /* no speed readable on manual mode */
1178 if (asus->asus_hwmon_fan_manual_mode)
1179 return -ENXIO;
1180
1181 ret = asus_hwmon_agfn_fan_speed_read(asus, fan+1, &value);
1182 if (ret) {
1183 pr_warn("reading fan speed failed: %d\n", ret);
1184 return -ENXIO;
1185 }
1186
1187 return value;
1188 }
1189
1190 static void asus_hwmon_pwm_show(struct asus_wmi *asus, int fan, int *value)
1191 {
1192 int err;
1193
1194 if (asus->asus_hwmon_pwm >= 0) {
1195 *value = asus->asus_hwmon_pwm;
1196 return;
1197 }
1198
1199 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, value);
1200 if (err < 0)
1201 return;
1202
1203 *value &= 0xFF;
1204
1205 if (*value == 1) /* Low Speed */
1206 *value = 85;
1207 else if (*value == 2)
1208 *value = 170;
1209 else if (*value == 3)
1210 *value = 255;
1211 else if (*value) {
1212 pr_err("Unknown fan speed %#x\n", *value);
1213 *value = -1;
1214 }
1215 }
1216
1217 static ssize_t pwm1_show(struct device *dev,
1218 struct device_attribute *attr,
1219 char *buf)
1220 {
1221 struct asus_wmi *asus = dev_get_drvdata(dev);
1222 int value;
1223
1224 asus_hwmon_pwm_show(asus, 0, &value);
1225
1226 return sprintf(buf, "%d\n", value);
1227 }
1228
1229 static ssize_t pwm1_store(struct device *dev,
1230 struct device_attribute *attr,
1231 const char *buf, size_t count) {
1232 struct asus_wmi *asus = dev_get_drvdata(dev);
1233 int value;
1234 int state;
1235 int ret;
1236
1237 ret = kstrtouint(buf, 10, &value);
1238
1239 if (ret)
1240 return ret;
1241
1242 value = clamp(value, 0, 255);
1243
1244 state = asus_hwmon_agfn_fan_speed_write(asus, 1, &value);
1245 if (state)
1246 pr_warn("Setting fan speed failed: %d\n", state);
1247 else
1248 asus->asus_hwmon_fan_manual_mode = true;
1249
1250 return count;
1251 }
1252
1253 static ssize_t fan1_input_show(struct device *dev,
1254 struct device_attribute *attr,
1255 char *buf)
1256 {
1257 int value = asus_hwmon_fan_rpm_show(dev, 0);
1258
1259 return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1260
1261 }
1262
1263 static ssize_t pwm1_enable_show(struct device *dev,
1264 struct device_attribute *attr,
1265 char *buf)
1266 {
1267 struct asus_wmi *asus = dev_get_drvdata(dev);
1268
1269 if (asus->asus_hwmon_fan_manual_mode)
1270 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_MANUAL);
1271
1272 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_AUTO);
1273 }
1274
1275 static ssize_t pwm1_enable_store(struct device *dev,
1276 struct device_attribute *attr,
1277 const char *buf, size_t count)
1278 {
1279 struct asus_wmi *asus = dev_get_drvdata(dev);
1280 int status = 0;
1281 int state;
1282 int ret;
1283
1284 ret = kstrtouint(buf, 10, &state);
1285
1286 if (ret)
1287 return ret;
1288
1289 if (state == ASUS_FAN_CTRL_MANUAL)
1290 asus->asus_hwmon_fan_manual_mode = true;
1291 else
1292 status = asus_hwmon_fan_set_auto(asus);
1293
1294 if (status)
1295 return status;
1296
1297 return count;
1298 }
1299
1300 static ssize_t fan1_label_show(struct device *dev,
1301 struct device_attribute *attr,
1302 char *buf)
1303 {
1304 return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1305 }
1306
1307 static ssize_t asus_hwmon_temp1(struct device *dev,
1308 struct device_attribute *attr,
1309 char *buf)
1310 {
1311 struct asus_wmi *asus = dev_get_drvdata(dev);
1312 u32 value;
1313 int err;
1314
1315 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1316
1317 if (err < 0)
1318 return err;
1319
1320 value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
1321
1322 return sprintf(buf, "%d\n", value);
1323 }
1324
1325 /* Fan1 */
1326 static DEVICE_ATTR_RW(pwm1);
1327 static DEVICE_ATTR_RW(pwm1_enable);
1328 static DEVICE_ATTR_RO(fan1_input);
1329 static DEVICE_ATTR_RO(fan1_label);
1330
1331 /* Temperature */
1332 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1333
1334 static struct attribute *hwmon_attributes[] = {
1335 &dev_attr_pwm1.attr,
1336 &dev_attr_pwm1_enable.attr,
1337 &dev_attr_fan1_input.attr,
1338 &dev_attr_fan1_label.attr,
1339
1340 &dev_attr_temp1_input.attr,
1341 NULL
1342 };
1343
1344 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
1345 struct attribute *attr, int idx)
1346 {
1347 struct device *dev = container_of(kobj, struct device, kobj);
1348 struct platform_device *pdev = to_platform_device(dev->parent);
1349 struct asus_wmi *asus = platform_get_drvdata(pdev);
1350 int dev_id = -1;
1351 int fan_attr = -1;
1352 u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1353 bool ok = true;
1354
1355 if (attr == &dev_attr_pwm1.attr)
1356 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
1357 else if (attr == &dev_attr_temp1_input.attr)
1358 dev_id = ASUS_WMI_DEVID_THERMAL_CTRL;
1359
1360
1361 if (attr == &dev_attr_fan1_input.attr
1362 || attr == &dev_attr_fan1_label.attr
1363 || attr == &dev_attr_pwm1.attr
1364 || attr == &dev_attr_pwm1_enable.attr) {
1365 fan_attr = 1;
1366 }
1367
1368 if (dev_id != -1) {
1369 int err = asus_wmi_get_devstate(asus, dev_id, &value);
1370
1371 if (err < 0 && fan_attr == -1)
1372 return 0; /* can't return negative here */
1373 }
1374
1375 if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
1376 /*
1377 * We need to find a better way, probably using sfun,
1378 * bits or spec ...
1379 * Currently we disable it if:
1380 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1381 * - reverved bits are non-zero
1382 * - sfun and presence bit are not set
1383 */
1384 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1385 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
1386 ok = false;
1387 else
1388 ok = fan_attr <= asus->asus_hwmon_num_fans;
1389 } else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) {
1390 /* If value is zero, something is clearly wrong */
1391 if (!value)
1392 ok = false;
1393 } else if (fan_attr <= asus->asus_hwmon_num_fans && fan_attr != -1) {
1394 ok = true;
1395 } else {
1396 ok = false;
1397 }
1398
1399 return ok ? attr->mode : 0;
1400 }
1401
1402 static struct attribute_group hwmon_attribute_group = {
1403 .is_visible = asus_hwmon_sysfs_is_visible,
1404 .attrs = hwmon_attributes
1405 };
1406 __ATTRIBUTE_GROUPS(hwmon_attribute);
1407
1408 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1409 {
1410 struct device *hwmon;
1411
1412 hwmon = hwmon_device_register_with_groups(&asus->platform_device->dev,
1413 "asus", asus,
1414 hwmon_attribute_groups);
1415 if (IS_ERR(hwmon)) {
1416 pr_err("Could not register asus hwmon device\n");
1417 return PTR_ERR(hwmon);
1418 }
1419 return 0;
1420 }
1421
1422 /*
1423 * Backlight
1424 */
1425 static int read_backlight_power(struct asus_wmi *asus)
1426 {
1427 int ret;
1428 if (asus->driver->quirks->store_backlight_power)
1429 ret = !asus->driver->panel_power;
1430 else
1431 ret = asus_wmi_get_devstate_simple(asus,
1432 ASUS_WMI_DEVID_BACKLIGHT);
1433
1434 if (ret < 0)
1435 return ret;
1436
1437 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1438 }
1439
1440 static int read_brightness_max(struct asus_wmi *asus)
1441 {
1442 u32 retval;
1443 int err;
1444
1445 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1446
1447 if (err < 0)
1448 return err;
1449
1450 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1451 retval >>= 8;
1452
1453 if (!retval)
1454 return -ENODEV;
1455
1456 return retval;
1457 }
1458
1459 static int read_brightness(struct backlight_device *bd)
1460 {
1461 struct asus_wmi *asus = bl_get_data(bd);
1462 u32 retval;
1463 int err;
1464
1465 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1466
1467 if (err < 0)
1468 return err;
1469
1470 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1471 }
1472
1473 static u32 get_scalar_command(struct backlight_device *bd)
1474 {
1475 struct asus_wmi *asus = bl_get_data(bd);
1476 u32 ctrl_param = 0;
1477
1478 if ((asus->driver->brightness < bd->props.brightness) ||
1479 bd->props.brightness == bd->props.max_brightness)
1480 ctrl_param = 0x00008001;
1481 else if ((asus->driver->brightness > bd->props.brightness) ||
1482 bd->props.brightness == 0)
1483 ctrl_param = 0x00008000;
1484
1485 asus->driver->brightness = bd->props.brightness;
1486
1487 return ctrl_param;
1488 }
1489
1490 static int update_bl_status(struct backlight_device *bd)
1491 {
1492 struct asus_wmi *asus = bl_get_data(bd);
1493 u32 ctrl_param;
1494 int power, err = 0;
1495
1496 power = read_backlight_power(asus);
1497 if (power != -ENODEV && bd->props.power != power) {
1498 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1499 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1500 ctrl_param, NULL);
1501 if (asus->driver->quirks->store_backlight_power)
1502 asus->driver->panel_power = bd->props.power;
1503
1504 /* When using scalar brightness, updating the brightness
1505 * will mess with the backlight power */
1506 if (asus->driver->quirks->scalar_panel_brightness)
1507 return err;
1508 }
1509
1510 if (asus->driver->quirks->scalar_panel_brightness)
1511 ctrl_param = get_scalar_command(bd);
1512 else
1513 ctrl_param = bd->props.brightness;
1514
1515 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1516 ctrl_param, NULL);
1517
1518 return err;
1519 }
1520
1521 static const struct backlight_ops asus_wmi_bl_ops = {
1522 .get_brightness = read_brightness,
1523 .update_status = update_bl_status,
1524 };
1525
1526 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1527 {
1528 struct backlight_device *bd = asus->backlight_device;
1529 int old = bd->props.brightness;
1530 int new = old;
1531
1532 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1533 new = code - NOTIFY_BRNUP_MIN + 1;
1534 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1535 new = code - NOTIFY_BRNDOWN_MIN;
1536
1537 bd->props.brightness = new;
1538 backlight_update_status(bd);
1539 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1540
1541 return old;
1542 }
1543
1544 static int asus_wmi_backlight_init(struct asus_wmi *asus)
1545 {
1546 struct backlight_device *bd;
1547 struct backlight_properties props;
1548 int max;
1549 int power;
1550
1551 max = read_brightness_max(asus);
1552 if (max < 0)
1553 return max;
1554
1555 power = read_backlight_power(asus);
1556
1557 if (power == -ENODEV)
1558 power = FB_BLANK_UNBLANK;
1559 else if (power < 0)
1560 return power;
1561
1562 memset(&props, 0, sizeof(struct backlight_properties));
1563 props.type = BACKLIGHT_PLATFORM;
1564 props.max_brightness = max;
1565 bd = backlight_device_register(asus->driver->name,
1566 &asus->platform_device->dev, asus,
1567 &asus_wmi_bl_ops, &props);
1568 if (IS_ERR(bd)) {
1569 pr_err("Could not register backlight device\n");
1570 return PTR_ERR(bd);
1571 }
1572
1573 asus->backlight_device = bd;
1574
1575 if (asus->driver->quirks->store_backlight_power)
1576 asus->driver->panel_power = power;
1577
1578 bd->props.brightness = read_brightness(bd);
1579 bd->props.power = power;
1580 backlight_update_status(bd);
1581
1582 asus->driver->brightness = bd->props.brightness;
1583
1584 return 0;
1585 }
1586
1587 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
1588 {
1589 backlight_device_unregister(asus->backlight_device);
1590
1591 asus->backlight_device = NULL;
1592 }
1593
1594 static int is_display_toggle(int code)
1595 {
1596 /* display toggle keys */
1597 if ((code >= 0x61 && code <= 0x67) ||
1598 (code >= 0x8c && code <= 0x93) ||
1599 (code >= 0xa0 && code <= 0xa7) ||
1600 (code >= 0xd0 && code <= 0xd5))
1601 return 1;
1602
1603 return 0;
1604 }
1605
1606 static void asus_wmi_notify(u32 value, void *context)
1607 {
1608 struct asus_wmi *asus = context;
1609 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1610 union acpi_object *obj;
1611 acpi_status status;
1612 int code;
1613 int orig_code;
1614 unsigned int key_value = 1;
1615 bool autorelease = 1;
1616
1617 status = wmi_get_event_data(value, &response);
1618 if (status != AE_OK) {
1619 pr_err("bad event status 0x%x\n", status);
1620 return;
1621 }
1622
1623 obj = (union acpi_object *)response.pointer;
1624
1625 if (!obj || obj->type != ACPI_TYPE_INTEGER)
1626 goto exit;
1627
1628 code = obj->integer.value;
1629 orig_code = code;
1630
1631 if (asus->driver->key_filter) {
1632 asus->driver->key_filter(asus->driver, &code, &key_value,
1633 &autorelease);
1634 if (code == ASUS_WMI_KEY_IGNORE)
1635 goto exit;
1636 }
1637
1638 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1639 code = ASUS_WMI_BRN_UP;
1640 else if (code >= NOTIFY_BRNDOWN_MIN &&
1641 code <= NOTIFY_BRNDOWN_MAX)
1642 code = ASUS_WMI_BRN_DOWN;
1643
1644 if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
1645 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1646 asus_wmi_backlight_notify(asus, orig_code);
1647 goto exit;
1648 }
1649 }
1650
1651 if (is_display_toggle(code) &&
1652 asus->driver->quirks->no_display_toggle)
1653 goto exit;
1654
1655 if (!sparse_keymap_report_event(asus->inputdev, code,
1656 key_value, autorelease))
1657 pr_info("Unknown key %x pressed\n", code);
1658
1659 exit:
1660 kfree(obj);
1661 }
1662
1663 /*
1664 * Sys helpers
1665 */
1666 static int parse_arg(const char *buf, unsigned long count, int *val)
1667 {
1668 if (!count)
1669 return 0;
1670 if (sscanf(buf, "%i", val) != 1)
1671 return -EINVAL;
1672 return count;
1673 }
1674
1675 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1676 const char *buf, size_t count)
1677 {
1678 u32 retval;
1679 int rv, err, value;
1680
1681 value = asus_wmi_get_devstate_simple(asus, devid);
1682 if (value < 0)
1683 return value;
1684
1685 rv = parse_arg(buf, count, &value);
1686 err = asus_wmi_set_devstate(devid, value, &retval);
1687
1688 if (err < 0)
1689 return err;
1690
1691 return rv;
1692 }
1693
1694 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
1695 {
1696 int value = asus_wmi_get_devstate_simple(asus, devid);
1697
1698 if (value < 0)
1699 return value;
1700
1701 return sprintf(buf, "%d\n", value);
1702 }
1703
1704 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
1705 static ssize_t show_##_name(struct device *dev, \
1706 struct device_attribute *attr, \
1707 char *buf) \
1708 { \
1709 struct asus_wmi *asus = dev_get_drvdata(dev); \
1710 \
1711 return show_sys_wmi(asus, _cm, buf); \
1712 } \
1713 static ssize_t store_##_name(struct device *dev, \
1714 struct device_attribute *attr, \
1715 const char *buf, size_t count) \
1716 { \
1717 struct asus_wmi *asus = dev_get_drvdata(dev); \
1718 \
1719 return store_sys_wmi(asus, _cm, buf, count); \
1720 } \
1721 static struct device_attribute dev_attr_##_name = { \
1722 .attr = { \
1723 .name = __stringify(_name), \
1724 .mode = _mode }, \
1725 .show = show_##_name, \
1726 .store = store_##_name, \
1727 }
1728
1729 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1730 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1731 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
1732 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
1733
1734 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1735 const char *buf, size_t count)
1736 {
1737 int value, rv;
1738
1739 if (!count || sscanf(buf, "%i", &value) != 1)
1740 return -EINVAL;
1741 if (value < 0 || value > 2)
1742 return -EINVAL;
1743
1744 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1745 if (rv < 0)
1746 return rv;
1747
1748 return count;
1749 }
1750
1751 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1752
1753 static struct attribute *platform_attributes[] = {
1754 &dev_attr_cpufv.attr,
1755 &dev_attr_camera.attr,
1756 &dev_attr_cardr.attr,
1757 &dev_attr_touchpad.attr,
1758 &dev_attr_lid_resume.attr,
1759 NULL
1760 };
1761
1762 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
1763 struct attribute *attr, int idx)
1764 {
1765 struct device *dev = container_of(kobj, struct device, kobj);
1766 struct platform_device *pdev = to_platform_device(dev);
1767 struct asus_wmi *asus = platform_get_drvdata(pdev);
1768 bool ok = true;
1769 int devid = -1;
1770
1771 if (attr == &dev_attr_camera.attr)
1772 devid = ASUS_WMI_DEVID_CAMERA;
1773 else if (attr == &dev_attr_cardr.attr)
1774 devid = ASUS_WMI_DEVID_CARDREADER;
1775 else if (attr == &dev_attr_touchpad.attr)
1776 devid = ASUS_WMI_DEVID_TOUCHPAD;
1777 else if (attr == &dev_attr_lid_resume.attr)
1778 devid = ASUS_WMI_DEVID_LID_RESUME;
1779
1780 if (devid != -1)
1781 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1782
1783 return ok ? attr->mode : 0;
1784 }
1785
1786 static struct attribute_group platform_attribute_group = {
1787 .is_visible = asus_sysfs_is_visible,
1788 .attrs = platform_attributes
1789 };
1790
1791 static void asus_wmi_sysfs_exit(struct platform_device *device)
1792 {
1793 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1794 }
1795
1796 static int asus_wmi_sysfs_init(struct platform_device *device)
1797 {
1798 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1799 }
1800
1801 /*
1802 * Platform device
1803 */
1804 static int asus_wmi_platform_init(struct asus_wmi *asus)
1805 {
1806 int rv;
1807
1808 /* INIT enable hotkeys on some models */
1809 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1810 pr_info("Initialization: %#x\n", rv);
1811
1812 /* We don't know yet what to do with this version... */
1813 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
1814 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
1815 asus->spec = rv;
1816 }
1817
1818 /*
1819 * The SFUN method probably allows the original driver to get the list
1820 * of features supported by a given model. For now, 0x0100 or 0x0800
1821 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1822 * The significance of others is yet to be found.
1823 */
1824 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1825 pr_info("SFUN value: %#x\n", rv);
1826 asus->sfun = rv;
1827 }
1828
1829 /*
1830 * Eee PC and Notebooks seems to have different method_id for DSTS,
1831 * but it may also be related to the BIOS's SPEC.
1832 * Note, on most Eeepc, there is no way to check if a method exist
1833 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1834 * but once again, SPEC may probably be used for that kind of things.
1835 */
1836 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1837 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1838 else
1839 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1840
1841 /* CWAP allow to define the behavior of the Fn+F2 key,
1842 * this method doesn't seems to be present on Eee PCs */
1843 if (asus->driver->quirks->wapf >= 0)
1844 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
1845 asus->driver->quirks->wapf, NULL);
1846
1847 return asus_wmi_sysfs_init(asus->platform_device);
1848 }
1849
1850 static void asus_wmi_platform_exit(struct asus_wmi *asus)
1851 {
1852 asus_wmi_sysfs_exit(asus->platform_device);
1853 }
1854
1855 /*
1856 * debugfs
1857 */
1858 struct asus_wmi_debugfs_node {
1859 struct asus_wmi *asus;
1860 char *name;
1861 int (*show) (struct seq_file *m, void *data);
1862 };
1863
1864 static int show_dsts(struct seq_file *m, void *data)
1865 {
1866 struct asus_wmi *asus = m->private;
1867 int err;
1868 u32 retval = -1;
1869
1870 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1871
1872 if (err < 0)
1873 return err;
1874
1875 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
1876
1877 return 0;
1878 }
1879
1880 static int show_devs(struct seq_file *m, void *data)
1881 {
1882 struct asus_wmi *asus = m->private;
1883 int err;
1884 u32 retval = -1;
1885
1886 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1887 &retval);
1888
1889 if (err < 0)
1890 return err;
1891
1892 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
1893 asus->debug.ctrl_param, retval);
1894
1895 return 0;
1896 }
1897
1898 static int show_call(struct seq_file *m, void *data)
1899 {
1900 struct asus_wmi *asus = m->private;
1901 struct bios_args args = {
1902 .arg0 = asus->debug.dev_id,
1903 .arg1 = asus->debug.ctrl_param,
1904 };
1905 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1906 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1907 union acpi_object *obj;
1908 acpi_status status;
1909
1910 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1911 1, asus->debug.method_id,
1912 &input, &output);
1913
1914 if (ACPI_FAILURE(status))
1915 return -EIO;
1916
1917 obj = (union acpi_object *)output.pointer;
1918 if (obj && obj->type == ACPI_TYPE_INTEGER)
1919 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1920 asus->debug.dev_id, asus->debug.ctrl_param,
1921 (u32) obj->integer.value);
1922 else
1923 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1924 asus->debug.dev_id, asus->debug.ctrl_param,
1925 obj ? obj->type : -1);
1926
1927 kfree(obj);
1928
1929 return 0;
1930 }
1931
1932 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1933 {NULL, "devs", show_devs},
1934 {NULL, "dsts", show_dsts},
1935 {NULL, "call", show_call},
1936 };
1937
1938 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1939 {
1940 struct asus_wmi_debugfs_node *node = inode->i_private;
1941
1942 return single_open(file, node->show, node->asus);
1943 }
1944
1945 static const struct file_operations asus_wmi_debugfs_io_ops = {
1946 .owner = THIS_MODULE,
1947 .open = asus_wmi_debugfs_open,
1948 .read = seq_read,
1949 .llseek = seq_lseek,
1950 .release = single_release,
1951 };
1952
1953 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1954 {
1955 debugfs_remove_recursive(asus->debug.root);
1956 }
1957
1958 static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1959 {
1960 struct dentry *dent;
1961 int i;
1962
1963 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1964 if (!asus->debug.root) {
1965 pr_err("failed to create debugfs directory\n");
1966 goto error_debugfs;
1967 }
1968
1969 dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1970 asus->debug.root, &asus->debug.method_id);
1971 if (!dent)
1972 goto error_debugfs;
1973
1974 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1975 asus->debug.root, &asus->debug.dev_id);
1976 if (!dent)
1977 goto error_debugfs;
1978
1979 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1980 asus->debug.root, &asus->debug.ctrl_param);
1981 if (!dent)
1982 goto error_debugfs;
1983
1984 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1985 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1986
1987 node->asus = asus;
1988 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1989 asus->debug.root, node,
1990 &asus_wmi_debugfs_io_ops);
1991 if (!dent) {
1992 pr_err("failed to create debug file: %s\n", node->name);
1993 goto error_debugfs;
1994 }
1995 }
1996
1997 return 0;
1998
1999 error_debugfs:
2000 asus_wmi_debugfs_exit(asus);
2001 return -ENOMEM;
2002 }
2003
2004 static int asus_wmi_fan_init(struct asus_wmi *asus)
2005 {
2006 int status;
2007
2008 asus->asus_hwmon_pwm = -1;
2009 asus->asus_hwmon_num_fans = -1;
2010 asus->asus_hwmon_fan_manual_mode = false;
2011
2012 status = asus_hwmon_get_fan_number(asus, &asus->asus_hwmon_num_fans);
2013 if (status) {
2014 asus->asus_hwmon_num_fans = 0;
2015 pr_warn("Could not determine number of fans: %d\n", status);
2016 return -ENXIO;
2017 }
2018
2019 pr_info("Number of fans: %d\n", asus->asus_hwmon_num_fans);
2020 return 0;
2021 }
2022
2023 /*
2024 * WMI Driver
2025 */
2026 static int asus_wmi_add(struct platform_device *pdev)
2027 {
2028 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2029 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2030 struct asus_wmi *asus;
2031 const char *chassis_type;
2032 acpi_status status;
2033 int err;
2034 u32 result;
2035
2036 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
2037 if (!asus)
2038 return -ENOMEM;
2039
2040 asus->driver = wdrv;
2041 asus->platform_device = pdev;
2042 wdrv->platform_device = pdev;
2043 platform_set_drvdata(asus->platform_device, asus);
2044
2045 if (wdrv->detect_quirks)
2046 wdrv->detect_quirks(asus->driver);
2047
2048 err = asus_wmi_platform_init(asus);
2049 if (err)
2050 goto fail_platform;
2051
2052 err = asus_wmi_input_init(asus);
2053 if (err)
2054 goto fail_input;
2055
2056 err = asus_wmi_fan_init(asus); /* probably no problems on error */
2057 asus_hwmon_fan_set_auto(asus);
2058
2059 err = asus_wmi_hwmon_init(asus);
2060 if (err)
2061 goto fail_hwmon;
2062
2063 err = asus_wmi_led_init(asus);
2064 if (err)
2065 goto fail_leds;
2066
2067 err = asus_wmi_rfkill_init(asus);
2068 if (err)
2069 goto fail_rfkill;
2070
2071 /* Some Asus desktop boards export an acpi-video backlight interface,
2072 stop this from showing up */
2073 chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2074 if (chassis_type && !strcmp(chassis_type, "3"))
2075 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2076
2077 if (asus->driver->quirks->wmi_backlight_power)
2078 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2079
2080 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2081 err = asus_wmi_backlight_init(asus);
2082 if (err && err != -ENODEV)
2083 goto fail_backlight;
2084 }
2085
2086 status = wmi_install_notify_handler(asus->driver->event_guid,
2087 asus_wmi_notify, asus);
2088 if (ACPI_FAILURE(status)) {
2089 pr_err("Unable to register notify handler - %d\n", status);
2090 err = -ENODEV;
2091 goto fail_wmi_handler;
2092 }
2093
2094 err = asus_wmi_debugfs_init(asus);
2095 if (err)
2096 goto fail_debugfs;
2097
2098 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
2099 if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
2100 asus->driver->wlan_ctrl_by_user = 1;
2101
2102 return 0;
2103
2104 fail_debugfs:
2105 wmi_remove_notify_handler(asus->driver->event_guid);
2106 fail_wmi_handler:
2107 asus_wmi_backlight_exit(asus);
2108 fail_backlight:
2109 asus_wmi_rfkill_exit(asus);
2110 fail_rfkill:
2111 asus_wmi_led_exit(asus);
2112 fail_leds:
2113 fail_hwmon:
2114 asus_wmi_input_exit(asus);
2115 fail_input:
2116 asus_wmi_platform_exit(asus);
2117 fail_platform:
2118 kfree(asus);
2119 return err;
2120 }
2121
2122 static int asus_wmi_remove(struct platform_device *device)
2123 {
2124 struct asus_wmi *asus;
2125
2126 asus = platform_get_drvdata(device);
2127 wmi_remove_notify_handler(asus->driver->event_guid);
2128 asus_wmi_backlight_exit(asus);
2129 asus_wmi_input_exit(asus);
2130 asus_wmi_led_exit(asus);
2131 asus_wmi_rfkill_exit(asus);
2132 asus_wmi_debugfs_exit(asus);
2133 asus_wmi_platform_exit(asus);
2134 asus_hwmon_fan_set_auto(asus);
2135
2136 kfree(asus);
2137 return 0;
2138 }
2139
2140 /*
2141 * Platform driver - hibernate/resume callbacks
2142 */
2143 static int asus_hotk_thaw(struct device *device)
2144 {
2145 struct asus_wmi *asus = dev_get_drvdata(device);
2146
2147 if (asus->wlan.rfkill) {
2148 bool wlan;
2149
2150 /*
2151 * Work around bios bug - acpi _PTS turns off the wireless led
2152 * during suspend. Normally it restores it on resume, but
2153 * we should kick it ourselves in case hibernation is aborted.
2154 */
2155 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
2156 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
2157 }
2158
2159 return 0;
2160 }
2161
2162 static int asus_hotk_resume(struct device *device)
2163 {
2164 struct asus_wmi *asus = dev_get_drvdata(device);
2165
2166 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2167 queue_work(asus->led_workqueue, &asus->kbd_led_work);
2168
2169 return 0;
2170 }
2171
2172 static int asus_hotk_restore(struct device *device)
2173 {
2174 struct asus_wmi *asus = dev_get_drvdata(device);
2175 int bl;
2176
2177 /* Refresh both wlan rfkill state and pci hotplug */
2178 if (asus->wlan.rfkill)
2179 asus_rfkill_hotplug(asus);
2180
2181 if (asus->bluetooth.rfkill) {
2182 bl = !asus_wmi_get_devstate_simple(asus,
2183 ASUS_WMI_DEVID_BLUETOOTH);
2184 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
2185 }
2186 if (asus->wimax.rfkill) {
2187 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
2188 rfkill_set_sw_state(asus->wimax.rfkill, bl);
2189 }
2190 if (asus->wwan3g.rfkill) {
2191 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
2192 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
2193 }
2194 if (asus->gps.rfkill) {
2195 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
2196 rfkill_set_sw_state(asus->gps.rfkill, bl);
2197 }
2198 if (asus->uwb.rfkill) {
2199 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
2200 rfkill_set_sw_state(asus->uwb.rfkill, bl);
2201 }
2202 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2203 queue_work(asus->led_workqueue, &asus->kbd_led_work);
2204
2205 return 0;
2206 }
2207
2208 static const struct dev_pm_ops asus_pm_ops = {
2209 .thaw = asus_hotk_thaw,
2210 .restore = asus_hotk_restore,
2211 .resume = asus_hotk_resume,
2212 };
2213
2214 static int asus_wmi_probe(struct platform_device *pdev)
2215 {
2216 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2217 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2218 int ret;
2219
2220 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2221 pr_warn("Management GUID not found\n");
2222 return -ENODEV;
2223 }
2224
2225 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
2226 pr_warn("Event GUID not found\n");
2227 return -ENODEV;
2228 }
2229
2230 if (wdrv->probe) {
2231 ret = wdrv->probe(pdev);
2232 if (ret)
2233 return ret;
2234 }
2235
2236 return asus_wmi_add(pdev);
2237 }
2238
2239 static bool used;
2240
2241 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
2242 {
2243 struct platform_driver *platform_driver;
2244 struct platform_device *platform_device;
2245
2246 if (used)
2247 return -EBUSY;
2248
2249 platform_driver = &driver->platform_driver;
2250 platform_driver->remove = asus_wmi_remove;
2251 platform_driver->driver.owner = driver->owner;
2252 platform_driver->driver.name = driver->name;
2253 platform_driver->driver.pm = &asus_pm_ops;
2254
2255 platform_device = platform_create_bundle(platform_driver,
2256 asus_wmi_probe,
2257 NULL, 0, NULL, 0);
2258 if (IS_ERR(platform_device))
2259 return PTR_ERR(platform_device);
2260
2261 used = true;
2262 return 0;
2263 }
2264 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
2265
2266 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
2267 {
2268 platform_device_unregister(driver->platform_device);
2269 platform_driver_unregister(&driver->platform_driver);
2270 used = false;
2271 }
2272 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
2273
2274 static int __init asus_wmi_init(void)
2275 {
2276 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2277 pr_info("Asus Management GUID not found\n");
2278 return -ENODEV;
2279 }
2280
2281 pr_info("ASUS WMI generic driver loaded\n");
2282 return 0;
2283 }
2284
2285 static void __exit asus_wmi_exit(void)
2286 {
2287 pr_info("ASUS WMI generic driver unloaded\n");
2288 }
2289
2290 module_init(asus_wmi_init);
2291 module_exit(asus_wmi_exit);
Linux kernel - Deliverables
This page took 0.079454 seconds and 5 git commands to generate.