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