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 (FAN_CURVE_POINTS * 2) 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 = "asus::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 return err; 2238 2239 fan_curve_copy_from_buf(curves, buf); 2240 curves->device_id = fan_dev; 2241 2242 return 0; 2243 } 2244 2245 /* Check if capability exists, and populate defaults */ 2246 static int fan_curve_check_present(struct asus_wmi *asus, bool *available, 2247 u32 fan_dev) 2248 { 2249 int err; 2250 2251 *available = false; 2252 2253 err = fan_curve_get_factory_default(asus, fan_dev); 2254 if (err) { 2255 pr_debug("fan_curve_get_factory_default(0x%08x) failed: %d\n", 2256 fan_dev, err); 2257 /* Don't cause probe to fail on devices without fan-curves */ 2258 return 0; 2259 } 2260 2261 *available = true; 2262 return 0; 2263 } 2264 2265 /* Determine which fan the attribute is for if SENSOR_ATTR */ 2266 static struct fan_curve_data *fan_curve_attr_select(struct asus_wmi *asus, 2267 struct device_attribute *attr) 2268 { 2269 int index = to_sensor_dev_attr(attr)->index; 2270 2271 return &asus->custom_fan_curves[index & FAN_CURVE_DEV_GPU]; 2272 } 2273 2274 /* Determine which fan the attribute is for if SENSOR_ATTR_2 */ 2275 static struct fan_curve_data *fan_curve_attr_2_select(struct asus_wmi *asus, 2276 struct device_attribute *attr) 2277 { 2278 int nr = to_sensor_dev_attr_2(attr)->nr; 2279 2280 return &asus->custom_fan_curves[nr & FAN_CURVE_DEV_GPU]; 2281 } 2282 2283 static ssize_t fan_curve_show(struct device *dev, 2284 struct device_attribute *attr, char *buf) 2285 { 2286 struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr); 2287 struct asus_wmi *asus = dev_get_drvdata(dev); 2288 struct fan_curve_data *data; 2289 int value, index, nr; 2290 2291 data = fan_curve_attr_2_select(asus, attr); 2292 index = dev_attr->index; 2293 nr = dev_attr->nr; 2294 2295 if (nr & FAN_CURVE_PWM_MASK) 2296 value = data->percents[index]; 2297 else 2298 value = data->temps[index]; 2299 2300 return sysfs_emit(buf, "%d\n", value); 2301 } 2302 2303 /* 2304 * "fan_dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE. 2305 */ 2306 static int fan_curve_write(struct asus_wmi *asus, 2307 struct fan_curve_data *data) 2308 { 2309 u32 arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0; 2310 u8 *percents = data->percents; 2311 u8 *temps = data->temps; 2312 int ret, i, shift = 0; 2313 2314 if (!data->enabled) 2315 return 0; 2316 2317 for (i = 0; i < FAN_CURVE_POINTS / 2; i++) { 2318 arg1 += (temps[i]) << shift; 2319 arg2 += (temps[i + 4]) << shift; 2320 /* Scale to percentage for device */ 2321 arg3 += (100 * percents[i] / 255) << shift; 2322 arg4 += (100 * percents[i + 4] / 255) << shift; 2323 shift += 8; 2324 } 2325 2326 return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS, 2327 data->device_id, 2328 arg1, arg2, arg3, arg4, &ret); 2329 } 2330 2331 static ssize_t fan_curve_store(struct device *dev, 2332 struct device_attribute *attr, const char *buf, 2333 size_t count) 2334 { 2335 struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr); 2336 struct asus_wmi *asus = dev_get_drvdata(dev); 2337 struct fan_curve_data *data; 2338 u8 value; 2339 int err; 2340 2341 int pwm = dev_attr->nr & FAN_CURVE_PWM_MASK; 2342 int index = dev_attr->index; 2343 2344 data = fan_curve_attr_2_select(asus, attr); 2345 2346 err = kstrtou8(buf, 10, &value); 2347 if (err < 0) 2348 return err; 2349 2350 if (pwm) { 2351 data->percents[index] = value; 2352 } else { 2353 data->temps[index] = value; 2354 } 2355 2356 /* 2357 * Mark as disabled so the user has to explicitly enable to apply a 2358 * changed fan curve. This prevents potential lockups from writing out 2359 * many changes as one-write-per-change. 2360 */ 2361 data->enabled = false; 2362 2363 return count; 2364 } 2365 2366 static ssize_t fan_curve_enable_show(struct device *dev, 2367 struct device_attribute *attr, char *buf) 2368 { 2369 struct asus_wmi *asus = dev_get_drvdata(dev); 2370 struct fan_curve_data *data; 2371 int out = 2; 2372 2373 data = fan_curve_attr_select(asus, attr); 2374 2375 if (data->enabled) 2376 out = 1; 2377 2378 return sysfs_emit(buf, "%d\n", out); 2379 } 2380 2381 static ssize_t fan_curve_enable_store(struct device *dev, 2382 struct device_attribute *attr, 2383 const char *buf, size_t count) 2384 { 2385 struct asus_wmi *asus = dev_get_drvdata(dev); 2386 struct fan_curve_data *data; 2387 int value, err; 2388 2389 data = fan_curve_attr_select(asus, attr); 2390 2391 err = kstrtoint(buf, 10, &value); 2392 if (err < 0) 2393 return err; 2394 2395 switch (value) { 2396 case 1: 2397 data->enabled = true; 2398 break; 2399 case 2: 2400 data->enabled = false; 2401 break; 2402 /* 2403 * Auto + reset the fan curve data to defaults. Make it an explicit 2404 * option so that users don't accidentally overwrite a set fan curve. 2405 */ 2406 case 3: 2407 err = fan_curve_get_factory_default(asus, data->device_id); 2408 if (err) 2409 return err; 2410 data->enabled = false; 2411 break; 2412 default: 2413 return -EINVAL; 2414 } 2415 2416 if (data->enabled) { 2417 err = fan_curve_write(asus, data); 2418 if (err) 2419 return err; 2420 } else { 2421 /* 2422 * For machines with throttle this is the only way to reset fans 2423 * to default mode of operation (does not erase curve data). 2424 */ 2425 if (asus->throttle_thermal_policy_available) { 2426 err = throttle_thermal_policy_write(asus); 2427 if (err) 2428 return err; 2429 /* Similar is true for laptops with this fan */ 2430 } else if (asus->fan_type == FAN_TYPE_SPEC83) { 2431 err = asus_fan_set_auto(asus); 2432 if (err) 2433 return err; 2434 } else { 2435 /* Safeguard against fautly ACPI tables */ 2436 err = fan_curve_get_factory_default(asus, data->device_id); 2437 if (err) 2438 return err; 2439 err = fan_curve_write(asus, data); 2440 if (err) 2441 return err; 2442 } 2443 } 2444 return count; 2445 } 2446 2447 /* CPU */ 2448 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, FAN_CURVE_DEV_CPU); 2449 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve, 2450 FAN_CURVE_DEV_CPU, 0); 2451 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve, 2452 FAN_CURVE_DEV_CPU, 1); 2453 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve, 2454 FAN_CURVE_DEV_CPU, 2); 2455 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve, 2456 FAN_CURVE_DEV_CPU, 3); 2457 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve, 2458 FAN_CURVE_DEV_CPU, 4); 2459 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve, 2460 FAN_CURVE_DEV_CPU, 5); 2461 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve, 2462 FAN_CURVE_DEV_CPU, 6); 2463 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve, 2464 FAN_CURVE_DEV_CPU, 7); 2465 2466 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve, 2467 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0); 2468 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve, 2469 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1); 2470 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve, 2471 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2); 2472 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve, 2473 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3); 2474 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve, 2475 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4); 2476 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve, 2477 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5); 2478 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve, 2479 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6); 2480 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve, 2481 FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7); 2482 2483 /* GPU */ 2484 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, FAN_CURVE_DEV_GPU); 2485 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve, 2486 FAN_CURVE_DEV_GPU, 0); 2487 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve, 2488 FAN_CURVE_DEV_GPU, 1); 2489 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve, 2490 FAN_CURVE_DEV_GPU, 2); 2491 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve, 2492 FAN_CURVE_DEV_GPU, 3); 2493 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve, 2494 FAN_CURVE_DEV_GPU, 4); 2495 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve, 2496 FAN_CURVE_DEV_GPU, 5); 2497 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve, 2498 FAN_CURVE_DEV_GPU, 6); 2499 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve, 2500 FAN_CURVE_DEV_GPU, 7); 2501 2502 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve, 2503 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0); 2504 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve, 2505 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1); 2506 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve, 2507 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2); 2508 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve, 2509 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3); 2510 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve, 2511 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4); 2512 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve, 2513 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5); 2514 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve, 2515 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6); 2516 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve, 2517 FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7); 2518 2519 static struct attribute *asus_fan_curve_attr[] = { 2520 /* CPU */ 2521 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 2522 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, 2523 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, 2524 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr, 2525 &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr, 2526 &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr, 2527 &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr, 2528 &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr, 2529 &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr, 2530 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 2531 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 2532 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr, 2533 &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr, 2534 &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr, 2535 &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr, 2536 &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr, 2537 &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr, 2538 /* GPU */ 2539 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 2540 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, 2541 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, 2542 &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr, 2543 &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr, 2544 &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr, 2545 &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr, 2546 &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr, 2547 &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr, 2548 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 2549 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 2550 &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr, 2551 &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr, 2552 &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr, 2553 &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr, 2554 &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr, 2555 &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr, 2556 NULL 2557 }; 2558 2559 static umode_t asus_fan_curve_is_visible(struct kobject *kobj, 2560 struct attribute *attr, int idx) 2561 { 2562 struct device *dev = kobj_to_dev(kobj); 2563 struct asus_wmi *asus = dev_get_drvdata(dev->parent); 2564 2565 /* 2566 * Check the char instead of casting attr as there are two attr types 2567 * involved here (attr1 and attr2) 2568 */ 2569 if (asus->cpu_fan_curve_available && attr->name[3] == '1') 2570 return 0644; 2571 2572 if (asus->gpu_fan_curve_available && attr->name[3] == '2') 2573 return 0644; 2574 2575 return 0; 2576 } 2577 2578 static const struct attribute_group asus_fan_curve_attr_group = { 2579 .is_visible = asus_fan_curve_is_visible, 2580 .attrs = asus_fan_curve_attr, 2581 }; 2582 __ATTRIBUTE_GROUPS(asus_fan_curve_attr); 2583 2584 /* 2585 * Must be initialised after throttle_thermal_policy_check_present() as 2586 * we check the status of throttle_thermal_policy_available during init. 2587 */ 2588 static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus) 2589 { 2590 struct device *dev = &asus->platform_device->dev; 2591 struct device *hwmon; 2592 int err; 2593 2594 err = fan_curve_check_present(asus, &asus->cpu_fan_curve_available, 2595 ASUS_WMI_DEVID_CPU_FAN_CURVE); 2596 if (err) 2597 return err; 2598 2599 err = fan_curve_check_present(asus, &asus->gpu_fan_curve_available, 2600 ASUS_WMI_DEVID_GPU_FAN_CURVE); 2601 if (err) 2602 return err; 2603 2604 if (!asus->cpu_fan_curve_available && !asus->gpu_fan_curve_available) 2605 return 0; 2606 2607 hwmon = devm_hwmon_device_register_with_groups( 2608 dev, "asus_custom_fan_curve", asus, asus_fan_curve_attr_groups); 2609 2610 if (IS_ERR(hwmon)) { 2611 dev_err(dev, 2612 "Could not register asus_custom_fan_curve device\n"); 2613 return PTR_ERR(hwmon); 2614 } 2615 2616 return 0; 2617 } 2618 2619 /* Throttle thermal policy ****************************************************/ 2620 2621 static int throttle_thermal_policy_check_present(struct asus_wmi *asus) 2622 { 2623 u32 result; 2624 int err; 2625 2626 asus->throttle_thermal_policy_available = false; 2627 2628 err = asus_wmi_get_devstate(asus, 2629 ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, 2630 &result); 2631 if (err) { 2632 if (err == -ENODEV) 2633 return 0; 2634 return err; 2635 } 2636 2637 if (result & ASUS_WMI_DSTS_PRESENCE_BIT) 2638 asus->throttle_thermal_policy_available = true; 2639 2640 return 0; 2641 } 2642 2643 static int throttle_thermal_policy_write(struct asus_wmi *asus) 2644 { 2645 int err; 2646 u8 value; 2647 u32 retval; 2648 2649 value = asus->throttle_thermal_policy_mode; 2650 2651 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, 2652 value, &retval); 2653 2654 sysfs_notify(&asus->platform_device->dev.kobj, NULL, 2655 "throttle_thermal_policy"); 2656 2657 if (err) { 2658 pr_warn("Failed to set throttle thermal policy: %d\n", err); 2659 return err; 2660 } 2661 2662 if (retval != 1) { 2663 pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n", 2664 retval); 2665 return -EIO; 2666 } 2667 2668 /* Must set to disabled if mode is toggled */ 2669 if (asus->cpu_fan_curve_available) 2670 asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false; 2671 if (asus->gpu_fan_curve_available) 2672 asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false; 2673 2674 return 0; 2675 } 2676 2677 static int throttle_thermal_policy_set_default(struct asus_wmi *asus) 2678 { 2679 if (!asus->throttle_thermal_policy_available) 2680 return 0; 2681 2682 asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; 2683 return throttle_thermal_policy_write(asus); 2684 } 2685 2686 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus) 2687 { 2688 u8 new_mode = asus->throttle_thermal_policy_mode + 1; 2689 int err; 2690 2691 if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) 2692 new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; 2693 2694 asus->throttle_thermal_policy_mode = new_mode; 2695 err = throttle_thermal_policy_write(asus); 2696 if (err) 2697 return err; 2698 2699 /* 2700 * Ensure that platform_profile updates userspace with the change to ensure 2701 * that platform_profile and throttle_thermal_policy_mode are in sync. 2702 */ 2703 platform_profile_notify(); 2704 2705 return 0; 2706 } 2707 2708 static ssize_t throttle_thermal_policy_show(struct device *dev, 2709 struct device_attribute *attr, char *buf) 2710 { 2711 struct asus_wmi *asus = dev_get_drvdata(dev); 2712 u8 mode = asus->throttle_thermal_policy_mode; 2713 2714 return scnprintf(buf, PAGE_SIZE, "%d\n", mode); 2715 } 2716 2717 static ssize_t throttle_thermal_policy_store(struct device *dev, 2718 struct device_attribute *attr, 2719 const char *buf, size_t count) 2720 { 2721 struct asus_wmi *asus = dev_get_drvdata(dev); 2722 u8 new_mode; 2723 int result; 2724 int err; 2725 2726 result = kstrtou8(buf, 10, &new_mode); 2727 if (result < 0) 2728 return result; 2729 2730 if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) 2731 return -EINVAL; 2732 2733 asus->throttle_thermal_policy_mode = new_mode; 2734 err = throttle_thermal_policy_write(asus); 2735 if (err) 2736 return err; 2737 2738 /* 2739 * Ensure that platform_profile updates userspace with the change to ensure 2740 * that platform_profile and throttle_thermal_policy_mode are in sync. 2741 */ 2742 platform_profile_notify(); 2743 2744 return count; 2745 } 2746 2747 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent 2748 static DEVICE_ATTR_RW(throttle_thermal_policy); 2749 2750 /* Platform profile ***********************************************************/ 2751 static int asus_wmi_platform_profile_get(struct platform_profile_handler *pprof, 2752 enum platform_profile_option *profile) 2753 { 2754 struct asus_wmi *asus; 2755 int tp; 2756 2757 asus = container_of(pprof, struct asus_wmi, platform_profile_handler); 2758 2759 tp = asus->throttle_thermal_policy_mode; 2760 2761 switch (tp) { 2762 case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT: 2763 *profile = PLATFORM_PROFILE_BALANCED; 2764 break; 2765 case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST: 2766 *profile = PLATFORM_PROFILE_PERFORMANCE; 2767 break; 2768 case ASUS_THROTTLE_THERMAL_POLICY_SILENT: 2769 *profile = PLATFORM_PROFILE_QUIET; 2770 break; 2771 default: 2772 return -EINVAL; 2773 } 2774 2775 return 0; 2776 } 2777 2778 static int asus_wmi_platform_profile_set(struct platform_profile_handler *pprof, 2779 enum platform_profile_option profile) 2780 { 2781 struct asus_wmi *asus; 2782 int tp; 2783 2784 asus = container_of(pprof, struct asus_wmi, platform_profile_handler); 2785 2786 switch (profile) { 2787 case PLATFORM_PROFILE_PERFORMANCE: 2788 tp = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST; 2789 break; 2790 case PLATFORM_PROFILE_BALANCED: 2791 tp = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; 2792 break; 2793 case PLATFORM_PROFILE_QUIET: 2794 tp = ASUS_THROTTLE_THERMAL_POLICY_SILENT; 2795 break; 2796 default: 2797 return -EOPNOTSUPP; 2798 } 2799 2800 asus->throttle_thermal_policy_mode = tp; 2801 return throttle_thermal_policy_write(asus); 2802 } 2803 2804 static int platform_profile_setup(struct asus_wmi *asus) 2805 { 2806 struct device *dev = &asus->platform_device->dev; 2807 int err; 2808 2809 /* 2810 * Not an error if a component platform_profile relies on is unavailable 2811 * so early return, skipping the setup of platform_profile. 2812 */ 2813 if (!asus->throttle_thermal_policy_available) 2814 return 0; 2815 2816 dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n"); 2817 2818 asus->platform_profile_handler.profile_get = asus_wmi_platform_profile_get; 2819 asus->platform_profile_handler.profile_set = asus_wmi_platform_profile_set; 2820 2821 set_bit(PLATFORM_PROFILE_QUIET, asus->platform_profile_handler.choices); 2822 set_bit(PLATFORM_PROFILE_BALANCED, 2823 asus->platform_profile_handler.choices); 2824 set_bit(PLATFORM_PROFILE_PERFORMANCE, 2825 asus->platform_profile_handler.choices); 2826 2827 err = platform_profile_register(&asus->platform_profile_handler); 2828 if (err) 2829 return err; 2830 2831 asus->platform_profile_support = true; 2832 return 0; 2833 } 2834 2835 /* Backlight ******************************************************************/ 2836 2837 static int read_backlight_power(struct asus_wmi *asus) 2838 { 2839 int ret; 2840 2841 if (asus->driver->quirks->store_backlight_power) 2842 ret = !asus->driver->panel_power; 2843 else 2844 ret = asus_wmi_get_devstate_simple(asus, 2845 ASUS_WMI_DEVID_BACKLIGHT); 2846 2847 if (ret < 0) 2848 return ret; 2849 2850 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; 2851 } 2852 2853 static int read_brightness_max(struct asus_wmi *asus) 2854 { 2855 u32 retval; 2856 int err; 2857 2858 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval); 2859 if (err < 0) 2860 return err; 2861 2862 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK; 2863 retval >>= 8; 2864 2865 if (!retval) 2866 return -ENODEV; 2867 2868 return retval; 2869 } 2870 2871 static int read_brightness(struct backlight_device *bd) 2872 { 2873 struct asus_wmi *asus = bl_get_data(bd); 2874 u32 retval; 2875 int err; 2876 2877 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval); 2878 if (err < 0) 2879 return err; 2880 2881 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK; 2882 } 2883 2884 static u32 get_scalar_command(struct backlight_device *bd) 2885 { 2886 struct asus_wmi *asus = bl_get_data(bd); 2887 u32 ctrl_param = 0; 2888 2889 if ((asus->driver->brightness < bd->props.brightness) || 2890 bd->props.brightness == bd->props.max_brightness) 2891 ctrl_param = 0x00008001; 2892 else if ((asus->driver->brightness > bd->props.brightness) || 2893 bd->props.brightness == 0) 2894 ctrl_param = 0x00008000; 2895 2896 asus->driver->brightness = bd->props.brightness; 2897 2898 return ctrl_param; 2899 } 2900 2901 static int update_bl_status(struct backlight_device *bd) 2902 { 2903 struct asus_wmi *asus = bl_get_data(bd); 2904 u32 ctrl_param; 2905 int power, err = 0; 2906 2907 power = read_backlight_power(asus); 2908 if (power != -ENODEV && bd->props.power != power) { 2909 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK); 2910 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2911 ctrl_param, NULL); 2912 if (asus->driver->quirks->store_backlight_power) 2913 asus->driver->panel_power = bd->props.power; 2914 2915 /* When using scalar brightness, updating the brightness 2916 * will mess with the backlight power */ 2917 if (asus->driver->quirks->scalar_panel_brightness) 2918 return err; 2919 } 2920 2921 if (asus->driver->quirks->scalar_panel_brightness) 2922 ctrl_param = get_scalar_command(bd); 2923 else 2924 ctrl_param = bd->props.brightness; 2925 2926 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS, 2927 ctrl_param, NULL); 2928 2929 return err; 2930 } 2931 2932 static const struct backlight_ops asus_wmi_bl_ops = { 2933 .get_brightness = read_brightness, 2934 .update_status = update_bl_status, 2935 }; 2936 2937 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code) 2938 { 2939 struct backlight_device *bd = asus->backlight_device; 2940 int old = bd->props.brightness; 2941 int new = old; 2942 2943 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX) 2944 new = code - NOTIFY_BRNUP_MIN + 1; 2945 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX) 2946 new = code - NOTIFY_BRNDOWN_MIN; 2947 2948 bd->props.brightness = new; 2949 backlight_update_status(bd); 2950 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY); 2951 2952 return old; 2953 } 2954 2955 static int asus_wmi_backlight_init(struct asus_wmi *asus) 2956 { 2957 struct backlight_device *bd; 2958 struct backlight_properties props; 2959 int max; 2960 int power; 2961 2962 max = read_brightness_max(asus); 2963 if (max < 0) 2964 return max; 2965 2966 power = read_backlight_power(asus); 2967 if (power == -ENODEV) 2968 power = FB_BLANK_UNBLANK; 2969 else if (power < 0) 2970 return power; 2971 2972 memset(&props, 0, sizeof(struct backlight_properties)); 2973 props.type = BACKLIGHT_PLATFORM; 2974 props.max_brightness = max; 2975 bd = backlight_device_register(asus->driver->name, 2976 &asus->platform_device->dev, asus, 2977 &asus_wmi_bl_ops, &props); 2978 if (IS_ERR(bd)) { 2979 pr_err("Could not register backlight device\n"); 2980 return PTR_ERR(bd); 2981 } 2982 2983 asus->backlight_device = bd; 2984 2985 if (asus->driver->quirks->store_backlight_power) 2986 asus->driver->panel_power = power; 2987 2988 bd->props.brightness = read_brightness(bd); 2989 bd->props.power = power; 2990 backlight_update_status(bd); 2991 2992 asus->driver->brightness = bd->props.brightness; 2993 2994 return 0; 2995 } 2996 2997 static void asus_wmi_backlight_exit(struct asus_wmi *asus) 2998 { 2999 backlight_device_unregister(asus->backlight_device); 3000 3001 asus->backlight_device = NULL; 3002 } 3003 3004 static int is_display_toggle(int code) 3005 { 3006 /* display toggle keys */ 3007 if ((code >= 0x61 && code <= 0x67) || 3008 (code >= 0x8c && code <= 0x93) || 3009 (code >= 0xa0 && code <= 0xa7) || 3010 (code >= 0xd0 && code <= 0xd5)) 3011 return 1; 3012 3013 return 0; 3014 } 3015 3016 /* Fn-lock ********************************************************************/ 3017 3018 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus) 3019 { 3020 u32 result; 3021 3022 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result); 3023 3024 return (result & ASUS_WMI_DSTS_PRESENCE_BIT) && 3025 !(result & ASUS_WMI_FNLOCK_BIOS_DISABLED); 3026 } 3027 3028 static void asus_wmi_fnlock_update(struct asus_wmi *asus) 3029 { 3030 int mode = asus->fnlock_locked; 3031 3032 asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL); 3033 } 3034 3035 /* WMI events *****************************************************************/ 3036 3037 static int asus_wmi_get_event_code(u32 value) 3038 { 3039 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; 3040 union acpi_object *obj; 3041 acpi_status status; 3042 int code; 3043 3044 status = wmi_get_event_data(value, &response); 3045 if (ACPI_FAILURE(status)) { 3046 pr_warn("Failed to get WMI notify code: %s\n", 3047 acpi_format_exception(status)); 3048 return -EIO; 3049 } 3050 3051 obj = (union acpi_object *)response.pointer; 3052 3053 if (obj && obj->type == ACPI_TYPE_INTEGER) 3054 code = (int)(obj->integer.value & WMI_EVENT_MASK); 3055 else 3056 code = -EIO; 3057 3058 kfree(obj); 3059 return code; 3060 } 3061 3062 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus) 3063 { 3064 unsigned int key_value = 1; 3065 bool autorelease = 1; 3066 int result, orig_code; 3067 3068 orig_code = code; 3069 3070 if (asus->driver->key_filter) { 3071 asus->driver->key_filter(asus->driver, &code, &key_value, 3072 &autorelease); 3073 if (code == ASUS_WMI_KEY_IGNORE) 3074 return; 3075 } 3076 3077 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX) 3078 code = ASUS_WMI_BRN_UP; 3079 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX) 3080 code = ASUS_WMI_BRN_DOWN; 3081 3082 if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) { 3083 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { 3084 asus_wmi_backlight_notify(asus, orig_code); 3085 return; 3086 } 3087 } 3088 3089 if (code == NOTIFY_KBD_BRTUP) { 3090 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1); 3091 return; 3092 } 3093 if (code == NOTIFY_KBD_BRTDWN) { 3094 kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1); 3095 return; 3096 } 3097 if (code == NOTIFY_KBD_BRTTOGGLE) { 3098 if (asus->kbd_led_wk == asus->kbd_led.max_brightness) 3099 kbd_led_set_by_kbd(asus, 0); 3100 else 3101 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1); 3102 return; 3103 } 3104 3105 if (code == NOTIFY_FNLOCK_TOGGLE) { 3106 asus->fnlock_locked = !asus->fnlock_locked; 3107 asus_wmi_fnlock_update(asus); 3108 return; 3109 } 3110 3111 if (asus->driver->quirks->use_kbd_dock_devid && code == NOTIFY_KBD_DOCK_CHANGE) { 3112 result = asus_wmi_get_devstate_simple(asus, 3113 ASUS_WMI_DEVID_KBD_DOCK); 3114 if (result >= 0) { 3115 input_report_switch(asus->inputdev, SW_TABLET_MODE, 3116 !result); 3117 input_sync(asus->inputdev); 3118 } 3119 return; 3120 } 3121 3122 if (asus->driver->quirks->use_lid_flip_devid && code == NOTIFY_LID_FLIP) { 3123 lid_flip_tablet_mode_get_state(asus); 3124 return; 3125 } 3126 3127 if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) { 3128 fan_boost_mode_switch_next(asus); 3129 return; 3130 } 3131 3132 if (asus->throttle_thermal_policy_available && code == NOTIFY_KBD_TTP) { 3133 throttle_thermal_policy_switch_next(asus); 3134 return; 3135 } 3136 3137 if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle) 3138 return; 3139 3140 if (!sparse_keymap_report_event(asus->inputdev, code, 3141 key_value, autorelease)) 3142 pr_info("Unknown key code 0x%x\n", code); 3143 } 3144 3145 static void asus_wmi_notify(u32 value, void *context) 3146 { 3147 struct asus_wmi *asus = context; 3148 int code; 3149 int i; 3150 3151 for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) { 3152 code = asus_wmi_get_event_code(value); 3153 if (code < 0) { 3154 pr_warn("Failed to get notify code: %d\n", code); 3155 return; 3156 } 3157 3158 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK) 3159 return; 3160 3161 asus_wmi_handle_event_code(code, asus); 3162 3163 /* 3164 * Double check that queue is present: 3165 * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2. 3166 */ 3167 if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK) 3168 return; 3169 } 3170 3171 pr_warn("Failed to process event queue, last code: 0x%x\n", code); 3172 } 3173 3174 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus) 3175 { 3176 int code; 3177 int i; 3178 3179 for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) { 3180 code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK); 3181 if (code < 0) { 3182 pr_warn("Failed to get event during flush: %d\n", code); 3183 return code; 3184 } 3185 3186 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK) 3187 return 0; 3188 } 3189 3190 pr_warn("Failed to flush event queue\n"); 3191 return -EIO; 3192 } 3193 3194 /* Sysfs **********************************************************************/ 3195 3196 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid, 3197 const char *buf, size_t count) 3198 { 3199 u32 retval; 3200 int err, value; 3201 3202 value = asus_wmi_get_devstate_simple(asus, devid); 3203 if (value < 0) 3204 return value; 3205 3206 err = kstrtoint(buf, 0, &value); 3207 if (err) 3208 return err; 3209 3210 err = asus_wmi_set_devstate(devid, value, &retval); 3211 if (err < 0) 3212 return err; 3213 3214 return count; 3215 } 3216 3217 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf) 3218 { 3219 int value = asus_wmi_get_devstate_simple(asus, devid); 3220 3221 if (value < 0) 3222 return value; 3223 3224 return sprintf(buf, "%d\n", value); 3225 } 3226 3227 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \ 3228 static ssize_t show_##_name(struct device *dev, \ 3229 struct device_attribute *attr, \ 3230 char *buf) \ 3231 { \ 3232 struct asus_wmi *asus = dev_get_drvdata(dev); \ 3233 \ 3234 return show_sys_wmi(asus, _cm, buf); \ 3235 } \ 3236 static ssize_t store_##_name(struct device *dev, \ 3237 struct device_attribute *attr, \ 3238 const char *buf, size_t count) \ 3239 { \ 3240 struct asus_wmi *asus = dev_get_drvdata(dev); \ 3241 \ 3242 return store_sys_wmi(asus, _cm, buf, count); \ 3243 } \ 3244 static struct device_attribute dev_attr_##_name = { \ 3245 .attr = { \ 3246 .name = __stringify(_name), \ 3247 .mode = _mode }, \ 3248 .show = show_##_name, \ 3249 .store = store_##_name, \ 3250 } 3251 3252 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD); 3253 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA); 3254 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER); 3255 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME); 3256 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE); 3257 3258 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr, 3259 const char *buf, size_t count) 3260 { 3261 int value, rv; 3262 3263 rv = kstrtoint(buf, 0, &value); 3264 if (rv) 3265 return rv; 3266 3267 if (value < 0 || value > 2) 3268 return -EINVAL; 3269 3270 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL); 3271 if (rv < 0) 3272 return rv; 3273 3274 return count; 3275 } 3276 3277 static DEVICE_ATTR_WO(cpufv); 3278 3279 static struct attribute *platform_attributes[] = { 3280 &dev_attr_cpufv.attr, 3281 &dev_attr_camera.attr, 3282 &dev_attr_cardr.attr, 3283 &dev_attr_touchpad.attr, 3284 &dev_attr_egpu_enable.attr, 3285 &dev_attr_dgpu_disable.attr, 3286 &dev_attr_lid_resume.attr, 3287 &dev_attr_als_enable.attr, 3288 &dev_attr_fan_boost_mode.attr, 3289 &dev_attr_throttle_thermal_policy.attr, 3290 &dev_attr_panel_od.attr, 3291 NULL 3292 }; 3293 3294 static umode_t asus_sysfs_is_visible(struct kobject *kobj, 3295 struct attribute *attr, int idx) 3296 { 3297 struct device *dev = container_of(kobj, struct device, kobj); 3298 struct asus_wmi *asus = dev_get_drvdata(dev); 3299 bool ok = true; 3300 int devid = -1; 3301 3302 if (attr == &dev_attr_camera.attr) 3303 devid = ASUS_WMI_DEVID_CAMERA; 3304 else if (attr == &dev_attr_cardr.attr) 3305 devid = ASUS_WMI_DEVID_CARDREADER; 3306 else if (attr == &dev_attr_touchpad.attr) 3307 devid = ASUS_WMI_DEVID_TOUCHPAD; 3308 else if (attr == &dev_attr_lid_resume.attr) 3309 devid = ASUS_WMI_DEVID_LID_RESUME; 3310 else if (attr == &dev_attr_als_enable.attr) 3311 devid = ASUS_WMI_DEVID_ALS_ENABLE; 3312 else if (attr == &dev_attr_egpu_enable.attr) 3313 ok = asus->egpu_enable_available; 3314 else if (attr == &dev_attr_dgpu_disable.attr) 3315 ok = asus->dgpu_disable_available; 3316 else if (attr == &dev_attr_fan_boost_mode.attr) 3317 ok = asus->fan_boost_mode_available; 3318 else if (attr == &dev_attr_throttle_thermal_policy.attr) 3319 ok = asus->throttle_thermal_policy_available; 3320 else if (attr == &dev_attr_panel_od.attr) 3321 ok = asus->panel_overdrive_available; 3322 3323 if (devid != -1) 3324 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0); 3325 3326 return ok ? attr->mode : 0; 3327 } 3328 3329 static const struct attribute_group platform_attribute_group = { 3330 .is_visible = asus_sysfs_is_visible, 3331 .attrs = platform_attributes 3332 }; 3333 3334 static void asus_wmi_sysfs_exit(struct platform_device *device) 3335 { 3336 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group); 3337 } 3338 3339 static int asus_wmi_sysfs_init(struct platform_device *device) 3340 { 3341 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group); 3342 } 3343 3344 /* Platform device ************************************************************/ 3345 3346 static int asus_wmi_platform_init(struct asus_wmi *asus) 3347 { 3348 struct device *dev = &asus->platform_device->dev; 3349 char *wmi_uid; 3350 int rv; 3351 3352 /* INIT enable hotkeys on some models */ 3353 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv)) 3354 pr_info("Initialization: %#x\n", rv); 3355 3356 /* We don't know yet what to do with this version... */ 3357 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) { 3358 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF); 3359 asus->spec = rv; 3360 } 3361 3362 /* 3363 * The SFUN method probably allows the original driver to get the list 3364 * of features supported by a given model. For now, 0x0100 or 0x0800 3365 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card. 3366 * The significance of others is yet to be found. 3367 */ 3368 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) { 3369 pr_info("SFUN value: %#x\n", rv); 3370 asus->sfun = rv; 3371 } 3372 3373 /* 3374 * Eee PC and Notebooks seems to have different method_id for DSTS, 3375 * but it may also be related to the BIOS's SPEC. 3376 * Note, on most Eeepc, there is no way to check if a method exist 3377 * or note, while on notebooks, they returns 0xFFFFFFFE on failure, 3378 * but once again, SPEC may probably be used for that kind of things. 3379 * 3380 * Additionally at least TUF Gaming series laptops return nothing for 3381 * unknown methods, so the detection in this way is not possible. 3382 * 3383 * There is strong indication that only ACPI WMI devices that have _UID 3384 * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS. 3385 */ 3386 wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID); 3387 if (!wmi_uid) 3388 return -ENODEV; 3389 3390 if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) { 3391 dev_info(dev, "Detected ASUSWMI, use DCTS\n"); 3392 asus->dsts_id = ASUS_WMI_METHODID_DCTS; 3393 } else { 3394 dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid); 3395 asus->dsts_id = ASUS_WMI_METHODID_DSTS; 3396 } 3397 3398 /* 3399 * Some devices can have multiple event codes stored in a queue before 3400 * the module load if it was unloaded intermittently after calling 3401 * the INIT method (enables event handling). The WMI notify handler is 3402 * expected to retrieve all event codes until a retrieved code equals 3403 * queue end marker (One or Ones). Old codes are flushed from the queue 3404 * upon module load. Not enabling this when it should be has minimal 3405 * visible impact so fall back if anything goes wrong. 3406 */ 3407 wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid); 3408 if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) { 3409 dev_info(dev, "Detected ATK, enable event queue\n"); 3410 3411 if (!asus_wmi_notify_queue_flush(asus)) 3412 asus->wmi_event_queue = true; 3413 } 3414 3415 /* CWAP allow to define the behavior of the Fn+F2 key, 3416 * this method doesn't seems to be present on Eee PCs */ 3417 if (asus->driver->quirks->wapf >= 0) 3418 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP, 3419 asus->driver->quirks->wapf, NULL); 3420 3421 return 0; 3422 } 3423 3424 /* debugfs ********************************************************************/ 3425 3426 struct asus_wmi_debugfs_node { 3427 struct asus_wmi *asus; 3428 char *name; 3429 int (*show) (struct seq_file *m, void *data); 3430 }; 3431 3432 static int show_dsts(struct seq_file *m, void *data) 3433 { 3434 struct asus_wmi *asus = m->private; 3435 int err; 3436 u32 retval = -1; 3437 3438 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval); 3439 if (err < 0) 3440 return err; 3441 3442 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval); 3443 3444 return 0; 3445 } 3446 3447 static int show_devs(struct seq_file *m, void *data) 3448 { 3449 struct asus_wmi *asus = m->private; 3450 int err; 3451 u32 retval = -1; 3452 3453 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param, 3454 &retval); 3455 if (err < 0) 3456 return err; 3457 3458 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id, 3459 asus->debug.ctrl_param, retval); 3460 3461 return 0; 3462 } 3463 3464 static int show_call(struct seq_file *m, void *data) 3465 { 3466 struct asus_wmi *asus = m->private; 3467 struct bios_args args = { 3468 .arg0 = asus->debug.dev_id, 3469 .arg1 = asus->debug.ctrl_param, 3470 }; 3471 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 3472 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 3473 union acpi_object *obj; 3474 acpi_status status; 3475 3476 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 3477 0, asus->debug.method_id, 3478 &input, &output); 3479 3480 if (ACPI_FAILURE(status)) 3481 return -EIO; 3482 3483 obj = (union acpi_object *)output.pointer; 3484 if (obj && obj->type == ACPI_TYPE_INTEGER) 3485 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id, 3486 asus->debug.dev_id, asus->debug.ctrl_param, 3487 (u32) obj->integer.value); 3488 else 3489 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id, 3490 asus->debug.dev_id, asus->debug.ctrl_param, 3491 obj ? obj->type : -1); 3492 3493 kfree(obj); 3494 3495 return 0; 3496 } 3497 3498 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = { 3499 {NULL, "devs", show_devs}, 3500 {NULL, "dsts", show_dsts}, 3501 {NULL, "call", show_call}, 3502 }; 3503 3504 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file) 3505 { 3506 struct asus_wmi_debugfs_node *node = inode->i_private; 3507 3508 return single_open(file, node->show, node->asus); 3509 } 3510 3511 static const struct file_operations asus_wmi_debugfs_io_ops = { 3512 .owner = THIS_MODULE, 3513 .open = asus_wmi_debugfs_open, 3514 .read = seq_read, 3515 .llseek = seq_lseek, 3516 .release = single_release, 3517 }; 3518 3519 static void asus_wmi_debugfs_exit(struct asus_wmi *asus) 3520 { 3521 debugfs_remove_recursive(asus->debug.root); 3522 } 3523 3524 static void asus_wmi_debugfs_init(struct asus_wmi *asus) 3525 { 3526 int i; 3527 3528 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL); 3529 3530 debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root, 3531 &asus->debug.method_id); 3532 3533 debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root, 3534 &asus->debug.dev_id); 3535 3536 debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root, 3537 &asus->debug.ctrl_param); 3538 3539 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) { 3540 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i]; 3541 3542 node->asus = asus; 3543 debugfs_create_file(node->name, S_IFREG | S_IRUGO, 3544 asus->debug.root, node, 3545 &asus_wmi_debugfs_io_ops); 3546 } 3547 } 3548 3549 /* Init / exit ****************************************************************/ 3550 3551 static int asus_wmi_add(struct platform_device *pdev) 3552 { 3553 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver); 3554 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv); 3555 struct asus_wmi *asus; 3556 const char *chassis_type; 3557 acpi_status status; 3558 int err; 3559 u32 result; 3560 3561 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL); 3562 if (!asus) 3563 return -ENOMEM; 3564 3565 asus->driver = wdrv; 3566 asus->platform_device = pdev; 3567 wdrv->platform_device = pdev; 3568 platform_set_drvdata(asus->platform_device, asus); 3569 3570 if (wdrv->detect_quirks) 3571 wdrv->detect_quirks(asus->driver); 3572 3573 err = asus_wmi_platform_init(asus); 3574 if (err) 3575 goto fail_platform; 3576 3577 err = egpu_enable_check_present(asus); 3578 if (err) 3579 goto fail_egpu_enable; 3580 3581 err = dgpu_disable_check_present(asus); 3582 if (err) 3583 goto fail_dgpu_disable; 3584 3585 err = fan_boost_mode_check_present(asus); 3586 if (err) 3587 goto fail_fan_boost_mode; 3588 3589 err = throttle_thermal_policy_check_present(asus); 3590 if (err) 3591 goto fail_throttle_thermal_policy; 3592 else 3593 throttle_thermal_policy_set_default(asus); 3594 3595 err = platform_profile_setup(asus); 3596 if (err) 3597 goto fail_platform_profile_setup; 3598 3599 err = panel_od_check_present(asus); 3600 if (err) 3601 goto fail_panel_od; 3602 3603 err = asus_wmi_sysfs_init(asus->platform_device); 3604 if (err) 3605 goto fail_sysfs; 3606 3607 err = asus_wmi_input_init(asus); 3608 if (err) 3609 goto fail_input; 3610 3611 err = asus_wmi_fan_init(asus); /* probably no problems on error */ 3612 3613 err = asus_wmi_hwmon_init(asus); 3614 if (err) 3615 goto fail_hwmon; 3616 3617 err = asus_wmi_custom_fan_curve_init(asus); 3618 if (err) 3619 goto fail_custom_fan_curve; 3620 3621 err = asus_wmi_led_init(asus); 3622 if (err) 3623 goto fail_leds; 3624 3625 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result); 3626 if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT)) 3627 asus->driver->wlan_ctrl_by_user = 1; 3628 3629 if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) { 3630 err = asus_wmi_rfkill_init(asus); 3631 if (err) 3632 goto fail_rfkill; 3633 } 3634 3635 if (asus->driver->quirks->wmi_force_als_set) 3636 asus_wmi_set_als(); 3637 3638 /* Some Asus desktop boards export an acpi-video backlight interface, 3639 stop this from showing up */ 3640 chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE); 3641 if (chassis_type && !strcmp(chassis_type, "3")) 3642 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 3643 3644 if (asus->driver->quirks->wmi_backlight_power) 3645 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 3646 3647 if (asus->driver->quirks->wmi_backlight_native) 3648 acpi_video_set_dmi_backlight_type(acpi_backlight_native); 3649 3650 if (asus->driver->quirks->xusb2pr) 3651 asus_wmi_set_xusb2pr(asus); 3652 3653 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { 3654 err = asus_wmi_backlight_init(asus); 3655 if (err && err != -ENODEV) 3656 goto fail_backlight; 3657 } else if (asus->driver->quirks->wmi_backlight_set_devstate) 3658 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL); 3659 3660 if (asus_wmi_has_fnlock_key(asus)) { 3661 asus->fnlock_locked = fnlock_default; 3662 asus_wmi_fnlock_update(asus); 3663 } 3664 3665 status = wmi_install_notify_handler(asus->driver->event_guid, 3666 asus_wmi_notify, asus); 3667 if (ACPI_FAILURE(status)) { 3668 pr_err("Unable to register notify handler - %d\n", status); 3669 err = -ENODEV; 3670 goto fail_wmi_handler; 3671 } 3672 3673 asus_wmi_battery_init(asus); 3674 3675 asus_wmi_debugfs_init(asus); 3676 3677 return 0; 3678 3679 fail_wmi_handler: 3680 asus_wmi_backlight_exit(asus); 3681 fail_backlight: 3682 asus_wmi_rfkill_exit(asus); 3683 fail_rfkill: 3684 asus_wmi_led_exit(asus); 3685 fail_leds: 3686 fail_hwmon: 3687 asus_wmi_input_exit(asus); 3688 fail_input: 3689 asus_wmi_sysfs_exit(asus->platform_device); 3690 fail_sysfs: 3691 fail_throttle_thermal_policy: 3692 fail_custom_fan_curve: 3693 fail_platform_profile_setup: 3694 if (asus->platform_profile_support) 3695 platform_profile_remove(); 3696 fail_fan_boost_mode: 3697 fail_egpu_enable: 3698 fail_dgpu_disable: 3699 fail_platform: 3700 fail_panel_od: 3701 kfree(asus); 3702 return err; 3703 } 3704 3705 static int asus_wmi_remove(struct platform_device *device) 3706 { 3707 struct asus_wmi *asus; 3708 3709 asus = platform_get_drvdata(device); 3710 wmi_remove_notify_handler(asus->driver->event_guid); 3711 asus_wmi_backlight_exit(asus); 3712 asus_wmi_input_exit(asus); 3713 asus_wmi_led_exit(asus); 3714 asus_wmi_rfkill_exit(asus); 3715 asus_wmi_debugfs_exit(asus); 3716 asus_wmi_sysfs_exit(asus->platform_device); 3717 asus_fan_set_auto(asus); 3718 throttle_thermal_policy_set_default(asus); 3719 asus_wmi_battery_exit(asus); 3720 3721 if (asus->platform_profile_support) 3722 platform_profile_remove(); 3723 3724 kfree(asus); 3725 return 0; 3726 } 3727 3728 /* Platform driver - hibernate/resume callbacks *******************************/ 3729 3730 static int asus_hotk_thaw(struct device *device) 3731 { 3732 struct asus_wmi *asus = dev_get_drvdata(device); 3733 3734 if (asus->wlan.rfkill) { 3735 bool wlan; 3736 3737 /* 3738 * Work around bios bug - acpi _PTS turns off the wireless led 3739 * during suspend. Normally it restores it on resume, but 3740 * we should kick it ourselves in case hibernation is aborted. 3741 */ 3742 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN); 3743 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL); 3744 } 3745 3746 return 0; 3747 } 3748 3749 static int asus_hotk_resume(struct device *device) 3750 { 3751 struct asus_wmi *asus = dev_get_drvdata(device); 3752 3753 if (!IS_ERR_OR_NULL(asus->kbd_led.dev)) 3754 kbd_led_update(asus); 3755 3756 if (asus_wmi_has_fnlock_key(asus)) 3757 asus_wmi_fnlock_update(asus); 3758 3759 if (asus->driver->quirks->use_lid_flip_devid) 3760 lid_flip_tablet_mode_get_state(asus); 3761 3762 return 0; 3763 } 3764 3765 static int asus_hotk_restore(struct device *device) 3766 { 3767 struct asus_wmi *asus = dev_get_drvdata(device); 3768 int bl; 3769 3770 /* Refresh both wlan rfkill state and pci hotplug */ 3771 if (asus->wlan.rfkill) 3772 asus_rfkill_hotplug(asus); 3773 3774 if (asus->bluetooth.rfkill) { 3775 bl = !asus_wmi_get_devstate_simple(asus, 3776 ASUS_WMI_DEVID_BLUETOOTH); 3777 rfkill_set_sw_state(asus->bluetooth.rfkill, bl); 3778 } 3779 if (asus->wimax.rfkill) { 3780 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX); 3781 rfkill_set_sw_state(asus->wimax.rfkill, bl); 3782 } 3783 if (asus->wwan3g.rfkill) { 3784 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G); 3785 rfkill_set_sw_state(asus->wwan3g.rfkill, bl); 3786 } 3787 if (asus->gps.rfkill) { 3788 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS); 3789 rfkill_set_sw_state(asus->gps.rfkill, bl); 3790 } 3791 if (asus->uwb.rfkill) { 3792 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB); 3793 rfkill_set_sw_state(asus->uwb.rfkill, bl); 3794 } 3795 if (!IS_ERR_OR_NULL(asus->kbd_led.dev)) 3796 kbd_led_update(asus); 3797 3798 if (asus_wmi_has_fnlock_key(asus)) 3799 asus_wmi_fnlock_update(asus); 3800 3801 if (asus->driver->quirks->use_lid_flip_devid) 3802 lid_flip_tablet_mode_get_state(asus); 3803 3804 return 0; 3805 } 3806 3807 static const struct dev_pm_ops asus_pm_ops = { 3808 .thaw = asus_hotk_thaw, 3809 .restore = asus_hotk_restore, 3810 .resume = asus_hotk_resume, 3811 }; 3812 3813 /* Registration ***************************************************************/ 3814 3815 static int asus_wmi_probe(struct platform_device *pdev) 3816 { 3817 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver); 3818 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv); 3819 int ret; 3820 3821 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) { 3822 pr_warn("ASUS Management GUID not found\n"); 3823 return -ENODEV; 3824 } 3825 3826 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) { 3827 pr_warn("ASUS Event GUID not found\n"); 3828 return -ENODEV; 3829 } 3830 3831 if (wdrv->probe) { 3832 ret = wdrv->probe(pdev); 3833 if (ret) 3834 return ret; 3835 } 3836 3837 return asus_wmi_add(pdev); 3838 } 3839 3840 static bool used; 3841 3842 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver) 3843 { 3844 struct platform_driver *platform_driver; 3845 struct platform_device *platform_device; 3846 3847 if (used) 3848 return -EBUSY; 3849 3850 platform_driver = &driver->platform_driver; 3851 platform_driver->remove = asus_wmi_remove; 3852 platform_driver->driver.owner = driver->owner; 3853 platform_driver->driver.name = driver->name; 3854 platform_driver->driver.pm = &asus_pm_ops; 3855 3856 platform_device = platform_create_bundle(platform_driver, 3857 asus_wmi_probe, 3858 NULL, 0, NULL, 0); 3859 if (IS_ERR(platform_device)) 3860 return PTR_ERR(platform_device); 3861 3862 used = true; 3863 return 0; 3864 } 3865 EXPORT_SYMBOL_GPL(asus_wmi_register_driver); 3866 3867 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver) 3868 { 3869 platform_device_unregister(driver->platform_device); 3870 platform_driver_unregister(&driver->platform_driver); 3871 used = false; 3872 } 3873 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver); 3874 3875 static int __init asus_wmi_init(void) 3876 { 3877 pr_info("ASUS WMI generic driver loaded\n"); 3878 return 0; 3879 } 3880 3881 static void __exit asus_wmi_exit(void) 3882 { 3883 pr_info("ASUS WMI generic driver unloaded\n"); 3884 } 3885 3886 module_init(asus_wmi_init); 3887 module_exit(asus_wmi_exit); 3888