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