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