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