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