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