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