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