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