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