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