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