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