1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Asus PC WMI hotkey driver
4 *
5 * Copyright(C) 2010 Intel Corporation.
6 * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
7 *
8 * Portions based on wistron_btns.c:
9 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
10 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
11 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
12 */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/acpi.h>
17 #include <linux/backlight.h>
18 #include <linux/debugfs.h>
19 #include <linux/dmi.h>
20 #include <linux/fb.h>
21 #include <linux/hwmon.h>
22 #include <linux/hwmon-sysfs.h>
23 #include <linux/init.h>
24 #include <linux/input.h>
25 #include <linux/input/sparse-keymap.h>
26 #include <linux/kernel.h>
27 #include <linux/leds.h>
28 #include <linux/module.h>
29 #include <linux/pci.h>
30 #include <linux/pci_hotplug.h>
31 #include <linux/platform_data/x86/asus-wmi.h>
32 #include <linux/platform_device.h>
33 #include <linux/platform_profile.h>
34 #include <linux/power_supply.h>
35 #include <linux/rfkill.h>
36 #include <linux/seq_file.h>
37 #include <linux/slab.h>
38 #include <linux/types.h>
39 #include <linux/units.h>
40
41 #include <acpi/battery.h>
42 #include <acpi/video.h>
43
44 #include "asus-wmi.h"
45
46 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>");
47 MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
48 MODULE_DESCRIPTION("Asus Generic WMI Driver");
49 MODULE_LICENSE("GPL");
50
51 static bool fnlock_default = true;
52 module_param(fnlock_default, bool, 0444);
53
54 #define to_asus_wmi_driver(pdrv) \
55 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
56
57 #define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
58
59 #define NOTIFY_BRNUP_MIN 0x11
60 #define NOTIFY_BRNUP_MAX 0x1f
61 #define NOTIFY_BRNDOWN_MIN 0x20
62 #define NOTIFY_BRNDOWN_MAX 0x2e
63 #define NOTIFY_FNLOCK_TOGGLE 0x4e
64 #define NOTIFY_KBD_DOCK_CHANGE 0x75
65 #define NOTIFY_KBD_BRTUP 0xc4
66 #define NOTIFY_KBD_BRTDWN 0xc5
67 #define NOTIFY_KBD_BRTTOGGLE 0xc7
68 #define NOTIFY_KBD_FBM 0x99
69 #define NOTIFY_KBD_TTP 0xae
70 #define NOTIFY_LID_FLIP 0xfa
71 #define NOTIFY_LID_FLIP_ROG 0xbd
72
73 #define ASUS_WMI_FNLOCK_BIOS_DISABLED BIT(0)
74
75 #define ASUS_MID_FAN_DESC "mid_fan"
76 #define ASUS_GPU_FAN_DESC "gpu_fan"
77 #define ASUS_FAN_DESC "cpu_fan"
78 #define ASUS_FAN_MFUN 0x13
79 #define ASUS_FAN_SFUN_READ 0x06
80 #define ASUS_FAN_SFUN_WRITE 0x07
81
82 /* Based on standard hwmon pwmX_enable values */
83 #define ASUS_FAN_CTRL_FULLSPEED 0
84 #define ASUS_FAN_CTRL_MANUAL 1
85 #define ASUS_FAN_CTRL_AUTO 2
86
87 #define ASUS_FAN_BOOST_MODE_NORMAL 0
88 #define ASUS_FAN_BOOST_MODE_OVERBOOST 1
89 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK 0x01
90 #define ASUS_FAN_BOOST_MODE_SILENT 2
91 #define ASUS_FAN_BOOST_MODE_SILENT_MASK 0x02
92 #define ASUS_FAN_BOOST_MODES_MASK 0x03
93
94 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT 0
95 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST 1
96 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT 2
97
98 #define USB_INTEL_XUSB2PR 0xD0
99 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31
100
101 #define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
102 #define ASUS_ACPI_UID_ATK "ATK"
103
104 #define WMI_EVENT_QUEUE_SIZE 0x10
105 #define WMI_EVENT_QUEUE_END 0x1
106 #define WMI_EVENT_MASK 0xFFFF
107 /* The WMI hotkey event value is always the same. */
108 #define WMI_EVENT_VALUE_ATK 0xFF
109
110 #define WMI_EVENT_MASK 0xFFFF
111
112 #define FAN_CURVE_POINTS 8
113 #define FAN_CURVE_BUF_LEN 32
114 #define FAN_CURVE_DEV_CPU 0x00
115 #define FAN_CURVE_DEV_GPU 0x01
116 #define FAN_CURVE_DEV_MID 0x02
117 /* Mask to determine if setting temperature or percentage */
118 #define FAN_CURVE_PWM_MASK 0x04
119
120 /* Limits for tunables available on ASUS ROG laptops */
121 #define PPT_TOTAL_MIN 5
122 #define PPT_TOTAL_MAX 250
123 #define PPT_CPU_MIN 5
124 #define PPT_CPU_MAX 130
125 #define NVIDIA_BOOST_MIN 5
126 #define NVIDIA_BOOST_MAX 25
127 #define NVIDIA_TEMP_MIN 75
128 #define NVIDIA_TEMP_MAX 87
129
130 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
131
132 static int throttle_thermal_policy_write(struct asus_wmi *);
133
ashs_present(void)134 static bool ashs_present(void)
135 {
136 int i = 0;
137 while (ashs_ids[i]) {
138 if (acpi_dev_found(ashs_ids[i++]))
139 return true;
140 }
141 return false;
142 }
143
144 struct bios_args {
145 u32 arg0;
146 u32 arg1;
147 u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
148 u32 arg3;
149 u32 arg4; /* Some ROG laptops require a full 5 input args */
150 u32 arg5;
151 } __packed;
152
153 /*
154 * Struct that's used for all methods called via AGFN. Naming is
155 * identically to the AML code.
156 */
157 struct agfn_args {
158 u16 mfun; /* probably "Multi-function" to be called */
159 u16 sfun; /* probably "Sub-function" to be called */
160 u16 len; /* size of the hole struct, including subfunction fields */
161 u8 stas; /* not used by now */
162 u8 err; /* zero on success */
163 } __packed;
164
165 /* struct used for calling fan read and write methods */
166 struct agfn_fan_args {
167 struct agfn_args agfn; /* common fields */
168 u8 fan; /* fan number: 0: set auto mode 1: 1st fan */
169 u32 speed; /* read: RPM/100 - write: 0-255 */
170 } __packed;
171
172 /*
173 * <platform>/ - debugfs root directory
174 * dev_id - current dev_id
175 * ctrl_param - current ctrl_param
176 * method_id - current method_id
177 * devs - call DEVS(dev_id, ctrl_param) and print result
178 * dsts - call DSTS(dev_id) and print result
179 * call - call method_id(dev_id, ctrl_param) and print result
180 */
181 struct asus_wmi_debug {
182 struct dentry *root;
183 u32 method_id;
184 u32 dev_id;
185 u32 ctrl_param;
186 };
187
188 struct asus_rfkill {
189 struct asus_wmi *asus;
190 struct rfkill *rfkill;
191 u32 dev_id;
192 };
193
194 enum fan_type {
195 FAN_TYPE_NONE = 0,
196 FAN_TYPE_AGFN, /* deprecated on newer platforms */
197 FAN_TYPE_SPEC83, /* starting in Spec 8.3, use CPU_FAN_CTRL */
198 };
199
200 struct fan_curve_data {
201 bool enabled;
202 u32 device_id;
203 u8 temps[FAN_CURVE_POINTS];
204 u8 percents[FAN_CURVE_POINTS];
205 };
206
207 struct asus_wmi {
208 int dsts_id;
209 int spec;
210 int sfun;
211 bool wmi_event_queue;
212
213 struct input_dev *inputdev;
214 struct backlight_device *backlight_device;
215 struct platform_device *platform_device;
216
217 struct led_classdev wlan_led;
218 int wlan_led_wk;
219 struct led_classdev tpd_led;
220 int tpd_led_wk;
221 struct led_classdev kbd_led;
222 int kbd_led_wk;
223 struct led_classdev lightbar_led;
224 int lightbar_led_wk;
225 struct led_classdev micmute_led;
226 struct workqueue_struct *led_workqueue;
227 struct work_struct tpd_led_work;
228 struct work_struct wlan_led_work;
229 struct work_struct lightbar_led_work;
230
231 struct asus_rfkill wlan;
232 struct asus_rfkill bluetooth;
233 struct asus_rfkill wimax;
234 struct asus_rfkill wwan3g;
235 struct asus_rfkill gps;
236 struct asus_rfkill uwb;
237
238 int tablet_switch_event_code;
239 u32 tablet_switch_dev_id;
240 bool tablet_switch_inverted;
241
242 enum fan_type fan_type;
243 enum fan_type gpu_fan_type;
244 enum fan_type mid_fan_type;
245 int fan_pwm_mode;
246 int gpu_fan_pwm_mode;
247 int mid_fan_pwm_mode;
248 int agfn_pwm;
249
250 bool fan_boost_mode_available;
251 u8 fan_boost_mode_mask;
252 u8 fan_boost_mode;
253
254 bool charge_mode_available;
255 bool egpu_enable_available;
256 bool egpu_connect_available;
257 bool dgpu_disable_available;
258 bool gpu_mux_mode_available;
259
260 /* Tunables provided by ASUS for gaming laptops */
261 bool ppt_pl2_sppt_available;
262 bool ppt_pl1_spl_available;
263 bool ppt_apu_sppt_available;
264 bool ppt_plat_sppt_available;
265 bool ppt_fppt_available;
266 bool nv_dyn_boost_available;
267 bool nv_temp_tgt_available;
268
269 bool kbd_rgb_mode_available;
270 bool kbd_rgb_state_available;
271
272 bool throttle_thermal_policy_available;
273 u8 throttle_thermal_policy_mode;
274
275 bool cpu_fan_curve_available;
276 bool gpu_fan_curve_available;
277 bool mid_fan_curve_available;
278 struct fan_curve_data custom_fan_curves[3];
279
280 struct platform_profile_handler platform_profile_handler;
281 bool platform_profile_support;
282
283 // The RSOC controls the maximum charging percentage.
284 bool battery_rsoc_available;
285
286 bool panel_overdrive_available;
287 bool mini_led_mode_available;
288
289 struct hotplug_slot hotplug_slot;
290 struct mutex hotplug_lock;
291 struct mutex wmi_lock;
292 struct workqueue_struct *hotplug_workqueue;
293 struct work_struct hotplug_work;
294
295 bool fnlock_locked;
296
297 struct asus_wmi_debug debug;
298
299 struct asus_wmi_driver *driver;
300 };
301
302 /* WMI ************************************************************************/
303
asus_wmi_evaluate_method3(u32 method_id,u32 arg0,u32 arg1,u32 arg2,u32 * retval)304 static int asus_wmi_evaluate_method3(u32 method_id,
305 u32 arg0, u32 arg1, u32 arg2, u32 *retval)
306 {
307 struct bios_args args = {
308 .arg0 = arg0,
309 .arg1 = arg1,
310 .arg2 = arg2,
311 };
312 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
313 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
314 acpi_status status;
315 union acpi_object *obj;
316 u32 tmp = 0;
317
318 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
319 &input, &output);
320
321 if (ACPI_FAILURE(status))
322 return -EIO;
323
324 obj = (union acpi_object *)output.pointer;
325 if (obj && obj->type == ACPI_TYPE_INTEGER)
326 tmp = (u32) obj->integer.value;
327
328 if (retval)
329 *retval = tmp;
330
331 kfree(obj);
332
333 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
334 return -ENODEV;
335
336 return 0;
337 }
338
asus_wmi_evaluate_method(u32 method_id,u32 arg0,u32 arg1,u32 * retval)339 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
340 {
341 return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
342 }
343 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
344
asus_wmi_evaluate_method5(u32 method_id,u32 arg0,u32 arg1,u32 arg2,u32 arg3,u32 arg4,u32 * retval)345 static int asus_wmi_evaluate_method5(u32 method_id,
346 u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
347 {
348 struct bios_args args = {
349 .arg0 = arg0,
350 .arg1 = arg1,
351 .arg2 = arg2,
352 .arg3 = arg3,
353 .arg4 = arg4,
354 };
355 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
356 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
357 acpi_status status;
358 union acpi_object *obj;
359 u32 tmp = 0;
360
361 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
362 &input, &output);
363
364 if (ACPI_FAILURE(status))
365 return -EIO;
366
367 obj = (union acpi_object *)output.pointer;
368 if (obj && obj->type == ACPI_TYPE_INTEGER)
369 tmp = (u32) obj->integer.value;
370
371 if (retval)
372 *retval = tmp;
373
374 kfree(obj);
375
376 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
377 return -ENODEV;
378
379 return 0;
380 }
381
382 /*
383 * Returns as an error if the method output is not a buffer. Typically this
384 * means that the method called is unsupported.
385 */
asus_wmi_evaluate_method_buf(u32 method_id,u32 arg0,u32 arg1,u8 * ret_buffer,size_t size)386 static int asus_wmi_evaluate_method_buf(u32 method_id,
387 u32 arg0, u32 arg1, u8 *ret_buffer, size_t size)
388 {
389 struct bios_args args = {
390 .arg0 = arg0,
391 .arg1 = arg1,
392 .arg2 = 0,
393 };
394 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
395 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
396 acpi_status status;
397 union acpi_object *obj;
398 int err = 0;
399
400 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
401 &input, &output);
402
403 if (ACPI_FAILURE(status))
404 return -EIO;
405
406 obj = (union acpi_object *)output.pointer;
407
408 switch (obj->type) {
409 case ACPI_TYPE_BUFFER:
410 if (obj->buffer.length > size) {
411 err = -ENOSPC;
412 break;
413 }
414 if (obj->buffer.length == 0) {
415 err = -ENODATA;
416 break;
417 }
418
419 memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length);
420 break;
421 case ACPI_TYPE_INTEGER:
422 err = (u32)obj->integer.value;
423
424 if (err == ASUS_WMI_UNSUPPORTED_METHOD)
425 err = -ENODEV;
426 /*
427 * At least one method returns a 0 with no buffer if no arg
428 * is provided, such as ASUS_WMI_DEVID_CPU_FAN_CURVE
429 */
430 if (err == 0)
431 err = -ENODATA;
432 break;
433 default:
434 err = -ENODATA;
435 break;
436 }
437
438 kfree(obj);
439
440 if (err)
441 return err;
442
443 return 0;
444 }
445
asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)446 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
447 {
448 struct acpi_buffer input;
449 u64 phys_addr;
450 u32 retval;
451 u32 status;
452
453 /*
454 * Copy to dma capable address otherwise memory corruption occurs as
455 * bios has to be able to access it.
456 */
457 input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
458 input.length = args.length;
459 if (!input.pointer)
460 return -ENOMEM;
461 phys_addr = virt_to_phys(input.pointer);
462
463 status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
464 phys_addr, 0, &retval);
465 if (!status)
466 memcpy(args.pointer, input.pointer, args.length);
467
468 kfree(input.pointer);
469 if (status)
470 return -ENXIO;
471
472 return retval;
473 }
474
asus_wmi_get_devstate(struct asus_wmi * asus,u32 dev_id,u32 * retval)475 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
476 {
477 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
478 }
479
asus_wmi_set_devstate(u32 dev_id,u32 ctrl_param,u32 * retval)480 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
481 u32 *retval)
482 {
483 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
484 ctrl_param, retval);
485 }
486
487 /* Helper for special devices with magic return codes */
asus_wmi_get_devstate_bits(struct asus_wmi * asus,u32 dev_id,u32 mask)488 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
489 u32 dev_id, u32 mask)
490 {
491 u32 retval = 0;
492 int err;
493
494 err = asus_wmi_get_devstate(asus, dev_id, &retval);
495 if (err < 0)
496 return err;
497
498 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
499 return -ENODEV;
500
501 if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
502 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
503 return -ENODEV;
504 }
505
506 return retval & mask;
507 }
508
asus_wmi_get_devstate_simple(struct asus_wmi * asus,u32 dev_id)509 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
510 {
511 return asus_wmi_get_devstate_bits(asus, dev_id,
512 ASUS_WMI_DSTS_STATUS_BIT);
513 }
514
asus_wmi_dev_is_present(struct asus_wmi * asus,u32 dev_id)515 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
516 {
517 u32 retval;
518 int status = asus_wmi_get_devstate(asus, dev_id, &retval);
519
520 return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
521 }
522
523 /* Input **********************************************************************/
asus_wmi_tablet_sw_report(struct asus_wmi * asus,bool value)524 static void asus_wmi_tablet_sw_report(struct asus_wmi *asus, bool value)
525 {
526 input_report_switch(asus->inputdev, SW_TABLET_MODE,
527 asus->tablet_switch_inverted ? !value : value);
528 input_sync(asus->inputdev);
529 }
530
asus_wmi_tablet_sw_init(struct asus_wmi * asus,u32 dev_id,int event_code)531 static void asus_wmi_tablet_sw_init(struct asus_wmi *asus, u32 dev_id, int event_code)
532 {
533 struct device *dev = &asus->platform_device->dev;
534 int result;
535
536 result = asus_wmi_get_devstate_simple(asus, dev_id);
537 if (result >= 0) {
538 input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
539 asus_wmi_tablet_sw_report(asus, result);
540 asus->tablet_switch_dev_id = dev_id;
541 asus->tablet_switch_event_code = event_code;
542 } else if (result == -ENODEV) {
543 dev_err(dev, "This device has tablet-mode-switch quirk but got ENODEV checking it. This is a bug.");
544 } else {
545 dev_err(dev, "Error checking for tablet-mode-switch: %d\n", result);
546 }
547 }
548
asus_wmi_input_init(struct asus_wmi * asus)549 static int asus_wmi_input_init(struct asus_wmi *asus)
550 {
551 struct device *dev = &asus->platform_device->dev;
552 int err;
553
554 asus->inputdev = input_allocate_device();
555 if (!asus->inputdev)
556 return -ENOMEM;
557
558 asus->inputdev->name = asus->driver->input_name;
559 asus->inputdev->phys = asus->driver->input_phys;
560 asus->inputdev->id.bustype = BUS_HOST;
561 asus->inputdev->dev.parent = dev;
562 set_bit(EV_REP, asus->inputdev->evbit);
563
564 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
565 if (err)
566 goto err_free_dev;
567
568 switch (asus->driver->quirks->tablet_switch_mode) {
569 case asus_wmi_no_tablet_switch:
570 break;
571 case asus_wmi_kbd_dock_devid:
572 asus->tablet_switch_inverted = true;
573 asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_KBD_DOCK, NOTIFY_KBD_DOCK_CHANGE);
574 break;
575 case asus_wmi_lid_flip_devid:
576 asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_LID_FLIP, NOTIFY_LID_FLIP);
577 break;
578 case asus_wmi_lid_flip_rog_devid:
579 asus_wmi_tablet_sw_init(asus, ASUS_WMI_DEVID_LID_FLIP_ROG, NOTIFY_LID_FLIP_ROG);
580 break;
581 }
582
583 err = input_register_device(asus->inputdev);
584 if (err)
585 goto err_free_dev;
586
587 return 0;
588
589 err_free_dev:
590 input_free_device(asus->inputdev);
591 return err;
592 }
593
asus_wmi_input_exit(struct asus_wmi * asus)594 static void asus_wmi_input_exit(struct asus_wmi *asus)
595 {
596 if (asus->inputdev)
597 input_unregister_device(asus->inputdev);
598
599 asus->inputdev = NULL;
600 }
601
602 /* Tablet mode ****************************************************************/
603
asus_wmi_tablet_mode_get_state(struct asus_wmi * asus)604 static void asus_wmi_tablet_mode_get_state(struct asus_wmi *asus)
605 {
606 int result;
607
608 if (!asus->tablet_switch_dev_id)
609 return;
610
611 result = asus_wmi_get_devstate_simple(asus, asus->tablet_switch_dev_id);
612 if (result >= 0)
613 asus_wmi_tablet_sw_report(asus, result);
614 }
615
616 /* Charging mode, 1=Barrel, 2=USB ******************************************/
charge_mode_show(struct device * dev,struct device_attribute * attr,char * buf)617 static ssize_t charge_mode_show(struct device *dev,
618 struct device_attribute *attr, char *buf)
619 {
620 struct asus_wmi *asus = dev_get_drvdata(dev);
621 int result, value;
622
623 result = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CHARGE_MODE, &value);
624 if (result < 0)
625 return result;
626
627 return sysfs_emit(buf, "%d\n", value & 0xff);
628 }
629
630 static DEVICE_ATTR_RO(charge_mode);
631
632 /* dGPU ********************************************************************/
dgpu_disable_show(struct device * dev,struct device_attribute * attr,char * buf)633 static ssize_t dgpu_disable_show(struct device *dev,
634 struct device_attribute *attr, char *buf)
635 {
636 struct asus_wmi *asus = dev_get_drvdata(dev);
637 int result;
638
639 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU);
640 if (result < 0)
641 return result;
642
643 return sysfs_emit(buf, "%d\n", result);
644 }
645
646 /*
647 * A user may be required to store the value twice, typcial store first, then
648 * rescan PCI bus to activate power, then store a second time to save correctly.
649 * The reason for this is that an extra code path in the ACPI is enabled when
650 * the device and bus are powered.
651 */
dgpu_disable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)652 static ssize_t dgpu_disable_store(struct device *dev,
653 struct device_attribute *attr,
654 const char *buf, size_t count)
655 {
656 int result, err;
657 u32 disable;
658
659 struct asus_wmi *asus = dev_get_drvdata(dev);
660
661 result = kstrtou32(buf, 10, &disable);
662 if (result)
663 return result;
664
665 if (disable > 1)
666 return -EINVAL;
667
668 if (asus->gpu_mux_mode_available) {
669 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX);
670 if (result < 0)
671 /* An error here may signal greater failure of GPU handling */
672 return result;
673 if (!result && disable) {
674 err = -ENODEV;
675 pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err);
676 return err;
677 }
678 }
679
680 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result);
681 if (err) {
682 pr_warn("Failed to set dgpu disable: %d\n", err);
683 return err;
684 }
685
686 if (result > 1) {
687 pr_warn("Failed to set dgpu disable (result): 0x%x\n", result);
688 return -EIO;
689 }
690
691 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "dgpu_disable");
692
693 return count;
694 }
695 static DEVICE_ATTR_RW(dgpu_disable);
696
697 /* eGPU ********************************************************************/
egpu_enable_show(struct device * dev,struct device_attribute * attr,char * buf)698 static ssize_t egpu_enable_show(struct device *dev,
699 struct device_attribute *attr, char *buf)
700 {
701 struct asus_wmi *asus = dev_get_drvdata(dev);
702 int result;
703
704 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU);
705 if (result < 0)
706 return result;
707
708 return sysfs_emit(buf, "%d\n", result);
709 }
710
711 /* The ACPI call to enable the eGPU also disables the internal dGPU */
egpu_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)712 static ssize_t egpu_enable_store(struct device *dev,
713 struct device_attribute *attr,
714 const char *buf, size_t count)
715 {
716 int result, err;
717 u32 enable;
718
719 struct asus_wmi *asus = dev_get_drvdata(dev);
720
721 err = kstrtou32(buf, 10, &enable);
722 if (err)
723 return err;
724
725 if (enable > 1)
726 return -EINVAL;
727
728 err = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED);
729 if (err < 0) {
730 pr_warn("Failed to get egpu connection status: %d\n", err);
731 return err;
732 }
733
734 if (asus->gpu_mux_mode_available) {
735 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX);
736 if (result < 0) {
737 /* An error here may signal greater failure of GPU handling */
738 pr_warn("Failed to get gpu mux status: %d\n", result);
739 return result;
740 }
741 if (!result && enable) {
742 err = -ENODEV;
743 pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err);
744 return err;
745 }
746 }
747
748 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result);
749 if (err) {
750 pr_warn("Failed to set egpu state: %d\n", err);
751 return err;
752 }
753
754 if (result > 1) {
755 pr_warn("Failed to set egpu state (retval): 0x%x\n", result);
756 return -EIO;
757 }
758
759 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "egpu_enable");
760
761 return count;
762 }
763 static DEVICE_ATTR_RW(egpu_enable);
764
765 /* Is eGPU connected? *********************************************************/
egpu_connected_show(struct device * dev,struct device_attribute * attr,char * buf)766 static ssize_t egpu_connected_show(struct device *dev,
767 struct device_attribute *attr, char *buf)
768 {
769 struct asus_wmi *asus = dev_get_drvdata(dev);
770 int result;
771
772 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED);
773 if (result < 0)
774 return result;
775
776 return sysfs_emit(buf, "%d\n", result);
777 }
778
779 static DEVICE_ATTR_RO(egpu_connected);
780
781 /* gpu mux switch *************************************************************/
gpu_mux_mode_show(struct device * dev,struct device_attribute * attr,char * buf)782 static ssize_t gpu_mux_mode_show(struct device *dev,
783 struct device_attribute *attr, char *buf)
784 {
785 struct asus_wmi *asus = dev_get_drvdata(dev);
786 int result;
787
788 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX);
789 if (result < 0)
790 return result;
791
792 return sysfs_emit(buf, "%d\n", result);
793 }
794
gpu_mux_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)795 static ssize_t gpu_mux_mode_store(struct device *dev,
796 struct device_attribute *attr,
797 const char *buf, size_t count)
798 {
799 struct asus_wmi *asus = dev_get_drvdata(dev);
800 int result, err;
801 u32 optimus;
802
803 err = kstrtou32(buf, 10, &optimus);
804 if (err)
805 return err;
806
807 if (optimus > 1)
808 return -EINVAL;
809
810 if (asus->dgpu_disable_available) {
811 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU);
812 if (result < 0)
813 /* An error here may signal greater failure of GPU handling */
814 return result;
815 if (result && !optimus) {
816 err = -ENODEV;
817 pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n", err);
818 return err;
819 }
820 }
821
822 if (asus->egpu_enable_available) {
823 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU);
824 if (result < 0)
825 /* An error here may signal greater failure of GPU handling */
826 return result;
827 if (result && !optimus) {
828 err = -ENODEV;
829 pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n", err);
830 return err;
831 }
832 }
833
834 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_MUX, optimus, &result);
835 if (err) {
836 dev_err(dev, "Failed to set GPU MUX mode: %d\n", err);
837 return err;
838 }
839 /* !1 is considered a fail by ASUS */
840 if (result != 1) {
841 dev_warn(dev, "Failed to set GPU MUX mode (result): 0x%x\n", result);
842 return -EIO;
843 }
844
845 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "gpu_mux_mode");
846
847 return count;
848 }
849 static DEVICE_ATTR_RW(gpu_mux_mode);
850
851 /* TUF Laptop Keyboard RGB Modes **********************************************/
kbd_rgb_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)852 static ssize_t kbd_rgb_mode_store(struct device *dev,
853 struct device_attribute *attr,
854 const char *buf, size_t count)
855 {
856 u32 cmd, mode, r, g, b, speed;
857 int err;
858
859 if (sscanf(buf, "%d %d %d %d %d %d", &cmd, &mode, &r, &g, &b, &speed) != 6)
860 return -EINVAL;
861
862 /* B3 is set and B4 is save to BIOS */
863 switch (cmd) {
864 case 0:
865 cmd = 0xb3;
866 break;
867 case 1:
868 cmd = 0xb4;
869 break;
870 default:
871 return -EINVAL;
872 }
873
874 /* These are the known usable modes across all TUF/ROG */
875 if (mode >= 12 || mode == 9)
876 mode = 10;
877
878 switch (speed) {
879 case 0:
880 speed = 0xe1;
881 break;
882 case 1:
883 speed = 0xeb;
884 break;
885 case 2:
886 speed = 0xf5;
887 break;
888 default:
889 speed = 0xeb;
890 }
891
892 err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS, ASUS_WMI_DEVID_TUF_RGB_MODE,
893 cmd | (mode << 8) | (r << 16) | (g << 24), b | (speed << 8), NULL);
894 if (err)
895 return err;
896
897 return count;
898 }
899 static DEVICE_ATTR_WO(kbd_rgb_mode);
900
kbd_rgb_mode_index_show(struct device * device,struct device_attribute * attr,char * buf)901 static ssize_t kbd_rgb_mode_index_show(struct device *device,
902 struct device_attribute *attr,
903 char *buf)
904 {
905 return sysfs_emit(buf, "%s\n", "cmd mode red green blue speed");
906 }
907 static DEVICE_ATTR_RO(kbd_rgb_mode_index);
908
909 static struct attribute *kbd_rgb_mode_attrs[] = {
910 &dev_attr_kbd_rgb_mode.attr,
911 &dev_attr_kbd_rgb_mode_index.attr,
912 NULL,
913 };
914
915 static const struct attribute_group kbd_rgb_mode_group = {
916 .attrs = kbd_rgb_mode_attrs,
917 };
918
919 /* TUF Laptop Keyboard RGB State **********************************************/
kbd_rgb_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)920 static ssize_t kbd_rgb_state_store(struct device *dev,
921 struct device_attribute *attr,
922 const char *buf, size_t count)
923 {
924 u32 flags, cmd, boot, awake, sleep, keyboard;
925 int err;
926
927 if (sscanf(buf, "%d %d %d %d %d", &cmd, &boot, &awake, &sleep, &keyboard) != 5)
928 return -EINVAL;
929
930 if (cmd)
931 cmd = BIT(2);
932
933 flags = 0;
934 if (boot)
935 flags |= BIT(1);
936 if (awake)
937 flags |= BIT(3);
938 if (sleep)
939 flags |= BIT(5);
940 if (keyboard)
941 flags |= BIT(7);
942
943 /* 0xbd is the required default arg0 for the method. Nothing happens otherwise */
944 err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS,
945 ASUS_WMI_DEVID_TUF_RGB_STATE, 0xbd | cmd << 8 | (flags << 16), 0, NULL);
946 if (err)
947 return err;
948
949 return count;
950 }
951 static DEVICE_ATTR_WO(kbd_rgb_state);
952
kbd_rgb_state_index_show(struct device * device,struct device_attribute * attr,char * buf)953 static ssize_t kbd_rgb_state_index_show(struct device *device,
954 struct device_attribute *attr,
955 char *buf)
956 {
957 return sysfs_emit(buf, "%s\n", "cmd boot awake sleep keyboard");
958 }
959 static DEVICE_ATTR_RO(kbd_rgb_state_index);
960
961 static struct attribute *kbd_rgb_state_attrs[] = {
962 &dev_attr_kbd_rgb_state.attr,
963 &dev_attr_kbd_rgb_state_index.attr,
964 NULL,
965 };
966
967 static const struct attribute_group kbd_rgb_state_group = {
968 .attrs = kbd_rgb_state_attrs,
969 };
970
971 static const struct attribute_group *kbd_rgb_mode_groups[] = {
972 NULL,
973 NULL,
974 NULL,
975 };
976
977 /* Tunable: PPT: Intel=PL1, AMD=SPPT *****************************************/
ppt_pl2_sppt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)978 static ssize_t ppt_pl2_sppt_store(struct device *dev,
979 struct device_attribute *attr,
980 const char *buf, size_t count)
981 {
982 int result, err;
983 u32 value;
984
985 struct asus_wmi *asus = dev_get_drvdata(dev);
986
987 result = kstrtou32(buf, 10, &value);
988 if (result)
989 return result;
990
991 if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
992 return -EINVAL;
993
994 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL2_SPPT, value, &result);
995 if (err) {
996 pr_warn("Failed to set ppt_pl2_sppt: %d\n", err);
997 return err;
998 }
999
1000 if (result > 1) {
1001 pr_warn("Failed to set ppt_pl2_sppt (result): 0x%x\n", result);
1002 return -EIO;
1003 }
1004
1005 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl2_sppt");
1006
1007 return count;
1008 }
1009 static DEVICE_ATTR_WO(ppt_pl2_sppt);
1010
1011 /* Tunable: PPT, Intel=PL1, AMD=SPL ******************************************/
ppt_pl1_spl_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1012 static ssize_t ppt_pl1_spl_store(struct device *dev,
1013 struct device_attribute *attr,
1014 const char *buf, size_t count)
1015 {
1016 int result, err;
1017 u32 value;
1018
1019 struct asus_wmi *asus = dev_get_drvdata(dev);
1020
1021 result = kstrtou32(buf, 10, &value);
1022 if (result)
1023 return result;
1024
1025 if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
1026 return -EINVAL;
1027
1028 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL1_SPL, value, &result);
1029 if (err) {
1030 pr_warn("Failed to set ppt_pl1_spl: %d\n", err);
1031 return err;
1032 }
1033
1034 if (result > 1) {
1035 pr_warn("Failed to set ppt_pl1_spl (result): 0x%x\n", result);
1036 return -EIO;
1037 }
1038
1039 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl1_spl");
1040
1041 return count;
1042 }
1043 static DEVICE_ATTR_WO(ppt_pl1_spl);
1044
1045 /* Tunable: PPT APU FPPT ******************************************************/
ppt_fppt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1046 static ssize_t ppt_fppt_store(struct device *dev,
1047 struct device_attribute *attr,
1048 const char *buf, size_t count)
1049 {
1050 int result, err;
1051 u32 value;
1052
1053 struct asus_wmi *asus = dev_get_drvdata(dev);
1054
1055 result = kstrtou32(buf, 10, &value);
1056 if (result)
1057 return result;
1058
1059 if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
1060 return -EINVAL;
1061
1062 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_FPPT, value, &result);
1063 if (err) {
1064 pr_warn("Failed to set ppt_fppt: %d\n", err);
1065 return err;
1066 }
1067
1068 if (result > 1) {
1069 pr_warn("Failed to set ppt_fppt (result): 0x%x\n", result);
1070 return -EIO;
1071 }
1072
1073 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_fpu_sppt");
1074
1075 return count;
1076 }
1077 static DEVICE_ATTR_WO(ppt_fppt);
1078
1079 /* Tunable: PPT APU SPPT *****************************************************/
ppt_apu_sppt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1080 static ssize_t ppt_apu_sppt_store(struct device *dev,
1081 struct device_attribute *attr,
1082 const char *buf, size_t count)
1083 {
1084 int result, err;
1085 u32 value;
1086
1087 struct asus_wmi *asus = dev_get_drvdata(dev);
1088
1089 result = kstrtou32(buf, 10, &value);
1090 if (result)
1091 return result;
1092
1093 if (value < PPT_CPU_MIN || value > PPT_CPU_MAX)
1094 return -EINVAL;
1095
1096 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_APU_SPPT, value, &result);
1097 if (err) {
1098 pr_warn("Failed to set ppt_apu_sppt: %d\n", err);
1099 return err;
1100 }
1101
1102 if (result > 1) {
1103 pr_warn("Failed to set ppt_apu_sppt (result): 0x%x\n", result);
1104 return -EIO;
1105 }
1106
1107 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_apu_sppt");
1108
1109 return count;
1110 }
1111 static DEVICE_ATTR_WO(ppt_apu_sppt);
1112
1113 /* Tunable: PPT platform SPPT ************************************************/
ppt_platform_sppt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1114 static ssize_t ppt_platform_sppt_store(struct device *dev,
1115 struct device_attribute *attr,
1116 const char *buf, size_t count)
1117 {
1118 int result, err;
1119 u32 value;
1120
1121 struct asus_wmi *asus = dev_get_drvdata(dev);
1122
1123 result = kstrtou32(buf, 10, &value);
1124 if (result)
1125 return result;
1126
1127 if (value < PPT_CPU_MIN || value > PPT_CPU_MAX)
1128 return -EINVAL;
1129
1130 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PLAT_SPPT, value, &result);
1131 if (err) {
1132 pr_warn("Failed to set ppt_platform_sppt: %d\n", err);
1133 return err;
1134 }
1135
1136 if (result > 1) {
1137 pr_warn("Failed to set ppt_platform_sppt (result): 0x%x\n", result);
1138 return -EIO;
1139 }
1140
1141 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_platform_sppt");
1142
1143 return count;
1144 }
1145 static DEVICE_ATTR_WO(ppt_platform_sppt);
1146
1147 /* Tunable: NVIDIA dynamic boost *********************************************/
nv_dynamic_boost_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1148 static ssize_t nv_dynamic_boost_store(struct device *dev,
1149 struct device_attribute *attr,
1150 const char *buf, size_t count)
1151 {
1152 int result, err;
1153 u32 value;
1154
1155 struct asus_wmi *asus = dev_get_drvdata(dev);
1156
1157 result = kstrtou32(buf, 10, &value);
1158 if (result)
1159 return result;
1160
1161 if (value < NVIDIA_BOOST_MIN || value > NVIDIA_BOOST_MAX)
1162 return -EINVAL;
1163
1164 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_NV_DYN_BOOST, value, &result);
1165 if (err) {
1166 pr_warn("Failed to set nv_dynamic_boost: %d\n", err);
1167 return err;
1168 }
1169
1170 if (result > 1) {
1171 pr_warn("Failed to set nv_dynamic_boost (result): 0x%x\n", result);
1172 return -EIO;
1173 }
1174
1175 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_dynamic_boost");
1176
1177 return count;
1178 }
1179 static DEVICE_ATTR_WO(nv_dynamic_boost);
1180
1181 /* Tunable: NVIDIA temperature target ****************************************/
nv_temp_target_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1182 static ssize_t nv_temp_target_store(struct device *dev,
1183 struct device_attribute *attr,
1184 const char *buf, size_t count)
1185 {
1186 int result, err;
1187 u32 value;
1188
1189 struct asus_wmi *asus = dev_get_drvdata(dev);
1190
1191 result = kstrtou32(buf, 10, &value);
1192 if (result)
1193 return result;
1194
1195 if (value < NVIDIA_TEMP_MIN || value > NVIDIA_TEMP_MAX)
1196 return -EINVAL;
1197
1198 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_NV_THERM_TARGET, value, &result);
1199 if (err) {
1200 pr_warn("Failed to set nv_temp_target: %d\n", err);
1201 return err;
1202 }
1203
1204 if (result > 1) {
1205 pr_warn("Failed to set nv_temp_target (result): 0x%x\n", result);
1206 return -EIO;
1207 }
1208
1209 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_temp_target");
1210
1211 return count;
1212 }
1213 static DEVICE_ATTR_WO(nv_temp_target);
1214
1215 /* Battery ********************************************************************/
1216
1217 /* The battery maximum charging percentage */
1218 static int charge_end_threshold;
1219
charge_control_end_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1220 static ssize_t charge_control_end_threshold_store(struct device *dev,
1221 struct device_attribute *attr,
1222 const char *buf, size_t count)
1223 {
1224 int value, ret, rv;
1225
1226 ret = kstrtouint(buf, 10, &value);
1227 if (ret)
1228 return ret;
1229
1230 if (value < 0 || value > 100)
1231 return -EINVAL;
1232
1233 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
1234 if (ret)
1235 return ret;
1236
1237 if (rv != 1)
1238 return -EIO;
1239
1240 /* There isn't any method in the DSDT to read the threshold, so we
1241 * save the threshold.
1242 */
1243 charge_end_threshold = value;
1244 return count;
1245 }
1246
charge_control_end_threshold_show(struct device * device,struct device_attribute * attr,char * buf)1247 static ssize_t charge_control_end_threshold_show(struct device *device,
1248 struct device_attribute *attr,
1249 char *buf)
1250 {
1251 return sysfs_emit(buf, "%d\n", charge_end_threshold);
1252 }
1253
1254 static DEVICE_ATTR_RW(charge_control_end_threshold);
1255
asus_wmi_battery_add(struct power_supply * battery,struct acpi_battery_hook * hook)1256 static int asus_wmi_battery_add(struct power_supply *battery, struct acpi_battery_hook *hook)
1257 {
1258 /* The WMI method does not provide a way to specific a battery, so we
1259 * just assume it is the first battery.
1260 * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
1261 * battery is named BATT.
1262 */
1263 if (strcmp(battery->desc->name, "BAT0") != 0 &&
1264 strcmp(battery->desc->name, "BAT1") != 0 &&
1265 strcmp(battery->desc->name, "BATC") != 0 &&
1266 strcmp(battery->desc->name, "BATT") != 0)
1267 return -ENODEV;
1268
1269 if (device_create_file(&battery->dev,
1270 &dev_attr_charge_control_end_threshold))
1271 return -ENODEV;
1272
1273 /* The charge threshold is only reset when the system is power cycled,
1274 * and we can't get the current threshold so let set it to 100% when
1275 * a battery is added.
1276 */
1277 asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
1278 charge_end_threshold = 100;
1279
1280 return 0;
1281 }
1282
asus_wmi_battery_remove(struct power_supply * battery,struct acpi_battery_hook * hook)1283 static int asus_wmi_battery_remove(struct power_supply *battery, struct acpi_battery_hook *hook)
1284 {
1285 device_remove_file(&battery->dev,
1286 &dev_attr_charge_control_end_threshold);
1287 return 0;
1288 }
1289
1290 static struct acpi_battery_hook battery_hook = {
1291 .add_battery = asus_wmi_battery_add,
1292 .remove_battery = asus_wmi_battery_remove,
1293 .name = "ASUS Battery Extension",
1294 };
1295
asus_wmi_battery_init(struct asus_wmi * asus)1296 static void asus_wmi_battery_init(struct asus_wmi *asus)
1297 {
1298 asus->battery_rsoc_available = false;
1299 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
1300 asus->battery_rsoc_available = true;
1301 battery_hook_register(&battery_hook);
1302 }
1303 }
1304
asus_wmi_battery_exit(struct asus_wmi * asus)1305 static void asus_wmi_battery_exit(struct asus_wmi *asus)
1306 {
1307 if (asus->battery_rsoc_available)
1308 battery_hook_unregister(&battery_hook);
1309 }
1310
1311 /* LEDs ***********************************************************************/
1312
1313 /*
1314 * These functions actually update the LED's, and are called from a
1315 * workqueue. By doing this as separate work rather than when the LED
1316 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
1317 * potentially bad time, such as a timer interrupt.
1318 */
tpd_led_update(struct work_struct * work)1319 static void tpd_led_update(struct work_struct *work)
1320 {
1321 int ctrl_param;
1322 struct asus_wmi *asus;
1323
1324 asus = container_of(work, struct asus_wmi, tpd_led_work);
1325
1326 ctrl_param = asus->tpd_led_wk;
1327 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
1328 }
1329
tpd_led_set(struct led_classdev * led_cdev,enum led_brightness value)1330 static void tpd_led_set(struct led_classdev *led_cdev,
1331 enum led_brightness value)
1332 {
1333 struct asus_wmi *asus;
1334
1335 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
1336
1337 asus->tpd_led_wk = !!value;
1338 queue_work(asus->led_workqueue, &asus->tpd_led_work);
1339 }
1340
read_tpd_led_state(struct asus_wmi * asus)1341 static int read_tpd_led_state(struct asus_wmi *asus)
1342 {
1343 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
1344 }
1345
tpd_led_get(struct led_classdev * led_cdev)1346 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
1347 {
1348 struct asus_wmi *asus;
1349
1350 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
1351
1352 return read_tpd_led_state(asus);
1353 }
1354
kbd_led_update(struct asus_wmi * asus)1355 static void kbd_led_update(struct asus_wmi *asus)
1356 {
1357 int ctrl_param = 0;
1358
1359 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
1360 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
1361 }
1362
kbd_led_read(struct asus_wmi * asus,int * level,int * env)1363 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
1364 {
1365 int retval;
1366
1367 /*
1368 * bits 0-2: level
1369 * bit 7: light on/off
1370 * bit 8-10: environment (0: dark, 1: normal, 2: light)
1371 * bit 17: status unknown
1372 */
1373 retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
1374 0xFFFF);
1375
1376 /* Unknown status is considered as off */
1377 if (retval == 0x8000)
1378 retval = 0;
1379
1380 if (retval < 0)
1381 return retval;
1382
1383 if (level)
1384 *level = retval & 0x7F;
1385 if (env)
1386 *env = (retval >> 8) & 0x7F;
1387 return 0;
1388 }
1389
do_kbd_led_set(struct led_classdev * led_cdev,int value)1390 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
1391 {
1392 struct asus_wmi *asus;
1393 int max_level;
1394
1395 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
1396 max_level = asus->kbd_led.max_brightness;
1397
1398 asus->kbd_led_wk = clamp_val(value, 0, max_level);
1399 kbd_led_update(asus);
1400 }
1401
kbd_led_set(struct led_classdev * led_cdev,enum led_brightness value)1402 static void kbd_led_set(struct led_classdev *led_cdev,
1403 enum led_brightness value)
1404 {
1405 /* Prevent disabling keyboard backlight on module unregister */
1406 if (led_cdev->flags & LED_UNREGISTERING)
1407 return;
1408
1409 do_kbd_led_set(led_cdev, value);
1410 }
1411
kbd_led_set_by_kbd(struct asus_wmi * asus,enum led_brightness value)1412 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
1413 {
1414 struct led_classdev *led_cdev = &asus->kbd_led;
1415
1416 do_kbd_led_set(led_cdev, value);
1417 led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
1418 }
1419
kbd_led_get(struct led_classdev * led_cdev)1420 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
1421 {
1422 struct asus_wmi *asus;
1423 int retval, value;
1424
1425 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
1426
1427 retval = kbd_led_read(asus, &value, NULL);
1428 if (retval < 0)
1429 return retval;
1430
1431 return value;
1432 }
1433
wlan_led_unknown_state(struct asus_wmi * asus)1434 static int wlan_led_unknown_state(struct asus_wmi *asus)
1435 {
1436 u32 result;
1437
1438 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
1439
1440 return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
1441 }
1442
wlan_led_update(struct work_struct * work)1443 static void wlan_led_update(struct work_struct *work)
1444 {
1445 int ctrl_param;
1446 struct asus_wmi *asus;
1447
1448 asus = container_of(work, struct asus_wmi, wlan_led_work);
1449
1450 ctrl_param = asus->wlan_led_wk;
1451 asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
1452 }
1453
wlan_led_set(struct led_classdev * led_cdev,enum led_brightness value)1454 static void wlan_led_set(struct led_classdev *led_cdev,
1455 enum led_brightness value)
1456 {
1457 struct asus_wmi *asus;
1458
1459 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
1460
1461 asus->wlan_led_wk = !!value;
1462 queue_work(asus->led_workqueue, &asus->wlan_led_work);
1463 }
1464
wlan_led_get(struct led_classdev * led_cdev)1465 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
1466 {
1467 struct asus_wmi *asus;
1468 u32 result;
1469
1470 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
1471 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
1472
1473 return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1474 }
1475
lightbar_led_update(struct work_struct * work)1476 static void lightbar_led_update(struct work_struct *work)
1477 {
1478 struct asus_wmi *asus;
1479 int ctrl_param;
1480
1481 asus = container_of(work, struct asus_wmi, lightbar_led_work);
1482
1483 ctrl_param = asus->lightbar_led_wk;
1484 asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
1485 }
1486
lightbar_led_set(struct led_classdev * led_cdev,enum led_brightness value)1487 static void lightbar_led_set(struct led_classdev *led_cdev,
1488 enum led_brightness value)
1489 {
1490 struct asus_wmi *asus;
1491
1492 asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1493
1494 asus->lightbar_led_wk = !!value;
1495 queue_work(asus->led_workqueue, &asus->lightbar_led_work);
1496 }
1497
lightbar_led_get(struct led_classdev * led_cdev)1498 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
1499 {
1500 struct asus_wmi *asus;
1501 u32 result;
1502
1503 asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1504 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
1505
1506 return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
1507 }
1508
micmute_led_set(struct led_classdev * led_cdev,enum led_brightness brightness)1509 static int micmute_led_set(struct led_classdev *led_cdev,
1510 enum led_brightness brightness)
1511 {
1512 int state = brightness != LED_OFF;
1513 int err;
1514
1515 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MICMUTE_LED, state, NULL);
1516 return err < 0 ? err : 0;
1517 }
1518
asus_wmi_led_exit(struct asus_wmi * asus)1519 static void asus_wmi_led_exit(struct asus_wmi *asus)
1520 {
1521 led_classdev_unregister(&asus->kbd_led);
1522 led_classdev_unregister(&asus->tpd_led);
1523 led_classdev_unregister(&asus->wlan_led);
1524 led_classdev_unregister(&asus->lightbar_led);
1525 led_classdev_unregister(&asus->micmute_led);
1526
1527 if (asus->led_workqueue)
1528 destroy_workqueue(asus->led_workqueue);
1529 }
1530
asus_wmi_led_init(struct asus_wmi * asus)1531 static int asus_wmi_led_init(struct asus_wmi *asus)
1532 {
1533 int rv = 0, num_rgb_groups = 0, led_val;
1534
1535 if (asus->kbd_rgb_mode_available)
1536 kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_mode_group;
1537 if (asus->kbd_rgb_state_available)
1538 kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_state_group;
1539
1540 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
1541 if (!asus->led_workqueue)
1542 return -ENOMEM;
1543
1544 if (read_tpd_led_state(asus) >= 0) {
1545 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
1546
1547 asus->tpd_led.name = "asus::touchpad";
1548 asus->tpd_led.brightness_set = tpd_led_set;
1549 asus->tpd_led.brightness_get = tpd_led_get;
1550 asus->tpd_led.max_brightness = 1;
1551
1552 rv = led_classdev_register(&asus->platform_device->dev,
1553 &asus->tpd_led);
1554 if (rv)
1555 goto error;
1556 }
1557
1558 if (!kbd_led_read(asus, &led_val, NULL)) {
1559 asus->kbd_led_wk = led_val;
1560 asus->kbd_led.name = "asus::kbd_backlight";
1561 asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
1562 asus->kbd_led.brightness_set = kbd_led_set;
1563 asus->kbd_led.brightness_get = kbd_led_get;
1564 asus->kbd_led.max_brightness = 3;
1565
1566 if (num_rgb_groups != 0)
1567 asus->kbd_led.groups = kbd_rgb_mode_groups;
1568
1569 rv = led_classdev_register(&asus->platform_device->dev,
1570 &asus->kbd_led);
1571 if (rv)
1572 goto error;
1573 }
1574
1575 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
1576 && (asus->driver->quirks->wapf > 0)) {
1577 INIT_WORK(&asus->wlan_led_work, wlan_led_update);
1578
1579 asus->wlan_led.name = "asus::wlan";
1580 asus->wlan_led.brightness_set = wlan_led_set;
1581 if (!wlan_led_unknown_state(asus))
1582 asus->wlan_led.brightness_get = wlan_led_get;
1583 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
1584 asus->wlan_led.max_brightness = 1;
1585 asus->wlan_led.default_trigger = "asus-wlan";
1586
1587 rv = led_classdev_register(&asus->platform_device->dev,
1588 &asus->wlan_led);
1589 if (rv)
1590 goto error;
1591 }
1592
1593 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
1594 INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
1595
1596 asus->lightbar_led.name = "asus::lightbar";
1597 asus->lightbar_led.brightness_set = lightbar_led_set;
1598 asus->lightbar_led.brightness_get = lightbar_led_get;
1599 asus->lightbar_led.max_brightness = 1;
1600
1601 rv = led_classdev_register(&asus->platform_device->dev,
1602 &asus->lightbar_led);
1603 }
1604
1605 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MICMUTE_LED)) {
1606 asus->micmute_led.name = "platform::micmute";
1607 asus->micmute_led.max_brightness = 1;
1608 asus->micmute_led.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
1609 asus->micmute_led.brightness_set_blocking = micmute_led_set;
1610 asus->micmute_led.default_trigger = "audio-micmute";
1611
1612 rv = led_classdev_register(&asus->platform_device->dev,
1613 &asus->micmute_led);
1614 if (rv)
1615 goto error;
1616 }
1617
1618 error:
1619 if (rv)
1620 asus_wmi_led_exit(asus);
1621
1622 return rv;
1623 }
1624
1625 /* RF *************************************************************************/
1626
1627 /*
1628 * PCI hotplug (for wlan rfkill)
1629 */
asus_wlan_rfkill_blocked(struct asus_wmi * asus)1630 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
1631 {
1632 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1633
1634 if (result < 0)
1635 return false;
1636 return !result;
1637 }
1638
asus_rfkill_hotplug(struct asus_wmi * asus)1639 static void asus_rfkill_hotplug(struct asus_wmi *asus)
1640 {
1641 struct pci_dev *dev;
1642 struct pci_bus *bus;
1643 bool blocked;
1644 bool absent;
1645 u32 l;
1646
1647 mutex_lock(&asus->wmi_lock);
1648 blocked = asus_wlan_rfkill_blocked(asus);
1649 mutex_unlock(&asus->wmi_lock);
1650
1651 mutex_lock(&asus->hotplug_lock);
1652 pci_lock_rescan_remove();
1653
1654 if (asus->wlan.rfkill)
1655 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
1656
1657 if (asus->hotplug_slot.ops) {
1658 bus = pci_find_bus(0, 1);
1659 if (!bus) {
1660 pr_warn("Unable to find PCI bus 1?\n");
1661 goto out_unlock;
1662 }
1663
1664 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
1665 pr_err("Unable to read PCI config space?\n");
1666 goto out_unlock;
1667 }
1668 absent = (l == 0xffffffff);
1669
1670 if (blocked != absent) {
1671 pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
1672 blocked ? "blocked" : "unblocked",
1673 absent ? "absent" : "present");
1674 pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
1675 goto out_unlock;
1676 }
1677
1678 if (!blocked) {
1679 dev = pci_get_slot(bus, 0);
1680 if (dev) {
1681 /* Device already present */
1682 pci_dev_put(dev);
1683 goto out_unlock;
1684 }
1685 dev = pci_scan_single_device(bus, 0);
1686 if (dev) {
1687 pci_bus_assign_resources(bus);
1688 pci_bus_add_device(dev);
1689 }
1690 } else {
1691 dev = pci_get_slot(bus, 0);
1692 if (dev) {
1693 pci_stop_and_remove_bus_device(dev);
1694 pci_dev_put(dev);
1695 }
1696 }
1697 }
1698
1699 out_unlock:
1700 pci_unlock_rescan_remove();
1701 mutex_unlock(&asus->hotplug_lock);
1702 }
1703
asus_rfkill_notify(acpi_handle handle,u32 event,void * data)1704 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
1705 {
1706 struct asus_wmi *asus = data;
1707
1708 if (event != ACPI_NOTIFY_BUS_CHECK)
1709 return;
1710
1711 /*
1712 * We can't call directly asus_rfkill_hotplug because most
1713 * of the time WMBC is still being executed and not reetrant.
1714 * There is currently no way to tell ACPICA that we want this
1715 * method to be serialized, we schedule a asus_rfkill_hotplug
1716 * call later, in a safer context.
1717 */
1718 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
1719 }
1720
asus_register_rfkill_notifier(struct asus_wmi * asus,char * node)1721 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
1722 {
1723 acpi_status status;
1724 acpi_handle handle;
1725
1726 status = acpi_get_handle(NULL, node, &handle);
1727 if (ACPI_FAILURE(status))
1728 return -ENODEV;
1729
1730 status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1731 asus_rfkill_notify, asus);
1732 if (ACPI_FAILURE(status))
1733 pr_warn("Failed to register notify on %s\n", node);
1734
1735 return 0;
1736 }
1737
asus_unregister_rfkill_notifier(struct asus_wmi * asus,char * node)1738 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
1739 {
1740 acpi_status status = AE_OK;
1741 acpi_handle handle;
1742
1743 status = acpi_get_handle(NULL, node, &handle);
1744 if (ACPI_FAILURE(status))
1745 return;
1746
1747 status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1748 asus_rfkill_notify);
1749 if (ACPI_FAILURE(status))
1750 pr_err("Error removing rfkill notify handler %s\n", node);
1751 }
1752
asus_get_adapter_status(struct hotplug_slot * hotplug_slot,u8 * value)1753 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
1754 u8 *value)
1755 {
1756 struct asus_wmi *asus = container_of(hotplug_slot,
1757 struct asus_wmi, hotplug_slot);
1758 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1759
1760 if (result < 0)
1761 return result;
1762
1763 *value = !!result;
1764 return 0;
1765 }
1766
1767 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
1768 .get_adapter_status = asus_get_adapter_status,
1769 .get_power_status = asus_get_adapter_status,
1770 };
1771
asus_hotplug_work(struct work_struct * work)1772 static void asus_hotplug_work(struct work_struct *work)
1773 {
1774 struct asus_wmi *asus;
1775
1776 asus = container_of(work, struct asus_wmi, hotplug_work);
1777 asus_rfkill_hotplug(asus);
1778 }
1779
asus_setup_pci_hotplug(struct asus_wmi * asus)1780 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
1781 {
1782 int ret = -ENOMEM;
1783 struct pci_bus *bus = pci_find_bus(0, 1);
1784
1785 if (!bus) {
1786 pr_err("Unable to find wifi PCI bus\n");
1787 return -ENODEV;
1788 }
1789
1790 asus->hotplug_workqueue =
1791 create_singlethread_workqueue("hotplug_workqueue");
1792 if (!asus->hotplug_workqueue)
1793 goto error_workqueue;
1794
1795 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
1796
1797 asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
1798
1799 ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
1800 if (ret) {
1801 pr_err("Unable to register hotplug slot - %d\n", ret);
1802 goto error_register;
1803 }
1804
1805 return 0;
1806
1807 error_register:
1808 asus->hotplug_slot.ops = NULL;
1809 destroy_workqueue(asus->hotplug_workqueue);
1810 error_workqueue:
1811 return ret;
1812 }
1813
1814 /*
1815 * Rfkill devices
1816 */
asus_rfkill_set(void * data,bool blocked)1817 static int asus_rfkill_set(void *data, bool blocked)
1818 {
1819 struct asus_rfkill *priv = data;
1820 u32 ctrl_param = !blocked;
1821 u32 dev_id = priv->dev_id;
1822
1823 /*
1824 * If the user bit is set, BIOS can't set and record the wlan status,
1825 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
1826 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
1827 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
1828 * while setting the wlan status through WMI.
1829 * This is also the behavior that windows app will do.
1830 */
1831 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1832 priv->asus->driver->wlan_ctrl_by_user)
1833 dev_id = ASUS_WMI_DEVID_WLAN_LED;
1834
1835 return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
1836 }
1837
asus_rfkill_query(struct rfkill * rfkill,void * data)1838 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
1839 {
1840 struct asus_rfkill *priv = data;
1841 int result;
1842
1843 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
1844
1845 if (result < 0)
1846 return;
1847
1848 rfkill_set_sw_state(priv->rfkill, !result);
1849 }
1850
asus_rfkill_wlan_set(void * data,bool blocked)1851 static int asus_rfkill_wlan_set(void *data, bool blocked)
1852 {
1853 struct asus_rfkill *priv = data;
1854 struct asus_wmi *asus = priv->asus;
1855 int ret;
1856
1857 /*
1858 * This handler is enabled only if hotplug is enabled.
1859 * In this case, the asus_wmi_set_devstate() will
1860 * trigger a wmi notification and we need to wait
1861 * this call to finish before being able to call
1862 * any wmi method
1863 */
1864 mutex_lock(&asus->wmi_lock);
1865 ret = asus_rfkill_set(data, blocked);
1866 mutex_unlock(&asus->wmi_lock);
1867 return ret;
1868 }
1869
1870 static const struct rfkill_ops asus_rfkill_wlan_ops = {
1871 .set_block = asus_rfkill_wlan_set,
1872 .query = asus_rfkill_query,
1873 };
1874
1875 static const struct rfkill_ops asus_rfkill_ops = {
1876 .set_block = asus_rfkill_set,
1877 .query = asus_rfkill_query,
1878 };
1879
asus_new_rfkill(struct asus_wmi * asus,struct asus_rfkill * arfkill,const char * name,enum rfkill_type type,int dev_id)1880 static int asus_new_rfkill(struct asus_wmi *asus,
1881 struct asus_rfkill *arfkill,
1882 const char *name, enum rfkill_type type, int dev_id)
1883 {
1884 int result = asus_wmi_get_devstate_simple(asus, dev_id);
1885 struct rfkill **rfkill = &arfkill->rfkill;
1886
1887 if (result < 0)
1888 return result;
1889
1890 arfkill->dev_id = dev_id;
1891 arfkill->asus = asus;
1892
1893 if (dev_id == ASUS_WMI_DEVID_WLAN &&
1894 asus->driver->quirks->hotplug_wireless)
1895 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1896 &asus_rfkill_wlan_ops, arfkill);
1897 else
1898 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1899 &asus_rfkill_ops, arfkill);
1900
1901 if (!*rfkill)
1902 return -EINVAL;
1903
1904 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1905 (asus->driver->quirks->wapf > 0))
1906 rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
1907
1908 rfkill_init_sw_state(*rfkill, !result);
1909 result = rfkill_register(*rfkill);
1910 if (result) {
1911 rfkill_destroy(*rfkill);
1912 *rfkill = NULL;
1913 return result;
1914 }
1915 return 0;
1916 }
1917
asus_wmi_rfkill_exit(struct asus_wmi * asus)1918 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
1919 {
1920 if (asus->driver->wlan_ctrl_by_user && ashs_present())
1921 return;
1922
1923 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1924 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1925 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1926 if (asus->wlan.rfkill) {
1927 rfkill_unregister(asus->wlan.rfkill);
1928 rfkill_destroy(asus->wlan.rfkill);
1929 asus->wlan.rfkill = NULL;
1930 }
1931 /*
1932 * Refresh pci hotplug in case the rfkill state was changed after
1933 * asus_unregister_rfkill_notifier()
1934 */
1935 asus_rfkill_hotplug(asus);
1936 if (asus->hotplug_slot.ops)
1937 pci_hp_deregister(&asus->hotplug_slot);
1938 if (asus->hotplug_workqueue)
1939 destroy_workqueue(asus->hotplug_workqueue);
1940
1941 if (asus->bluetooth.rfkill) {
1942 rfkill_unregister(asus->bluetooth.rfkill);
1943 rfkill_destroy(asus->bluetooth.rfkill);
1944 asus->bluetooth.rfkill = NULL;
1945 }
1946 if (asus->wimax.rfkill) {
1947 rfkill_unregister(asus->wimax.rfkill);
1948 rfkill_destroy(asus->wimax.rfkill);
1949 asus->wimax.rfkill = NULL;
1950 }
1951 if (asus->wwan3g.rfkill) {
1952 rfkill_unregister(asus->wwan3g.rfkill);
1953 rfkill_destroy(asus->wwan3g.rfkill);
1954 asus->wwan3g.rfkill = NULL;
1955 }
1956 if (asus->gps.rfkill) {
1957 rfkill_unregister(asus->gps.rfkill);
1958 rfkill_destroy(asus->gps.rfkill);
1959 asus->gps.rfkill = NULL;
1960 }
1961 if (asus->uwb.rfkill) {
1962 rfkill_unregister(asus->uwb.rfkill);
1963 rfkill_destroy(asus->uwb.rfkill);
1964 asus->uwb.rfkill = NULL;
1965 }
1966 }
1967
asus_wmi_rfkill_init(struct asus_wmi * asus)1968 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1969 {
1970 int result = 0;
1971
1972 mutex_init(&asus->hotplug_lock);
1973 mutex_init(&asus->wmi_lock);
1974
1975 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1976 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1977
1978 if (result && result != -ENODEV)
1979 goto exit;
1980
1981 result = asus_new_rfkill(asus, &asus->bluetooth,
1982 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1983 ASUS_WMI_DEVID_BLUETOOTH);
1984
1985 if (result && result != -ENODEV)
1986 goto exit;
1987
1988 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1989 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1990
1991 if (result && result != -ENODEV)
1992 goto exit;
1993
1994 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1995 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1996
1997 if (result && result != -ENODEV)
1998 goto exit;
1999
2000 result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
2001 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
2002
2003 if (result && result != -ENODEV)
2004 goto exit;
2005
2006 result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
2007 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
2008
2009 if (result && result != -ENODEV)
2010 goto exit;
2011
2012 if (!asus->driver->quirks->hotplug_wireless)
2013 goto exit;
2014
2015 result = asus_setup_pci_hotplug(asus);
2016 /*
2017 * If we get -EBUSY then something else is handling the PCI hotplug -
2018 * don't fail in this case
2019 */
2020 if (result == -EBUSY)
2021 result = 0;
2022
2023 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
2024 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
2025 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
2026 /*
2027 * Refresh pci hotplug in case the rfkill state was changed during
2028 * setup.
2029 */
2030 asus_rfkill_hotplug(asus);
2031
2032 exit:
2033 if (result && result != -ENODEV)
2034 asus_wmi_rfkill_exit(asus);
2035
2036 if (result == -ENODEV)
2037 result = 0;
2038
2039 return result;
2040 }
2041
2042 /* Panel Overdrive ************************************************************/
panel_od_show(struct device * dev,struct device_attribute * attr,char * buf)2043 static ssize_t panel_od_show(struct device *dev,
2044 struct device_attribute *attr, char *buf)
2045 {
2046 struct asus_wmi *asus = dev_get_drvdata(dev);
2047 int result;
2048
2049 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_PANEL_OD);
2050 if (result < 0)
2051 return result;
2052
2053 return sysfs_emit(buf, "%d\n", result);
2054 }
2055
panel_od_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2056 static ssize_t panel_od_store(struct device *dev,
2057 struct device_attribute *attr,
2058 const char *buf, size_t count)
2059 {
2060 int result, err;
2061 u32 overdrive;
2062
2063 struct asus_wmi *asus = dev_get_drvdata(dev);
2064
2065 result = kstrtou32(buf, 10, &overdrive);
2066 if (result)
2067 return result;
2068
2069 if (overdrive > 1)
2070 return -EINVAL;
2071
2072 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PANEL_OD, overdrive, &result);
2073
2074 if (err) {
2075 pr_warn("Failed to set panel overdrive: %d\n", err);
2076 return err;
2077 }
2078
2079 if (result > 1) {
2080 pr_warn("Failed to set panel overdrive (result): 0x%x\n", result);
2081 return -EIO;
2082 }
2083
2084 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "panel_od");
2085
2086 return count;
2087 }
2088 static DEVICE_ATTR_RW(panel_od);
2089
2090 /* Mini-LED mode **************************************************************/
mini_led_mode_show(struct device * dev,struct device_attribute * attr,char * buf)2091 static ssize_t mini_led_mode_show(struct device *dev,
2092 struct device_attribute *attr, char *buf)
2093 {
2094 struct asus_wmi *asus = dev_get_drvdata(dev);
2095 int result;
2096
2097 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_MINI_LED_MODE);
2098 if (result < 0)
2099 return result;
2100
2101 return sysfs_emit(buf, "%d\n", result);
2102 }
2103
mini_led_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2104 static ssize_t mini_led_mode_store(struct device *dev,
2105 struct device_attribute *attr,
2106 const char *buf, size_t count)
2107 {
2108 int result, err;
2109 u32 mode;
2110
2111 struct asus_wmi *asus = dev_get_drvdata(dev);
2112
2113 result = kstrtou32(buf, 10, &mode);
2114 if (result)
2115 return result;
2116
2117 if (mode > 1)
2118 return -EINVAL;
2119
2120 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MINI_LED_MODE, mode, &result);
2121
2122 if (err) {
2123 pr_warn("Failed to set mini-LED: %d\n", err);
2124 return err;
2125 }
2126
2127 if (result > 1) {
2128 pr_warn("Failed to set mini-LED mode (result): 0x%x\n", result);
2129 return -EIO;
2130 }
2131
2132 sysfs_notify(&asus->platform_device->dev.kobj, NULL, "mini_led_mode");
2133
2134 return count;
2135 }
2136 static DEVICE_ATTR_RW(mini_led_mode);
2137
2138 /* Quirks *********************************************************************/
2139
asus_wmi_set_xusb2pr(struct asus_wmi * asus)2140 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
2141 {
2142 struct pci_dev *xhci_pdev;
2143 u32 orig_ports_available;
2144 u32 ports_available = asus->driver->quirks->xusb2pr;
2145
2146 xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
2147 PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
2148 NULL);
2149
2150 if (!xhci_pdev)
2151 return;
2152
2153 pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
2154 &orig_ports_available);
2155
2156 pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
2157 cpu_to_le32(ports_available));
2158
2159 pci_dev_put(xhci_pdev);
2160
2161 pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
2162 orig_ports_available, ports_available);
2163 }
2164
2165 /*
2166 * Some devices dont support or have borcken get_als method
2167 * but still support set method.
2168 */
asus_wmi_set_als(void)2169 static void asus_wmi_set_als(void)
2170 {
2171 asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
2172 }
2173
2174 /* Hwmon device ***************************************************************/
2175
asus_agfn_fan_speed_read(struct asus_wmi * asus,int fan,int * speed)2176 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
2177 int *speed)
2178 {
2179 struct agfn_fan_args args = {
2180 .agfn.len = sizeof(args),
2181 .agfn.mfun = ASUS_FAN_MFUN,
2182 .agfn.sfun = ASUS_FAN_SFUN_READ,
2183 .fan = fan,
2184 .speed = 0,
2185 };
2186 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2187 int status;
2188
2189 if (fan != 1)
2190 return -EINVAL;
2191
2192 status = asus_wmi_evaluate_method_agfn(input);
2193
2194 if (status || args.agfn.err)
2195 return -ENXIO;
2196
2197 if (speed)
2198 *speed = args.speed;
2199
2200 return 0;
2201 }
2202
asus_agfn_fan_speed_write(struct asus_wmi * asus,int fan,int * speed)2203 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
2204 int *speed)
2205 {
2206 struct agfn_fan_args args = {
2207 .agfn.len = sizeof(args),
2208 .agfn.mfun = ASUS_FAN_MFUN,
2209 .agfn.sfun = ASUS_FAN_SFUN_WRITE,
2210 .fan = fan,
2211 .speed = speed ? *speed : 0,
2212 };
2213 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2214 int status;
2215
2216 /* 1: for setting 1st fan's speed 0: setting auto mode */
2217 if (fan != 1 && fan != 0)
2218 return -EINVAL;
2219
2220 status = asus_wmi_evaluate_method_agfn(input);
2221
2222 if (status || args.agfn.err)
2223 return -ENXIO;
2224
2225 if (speed && fan == 1)
2226 asus->agfn_pwm = *speed;
2227
2228 return 0;
2229 }
2230
2231 /*
2232 * Check if we can read the speed of one fan. If true we assume we can also
2233 * control it.
2234 */
asus_wmi_has_agfn_fan(struct asus_wmi * asus)2235 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
2236 {
2237 int status;
2238 int speed;
2239 u32 value;
2240
2241 status = asus_agfn_fan_speed_read(asus, 1, &speed);
2242 if (status != 0)
2243 return false;
2244
2245 status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
2246 if (status != 0)
2247 return false;
2248
2249 /*
2250 * We need to find a better way, probably using sfun,
2251 * bits or spec ...
2252 * Currently we disable it if:
2253 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
2254 * - reverved bits are non-zero
2255 * - sfun and presence bit are not set
2256 */
2257 return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
2258 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
2259 }
2260
asus_fan_set_auto(struct asus_wmi * asus)2261 static int asus_fan_set_auto(struct asus_wmi *asus)
2262 {
2263 int status;
2264 u32 retval;
2265
2266 switch (asus->fan_type) {
2267 case FAN_TYPE_SPEC83:
2268 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
2269 0, &retval);
2270 if (status)
2271 return status;
2272
2273 if (retval != 1)
2274 return -EIO;
2275 break;
2276
2277 case FAN_TYPE_AGFN:
2278 status = asus_agfn_fan_speed_write(asus, 0, NULL);
2279 if (status)
2280 return -ENXIO;
2281 break;
2282
2283 default:
2284 return -ENXIO;
2285 }
2286
2287 /*
2288 * Modern models like the G713 also have GPU fan control (this is not AGFN)
2289 */
2290 if (asus->gpu_fan_type == FAN_TYPE_SPEC83) {
2291 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_FAN_CTRL,
2292 0, &retval);
2293 if (status)
2294 return status;
2295
2296 if (retval != 1)
2297 return -EIO;
2298 }
2299
2300 return 0;
2301 }
2302
pwm1_show(struct device * dev,struct device_attribute * attr,char * buf)2303 static ssize_t pwm1_show(struct device *dev,
2304 struct device_attribute *attr,
2305 char *buf)
2306 {
2307 struct asus_wmi *asus = dev_get_drvdata(dev);
2308 int err;
2309 int value;
2310
2311 /* If we already set a value then just return it */
2312 if (asus->agfn_pwm >= 0)
2313 return sprintf(buf, "%d\n", asus->agfn_pwm);
2314
2315 /*
2316 * If we haven't set already set a value through the AGFN interface,
2317 * we read a current value through the (now-deprecated) FAN_CTRL device.
2318 */
2319 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
2320 if (err < 0)
2321 return err;
2322
2323 value &= 0xFF;
2324
2325 if (value == 1) /* Low Speed */
2326 value = 85;
2327 else if (value == 2)
2328 value = 170;
2329 else if (value == 3)
2330 value = 255;
2331 else if (value) {
2332 pr_err("Unknown fan speed %#x\n", value);
2333 value = -1;
2334 }
2335
2336 return sysfs_emit(buf, "%d\n", value);
2337 }
2338
pwm1_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2339 static ssize_t pwm1_store(struct device *dev,
2340 struct device_attribute *attr,
2341 const char *buf, size_t count) {
2342 struct asus_wmi *asus = dev_get_drvdata(dev);
2343 int value;
2344 int state;
2345 int ret;
2346
2347 ret = kstrtouint(buf, 10, &value);
2348 if (ret)
2349 return ret;
2350
2351 value = clamp(value, 0, 255);
2352
2353 state = asus_agfn_fan_speed_write(asus, 1, &value);
2354 if (state)
2355 pr_warn("Setting fan speed failed: %d\n", state);
2356 else
2357 asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
2358
2359 return count;
2360 }
2361
fan1_input_show(struct device * dev,struct device_attribute * attr,char * buf)2362 static ssize_t fan1_input_show(struct device *dev,
2363 struct device_attribute *attr,
2364 char *buf)
2365 {
2366 struct asus_wmi *asus = dev_get_drvdata(dev);
2367 int value;
2368 int ret;
2369
2370 switch (asus->fan_type) {
2371 case FAN_TYPE_SPEC83:
2372 ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
2373 &value);
2374 if (ret < 0)
2375 return ret;
2376
2377 value &= 0xffff;
2378 break;
2379
2380 case FAN_TYPE_AGFN:
2381 /* no speed readable on manual mode */
2382 if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
2383 return -ENXIO;
2384
2385 ret = asus_agfn_fan_speed_read(asus, 1, &value);
2386 if (ret) {
2387 pr_warn("reading fan speed failed: %d\n", ret);
2388 return -ENXIO;
2389 }
2390 break;
2391
2392 default:
2393 return -ENXIO;
2394 }
2395
2396 return sysfs_emit(buf, "%d\n", value < 0 ? -1 : value * 100);
2397 }
2398
pwm1_enable_show(struct device * dev,struct device_attribute * attr,char * buf)2399 static ssize_t pwm1_enable_show(struct device *dev,
2400 struct device_attribute *attr,
2401 char *buf)
2402 {
2403 struct asus_wmi *asus = dev_get_drvdata(dev);
2404
2405 /*
2406 * Just read back the cached pwm mode.
2407 *
2408 * For the CPU_FAN device, the spec indicates that we should be
2409 * able to read the device status and consult bit 19 to see if we
2410 * are in Full On or Automatic mode. However, this does not work
2411 * in practice on X532FL at least (the bit is always 0) and there's
2412 * also nothing in the DSDT to indicate that this behaviour exists.
2413 */
2414 return sysfs_emit(buf, "%d\n", asus->fan_pwm_mode);
2415 }
2416
pwm1_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2417 static ssize_t pwm1_enable_store(struct device *dev,
2418 struct device_attribute *attr,
2419 const char *buf, size_t count)
2420 {
2421 struct asus_wmi *asus = dev_get_drvdata(dev);
2422 int status = 0;
2423 int state;
2424 int value;
2425 int ret;
2426 u32 retval;
2427
2428 ret = kstrtouint(buf, 10, &state);
2429 if (ret)
2430 return ret;
2431
2432 if (asus->fan_type == FAN_TYPE_SPEC83) {
2433 switch (state) { /* standard documented hwmon values */
2434 case ASUS_FAN_CTRL_FULLSPEED:
2435 value = 1;
2436 break;
2437 case ASUS_FAN_CTRL_AUTO:
2438 value = 0;
2439 break;
2440 default:
2441 return -EINVAL;
2442 }
2443
2444 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
2445 value, &retval);
2446 if (ret)
2447 return ret;
2448
2449 if (retval != 1)
2450 return -EIO;
2451 } else if (asus->fan_type == FAN_TYPE_AGFN) {
2452 switch (state) {
2453 case ASUS_FAN_CTRL_MANUAL:
2454 break;
2455
2456 case ASUS_FAN_CTRL_AUTO:
2457 status = asus_fan_set_auto(asus);
2458 if (status)
2459 return status;
2460 break;
2461
2462 default:
2463 return -EINVAL;
2464 }
2465 }
2466
2467 asus->fan_pwm_mode = state;
2468
2469 /* Must set to disabled if mode is toggled */
2470 if (asus->cpu_fan_curve_available)
2471 asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
2472 if (asus->gpu_fan_curve_available)
2473 asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
2474 if (asus->mid_fan_curve_available)
2475 asus->custom_fan_curves[FAN_CURVE_DEV_MID].enabled = false;
2476
2477 return count;
2478 }
2479
fan1_label_show(struct device * dev,struct device_attribute * attr,char * buf)2480 static ssize_t fan1_label_show(struct device *dev,
2481 struct device_attribute *attr,
2482 char *buf)
2483 {
2484 return sysfs_emit(buf, "%s\n", ASUS_FAN_DESC);
2485 }
2486
asus_hwmon_temp1(struct device * dev,struct device_attribute * attr,char * buf)2487 static ssize_t asus_hwmon_temp1(struct device *dev,
2488 struct device_attribute *attr,
2489 char *buf)
2490 {
2491 struct asus_wmi *asus = dev_get_drvdata(dev);
2492 u32 value;
2493 int err;
2494
2495 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
2496 if (err < 0)
2497 return err;
2498
2499 return sprintf(buf, "%ld\n",
2500 deci_kelvin_to_millicelsius(value & 0xFFFF));
2501 }
2502
2503 /* GPU fan on modern ROG laptops */
fan2_input_show(struct device * dev,struct device_attribute * attr,char * buf)2504 static ssize_t fan2_input_show(struct device *dev,
2505 struct device_attribute *attr,
2506 char *buf)
2507 {
2508 struct asus_wmi *asus = dev_get_drvdata(dev);
2509 int value;
2510 int ret;
2511
2512 ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_GPU_FAN_CTRL, &value);
2513 if (ret < 0)
2514 return ret;
2515
2516 value &= 0xffff;
2517
2518 return sysfs_emit(buf, "%d\n", value * 100);
2519 }
2520
fan2_label_show(struct device * dev,struct device_attribute * attr,char * buf)2521 static ssize_t fan2_label_show(struct device *dev,
2522 struct device_attribute *attr,
2523 char *buf)
2524 {
2525 return sysfs_emit(buf, "%s\n", ASUS_GPU_FAN_DESC);
2526 }
2527
2528 /* Middle/Center fan on modern ROG laptops */
fan3_input_show(struct device * dev,struct device_attribute * attr,char * buf)2529 static ssize_t fan3_input_show(struct device *dev,
2530 struct device_attribute *attr,
2531 char *buf)
2532 {
2533 struct asus_wmi *asus = dev_get_drvdata(dev);
2534 int value;
2535 int ret;
2536
2537 ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_MID_FAN_CTRL, &value);
2538 if (ret < 0)
2539 return ret;
2540
2541 value &= 0xffff;
2542
2543 return sysfs_emit(buf, "%d\n", value * 100);
2544 }
2545
fan3_label_show(struct device * dev,struct device_attribute * attr,char * buf)2546 static ssize_t fan3_label_show(struct device *dev,
2547 struct device_attribute *attr,
2548 char *buf)
2549 {
2550 return sysfs_emit(buf, "%s\n", ASUS_MID_FAN_DESC);
2551 }
2552
pwm2_enable_show(struct device * dev,struct device_attribute * attr,char * buf)2553 static ssize_t pwm2_enable_show(struct device *dev,
2554 struct device_attribute *attr,
2555 char *buf)
2556 {
2557 struct asus_wmi *asus = dev_get_drvdata(dev);
2558
2559 return sysfs_emit(buf, "%d\n", asus->gpu_fan_pwm_mode);
2560 }
2561
pwm2_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2562 static ssize_t pwm2_enable_store(struct device *dev,
2563 struct device_attribute *attr,
2564 const char *buf, size_t count)
2565 {
2566 struct asus_wmi *asus = dev_get_drvdata(dev);
2567 int state;
2568 int value;
2569 int ret;
2570 u32 retval;
2571
2572 ret = kstrtouint(buf, 10, &state);
2573 if (ret)
2574 return ret;
2575
2576 switch (state) { /* standard documented hwmon values */
2577 case ASUS_FAN_CTRL_FULLSPEED:
2578 value = 1;
2579 break;
2580 case ASUS_FAN_CTRL_AUTO:
2581 value = 0;
2582 break;
2583 default:
2584 return -EINVAL;
2585 }
2586
2587 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_FAN_CTRL,
2588 value, &retval);
2589 if (ret)
2590 return ret;
2591
2592 if (retval != 1)
2593 return -EIO;
2594
2595 asus->gpu_fan_pwm_mode = state;
2596 return count;
2597 }
2598
pwm3_enable_show(struct device * dev,struct device_attribute * attr,char * buf)2599 static ssize_t pwm3_enable_show(struct device *dev,
2600 struct device_attribute *attr,
2601 char *buf)
2602 {
2603 struct asus_wmi *asus = dev_get_drvdata(dev);
2604
2605 return sysfs_emit(buf, "%d\n", asus->mid_fan_pwm_mode);
2606 }
2607
pwm3_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2608 static ssize_t pwm3_enable_store(struct device *dev,
2609 struct device_attribute *attr,
2610 const char *buf, size_t count)
2611 {
2612 struct asus_wmi *asus = dev_get_drvdata(dev);
2613 int state;
2614 int value;
2615 int ret;
2616 u32 retval;
2617
2618 ret = kstrtouint(buf, 10, &state);
2619 if (ret)
2620 return ret;
2621
2622 switch (state) { /* standard documented hwmon values */
2623 case ASUS_FAN_CTRL_FULLSPEED:
2624 value = 1;
2625 break;
2626 case ASUS_FAN_CTRL_AUTO:
2627 value = 0;
2628 break;
2629 default:
2630 return -EINVAL;
2631 }
2632
2633 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_MID_FAN_CTRL,
2634 value, &retval);
2635 if (ret)
2636 return ret;
2637
2638 if (retval != 1)
2639 return -EIO;
2640
2641 asus->mid_fan_pwm_mode = state;
2642 return count;
2643 }
2644
2645 /* Fan1 */
2646 static DEVICE_ATTR_RW(pwm1);
2647 static DEVICE_ATTR_RW(pwm1_enable);
2648 static DEVICE_ATTR_RO(fan1_input);
2649 static DEVICE_ATTR_RO(fan1_label);
2650 /* Fan2 - GPU fan */
2651 static DEVICE_ATTR_RW(pwm2_enable);
2652 static DEVICE_ATTR_RO(fan2_input);
2653 static DEVICE_ATTR_RO(fan2_label);
2654 /* Fan3 - Middle/center fan */
2655 static DEVICE_ATTR_RW(pwm3_enable);
2656 static DEVICE_ATTR_RO(fan3_input);
2657 static DEVICE_ATTR_RO(fan3_label);
2658
2659 /* Temperature */
2660 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
2661
2662 static struct attribute *hwmon_attributes[] = {
2663 &dev_attr_pwm1.attr,
2664 &dev_attr_pwm1_enable.attr,
2665 &dev_attr_pwm2_enable.attr,
2666 &dev_attr_pwm3_enable.attr,
2667 &dev_attr_fan1_input.attr,
2668 &dev_attr_fan1_label.attr,
2669 &dev_attr_fan2_input.attr,
2670 &dev_attr_fan2_label.attr,
2671 &dev_attr_fan3_input.attr,
2672 &dev_attr_fan3_label.attr,
2673
2674 &dev_attr_temp1_input.attr,
2675 NULL
2676 };
2677
asus_hwmon_sysfs_is_visible(struct kobject * kobj,struct attribute * attr,int idx)2678 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
2679 struct attribute *attr, int idx)
2680 {
2681 struct device *dev = kobj_to_dev(kobj);
2682 struct asus_wmi *asus = dev_get_drvdata(dev->parent);
2683 u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
2684
2685 if (attr == &dev_attr_pwm1.attr) {
2686 if (asus->fan_type != FAN_TYPE_AGFN)
2687 return 0;
2688 } else if (attr == &dev_attr_fan1_input.attr
2689 || attr == &dev_attr_fan1_label.attr
2690 || attr == &dev_attr_pwm1_enable.attr) {
2691 if (asus->fan_type == FAN_TYPE_NONE)
2692 return 0;
2693 } else if (attr == &dev_attr_fan2_input.attr
2694 || attr == &dev_attr_fan2_label.attr
2695 || attr == &dev_attr_pwm2_enable.attr) {
2696 if (asus->gpu_fan_type == FAN_TYPE_NONE)
2697 return 0;
2698 } else if (attr == &dev_attr_fan3_input.attr
2699 || attr == &dev_attr_fan3_label.attr
2700 || attr == &dev_attr_pwm3_enable.attr) {
2701 if (asus->mid_fan_type == FAN_TYPE_NONE)
2702 return 0;
2703 } else if (attr == &dev_attr_temp1_input.attr) {
2704 int err = asus_wmi_get_devstate(asus,
2705 ASUS_WMI_DEVID_THERMAL_CTRL,
2706 &value);
2707
2708 if (err < 0)
2709 return 0; /* can't return negative here */
2710
2711 /*
2712 * If the temperature value in deci-Kelvin is near the absolute
2713 * zero temperature, something is clearly wrong
2714 */
2715 if (value == 0 || value == 1)
2716 return 0;
2717 }
2718
2719 return attr->mode;
2720 }
2721
2722 static const struct attribute_group hwmon_attribute_group = {
2723 .is_visible = asus_hwmon_sysfs_is_visible,
2724 .attrs = hwmon_attributes
2725 };
2726 __ATTRIBUTE_GROUPS(hwmon_attribute);
2727
asus_wmi_hwmon_init(struct asus_wmi * asus)2728 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
2729 {
2730 struct device *dev = &asus->platform_device->dev;
2731 struct device *hwmon;
2732
2733 hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
2734 hwmon_attribute_groups);
2735
2736 if (IS_ERR(hwmon)) {
2737 pr_err("Could not register asus hwmon device\n");
2738 return PTR_ERR(hwmon);
2739 }
2740 return 0;
2741 }
2742
asus_wmi_fan_init(struct asus_wmi * asus)2743 static int asus_wmi_fan_init(struct asus_wmi *asus)
2744 {
2745 asus->gpu_fan_type = FAN_TYPE_NONE;
2746 asus->mid_fan_type = FAN_TYPE_NONE;
2747 asus->fan_type = FAN_TYPE_NONE;
2748 asus->agfn_pwm = -1;
2749
2750 if (asus->driver->quirks->wmi_ignore_fan)
2751 asus->fan_type = FAN_TYPE_NONE;
2752 else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
2753 asus->fan_type = FAN_TYPE_SPEC83;
2754 else if (asus_wmi_has_agfn_fan(asus))
2755 asus->fan_type = FAN_TYPE_AGFN;
2756
2757 /* Modern models like G713 also have GPU fan control */
2758 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_FAN_CTRL))
2759 asus->gpu_fan_type = FAN_TYPE_SPEC83;
2760
2761 /* Some models also have a center/middle fan */
2762 if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MID_FAN_CTRL))
2763 asus->mid_fan_type = FAN_TYPE_SPEC83;
2764
2765 if (asus->fan_type == FAN_TYPE_NONE)
2766 return -ENODEV;
2767
2768 asus_fan_set_auto(asus);
2769 asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
2770 return 0;
2771 }
2772
2773 /* Fan mode *******************************************************************/
2774
fan_boost_mode_check_present(struct asus_wmi * asus)2775 static int fan_boost_mode_check_present(struct asus_wmi *asus)
2776 {
2777 u32 result;
2778 int err;
2779
2780 asus->fan_boost_mode_available = false;
2781
2782 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
2783 &result);
2784 if (err) {
2785 if (err == -ENODEV)
2786 return 0;
2787 else
2788 return err;
2789 }
2790
2791 if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
2792 (result & ASUS_FAN_BOOST_MODES_MASK)) {
2793 asus->fan_boost_mode_available = true;
2794 asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
2795 }
2796
2797 return 0;
2798 }
2799
fan_boost_mode_write(struct asus_wmi * asus)2800 static int fan_boost_mode_write(struct asus_wmi *asus)
2801 {
2802 u32 retval;
2803 u8 value;
2804 int err;
2805
2806 value = asus->fan_boost_mode;
2807
2808 pr_info("Set fan boost mode: %u\n", value);
2809 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
2810 &retval);
2811
2812 sysfs_notify(&asus->platform_device->dev.kobj, NULL,
2813 "fan_boost_mode");
2814
2815 if (err) {
2816 pr_warn("Failed to set fan boost mode: %d\n", err);
2817 return err;
2818 }
2819
2820 if (retval != 1) {
2821 pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
2822 retval);
2823 return -EIO;
2824 }
2825
2826 return 0;
2827 }
2828
fan_boost_mode_switch_next(struct asus_wmi * asus)2829 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
2830 {
2831 u8 mask = asus->fan_boost_mode_mask;
2832
2833 if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
2834 if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
2835 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
2836 else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2837 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2838 } else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2839 if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2840 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2841 else
2842 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2843 } else {
2844 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2845 }
2846
2847 return fan_boost_mode_write(asus);
2848 }
2849
fan_boost_mode_show(struct device * dev,struct device_attribute * attr,char * buf)2850 static ssize_t fan_boost_mode_show(struct device *dev,
2851 struct device_attribute *attr, char *buf)
2852 {
2853 struct asus_wmi *asus = dev_get_drvdata(dev);
2854
2855 return sysfs_emit(buf, "%d\n", asus->fan_boost_mode);
2856 }
2857
fan_boost_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2858 static ssize_t fan_boost_mode_store(struct device *dev,
2859 struct device_attribute *attr,
2860 const char *buf, size_t count)
2861 {
2862 struct asus_wmi *asus = dev_get_drvdata(dev);
2863 u8 mask = asus->fan_boost_mode_mask;
2864 u8 new_mode;
2865 int result;
2866
2867 result = kstrtou8(buf, 10, &new_mode);
2868 if (result < 0) {
2869 pr_warn("Trying to store invalid value\n");
2870 return result;
2871 }
2872
2873 if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2874 if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
2875 return -EINVAL;
2876 } else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
2877 if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
2878 return -EINVAL;
2879 } else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
2880 return -EINVAL;
2881 }
2882
2883 asus->fan_boost_mode = new_mode;
2884 fan_boost_mode_write(asus);
2885
2886 return count;
2887 }
2888
2889 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
2890 static DEVICE_ATTR_RW(fan_boost_mode);
2891
2892 /* Custom fan curves **********************************************************/
2893
fan_curve_copy_from_buf(struct fan_curve_data * data,u8 * buf)2894 static void fan_curve_copy_from_buf(struct fan_curve_data *data, u8 *buf)
2895 {
2896 int i;
2897
2898 for (i = 0; i < FAN_CURVE_POINTS; i++) {
2899 data->temps[i] = buf[i];
2900 }
2901
2902 for (i = 0; i < FAN_CURVE_POINTS; i++) {
2903 data->percents[i] =
2904 255 * buf[i + FAN_CURVE_POINTS] / 100;
2905 }
2906 }
2907
fan_curve_get_factory_default(struct asus_wmi * asus,u32 fan_dev)2908 static int fan_curve_get_factory_default(struct asus_wmi *asus, u32 fan_dev)
2909 {
2910 struct fan_curve_data *curves;
2911 u8 buf[FAN_CURVE_BUF_LEN];
2912 int err, fan_idx;
2913 u8 mode = 0;
2914
2915 if (asus->throttle_thermal_policy_available)
2916 mode = asus->throttle_thermal_policy_mode;
2917 /* DEVID_<C/G>PU_FAN_CURVE is switched for OVERBOOST vs SILENT */
2918 if (mode == 2)
2919 mode = 1;
2920 else if (mode == 1)
2921 mode = 2;
2922
2923 err = asus_wmi_evaluate_method_buf(asus->dsts_id, fan_dev, mode, buf,
2924 FAN_CURVE_BUF_LEN);
2925 if (err) {
2926 pr_warn("%s (0x%08x) failed: %d\n", __func__, fan_dev, err);
2927 return err;
2928 }
2929
2930 fan_idx = FAN_CURVE_DEV_CPU;
2931 if (fan_dev == ASUS_WMI_DEVID_GPU_FAN_CURVE)
2932 fan_idx = FAN_CURVE_DEV_GPU;
2933
2934 if (fan_dev == ASUS_WMI_DEVID_MID_FAN_CURVE)
2935 fan_idx = FAN_CURVE_DEV_MID;
2936
2937 curves = &asus->custom_fan_curves[fan_idx];
2938 curves->device_id = fan_dev;
2939
2940 fan_curve_copy_from_buf(curves, buf);
2941 return 0;
2942 }
2943
2944 /* Check if capability exists, and populate defaults */
fan_curve_check_present(struct asus_wmi * asus,bool * available,u32 fan_dev)2945 static int fan_curve_check_present(struct asus_wmi *asus, bool *available,
2946 u32 fan_dev)
2947 {
2948 int err;
2949
2950 *available = false;
2951
2952 if (asus->fan_type == FAN_TYPE_NONE)
2953 return 0;
2954
2955 err = fan_curve_get_factory_default(asus, fan_dev);
2956 if (err) {
2957 return 0;
2958 }
2959
2960 *available = true;
2961 return 0;
2962 }
2963
2964 /* Determine which fan the attribute is for if SENSOR_ATTR */
fan_curve_attr_select(struct asus_wmi * asus,struct device_attribute * attr)2965 static struct fan_curve_data *fan_curve_attr_select(struct asus_wmi *asus,
2966 struct device_attribute *attr)
2967 {
2968 int index = to_sensor_dev_attr(attr)->index;
2969
2970 return &asus->custom_fan_curves[index];
2971 }
2972
2973 /* Determine which fan the attribute is for if SENSOR_ATTR_2 */
fan_curve_attr_2_select(struct asus_wmi * asus,struct device_attribute * attr)2974 static struct fan_curve_data *fan_curve_attr_2_select(struct asus_wmi *asus,
2975 struct device_attribute *attr)
2976 {
2977 int nr = to_sensor_dev_attr_2(attr)->nr;
2978
2979 return &asus->custom_fan_curves[nr & ~FAN_CURVE_PWM_MASK];
2980 }
2981
fan_curve_show(struct device * dev,struct device_attribute * attr,char * buf)2982 static ssize_t fan_curve_show(struct device *dev,
2983 struct device_attribute *attr, char *buf)
2984 {
2985 struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
2986 struct asus_wmi *asus = dev_get_drvdata(dev);
2987 struct fan_curve_data *data;
2988 int value, pwm, index;
2989
2990 data = fan_curve_attr_2_select(asus, attr);
2991 pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
2992 index = dev_attr->index;
2993
2994 if (pwm)
2995 value = data->percents[index];
2996 else
2997 value = data->temps[index];
2998
2999 return sysfs_emit(buf, "%d\n", value);
3000 }
3001
3002 /*
3003 * "fan_dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE.
3004 */
fan_curve_write(struct asus_wmi * asus,struct fan_curve_data * data)3005 static int fan_curve_write(struct asus_wmi *asus,
3006 struct fan_curve_data *data)
3007 {
3008 u32 arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0;
3009 u8 *percents = data->percents;
3010 u8 *temps = data->temps;
3011 int ret, i, shift = 0;
3012
3013 if (!data->enabled)
3014 return 0;
3015
3016 for (i = 0; i < FAN_CURVE_POINTS / 2; i++) {
3017 arg1 += (temps[i]) << shift;
3018 arg2 += (temps[i + 4]) << shift;
3019 /* Scale to percentage for device */
3020 arg3 += (100 * percents[i] / 255) << shift;
3021 arg4 += (100 * percents[i + 4] / 255) << shift;
3022 shift += 8;
3023 }
3024
3025 return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS,
3026 data->device_id,
3027 arg1, arg2, arg3, arg4, &ret);
3028 }
3029
fan_curve_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3030 static ssize_t fan_curve_store(struct device *dev,
3031 struct device_attribute *attr, const char *buf,
3032 size_t count)
3033 {
3034 struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
3035 struct asus_wmi *asus = dev_get_drvdata(dev);
3036 struct fan_curve_data *data;
3037 int err, pwm, index;
3038 u8 value;
3039
3040 data = fan_curve_attr_2_select(asus, attr);
3041 pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
3042 index = dev_attr->index;
3043
3044 err = kstrtou8(buf, 10, &value);
3045 if (err < 0)
3046 return err;
3047
3048 if (pwm)
3049 data->percents[index] = value;
3050 else
3051 data->temps[index] = value;
3052
3053 /*
3054 * Mark as disabled so the user has to explicitly enable to apply a
3055 * changed fan curve. This prevents potential lockups from writing out
3056 * many changes as one-write-per-change.
3057 */
3058 data->enabled = false;
3059
3060 return count;
3061 }
3062
fan_curve_enable_show(struct device * dev,struct device_attribute * attr,char * buf)3063 static ssize_t fan_curve_enable_show(struct device *dev,
3064 struct device_attribute *attr, char *buf)
3065 {
3066 struct asus_wmi *asus = dev_get_drvdata(dev);
3067 struct fan_curve_data *data;
3068 int out = 2;
3069
3070 data = fan_curve_attr_select(asus, attr);
3071
3072 if (data->enabled)
3073 out = 1;
3074
3075 return sysfs_emit(buf, "%d\n", out);
3076 }
3077
fan_curve_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3078 static ssize_t fan_curve_enable_store(struct device *dev,
3079 struct device_attribute *attr,
3080 const char *buf, size_t count)
3081 {
3082 struct asus_wmi *asus = dev_get_drvdata(dev);
3083 struct fan_curve_data *data;
3084 int value, err;
3085
3086 data = fan_curve_attr_select(asus, attr);
3087
3088 err = kstrtoint(buf, 10, &value);
3089 if (err < 0)
3090 return err;
3091
3092 switch (value) {
3093 case 1:
3094 data->enabled = true;
3095 break;
3096 case 2:
3097 data->enabled = false;
3098 break;
3099 /*
3100 * Auto + reset the fan curve data to defaults. Make it an explicit
3101 * option so that users don't accidentally overwrite a set fan curve.
3102 */
3103 case 3:
3104 err = fan_curve_get_factory_default(asus, data->device_id);
3105 if (err)
3106 return err;
3107 data->enabled = false;
3108 break;
3109 default:
3110 return -EINVAL;
3111 }
3112
3113 if (data->enabled) {
3114 err = fan_curve_write(asus, data);
3115 if (err)
3116 return err;
3117 } else {
3118 /*
3119 * For machines with throttle this is the only way to reset fans
3120 * to default mode of operation (does not erase curve data).
3121 */
3122 if (asus->throttle_thermal_policy_available) {
3123 err = throttle_thermal_policy_write(asus);
3124 if (err)
3125 return err;
3126 /* Similar is true for laptops with this fan */
3127 } else if (asus->fan_type == FAN_TYPE_SPEC83) {
3128 err = asus_fan_set_auto(asus);
3129 if (err)
3130 return err;
3131 } else {
3132 /* Safeguard against fautly ACPI tables */
3133 err = fan_curve_get_factory_default(asus, data->device_id);
3134 if (err)
3135 return err;
3136 err = fan_curve_write(asus, data);
3137 if (err)
3138 return err;
3139 }
3140 }
3141 return count;
3142 }
3143
3144 /* CPU */
3145 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, FAN_CURVE_DEV_CPU);
3146 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve,
3147 FAN_CURVE_DEV_CPU, 0);
3148 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve,
3149 FAN_CURVE_DEV_CPU, 1);
3150 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve,
3151 FAN_CURVE_DEV_CPU, 2);
3152 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve,
3153 FAN_CURVE_DEV_CPU, 3);
3154 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve,
3155 FAN_CURVE_DEV_CPU, 4);
3156 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve,
3157 FAN_CURVE_DEV_CPU, 5);
3158 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve,
3159 FAN_CURVE_DEV_CPU, 6);
3160 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve,
3161 FAN_CURVE_DEV_CPU, 7);
3162
3163 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve,
3164 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0);
3165 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve,
3166 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1);
3167 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve,
3168 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2);
3169 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve,
3170 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3);
3171 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve,
3172 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4);
3173 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve,
3174 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5);
3175 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve,
3176 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6);
3177 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve,
3178 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7);
3179
3180 /* GPU */
3181 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, FAN_CURVE_DEV_GPU);
3182 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve,
3183 FAN_CURVE_DEV_GPU, 0);
3184 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve,
3185 FAN_CURVE_DEV_GPU, 1);
3186 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve,
3187 FAN_CURVE_DEV_GPU, 2);
3188 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve,
3189 FAN_CURVE_DEV_GPU, 3);
3190 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve,
3191 FAN_CURVE_DEV_GPU, 4);
3192 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve,
3193 FAN_CURVE_DEV_GPU, 5);
3194 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve,
3195 FAN_CURVE_DEV_GPU, 6);
3196 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve,
3197 FAN_CURVE_DEV_GPU, 7);
3198
3199 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve,
3200 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0);
3201 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve,
3202 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1);
3203 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve,
3204 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2);
3205 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve,
3206 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3);
3207 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve,
3208 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4);
3209 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve,
3210 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5);
3211 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve,
3212 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6);
3213 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve,
3214 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7);
3215
3216 /* MID */
3217 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, fan_curve_enable, FAN_CURVE_DEV_MID);
3218 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_temp, fan_curve,
3219 FAN_CURVE_DEV_MID, 0);
3220 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_temp, fan_curve,
3221 FAN_CURVE_DEV_MID, 1);
3222 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_temp, fan_curve,
3223 FAN_CURVE_DEV_MID, 2);
3224 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_temp, fan_curve,
3225 FAN_CURVE_DEV_MID, 3);
3226 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_temp, fan_curve,
3227 FAN_CURVE_DEV_MID, 4);
3228 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point6_temp, fan_curve,
3229 FAN_CURVE_DEV_MID, 5);
3230 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point7_temp, fan_curve,
3231 FAN_CURVE_DEV_MID, 6);
3232 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point8_temp, fan_curve,
3233 FAN_CURVE_DEV_MID, 7);
3234
3235 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, fan_curve,
3236 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 0);
3237 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, fan_curve,
3238 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 1);
3239 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point3_pwm, fan_curve,
3240 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 2);
3241 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point4_pwm, fan_curve,
3242 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 3);
3243 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point5_pwm, fan_curve,
3244 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 4);
3245 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point6_pwm, fan_curve,
3246 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 5);
3247 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point7_pwm, fan_curve,
3248 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 6);
3249 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point8_pwm, fan_curve,
3250 FAN_CURVE_DEV_MID | FAN_CURVE_PWM_MASK, 7);
3251
3252 static struct attribute *asus_fan_curve_attr[] = {
3253 /* CPU */
3254 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
3255 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
3256 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
3257 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
3258 &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
3259 &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
3260 &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
3261 &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
3262 &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
3263 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
3264 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
3265 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
3266 &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
3267 &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
3268 &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
3269 &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
3270 &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
3271 /* GPU */
3272 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
3273 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
3274 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
3275 &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
3276 &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr,
3277 &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr,
3278 &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr,
3279 &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr,
3280 &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr,
3281 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
3282 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
3283 &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr,
3284 &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr,
3285 &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr,
3286 &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr,
3287 &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr,
3288 &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr,
3289 /* MID */
3290 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
3291 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
3292 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
3293 &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
3294 &sensor_dev_attr_pwm3_auto_point4_temp.dev_attr.attr,
3295 &sensor_dev_attr_pwm3_auto_point5_temp.dev_attr.attr,
3296 &sensor_dev_attr_pwm3_auto_point6_temp.dev_attr.attr,
3297 &sensor_dev_attr_pwm3_auto_point7_temp.dev_attr.attr,
3298 &sensor_dev_attr_pwm3_auto_point8_temp.dev_attr.attr,
3299 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
3300 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
3301 &sensor_dev_attr_pwm3_auto_point3_pwm.dev_attr.attr,
3302 &sensor_dev_attr_pwm3_auto_point4_pwm.dev_attr.attr,
3303 &sensor_dev_attr_pwm3_auto_point5_pwm.dev_attr.attr,
3304 &sensor_dev_attr_pwm3_auto_point6_pwm.dev_attr.attr,
3305 &sensor_dev_attr_pwm3_auto_point7_pwm.dev_attr.attr,
3306 &sensor_dev_attr_pwm3_auto_point8_pwm.dev_attr.attr,
3307 NULL
3308 };
3309
asus_fan_curve_is_visible(struct kobject * kobj,struct attribute * attr,int idx)3310 static umode_t asus_fan_curve_is_visible(struct kobject *kobj,
3311 struct attribute *attr, int idx)
3312 {
3313 struct device *dev = kobj_to_dev(kobj);
3314 struct asus_wmi *asus = dev_get_drvdata(dev->parent);
3315
3316 /*
3317 * Check the char instead of casting attr as there are two attr types
3318 * involved here (attr1 and attr2)
3319 */
3320 if (asus->cpu_fan_curve_available && attr->name[3] == '1')
3321 return 0644;
3322
3323 if (asus->gpu_fan_curve_available && attr->name[3] == '2')
3324 return 0644;
3325
3326 if (asus->mid_fan_curve_available && attr->name[3] == '3')
3327 return 0644;
3328
3329 return 0;
3330 }
3331
3332 static const struct attribute_group asus_fan_curve_attr_group = {
3333 .is_visible = asus_fan_curve_is_visible,
3334 .attrs = asus_fan_curve_attr,
3335 };
3336 __ATTRIBUTE_GROUPS(asus_fan_curve_attr);
3337
3338 /*
3339 * Must be initialised after throttle_thermal_policy_check_present() as
3340 * we check the status of throttle_thermal_policy_available during init.
3341 */
asus_wmi_custom_fan_curve_init(struct asus_wmi * asus)3342 static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus)
3343 {
3344 struct device *dev = &asus->platform_device->dev;
3345 struct device *hwmon;
3346 int err;
3347
3348 err = fan_curve_check_present(asus, &asus->cpu_fan_curve_available,
3349 ASUS_WMI_DEVID_CPU_FAN_CURVE);
3350 if (err)
3351 return err;
3352
3353 err = fan_curve_check_present(asus, &asus->gpu_fan_curve_available,
3354 ASUS_WMI_DEVID_GPU_FAN_CURVE);
3355 if (err)
3356 return err;
3357
3358 err = fan_curve_check_present(asus, &asus->mid_fan_curve_available,
3359 ASUS_WMI_DEVID_MID_FAN_CURVE);
3360 if (err)
3361 return err;
3362
3363 if (!asus->cpu_fan_curve_available
3364 && !asus->gpu_fan_curve_available
3365 && !asus->mid_fan_curve_available)
3366 return 0;
3367
3368 hwmon = devm_hwmon_device_register_with_groups(
3369 dev, "asus_custom_fan_curve", asus, asus_fan_curve_attr_groups);
3370
3371 if (IS_ERR(hwmon)) {
3372 dev_err(dev,
3373 "Could not register asus_custom_fan_curve device\n");
3374 return PTR_ERR(hwmon);
3375 }
3376
3377 return 0;
3378 }
3379
3380 /* Throttle thermal policy ****************************************************/
3381
throttle_thermal_policy_check_present(struct asus_wmi * asus)3382 static int throttle_thermal_policy_check_present(struct asus_wmi *asus)
3383 {
3384 u32 result;
3385 int err;
3386
3387 asus->throttle_thermal_policy_available = false;
3388
3389 err = asus_wmi_get_devstate(asus,
3390 ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
3391 &result);
3392 if (err) {
3393 if (err == -ENODEV)
3394 return 0;
3395 return err;
3396 }
3397
3398 if (result & ASUS_WMI_DSTS_PRESENCE_BIT)
3399 asus->throttle_thermal_policy_available = true;
3400
3401 return 0;
3402 }
3403
throttle_thermal_policy_write(struct asus_wmi * asus)3404 static int throttle_thermal_policy_write(struct asus_wmi *asus)
3405 {
3406 int err;
3407 u8 value;
3408 u32 retval;
3409
3410 value = asus->throttle_thermal_policy_mode;
3411
3412 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
3413 value, &retval);
3414
3415 sysfs_notify(&asus->platform_device->dev.kobj, NULL,
3416 "throttle_thermal_policy");
3417
3418 if (err) {
3419 pr_warn("Failed to set throttle thermal policy: %d\n", err);
3420 return err;
3421 }
3422
3423 if (retval != 1) {
3424 pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
3425 retval);
3426 return -EIO;
3427 }
3428
3429 /* Must set to disabled if mode is toggled */
3430 if (asus->cpu_fan_curve_available)
3431 asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
3432 if (asus->gpu_fan_curve_available)
3433 asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
3434 if (asus->mid_fan_curve_available)
3435 asus->custom_fan_curves[FAN_CURVE_DEV_MID].enabled = false;
3436
3437 return 0;
3438 }
3439
throttle_thermal_policy_set_default(struct asus_wmi * asus)3440 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
3441 {
3442 if (!asus->throttle_thermal_policy_available)
3443 return 0;
3444
3445 asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3446 return throttle_thermal_policy_write(asus);
3447 }
3448
throttle_thermal_policy_switch_next(struct asus_wmi * asus)3449 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
3450 {
3451 u8 new_mode = asus->throttle_thermal_policy_mode + 1;
3452 int err;
3453
3454 if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
3455 new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3456
3457 asus->throttle_thermal_policy_mode = new_mode;
3458 err = throttle_thermal_policy_write(asus);
3459 if (err)
3460 return err;
3461
3462 /*
3463 * Ensure that platform_profile updates userspace with the change to ensure
3464 * that platform_profile and throttle_thermal_policy_mode are in sync.
3465 */
3466 platform_profile_notify();
3467
3468 return 0;
3469 }
3470
throttle_thermal_policy_show(struct device * dev,struct device_attribute * attr,char * buf)3471 static ssize_t throttle_thermal_policy_show(struct device *dev,
3472 struct device_attribute *attr, char *buf)
3473 {
3474 struct asus_wmi *asus = dev_get_drvdata(dev);
3475 u8 mode = asus->throttle_thermal_policy_mode;
3476
3477 return sysfs_emit(buf, "%d\n", mode);
3478 }
3479
throttle_thermal_policy_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3480 static ssize_t throttle_thermal_policy_store(struct device *dev,
3481 struct device_attribute *attr,
3482 const char *buf, size_t count)
3483 {
3484 struct asus_wmi *asus = dev_get_drvdata(dev);
3485 u8 new_mode;
3486 int result;
3487 int err;
3488
3489 result = kstrtou8(buf, 10, &new_mode);
3490 if (result < 0)
3491 return result;
3492
3493 if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
3494 return -EINVAL;
3495
3496 asus->throttle_thermal_policy_mode = new_mode;
3497 err = throttle_thermal_policy_write(asus);
3498 if (err)
3499 return err;
3500
3501 /*
3502 * Ensure that platform_profile updates userspace with the change to ensure
3503 * that platform_profile and throttle_thermal_policy_mode are in sync.
3504 */
3505 platform_profile_notify();
3506
3507 return count;
3508 }
3509
3510 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
3511 static DEVICE_ATTR_RW(throttle_thermal_policy);
3512
3513 /* Platform profile ***********************************************************/
asus_wmi_platform_profile_get(struct platform_profile_handler * pprof,enum platform_profile_option * profile)3514 static int asus_wmi_platform_profile_get(struct platform_profile_handler *pprof,
3515 enum platform_profile_option *profile)
3516 {
3517 struct asus_wmi *asus;
3518 int tp;
3519
3520 asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
3521
3522 tp = asus->throttle_thermal_policy_mode;
3523
3524 switch (tp) {
3525 case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT:
3526 *profile = PLATFORM_PROFILE_BALANCED;
3527 break;
3528 case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST:
3529 *profile = PLATFORM_PROFILE_PERFORMANCE;
3530 break;
3531 case ASUS_THROTTLE_THERMAL_POLICY_SILENT:
3532 *profile = PLATFORM_PROFILE_QUIET;
3533 break;
3534 default:
3535 return -EINVAL;
3536 }
3537
3538 return 0;
3539 }
3540
asus_wmi_platform_profile_set(struct platform_profile_handler * pprof,enum platform_profile_option profile)3541 static int asus_wmi_platform_profile_set(struct platform_profile_handler *pprof,
3542 enum platform_profile_option profile)
3543 {
3544 struct asus_wmi *asus;
3545 int tp;
3546
3547 asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
3548
3549 switch (profile) {
3550 case PLATFORM_PROFILE_PERFORMANCE:
3551 tp = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST;
3552 break;
3553 case PLATFORM_PROFILE_BALANCED:
3554 tp = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
3555 break;
3556 case PLATFORM_PROFILE_QUIET:
3557 tp = ASUS_THROTTLE_THERMAL_POLICY_SILENT;
3558 break;
3559 default:
3560 return -EOPNOTSUPP;
3561 }
3562
3563 asus->throttle_thermal_policy_mode = tp;
3564 return throttle_thermal_policy_write(asus);
3565 }
3566
platform_profile_setup(struct asus_wmi * asus)3567 static int platform_profile_setup(struct asus_wmi *asus)
3568 {
3569 struct device *dev = &asus->platform_device->dev;
3570 int err;
3571
3572 /*
3573 * Not an error if a component platform_profile relies on is unavailable
3574 * so early return, skipping the setup of platform_profile.
3575 */
3576 if (!asus->throttle_thermal_policy_available)
3577 return 0;
3578
3579 dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n");
3580
3581 asus->platform_profile_handler.profile_get = asus_wmi_platform_profile_get;
3582 asus->platform_profile_handler.profile_set = asus_wmi_platform_profile_set;
3583
3584 set_bit(PLATFORM_PROFILE_QUIET, asus->platform_profile_handler.choices);
3585 set_bit(PLATFORM_PROFILE_BALANCED,
3586 asus->platform_profile_handler.choices);
3587 set_bit(PLATFORM_PROFILE_PERFORMANCE,
3588 asus->platform_profile_handler.choices);
3589
3590 err = platform_profile_register(&asus->platform_profile_handler);
3591 if (err)
3592 return err;
3593
3594 asus->platform_profile_support = true;
3595 return 0;
3596 }
3597
3598 /* Backlight ******************************************************************/
3599
read_backlight_power(struct asus_wmi * asus)3600 static int read_backlight_power(struct asus_wmi *asus)
3601 {
3602 int ret;
3603
3604 if (asus->driver->quirks->store_backlight_power)
3605 ret = !asus->driver->panel_power;
3606 else
3607 ret = asus_wmi_get_devstate_simple(asus,
3608 ASUS_WMI_DEVID_BACKLIGHT);
3609
3610 if (ret < 0)
3611 return ret;
3612
3613 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
3614 }
3615
read_brightness_max(struct asus_wmi * asus)3616 static int read_brightness_max(struct asus_wmi *asus)
3617 {
3618 u32 retval;
3619 int err;
3620
3621 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
3622 if (err < 0)
3623 return err;
3624
3625 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
3626 retval >>= 8;
3627
3628 if (!retval)
3629 return -ENODEV;
3630
3631 return retval;
3632 }
3633
read_brightness(struct backlight_device * bd)3634 static int read_brightness(struct backlight_device *bd)
3635 {
3636 struct asus_wmi *asus = bl_get_data(bd);
3637 u32 retval;
3638 int err;
3639
3640 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
3641 if (err < 0)
3642 return err;
3643
3644 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
3645 }
3646
get_scalar_command(struct backlight_device * bd)3647 static u32 get_scalar_command(struct backlight_device *bd)
3648 {
3649 struct asus_wmi *asus = bl_get_data(bd);
3650 u32 ctrl_param = 0;
3651
3652 if ((asus->driver->brightness < bd->props.brightness) ||
3653 bd->props.brightness == bd->props.max_brightness)
3654 ctrl_param = 0x00008001;
3655 else if ((asus->driver->brightness > bd->props.brightness) ||
3656 bd->props.brightness == 0)
3657 ctrl_param = 0x00008000;
3658
3659 asus->driver->brightness = bd->props.brightness;
3660
3661 return ctrl_param;
3662 }
3663
update_bl_status(struct backlight_device * bd)3664 static int update_bl_status(struct backlight_device *bd)
3665 {
3666 struct asus_wmi *asus = bl_get_data(bd);
3667 u32 ctrl_param;
3668 int power, err = 0;
3669
3670 power = read_backlight_power(asus);
3671 if (power != -ENODEV && bd->props.power != power) {
3672 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
3673 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
3674 ctrl_param, NULL);
3675 if (asus->driver->quirks->store_backlight_power)
3676 asus->driver->panel_power = bd->props.power;
3677
3678 /* When using scalar brightness, updating the brightness
3679 * will mess with the backlight power */
3680 if (asus->driver->quirks->scalar_panel_brightness)
3681 return err;
3682 }
3683
3684 if (asus->driver->quirks->scalar_panel_brightness)
3685 ctrl_param = get_scalar_command(bd);
3686 else
3687 ctrl_param = bd->props.brightness;
3688
3689 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
3690 ctrl_param, NULL);
3691
3692 return err;
3693 }
3694
3695 static const struct backlight_ops asus_wmi_bl_ops = {
3696 .get_brightness = read_brightness,
3697 .update_status = update_bl_status,
3698 };
3699
asus_wmi_backlight_notify(struct asus_wmi * asus,int code)3700 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
3701 {
3702 struct backlight_device *bd = asus->backlight_device;
3703 int old = bd->props.brightness;
3704 int new = old;
3705
3706 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
3707 new = code - NOTIFY_BRNUP_MIN + 1;
3708 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
3709 new = code - NOTIFY_BRNDOWN_MIN;
3710
3711 bd->props.brightness = new;
3712 backlight_update_status(bd);
3713 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
3714
3715 return old;
3716 }
3717
asus_wmi_backlight_init(struct asus_wmi * asus)3718 static int asus_wmi_backlight_init(struct asus_wmi *asus)
3719 {
3720 struct backlight_device *bd;
3721 struct backlight_properties props;
3722 int max;
3723 int power;
3724
3725 max = read_brightness_max(asus);
3726 if (max < 0)
3727 return max;
3728
3729 power = read_backlight_power(asus);
3730 if (power == -ENODEV)
3731 power = FB_BLANK_UNBLANK;
3732 else if (power < 0)
3733 return power;
3734
3735 memset(&props, 0, sizeof(struct backlight_properties));
3736 props.type = BACKLIGHT_PLATFORM;
3737 props.max_brightness = max;
3738 bd = backlight_device_register(asus->driver->name,
3739 &asus->platform_device->dev, asus,
3740 &asus_wmi_bl_ops, &props);
3741 if (IS_ERR(bd)) {
3742 pr_err("Could not register backlight device\n");
3743 return PTR_ERR(bd);
3744 }
3745
3746 asus->backlight_device = bd;
3747
3748 if (asus->driver->quirks->store_backlight_power)
3749 asus->driver->panel_power = power;
3750
3751 bd->props.brightness = read_brightness(bd);
3752 bd->props.power = power;
3753 backlight_update_status(bd);
3754
3755 asus->driver->brightness = bd->props.brightness;
3756
3757 return 0;
3758 }
3759
asus_wmi_backlight_exit(struct asus_wmi * asus)3760 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
3761 {
3762 backlight_device_unregister(asus->backlight_device);
3763
3764 asus->backlight_device = NULL;
3765 }
3766
is_display_toggle(int code)3767 static int is_display_toggle(int code)
3768 {
3769 /* display toggle keys */
3770 if ((code >= 0x61 && code <= 0x67) ||
3771 (code >= 0x8c && code <= 0x93) ||
3772 (code >= 0xa0 && code <= 0xa7) ||
3773 (code >= 0xd0 && code <= 0xd5))
3774 return 1;
3775
3776 return 0;
3777 }
3778
3779 /* Fn-lock ********************************************************************/
3780
asus_wmi_has_fnlock_key(struct asus_wmi * asus)3781 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
3782 {
3783 u32 result;
3784
3785 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
3786
3787 return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
3788 !(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
3789 }
3790
asus_wmi_fnlock_update(struct asus_wmi * asus)3791 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
3792 {
3793 int mode = asus->fnlock_locked;
3794
3795 asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
3796 }
3797
3798 /* WMI events *****************************************************************/
3799
asus_wmi_get_event_code(u32 value)3800 static int asus_wmi_get_event_code(u32 value)
3801 {
3802 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
3803 union acpi_object *obj;
3804 acpi_status status;
3805 int code;
3806
3807 status = wmi_get_event_data(value, &response);
3808 if (ACPI_FAILURE(status)) {
3809 pr_warn("Failed to get WMI notify code: %s\n",
3810 acpi_format_exception(status));
3811 return -EIO;
3812 }
3813
3814 obj = (union acpi_object *)response.pointer;
3815
3816 if (obj && obj->type == ACPI_TYPE_INTEGER)
3817 code = (int)(obj->integer.value & WMI_EVENT_MASK);
3818 else
3819 code = -EIO;
3820
3821 kfree(obj);
3822 return code;
3823 }
3824
asus_wmi_handle_event_code(int code,struct asus_wmi * asus)3825 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
3826 {
3827 unsigned int key_value = 1;
3828 bool autorelease = 1;
3829
3830 if (asus->driver->key_filter) {
3831 asus->driver->key_filter(asus->driver, &code, &key_value,
3832 &autorelease);
3833 if (code == ASUS_WMI_KEY_IGNORE)
3834 return;
3835 }
3836
3837 if (acpi_video_get_backlight_type() == acpi_backlight_vendor &&
3838 code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNDOWN_MAX) {
3839 asus_wmi_backlight_notify(asus, code);
3840 return;
3841 }
3842
3843 if (code == NOTIFY_KBD_BRTUP) {
3844 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3845 return;
3846 }
3847 if (code == NOTIFY_KBD_BRTDWN) {
3848 kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
3849 return;
3850 }
3851 if (code == NOTIFY_KBD_BRTTOGGLE) {
3852 if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
3853 kbd_led_set_by_kbd(asus, 0);
3854 else
3855 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3856 return;
3857 }
3858
3859 if (code == NOTIFY_FNLOCK_TOGGLE) {
3860 asus->fnlock_locked = !asus->fnlock_locked;
3861 asus_wmi_fnlock_update(asus);
3862 return;
3863 }
3864
3865 if (code == asus->tablet_switch_event_code) {
3866 asus_wmi_tablet_mode_get_state(asus);
3867 return;
3868 }
3869
3870 if (code == NOTIFY_KBD_FBM || code == NOTIFY_KBD_TTP) {
3871 if (asus->fan_boost_mode_available)
3872 fan_boost_mode_switch_next(asus);
3873 if (asus->throttle_thermal_policy_available)
3874 throttle_thermal_policy_switch_next(asus);
3875 return;
3876
3877 }
3878
3879 if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
3880 return;
3881
3882 if (!sparse_keymap_report_event(asus->inputdev, code,
3883 key_value, autorelease))
3884 pr_info("Unknown key code 0x%x\n", code);
3885 }
3886
asus_wmi_notify(u32 value,void * context)3887 static void asus_wmi_notify(u32 value, void *context)
3888 {
3889 struct asus_wmi *asus = context;
3890 int code;
3891 int i;
3892
3893 for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3894 code = asus_wmi_get_event_code(value);
3895 if (code < 0) {
3896 pr_warn("Failed to get notify code: %d\n", code);
3897 return;
3898 }
3899
3900 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3901 return;
3902
3903 asus_wmi_handle_event_code(code, asus);
3904
3905 /*
3906 * Double check that queue is present:
3907 * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
3908 */
3909 if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
3910 return;
3911 }
3912
3913 pr_warn("Failed to process event queue, last code: 0x%x\n", code);
3914 }
3915
asus_wmi_notify_queue_flush(struct asus_wmi * asus)3916 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
3917 {
3918 int code;
3919 int i;
3920
3921 for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3922 code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
3923 if (code < 0) {
3924 pr_warn("Failed to get event during flush: %d\n", code);
3925 return code;
3926 }
3927
3928 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3929 return 0;
3930 }
3931
3932 pr_warn("Failed to flush event queue\n");
3933 return -EIO;
3934 }
3935
3936 /* Sysfs **********************************************************************/
3937
store_sys_wmi(struct asus_wmi * asus,int devid,const char * buf,size_t count)3938 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
3939 const char *buf, size_t count)
3940 {
3941 u32 retval;
3942 int err, value;
3943
3944 value = asus_wmi_get_devstate_simple(asus, devid);
3945 if (value < 0)
3946 return value;
3947
3948 err = kstrtoint(buf, 0, &value);
3949 if (err)
3950 return err;
3951
3952 err = asus_wmi_set_devstate(devid, value, &retval);
3953 if (err < 0)
3954 return err;
3955
3956 return count;
3957 }
3958
show_sys_wmi(struct asus_wmi * asus,int devid,char * buf)3959 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
3960 {
3961 int value = asus_wmi_get_devstate_simple(asus, devid);
3962
3963 if (value < 0)
3964 return value;
3965
3966 return sprintf(buf, "%d\n", value);
3967 }
3968
3969 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
3970 static ssize_t show_##_name(struct device *dev, \
3971 struct device_attribute *attr, \
3972 char *buf) \
3973 { \
3974 struct asus_wmi *asus = dev_get_drvdata(dev); \
3975 \
3976 return show_sys_wmi(asus, _cm, buf); \
3977 } \
3978 static ssize_t store_##_name(struct device *dev, \
3979 struct device_attribute *attr, \
3980 const char *buf, size_t count) \
3981 { \
3982 struct asus_wmi *asus = dev_get_drvdata(dev); \
3983 \
3984 return store_sys_wmi(asus, _cm, buf, count); \
3985 } \
3986 static struct device_attribute dev_attr_##_name = { \
3987 .attr = { \
3988 .name = __stringify(_name), \
3989 .mode = _mode }, \
3990 .show = show_##_name, \
3991 .store = store_##_name, \
3992 }
3993
3994 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
3995 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
3996 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
3997 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
3998 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
3999
cpufv_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4000 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
4001 const char *buf, size_t count)
4002 {
4003 int value, rv;
4004
4005 rv = kstrtoint(buf, 0, &value);
4006 if (rv)
4007 return rv;
4008
4009 if (value < 0 || value > 2)
4010 return -EINVAL;
4011
4012 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
4013 if (rv < 0)
4014 return rv;
4015
4016 return count;
4017 }
4018
4019 static DEVICE_ATTR_WO(cpufv);
4020
4021 static struct attribute *platform_attributes[] = {
4022 &dev_attr_cpufv.attr,
4023 &dev_attr_camera.attr,
4024 &dev_attr_cardr.attr,
4025 &dev_attr_touchpad.attr,
4026 &dev_attr_charge_mode.attr,
4027 &dev_attr_egpu_enable.attr,
4028 &dev_attr_egpu_connected.attr,
4029 &dev_attr_dgpu_disable.attr,
4030 &dev_attr_gpu_mux_mode.attr,
4031 &dev_attr_lid_resume.attr,
4032 &dev_attr_als_enable.attr,
4033 &dev_attr_fan_boost_mode.attr,
4034 &dev_attr_throttle_thermal_policy.attr,
4035 &dev_attr_ppt_pl2_sppt.attr,
4036 &dev_attr_ppt_pl1_spl.attr,
4037 &dev_attr_ppt_fppt.attr,
4038 &dev_attr_ppt_apu_sppt.attr,
4039 &dev_attr_ppt_platform_sppt.attr,
4040 &dev_attr_nv_dynamic_boost.attr,
4041 &dev_attr_nv_temp_target.attr,
4042 &dev_attr_panel_od.attr,
4043 &dev_attr_mini_led_mode.attr,
4044 NULL
4045 };
4046
asus_sysfs_is_visible(struct kobject * kobj,struct attribute * attr,int idx)4047 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
4048 struct attribute *attr, int idx)
4049 {
4050 struct device *dev = kobj_to_dev(kobj);
4051 struct asus_wmi *asus = dev_get_drvdata(dev);
4052 bool ok = true;
4053 int devid = -1;
4054
4055 if (attr == &dev_attr_camera.attr)
4056 devid = ASUS_WMI_DEVID_CAMERA;
4057 else if (attr == &dev_attr_cardr.attr)
4058 devid = ASUS_WMI_DEVID_CARDREADER;
4059 else if (attr == &dev_attr_touchpad.attr)
4060 devid = ASUS_WMI_DEVID_TOUCHPAD;
4061 else if (attr == &dev_attr_lid_resume.attr)
4062 devid = ASUS_WMI_DEVID_LID_RESUME;
4063 else if (attr == &dev_attr_als_enable.attr)
4064 devid = ASUS_WMI_DEVID_ALS_ENABLE;
4065 else if (attr == &dev_attr_charge_mode.attr)
4066 ok = asus->charge_mode_available;
4067 else if (attr == &dev_attr_egpu_enable.attr)
4068 ok = asus->egpu_enable_available;
4069 else if (attr == &dev_attr_egpu_connected.attr)
4070 ok = asus->egpu_connect_available;
4071 else if (attr == &dev_attr_dgpu_disable.attr)
4072 ok = asus->dgpu_disable_available;
4073 else if (attr == &dev_attr_gpu_mux_mode.attr)
4074 ok = asus->gpu_mux_mode_available;
4075 else if (attr == &dev_attr_fan_boost_mode.attr)
4076 ok = asus->fan_boost_mode_available;
4077 else if (attr == &dev_attr_throttle_thermal_policy.attr)
4078 ok = asus->throttle_thermal_policy_available;
4079 else if (attr == &dev_attr_ppt_pl2_sppt.attr)
4080 ok = asus->ppt_pl2_sppt_available;
4081 else if (attr == &dev_attr_ppt_pl1_spl.attr)
4082 ok = asus->ppt_pl1_spl_available;
4083 else if (attr == &dev_attr_ppt_fppt.attr)
4084 ok = asus->ppt_fppt_available;
4085 else if (attr == &dev_attr_ppt_apu_sppt.attr)
4086 ok = asus->ppt_apu_sppt_available;
4087 else if (attr == &dev_attr_ppt_platform_sppt.attr)
4088 ok = asus->ppt_plat_sppt_available;
4089 else if (attr == &dev_attr_nv_dynamic_boost.attr)
4090 ok = asus->nv_dyn_boost_available;
4091 else if (attr == &dev_attr_nv_temp_target.attr)
4092 ok = asus->nv_temp_tgt_available;
4093 else if (attr == &dev_attr_panel_od.attr)
4094 ok = asus->panel_overdrive_available;
4095 else if (attr == &dev_attr_mini_led_mode.attr)
4096 ok = asus->mini_led_mode_available;
4097
4098 if (devid != -1)
4099 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
4100
4101 return ok ? attr->mode : 0;
4102 }
4103
4104 static const struct attribute_group platform_attribute_group = {
4105 .is_visible = asus_sysfs_is_visible,
4106 .attrs = platform_attributes
4107 };
4108
asus_wmi_sysfs_exit(struct platform_device * device)4109 static void asus_wmi_sysfs_exit(struct platform_device *device)
4110 {
4111 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
4112 }
4113
asus_wmi_sysfs_init(struct platform_device * device)4114 static int asus_wmi_sysfs_init(struct platform_device *device)
4115 {
4116 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
4117 }
4118
4119 /* Platform device ************************************************************/
4120
asus_wmi_platform_init(struct asus_wmi * asus)4121 static int asus_wmi_platform_init(struct asus_wmi *asus)
4122 {
4123 struct device *dev = &asus->platform_device->dev;
4124 char *wmi_uid;
4125 int rv;
4126
4127 /* INIT enable hotkeys on some models */
4128 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
4129 pr_info("Initialization: %#x\n", rv);
4130
4131 /* We don't know yet what to do with this version... */
4132 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
4133 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
4134 asus->spec = rv;
4135 }
4136
4137 /*
4138 * The SFUN method probably allows the original driver to get the list
4139 * of features supported by a given model. For now, 0x0100 or 0x0800
4140 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
4141 * The significance of others is yet to be found.
4142 */
4143 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
4144 pr_info("SFUN value: %#x\n", rv);
4145 asus->sfun = rv;
4146 }
4147
4148 /*
4149 * Eee PC and Notebooks seems to have different method_id for DSTS,
4150 * but it may also be related to the BIOS's SPEC.
4151 * Note, on most Eeepc, there is no way to check if a method exist
4152 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
4153 * but once again, SPEC may probably be used for that kind of things.
4154 *
4155 * Additionally at least TUF Gaming series laptops return nothing for
4156 * unknown methods, so the detection in this way is not possible.
4157 *
4158 * There is strong indication that only ACPI WMI devices that have _UID
4159 * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
4160 */
4161 wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
4162 if (!wmi_uid)
4163 return -ENODEV;
4164
4165 if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
4166 dev_info(dev, "Detected ASUSWMI, use DCTS\n");
4167 asus->dsts_id = ASUS_WMI_METHODID_DCTS;
4168 } else {
4169 dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
4170 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
4171 }
4172
4173 /*
4174 * Some devices can have multiple event codes stored in a queue before
4175 * the module load if it was unloaded intermittently after calling
4176 * the INIT method (enables event handling). The WMI notify handler is
4177 * expected to retrieve all event codes until a retrieved code equals
4178 * queue end marker (One or Ones). Old codes are flushed from the queue
4179 * upon module load. Not enabling this when it should be has minimal
4180 * visible impact so fall back if anything goes wrong.
4181 */
4182 wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
4183 if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
4184 dev_info(dev, "Detected ATK, enable event queue\n");
4185
4186 if (!asus_wmi_notify_queue_flush(asus))
4187 asus->wmi_event_queue = true;
4188 }
4189
4190 /* CWAP allow to define the behavior of the Fn+F2 key,
4191 * this method doesn't seems to be present on Eee PCs */
4192 if (asus->driver->quirks->wapf >= 0)
4193 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
4194 asus->driver->quirks->wapf, NULL);
4195
4196 return 0;
4197 }
4198
4199 /* debugfs ********************************************************************/
4200
4201 struct asus_wmi_debugfs_node {
4202 struct asus_wmi *asus;
4203 char *name;
4204 int (*show) (struct seq_file *m, void *data);
4205 };
4206
show_dsts(struct seq_file * m,void * data)4207 static int show_dsts(struct seq_file *m, void *data)
4208 {
4209 struct asus_wmi *asus = m->private;
4210 int err;
4211 u32 retval = -1;
4212
4213 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
4214 if (err < 0)
4215 return err;
4216
4217 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
4218
4219 return 0;
4220 }
4221
show_devs(struct seq_file * m,void * data)4222 static int show_devs(struct seq_file *m, void *data)
4223 {
4224 struct asus_wmi *asus = m->private;
4225 int err;
4226 u32 retval = -1;
4227
4228 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
4229 &retval);
4230 if (err < 0)
4231 return err;
4232
4233 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
4234 asus->debug.ctrl_param, retval);
4235
4236 return 0;
4237 }
4238
show_call(struct seq_file * m,void * data)4239 static int show_call(struct seq_file *m, void *data)
4240 {
4241 struct asus_wmi *asus = m->private;
4242 struct bios_args args = {
4243 .arg0 = asus->debug.dev_id,
4244 .arg1 = asus->debug.ctrl_param,
4245 };
4246 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
4247 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
4248 union acpi_object *obj;
4249 acpi_status status;
4250
4251 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
4252 0, asus->debug.method_id,
4253 &input, &output);
4254
4255 if (ACPI_FAILURE(status))
4256 return -EIO;
4257
4258 obj = (union acpi_object *)output.pointer;
4259 if (obj && obj->type == ACPI_TYPE_INTEGER)
4260 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
4261 asus->debug.dev_id, asus->debug.ctrl_param,
4262 (u32) obj->integer.value);
4263 else
4264 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
4265 asus->debug.dev_id, asus->debug.ctrl_param,
4266 obj ? obj->type : -1);
4267
4268 kfree(obj);
4269
4270 return 0;
4271 }
4272
4273 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
4274 {NULL, "devs", show_devs},
4275 {NULL, "dsts", show_dsts},
4276 {NULL, "call", show_call},
4277 };
4278
asus_wmi_debugfs_open(struct inode * inode,struct file * file)4279 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
4280 {
4281 struct asus_wmi_debugfs_node *node = inode->i_private;
4282
4283 return single_open(file, node->show, node->asus);
4284 }
4285
4286 static const struct file_operations asus_wmi_debugfs_io_ops = {
4287 .owner = THIS_MODULE,
4288 .open = asus_wmi_debugfs_open,
4289 .read = seq_read,
4290 .llseek = seq_lseek,
4291 .release = single_release,
4292 };
4293
asus_wmi_debugfs_exit(struct asus_wmi * asus)4294 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
4295 {
4296 debugfs_remove_recursive(asus->debug.root);
4297 }
4298
asus_wmi_debugfs_init(struct asus_wmi * asus)4299 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
4300 {
4301 int i;
4302
4303 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
4304
4305 debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
4306 &asus->debug.method_id);
4307
4308 debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
4309 &asus->debug.dev_id);
4310
4311 debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
4312 &asus->debug.ctrl_param);
4313
4314 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
4315 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
4316
4317 node->asus = asus;
4318 debugfs_create_file(node->name, S_IFREG | S_IRUGO,
4319 asus->debug.root, node,
4320 &asus_wmi_debugfs_io_ops);
4321 }
4322 }
4323
4324 /* Init / exit ****************************************************************/
4325
asus_wmi_add(struct platform_device * pdev)4326 static int asus_wmi_add(struct platform_device *pdev)
4327 {
4328 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
4329 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
4330 struct asus_wmi *asus;
4331 acpi_status status;
4332 int err;
4333 u32 result;
4334
4335 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
4336 if (!asus)
4337 return -ENOMEM;
4338
4339 asus->driver = wdrv;
4340 asus->platform_device = pdev;
4341 wdrv->platform_device = pdev;
4342 platform_set_drvdata(asus->platform_device, asus);
4343
4344 if (wdrv->detect_quirks)
4345 wdrv->detect_quirks(asus->driver);
4346
4347 err = asus_wmi_platform_init(asus);
4348 if (err)
4349 goto fail_platform;
4350
4351 asus->charge_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CHARGE_MODE);
4352 asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU);
4353 asus->egpu_connect_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU_CONNECTED);
4354 asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU);
4355 asus->gpu_mux_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX);
4356 asus->kbd_rgb_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE);
4357 asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE);
4358 asus->ppt_pl2_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL2_SPPT);
4359 asus->ppt_pl1_spl_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL1_SPL);
4360 asus->ppt_fppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_FPPT);
4361 asus->ppt_apu_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_APU_SPPT);
4362 asus->ppt_plat_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PLAT_SPPT);
4363 asus->nv_dyn_boost_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_DYN_BOOST);
4364 asus->nv_temp_tgt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_THERM_TARGET);
4365 asus->panel_overdrive_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PANEL_OD);
4366 asus->mini_led_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE);
4367
4368 err = fan_boost_mode_check_present(asus);
4369 if (err)
4370 goto fail_fan_boost_mode;
4371
4372 err = throttle_thermal_policy_check_present(asus);
4373 if (err)
4374 goto fail_throttle_thermal_policy;
4375 else
4376 throttle_thermal_policy_set_default(asus);
4377
4378 err = platform_profile_setup(asus);
4379 if (err)
4380 goto fail_platform_profile_setup;
4381
4382 err = asus_wmi_sysfs_init(asus->platform_device);
4383 if (err)
4384 goto fail_sysfs;
4385
4386 err = asus_wmi_input_init(asus);
4387 if (err)
4388 goto fail_input;
4389
4390 err = asus_wmi_fan_init(asus); /* probably no problems on error */
4391
4392 err = asus_wmi_hwmon_init(asus);
4393 if (err)
4394 goto fail_hwmon;
4395
4396 err = asus_wmi_custom_fan_curve_init(asus);
4397 if (err)
4398 goto fail_custom_fan_curve;
4399
4400 err = asus_wmi_led_init(asus);
4401 if (err)
4402 goto fail_leds;
4403
4404 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
4405 if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
4406 asus->driver->wlan_ctrl_by_user = 1;
4407
4408 if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
4409 err = asus_wmi_rfkill_init(asus);
4410 if (err)
4411 goto fail_rfkill;
4412 }
4413
4414 if (asus->driver->quirks->wmi_force_als_set)
4415 asus_wmi_set_als();
4416
4417 if (asus->driver->quirks->xusb2pr)
4418 asus_wmi_set_xusb2pr(asus);
4419
4420 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
4421 err = asus_wmi_backlight_init(asus);
4422 if (err && err != -ENODEV)
4423 goto fail_backlight;
4424 } else if (asus->driver->quirks->wmi_backlight_set_devstate)
4425 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
4426
4427 if (asus_wmi_has_fnlock_key(asus)) {
4428 asus->fnlock_locked = fnlock_default;
4429 asus_wmi_fnlock_update(asus);
4430 }
4431
4432 status = wmi_install_notify_handler(asus->driver->event_guid,
4433 asus_wmi_notify, asus);
4434 if (ACPI_FAILURE(status)) {
4435 pr_err("Unable to register notify handler - %d\n", status);
4436 err = -ENODEV;
4437 goto fail_wmi_handler;
4438 }
4439
4440 if (asus->driver->quirks->i8042_filter) {
4441 err = i8042_install_filter(asus->driver->quirks->i8042_filter);
4442 if (err)
4443 pr_warn("Unable to install key filter - %d\n", err);
4444 }
4445
4446 asus_wmi_battery_init(asus);
4447
4448 asus_wmi_debugfs_init(asus);
4449
4450 return 0;
4451
4452 fail_wmi_handler:
4453 asus_wmi_backlight_exit(asus);
4454 fail_backlight:
4455 asus_wmi_rfkill_exit(asus);
4456 fail_rfkill:
4457 asus_wmi_led_exit(asus);
4458 fail_leds:
4459 fail_hwmon:
4460 asus_wmi_input_exit(asus);
4461 fail_input:
4462 asus_wmi_sysfs_exit(asus->platform_device);
4463 fail_sysfs:
4464 fail_throttle_thermal_policy:
4465 fail_custom_fan_curve:
4466 fail_platform_profile_setup:
4467 if (asus->platform_profile_support)
4468 platform_profile_remove();
4469 fail_fan_boost_mode:
4470 fail_platform:
4471 kfree(asus);
4472 return err;
4473 }
4474
asus_wmi_remove(struct platform_device * device)4475 static int asus_wmi_remove(struct platform_device *device)
4476 {
4477 struct asus_wmi *asus;
4478
4479 asus = platform_get_drvdata(device);
4480 if (asus->driver->quirks->i8042_filter)
4481 i8042_remove_filter(asus->driver->quirks->i8042_filter);
4482 wmi_remove_notify_handler(asus->driver->event_guid);
4483 asus_wmi_backlight_exit(asus);
4484 asus_wmi_input_exit(asus);
4485 asus_wmi_led_exit(asus);
4486 asus_wmi_rfkill_exit(asus);
4487 asus_wmi_debugfs_exit(asus);
4488 asus_wmi_sysfs_exit(asus->platform_device);
4489 asus_fan_set_auto(asus);
4490 throttle_thermal_policy_set_default(asus);
4491 asus_wmi_battery_exit(asus);
4492
4493 if (asus->platform_profile_support)
4494 platform_profile_remove();
4495
4496 kfree(asus);
4497 return 0;
4498 }
4499
4500 /* Platform driver - hibernate/resume callbacks *******************************/
4501
asus_hotk_thaw(struct device * device)4502 static int asus_hotk_thaw(struct device *device)
4503 {
4504 struct asus_wmi *asus = dev_get_drvdata(device);
4505
4506 if (asus->wlan.rfkill) {
4507 bool wlan;
4508
4509 /*
4510 * Work around bios bug - acpi _PTS turns off the wireless led
4511 * during suspend. Normally it restores it on resume, but
4512 * we should kick it ourselves in case hibernation is aborted.
4513 */
4514 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
4515 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
4516 }
4517
4518 return 0;
4519 }
4520
asus_hotk_resume(struct device * device)4521 static int asus_hotk_resume(struct device *device)
4522 {
4523 struct asus_wmi *asus = dev_get_drvdata(device);
4524
4525 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
4526 kbd_led_update(asus);
4527
4528 if (asus_wmi_has_fnlock_key(asus))
4529 asus_wmi_fnlock_update(asus);
4530
4531 asus_wmi_tablet_mode_get_state(asus);
4532 return 0;
4533 }
4534
asus_hotk_restore(struct device * device)4535 static int asus_hotk_restore(struct device *device)
4536 {
4537 struct asus_wmi *asus = dev_get_drvdata(device);
4538 int bl;
4539
4540 /* Refresh both wlan rfkill state and pci hotplug */
4541 if (asus->wlan.rfkill)
4542 asus_rfkill_hotplug(asus);
4543
4544 if (asus->bluetooth.rfkill) {
4545 bl = !asus_wmi_get_devstate_simple(asus,
4546 ASUS_WMI_DEVID_BLUETOOTH);
4547 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
4548 }
4549 if (asus->wimax.rfkill) {
4550 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
4551 rfkill_set_sw_state(asus->wimax.rfkill, bl);
4552 }
4553 if (asus->wwan3g.rfkill) {
4554 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
4555 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
4556 }
4557 if (asus->gps.rfkill) {
4558 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
4559 rfkill_set_sw_state(asus->gps.rfkill, bl);
4560 }
4561 if (asus->uwb.rfkill) {
4562 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
4563 rfkill_set_sw_state(asus->uwb.rfkill, bl);
4564 }
4565 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
4566 kbd_led_update(asus);
4567
4568 if (asus_wmi_has_fnlock_key(asus))
4569 asus_wmi_fnlock_update(asus);
4570
4571 asus_wmi_tablet_mode_get_state(asus);
4572 return 0;
4573 }
4574
4575 static const struct dev_pm_ops asus_pm_ops = {
4576 .thaw = asus_hotk_thaw,
4577 .restore = asus_hotk_restore,
4578 .resume = asus_hotk_resume,
4579 };
4580
4581 /* Registration ***************************************************************/
4582
asus_wmi_probe(struct platform_device * pdev)4583 static int asus_wmi_probe(struct platform_device *pdev)
4584 {
4585 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
4586 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
4587 int ret;
4588
4589 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
4590 pr_warn("ASUS Management GUID not found\n");
4591 return -ENODEV;
4592 }
4593
4594 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
4595 pr_warn("ASUS Event GUID not found\n");
4596 return -ENODEV;
4597 }
4598
4599 if (wdrv->probe) {
4600 ret = wdrv->probe(pdev);
4601 if (ret)
4602 return ret;
4603 }
4604
4605 return asus_wmi_add(pdev);
4606 }
4607
4608 static bool used;
4609
asus_wmi_register_driver(struct asus_wmi_driver * driver)4610 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
4611 {
4612 struct platform_driver *platform_driver;
4613 struct platform_device *platform_device;
4614
4615 if (used)
4616 return -EBUSY;
4617
4618 platform_driver = &driver->platform_driver;
4619 platform_driver->remove = asus_wmi_remove;
4620 platform_driver->driver.owner = driver->owner;
4621 platform_driver->driver.name = driver->name;
4622 platform_driver->driver.pm = &asus_pm_ops;
4623
4624 platform_device = platform_create_bundle(platform_driver,
4625 asus_wmi_probe,
4626 NULL, 0, NULL, 0);
4627 if (IS_ERR(platform_device))
4628 return PTR_ERR(platform_device);
4629
4630 used = true;
4631 return 0;
4632 }
4633 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
4634
asus_wmi_unregister_driver(struct asus_wmi_driver * driver)4635 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
4636 {
4637 platform_device_unregister(driver->platform_device);
4638 platform_driver_unregister(&driver->platform_driver);
4639 used = false;
4640 }
4641 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
4642
asus_wmi_init(void)4643 static int __init asus_wmi_init(void)
4644 {
4645 pr_info("ASUS WMI generic driver loaded\n");
4646 return 0;
4647 }
4648
asus_wmi_exit(void)4649 static void __exit asus_wmi_exit(void)
4650 {
4651 pr_info("ASUS WMI generic driver unloaded\n");
4652 }
4653
4654 module_init(asus_wmi_init);
4655 module_exit(asus_wmi_exit);
4656