* [PATCH v14 0/9] platform/x86: Add asus-armoury driver
@ 2025-10-15 1:47 Denis Benato
2025-10-15 1:47 ` [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI Denis Benato
` (9 more replies)
0 siblings, 10 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
Hi all,
the TL;DR:
1. Introduce new module to contain bios attributes, using fw_attributes_class
2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
3. Remove those in the next LTS cycle
The idea for this originates from a conversation with Mario Limonciello
https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
It is without a doubt much cleaner to use, easier to discover, and the
API is well defined as opposed to the random clutter of attributes I had
been placing in the platform sysfs. Given that Derek is also working on a
similar approach to Lenovo in part based on my initial work I'd like to think
that the overall approach is good and may become standardised for these types
of things.
Regarding PPT: it is intended to add support for "custom" platform profile
soon. If it's a blocker for this patch series being accepted I will drop the
platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
separately to avoid holding the bulk of the series up. Ideally I would like
to get the safe limits in so users don't fully lose functionality or continue
to be exposed to potential instability from setting too low, or be mislead
in to thinking they can set limits higher than actual limit.
The bulk of the PPT patch is data, the actual functional part is relatively
small and similar to the last version.
Unfortunately I've been rather busy over the months and may not cover
everything in the v7 changelog but I've tried to be as comprehensive as I can.
Regards,
Luke
Changelog:
- v1
- Initial submission
- v2
- Too many changes to list, but all concerns raised in previous submission addressed.
- History: https://lore.kernel.org/platform-driver-x86/20240716051612.64842-1-luke@ljones.dev/
- v3
- All concerns addressed.
- History: https://lore.kernel.org/platform-driver-x86/20240806020747.365042-1-luke@ljones.dev/
- v4
- Use EXPORT_SYMBOL_NS_GPL() for the symbols required in this patch series
- Add patch for hid-asus due to the use of EXPORT_SYMBOL_NS_GPL()
- Split the PPT knobs out to a separate patch
- Split the hd_panel setting out to a new patch
- Clarify some of APU MEM configuration and convert int to hex
- Rename deprecated Kconfig option to ASUS_WMI_DEPRECATED_ATTRS
- Fixup cyclic dependency in Kconfig
- v5
- deprecate patch: cleanup ``#if`, ``#endif` statements, edit kconfig detail, edit commit msg
- cleanup ppt* tuning patch
- proper error handling in module init, plus pr_err()
- ppt tunables have a notice if there is no match to get defaults
- better error handling in cpu core handling
- don't continue if failure
- use the mutex to gate WMI writes
- V6
- correctly cleanup/unwind if module init fails
- V7
- Remove review tags where the code changed significantly
- Add auto_screen_brightness WMI attribute support
- Move PPT patch to end
- Add support min/max PPT values for 36 laptops (and two handhelds)
- reword commit for "asus-wmi: export symbols used for read/write WMI"
- asus-armoury: move existing tunings to asus-armoury
- Correction to license header
- Remove the (initial) mutex use (added for core count only in that patch)
- Clarify some doc comments (attr_int_store)
- Cleanup pr_warn in dgpu/egpu/mux functions
- Restructure logic in asus_fw_attr_add()
- Check gpu_mux_dev_id and mini_led_dev_id before remove attrs
- asus-armoury: add core count control:
- add mutex to prevent possible concurrent write to the core
count WMI due to separated bit/little attributes
- asus-armoury: add ppt_* and nv_* tuning knobs:
- Move to end of series
- Refactor to use a table of allowed min/max values to
ensure safe settings
- General code cleanup
- Ensure checkpatch.pl returns clean for all
- V8
- asus-armoury: move existing tunings to asus-armoury module
- Further cleanup: https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m72e203f64a5a28c9c21672406b2e9f554a8a8e38
- asus-armoury: add ppt_* and nv_* tuning knobs
- Address concerns in https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m77971b5c1e7f018954c16354e623fc06522c5e41
- Refactor struct asus_armoury_priv to record both AC and DC settings
- Tidy macros and functions affected by the above to be clearer as a result
- Move repeated strings such as "ppt_pl1_spl" to #defines
- Split should_create_tunable_attr() in to two functions to better clarify:
- is_power_tunable_attr()
- has_valid_limit()
- Restructure init_rog_tunables() to initialise AC and DC in a
way that makes more sense.
- Ensure that if DC setting table is not available then attributes
return -ENODEV only if on DC mode.
- V9
- asus-armoury: move existing tunings to asus-armoury module
- return -EBUSY when eGPU/dGPU cannot be deactivated
- asus-armoury: add apu-mem control support
- discard the WMI presence bit fixing the functionality
- asus-armoury: add core count control
- replace mutex lock/unlock with guard
- move core count alloc for initialization in init_max_cpu_cores()
- v10
- platform/x86: asus-wmi: export symbols used for read/write WMI
- fix error with redefinition of asus_wmi_set_devstate
- asus-armoury: move existing tunings to asus-armoury module
- hwmon or other -> hwmon or others
- fix wrong function name in documentation (attr_uint_store)
- use kstrtouint where appropriate
- (*) fix unreachable code warning: the fix turned out to be partial
- improve return values in case of error in egpu_enable_current_value_store
- asus-armoury: asus-armoury: add screen auto-brightness toggle
- actually register screen_auto_brightness attribute
- v11
- cover-letter:
- reorganize the changelog of v10
- asus-armoury: move existing tunings to asus-armoury module
- move the DMIs list in its own include, fixing (*) for good
- asus-armoury: add ppt_* and nv_* tuning knobs
- fix warning about redefinition of ppt_pl2_sppt_def for GV601R
- v12
- asus-armoury: add ppt_* and nv_* tuning knobs
- add min/max values for FA608WI and FX507VI
- v13
- asus-armoury: add ppt_* and nv_* tuning knobs
- fix a typo in a comment about _def attributes
- add min/max values for GU605CW and G713PV
- asus-armoury: add apu-mem control support
- fix a possible out-of-bounds read in apu_mem_current_value_store
- v14
- platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
- added patch to rename the symbol for consistency
- platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
- remove the unchecked usage of dmi_get_system_info while
also increasing consistency with other messages
Denis Benato (1):
platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
Luke D. Jones (8):
platform/x86: asus-wmi: export symbols used for read/write WMI
platform/x86: asus-armoury: move existing tunings to asus-armoury
module
platform/x86: asus-armoury: add panel_hd_mode attribute
platform/x86: asus-armoury: add apu-mem control support
platform/x86: asus-armoury: add core count control
platform/x86: asus-armoury: add screen auto-brightness toggle
platform/x86: asus-wmi: deprecate bios features
platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
.../ABI/testing/sysfs-platform-asus-wmi | 17 +
drivers/hid/hid-asus.c | 1 +
drivers/platform/x86/Kconfig | 23 +
drivers/platform/x86/Makefile | 1 +
drivers/platform/x86/asus-armoury.c | 1172 ++++++++++++++
drivers/platform/x86/asus-armoury.h | 1402 +++++++++++++++++
drivers/platform/x86/asus-wmi.c | 170 +-
.../platform_data/x86/asus-wmi-leds-ids.h | 50 +
include/linux/platform_data/x86/asus-wmi.h | 62 +-
9 files changed, 2823 insertions(+), 75 deletions(-)
create mode 100644 drivers/platform/x86/asus-armoury.c
create mode 100644 drivers/platform/x86/asus-armoury.h
create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
--
2.51.0
^ permalink raw reply [flat|nested] 30+ messages in thread
* [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-15 13:03 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module Denis Benato
` (8 subsequent siblings)
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
Export symbols for reading/writing WMI symbols using a namespace.
Existing functions:
- asus_wmi_evaluate_method
- asus_wmi_set_devstate
New function:
- asus_wmi_get_devstate_dsts
The new function is intended for use with DSTS WMI method only and
avoids requiring the asus_wmi driver data to select the WMI method.
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
---
drivers/platform/x86/asus-wmi.c | 40 ++++++++++++++++++++--
include/linux/platform_data/x86/asus-wmi.h | 5 +++
2 files changed, 42 insertions(+), 3 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index e72a2b5d158e..38ab5306e05a 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -390,7 +390,7 @@ int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
{
return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
}
-EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
+EXPORT_SYMBOL_NS_GPL(asus_wmi_evaluate_method, "ASUS_WMI");
static int asus_wmi_evaluate_method5(u32 method_id,
u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
@@ -554,12 +554,46 @@ static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
return 0;
}
-int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
- u32 *retval)
+/**
+ * asus_wmi_get_devstate_dsts() - Get the WMI function state.
+ * @dev_id: The WMI method ID to call.
+ * @retval: A pointer to where to store the value returned from WMI.
+ * @return: 0 on success and retval is filled.
+ * @return: -ENODEV if the method ID is unsupported.
+ * @return: everything else is an error from WMI call.
+ */
+int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+ int err;
+
+ err = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, retval);
+ if (err)
+ return err;
+
+ if (*retval == ASUS_WMI_UNSUPPORTED_METHOD)
+ return -ENODEV;
+
+ return 0;
+}
+EXPORT_SYMBOL_NS_GPL(asus_wmi_get_devstate_dsts, "ASUS_WMI");
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ * @dev_id: The WMI function to call.
+ * @ctrl_param: The argument to be used for this WMI function.
+ * @retval: A pointer to where to store the value returned from WMI.
+ * @return: 0 on success and retval is filled.
+ * @return: everything else is an error from WMI call.
+ *
+ * A asus_wmi_set_devstate() call must be paired with a
+ * asus_wmi_get_devstate_dsts() to check if the WMI function is supported.
+ */
+int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
{
return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
ctrl_param, retval);
}
+EXPORT_SYMBOL_NS_GPL(asus_wmi_set_devstate, "ASUS_WMI");
/* Helper for special devices with magic return codes */
static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 8a515179113d..dbd44d9fbb6f 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -166,6 +166,7 @@ enum asus_ally_mcu_hack {
#if IS_REACHABLE(CONFIG_ASUS_WMI)
void set_ally_mcu_hack(enum asus_ally_mcu_hack status);
void set_ally_mcu_powersave(bool enabled);
+int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval);
int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval);
int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval);
#else
@@ -179,6 +180,10 @@ static inline int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
{
return -ENODEV;
}
+static inline int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+ return -ENODEV;
+}
static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
u32 *retval)
{
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
2025-10-15 1:47 ` [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-15 13:56 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 3/9] platform/x86: asus-armoury: add panel_hd_mode attribute Denis Benato
` (7 subsequent siblings)
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
The fw_attributes_class provides a much cleaner interface to all of the
attributes introduced to asus-wmi. This patch moves all of these extra
attributes over to fw_attributes_class, and shifts the bulk of these
definitions to a new kernel module to reduce the clutter of asus-wmi
with the intention of deprecating the asus-wmi attributes in future.
The work applies only to WMI methods which don't have a clearly defined
place within the sysfs and as a result ended up lumped together in
/sys/devices/platform/asus-nb-wmi/ with no standard API.
Where possible the fw attrs now implement defaults, min, max, scalar,
choices, etc. As en example dgpu_disable becomes:
/sys/class/firmware-attributes/asus-armoury/attributes/dgpu_disable/
├── current_value
├── display_name
├── possible_values
└── type
as do other attributes.
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
---
drivers/hid/hid-asus.c | 1 +
drivers/platform/x86/Kconfig | 12 +
drivers/platform/x86/Makefile | 1 +
drivers/platform/x86/asus-armoury.c | 545 ++++++++++++++++++
drivers/platform/x86/asus-armoury.h | 164 ++++++
drivers/platform/x86/asus-wmi.c | 5 +-
.../platform_data/x86/asus-wmi-leds-ids.h | 50 ++
include/linux/platform_data/x86/asus-wmi.h | 43 +-
8 files changed, 777 insertions(+), 44 deletions(-)
create mode 100644 drivers/platform/x86/asus-armoury.c
create mode 100644 drivers/platform/x86/asus-armoury.h
create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c
index a444d41e53b6..472bca54642b 100644
--- a/drivers/hid/hid-asus.c
+++ b/drivers/hid/hid-asus.c
@@ -27,6 +27,7 @@
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
#include <linux/input/mt.h>
#include <linux/usb.h> /* For to_usb_interface for T100 touchpad intf check */
#include <linux/power_supply.h>
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 46e62feeda3c..8b827680754c 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -262,6 +262,18 @@ config ASUS_WIRELESS
If you choose to compile this driver as a module the module will be
called asus-wireless.
+config ASUS_ARMOURY
+ tristate "ASUS Armoury driver"
+ depends on ASUS_WMI
+ select FW_ATTR_CLASS
+ help
+ Say Y here if you have a WMI aware Asus machine and would like to use the
+ firmware_attributes API to control various settings typically exposed in
+ the ASUS Armoury Crate application available on Windows.
+
+ To compile this driver as a module, choose M here: the module will
+ be called asus-armoury.
+
config ASUS_WMI
tristate "ASUS WMI Driver"
depends on ACPI_WMI
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index c7db2a88c11a..4b1220f9b194 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -33,6 +33,7 @@ obj-$(CONFIG_APPLE_GMUX) += apple-gmux.o
# ASUS
obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
obj-$(CONFIG_ASUS_WIRELESS) += asus-wireless.o
+obj-$(CONFIG_ASUS_ARMOURY) += asus-armoury.o
obj-$(CONFIG_ASUS_WMI) += asus-wmi.o
obj-$(CONFIG_ASUS_NB_WMI) += asus-nb-wmi.o
obj-$(CONFIG_ASUS_TF103C_DOCK) += asus-tf103c-dock.o
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
new file mode 100644
index 000000000000..57ed9449ec5f
--- /dev/null
+++ b/drivers/platform/x86/asus-armoury.c
@@ -0,0 +1,545 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Asus Armoury (WMI) attributes driver.
+ *
+ * This driver uses the fw_attributes class to expose various WMI functions
+ * that are present in many gaming and some non-gaming ASUS laptops.
+ *
+ * These typically don't fit anywhere else in the sysfs such as under LED class,
+ * hwmon or others, and are set in Windows using the ASUS Armoury Crate tool.
+ *
+ * Copyright(C) 2024 Luke Jones <luke@ljones.dev>
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/acpi.h>
+#include <linux/array_size.h>
+#include <linux/bitfield.h>
+#include <linux/device.h>
+#include <linux/dmi.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/kmod.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/printk.h>
+#include <linux/types.h>
+
+#include "asus-armoury.h"
+#include "firmware_attributes_class.h"
+
+#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+#define ASUS_MINI_LED_MODE_MASK 0x03
+/* Standard modes for devices with only on/off */
+#define ASUS_MINI_LED_OFF 0x00
+#define ASUS_MINI_LED_ON 0x01
+/* Like "on" but the effect is more vibrant or brighter */
+#define ASUS_MINI_LED_STRONG_MODE 0x02
+/* New modes for devices with 3 mini-led mode types */
+#define ASUS_MINI_LED_2024_WEAK 0x00
+#define ASUS_MINI_LED_2024_STRONG 0x01
+#define ASUS_MINI_LED_2024_OFF 0x02
+
+static struct asus_armoury_priv {
+ struct device *fw_attr_dev;
+ struct kset *fw_attr_kset;
+
+ u32 mini_led_dev_id;
+ u32 gpu_mux_dev_id;
+} asus_armoury;
+
+struct fw_attrs_group {
+ bool pending_reboot;
+};
+
+static struct fw_attrs_group fw_attrs = {
+ .pending_reboot = false,
+};
+
+struct asus_attr_group {
+ const struct attribute_group *attr_group;
+ u32 wmi_devid;
+};
+
+static bool asus_wmi_is_present(u32 dev_id)
+{
+ u32 retval;
+ int status;
+
+ status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, &retval);
+ pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
+
+ return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
+}
+
+static void asus_set_reboot_and_signal_event(void)
+{
+ fw_attrs.pending_reboot = true;
+ kobject_uevent(&asus_armoury.fw_attr_dev->kobj, KOBJ_CHANGE);
+}
+
+static ssize_t pending_reboot_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ return sysfs_emit(buf, "%d\n", fw_attrs.pending_reboot);
+}
+
+static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
+
+static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
+{
+ return !strcmp(attr->attr.name, "gpu_mux_mode");
+}
+
+static int armoury_wmi_set_devstate(struct kobj_attribute *attr, u32 value, u32 wmi_dev)
+{
+ u32 result;
+ int err;
+
+ err = asus_wmi_set_devstate(wmi_dev, value, &result);
+ if (err) {
+ pr_err("Failed to set %s: %d\n", attr->attr.name, err);
+ return err;
+ }
+ /*
+ * !1 is usually considered a fail by ASUS, but some WMI methods do use > 1
+ * to return a status code or similar.
+ */
+ if (result < 1) {
+ pr_err("Failed to set %s: (result): 0x%x\n", attr->attr.name, result);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/**
+ * attr_uint_store() - Send an uint to wmi method, checks if within min/max exclusive.
+ * @kobj: Pointer to the driver object.
+ * @attr: Pointer to the attribute calling this function.
+ * @buf: The buffer to read from, this is parsed to `uint` type.
+ * @count: Required by sysfs attribute macros, pass in from the callee attr.
+ * @min: Minimum accepted value. Below this returns -EINVAL.
+ * @max: Maximum accepted value. Above this returns -EINVAL.
+ * @store_value: Pointer to where the parsed value should be stored.
+ * @wmi_dev: The WMI function ID to use.
+ *
+ * This function is intended to be generic so it can be called from any "_store"
+ * attribute which works only with integers. The integer to be sent to the WMI method
+ * is range checked and an error returned if out of range.
+ *
+ * If the value is valid and WMI is success, then the sysfs attribute is notified
+ * and if asus_bios_requires_reboot() is true then reboot attribute is also notified.
+ *
+ * Returns: Either count, or an error.
+ */
+static ssize_t attr_uint_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf,
+ size_t count, u32 min, u32 max, u32 *store_value, u32 wmi_dev)
+{
+ u32 value;
+ int err;
+
+ err = kstrtouint(buf, 10, &value);
+ if (err)
+ return err;
+
+ if (value < min || value > max)
+ return -EINVAL;
+
+ err = armoury_wmi_set_devstate(attr, value, wmi_dev);
+ if (err)
+ return err;
+
+ if (store_value != NULL)
+ *store_value = value;
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ if (asus_bios_requires_reboot(attr))
+ asus_set_reboot_and_signal_event();
+
+ return count;
+}
+
+static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ return sysfs_emit(buf, "enumeration\n");
+}
+
+/* Mini-LED mode **************************************************************/
+static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ u32 value;
+ int err;
+
+ err = asus_wmi_get_devstate_dsts(asus_armoury.mini_led_dev_id, &value);
+ if (err)
+ return err;
+
+ value &= ASUS_MINI_LED_MODE_MASK;
+
+ /*
+ * Remap the mode values to match previous generation mini-LED. The last gen
+ * WMI 0 == off, while on this version WMI 2 == off (flipped).
+ */
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+ switch (value) {
+ case ASUS_MINI_LED_2024_WEAK:
+ value = ASUS_MINI_LED_ON;
+ break;
+ case ASUS_MINI_LED_2024_STRONG:
+ value = ASUS_MINI_LED_STRONG_MODE;
+ break;
+ case ASUS_MINI_LED_2024_OFF:
+ value = ASUS_MINI_LED_OFF;
+ break;
+ }
+ }
+
+ return sysfs_emit(buf, "%u\n", value);
+}
+
+static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ u32 mode;
+ int err;
+
+ err = kstrtou32(buf, 10, &mode);
+ if (err)
+ return err;
+
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
+ mode > ASUS_MINI_LED_ON)
+ return -EINVAL;
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
+ mode > ASUS_MINI_LED_STRONG_MODE)
+ return -EINVAL;
+
+ /*
+ * Remap the mode values so expected behaviour is the same as the last
+ * generation of mini-LED with 0 == off, 1 == on.
+ */
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+ switch (mode) {
+ case ASUS_MINI_LED_OFF:
+ mode = ASUS_MINI_LED_2024_OFF;
+ break;
+ case ASUS_MINI_LED_ON:
+ mode = ASUS_MINI_LED_2024_WEAK;
+ break;
+ case ASUS_MINI_LED_STRONG_MODE:
+ mode = ASUS_MINI_LED_2024_STRONG;
+ break;
+ }
+ }
+
+ err = armoury_wmi_set_devstate(attr, mode, asus_armoury.mini_led_dev_id);
+ if (err)
+ return err;
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+
+static ssize_t mini_led_mode_possible_values_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ switch (asus_armoury.mini_led_dev_id) {
+ case ASUS_WMI_DEVID_MINI_LED_MODE:
+ return sysfs_emit(buf, "0;1\n");
+ case ASUS_WMI_DEVID_MINI_LED_MODE2:
+ return sysfs_emit(buf, "0;1;2\n");
+ default:
+ return -ENODEV;
+ }
+}
+
+ATTR_GROUP_ENUM_CUSTOM(mini_led_mode, "mini_led_mode", "Set the mini-LED backlight mode");
+
+static ssize_t gpu_mux_mode_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int result, err;
+ u32 optimus;
+
+ err = kstrtou32(buf, 10, &optimus);
+ if (err)
+ return err;
+
+ if (optimus > 1)
+ return -EINVAL;
+
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_DGPU)) {
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_DGPU, &result);
+ if (err)
+ return err;
+ if (result && !optimus) {
+ pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %02X %02X\n",
+ result, optimus);
+ return -ENODEV;
+ }
+ }
+
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_EGPU)) {
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU, &result);
+ if (err)
+ return err;
+ if (result && !optimus) {
+ pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled\n");
+ return -EBUSY;
+ }
+ }
+
+ err = armoury_wmi_set_devstate(attr, optimus, asus_armoury.gpu_mux_dev_id);
+ if (err)
+ return err;
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+ asus_set_reboot_and_signal_event();
+
+ return count;
+}
+WMI_SHOW_INT(gpu_mux_mode_current_value, "%u\n", asus_armoury.gpu_mux_dev_id);
+ATTR_GROUP_BOOL_CUSTOM(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
+
+/*
+ * A user may be required to store the value twice, typical store first, then
+ * rescan PCI bus to activate power, then store a second time to save correctly.
+ */
+static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int result, err;
+ u32 disable;
+
+ err = kstrtou32(buf, 10, &disable);
+ if (err)
+ return err;
+
+ if (disable > 1)
+ return -EINVAL;
+
+ if (asus_armoury.gpu_mux_dev_id) {
+ err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+ if (err)
+ return err;
+ if (!result && disable) {
+ pr_warn("Can not disable dGPU when the MUX is in dGPU mode\n");
+ return -EBUSY;
+ }
+ }
+
+ err = armoury_wmi_set_devstate(attr, disable, ASUS_WMI_DEVID_DGPU);
+ if (err)
+ return err;
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
+ATTR_GROUP_BOOL_CUSTOM(dgpu_disable, "dgpu_disable", "Disable the dGPU");
+
+/* The ACPI call to enable the eGPU also disables the internal dGPU */
+static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ int result, err;
+ u32 enable;
+
+ err = kstrtou32(buf, 10, &enable);
+ if (err)
+ return err;
+
+ if (enable > 1)
+ return -EINVAL;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU_CONNECTED, &result);
+ if (err) {
+ pr_warn("Failed to get eGPU connection status: %d\n", err);
+ return err;
+ }
+
+ if (asus_armoury.gpu_mux_dev_id) {
+ err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+ if (err) {
+ pr_warn("Failed to get GPU MUX status: %d\n", result);
+ return err;
+ }
+ if (!result && enable) {
+ pr_warn("Can not enable eGPU when the MUX is in dGPU mode\n");
+ return -ENODEV;
+ }
+ }
+
+ err = armoury_wmi_set_devstate(attr, enable, ASUS_WMI_DEVID_EGPU);
+ if (err)
+ return err;
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
+ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
+
+/* Simple attribute creation */
+ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
+ "Show the current mode of charging");
+
+ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
+ "Set the boot POST sound");
+ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
+ "Set MCU powersaving mode");
+ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
+ "Set the panel refresh overdrive");
+ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
+ "Show the eGPU connection status");
+
+/* If an attribute does not require any special case handling add it here */
+static const struct asus_attr_group armoury_attr_groups[] = {
+ { &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
+ { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
+ { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
+
+ { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
+ { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
+ { &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
+ { &panel_od_attr_group, ASUS_WMI_DEVID_PANEL_OD },
+};
+
+static int asus_fw_attr_add(void)
+{
+ int err, i;
+
+ asus_armoury.fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
+ NULL, "%s", DRIVER_NAME);
+ if (IS_ERR(asus_armoury.fw_attr_dev)) {
+ err = PTR_ERR(asus_armoury.fw_attr_dev);
+ goto fail_class_get;
+ }
+
+ asus_armoury.fw_attr_kset = kset_create_and_add("attributes", NULL,
+ &asus_armoury.fw_attr_dev->kobj);
+ if (!asus_armoury.fw_attr_kset) {
+ err = -ENOMEM;
+ goto err_destroy_classdev;
+ }
+
+ err = sysfs_create_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+ if (err) {
+ pr_err("Failed to create sysfs level attributes\n");
+ goto err_destroy_kset;
+ }
+
+ asus_armoury.mini_led_dev_id = 0;
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE))
+ asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
+ else if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE2))
+ asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
+
+ if (asus_armoury.mini_led_dev_id) {
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &mini_led_mode_attr_group);
+ if (err) {
+ pr_err("Failed to create sysfs-group for mini_led\n");
+ goto err_remove_file;
+ }
+ }
+
+ asus_armoury.gpu_mux_dev_id = 0;
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX))
+ asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
+ else if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX_VIVO))
+ asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX_VIVO;
+
+ if (asus_armoury.gpu_mux_dev_id) {
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &gpu_mux_mode_attr_group);
+ if (err) {
+ pr_err("Failed to create sysfs-group for gpu_mux\n");
+ goto err_remove_mini_led_group;
+ }
+ }
+
+ for (i = 0; i < ARRAY_SIZE(armoury_attr_groups); i++) {
+ if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
+ continue;
+
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ armoury_attr_groups[i].attr_group);
+ if (err) {
+ pr_err("Failed to create sysfs-group for %s\n",
+ armoury_attr_groups[i].attr_group->name);
+ goto err_remove_groups;
+ }
+ }
+
+ return 0;
+
+err_remove_groups:
+ while (i--) {
+ if (asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
+ sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj,
+ armoury_attr_groups[i].attr_group);
+ }
+ if (asus_armoury.gpu_mux_dev_id)
+ sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &gpu_mux_mode_attr_group);
+err_remove_mini_led_group:
+ if (asus_armoury.mini_led_dev_id)
+ sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &mini_led_mode_attr_group);
+err_remove_file:
+ sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+err_destroy_kset:
+ kset_unregister(asus_armoury.fw_attr_kset);
+err_destroy_classdev:
+fail_class_get:
+ device_destroy(&firmware_attributes_class, MKDEV(0, 0));
+ return err;
+}
+
+/* Init / exit ****************************************************************/
+
+static int __init asus_fw_init(void)
+{
+ char *wmi_uid;
+
+ wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
+ if (!wmi_uid)
+ return -ENODEV;
+
+ /*
+ * if equal to "ASUSWMI" then it's DCTS that can't be used for this
+ * driver, DSTS is required.
+ */
+ if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
+ return -ENODEV;
+
+ return asus_fw_attr_add();
+}
+
+static void __exit asus_fw_exit(void)
+{
+ sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+ kset_unregister(asus_armoury.fw_attr_kset);
+ device_destroy(&firmware_attributes_class, MKDEV(0, 0));
+}
+
+module_init(asus_fw_init);
+module_exit(asus_fw_exit);
+
+MODULE_IMPORT_NS("ASUS_WMI");
+MODULE_AUTHOR("Luke Jones <luke@ljones.dev>");
+MODULE_DESCRIPTION("ASUS BIOS Configuration Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("wmi:" ASUS_NB_WMI_EVENT_GUID);
diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
new file mode 100644
index 000000000000..61675e7b5a60
--- /dev/null
+++ b/drivers/platform/x86/asus-armoury.h
@@ -0,0 +1,164 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Definitions for kernel modules using asus-armoury driver
+ *
+ * Copyright (c) 2024 Luke Jones <luke@ljones.dev>
+ */
+
+#ifndef _ASUS_ARMOURY_H_
+#define _ASUS_ARMOURY_H_
+
+#include <linux/types.h>
+#include <linux/platform_device.h>
+
+#define DRIVER_NAME "asus-armoury"
+
+#define __ASUS_ATTR_RO(_func, _name) \
+ { \
+ .attr = { .name = __stringify(_name), .mode = 0444 }, \
+ .show = _func##_##_name##_show, \
+ }
+
+#define __ASUS_ATTR_RO_AS(_name, _show) \
+ { \
+ .attr = { .name = __stringify(_name), .mode = 0444 }, \
+ .show = _show, \
+ }
+
+#define __ASUS_ATTR_RW(_func, _name) \
+ __ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store)
+
+#define __WMI_STORE_INT(_attr, _min, _max, _wmi) \
+ static ssize_t _attr##_store(struct kobject *kobj, \
+ struct kobj_attribute *attr, \
+ const char *buf, size_t count) \
+ { \
+ return attr_uint_store(kobj, attr, buf, count, _min, \
+ _max, NULL, _wmi); \
+ }
+
+#define WMI_SHOW_INT(_attr, _fmt, _wmi) \
+ static ssize_t _attr##_show(struct kobject *kobj, \
+ struct kobj_attribute *attr, char *buf) \
+ { \
+ u32 result; \
+ int err; \
+ \
+ err = asus_wmi_get_devstate_dsts(_wmi, &result); \
+ if (err) \
+ return err; \
+ return sysfs_emit(buf, _fmt, \
+ result & ~ASUS_WMI_DSTS_PRESENCE_BIT); \
+ }
+
+/* Create functions and attributes for use in other macros or on their own */
+
+/* Shows a formatted static variable */
+#define __ATTR_SHOW_FMT(_prop, _attrname, _fmt, _val) \
+ static ssize_t _attrname##_##_prop##_show( \
+ struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
+ { \
+ return sysfs_emit(buf, _fmt, _val); \
+ } \
+ static struct kobj_attribute attr_##_attrname##_##_prop = \
+ __ASUS_ATTR_RO(_attrname, _prop)
+
+#define __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)\
+ WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RO(_attrname, current_value); \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, enum_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+#define __ATTR_RW_INT_GROUP_ENUM(_attrname, _minv, _maxv, _wmi, _fsname,\
+ _possible, _dispname) \
+ __WMI_STORE_INT(_attrname##_current_value, _minv, _maxv, _wmi); \
+ WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value); \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, enum_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+/* Boolean style enumeration, base macro. Requires adding show/store */
+#define __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname) \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, enum_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+#define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
+ __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, "0;1", _dispname)
+
+
+#define ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname) \
+ __ATTR_RW_INT_GROUP_ENUM(_attrname, 0, 1, _wmi, _fsname, "0;1", _dispname)
+
+#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
+ __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ */
+#define ATTR_GROUP_BOOL_CUSTOM(_attrname, _fsname, _dispname) \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value); \
+ __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ * and <name>_possible_values_show()
+ */
+#define ATTR_GROUP_ENUM_CUSTOM(_attrname, _fsname, _dispname) \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value); \
+ static struct kobj_attribute attr_##_attrname##_possible_values = \
+ __ASUS_ATTR_RO(_attrname, possible_values); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, enum_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+#endif /* _ASUS_ARMOURY_H_ */
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 38ab5306e05a..0d0c84a37ad8 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -30,6 +30,7 @@
#include <linux/pci.h>
#include <linux/pci_hotplug.h>
#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
#include <linux/platform_device.h>
#include <linux/platform_profile.h>
#include <linux/power_supply.h>
@@ -55,8 +56,6 @@ module_param(fnlock_default, bool, 0444);
#define to_asus_wmi_driver(pdrv) \
(container_of((pdrv), struct asus_wmi_driver, platform_driver))
-#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
-
#define NOTIFY_BRNUP_MIN 0x11
#define NOTIFY_BRNUP_MAX 0x1f
#define NOTIFY_BRNDOWN_MIN 0x20
@@ -105,8 +104,6 @@ module_param(fnlock_default, bool, 0444);
#define USB_INTEL_XUSB2PR 0xD0
#define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31
-#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
-
#define WMI_EVENT_MASK 0xFFFF
#define FAN_CURVE_POINTS 8
diff --git a/include/linux/platform_data/x86/asus-wmi-leds-ids.h b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
new file mode 100644
index 000000000000..281b98ba0ca7
--- /dev/null
+++ b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
@@ -0,0 +1,50 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
+#define __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
+
+#include <linux/types.h>
+#include <linux/dmi.h>
+
+/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
+#if IS_REACHABLE(CONFIG_ASUS_WMI) || IS_REACHABLE(CONFIG_HID_ASUS)
+static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
+ {
+ .matches = {
+ DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
+ },
+ },
+ { },
+};
+#endif
+
+#endif /* __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H */
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index dbd44d9fbb6f..71c68425b3b9 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -6,6 +6,9 @@
#include <linux/types.h>
#include <linux/dmi.h>
+#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
+
/* WMI Methods */
#define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
#define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
@@ -191,44 +194,4 @@ static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
}
#endif
-/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
-static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
- {
- .matches = {
- DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
- },
- },
- {
- .matches = {
- DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
- },
- },
- { },
-};
-
#endif /* __PLATFORM_DATA_X86_ASUS_WMI_H */
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 3/9] platform/x86: asus-armoury: add panel_hd_mode attribute
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
2025-10-15 1:47 ` [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI Denis Benato
2025-10-15 1:47 ` [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-15 1:47 ` [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support Denis Benato
` (6 subsequent siblings)
9 siblings, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
From: "Luke D. Jones" <luke@ljones.dev>
Add panel_hd_mode to toggle the panel mode between single and high
definition modes.
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
---
drivers/platform/x86/asus-armoury.c | 6 +++++-
include/linux/platform_data/x86/asus-wmi.h | 1 +
2 files changed, 6 insertions(+), 1 deletion(-)
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index 57ed9449ec5f..68ce2c159ae1 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -92,7 +92,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
{
- return !strcmp(attr->attr.name, "gpu_mux_mode");
+ return !strcmp(attr->attr.name, "gpu_mux_mode") ||
+ !strcmp(attr->attr.name, "panel_hd_mode");
}
static int armoury_wmi_set_devstate(struct kobj_attribute *attr, u32 value, u32 wmi_dev)
@@ -403,6 +404,8 @@ ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
"Set MCU powersaving mode");
ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
"Set the panel refresh overdrive");
+ATTR_GROUP_BOOL_RW(panel_hd_mode, "panel_hd_mode", ASUS_WMI_DEVID_PANEL_HD,
+ "Set the panel HD mode to UHD<0> or FHD<1>");
ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
"Show the eGPU connection status");
@@ -416,6 +419,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
{ &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
{ &panel_od_attr_group, ASUS_WMI_DEVID_PANEL_OD },
+ { &panel_hd_mode_attr_group, ASUS_WMI_DEVID_PANEL_HD },
};
static int asus_fw_attr_add(void)
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 71c68425b3b9..10acd5d52e38 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -76,6 +76,7 @@
#define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO 0x00110019
/* Misc */
+#define ASUS_WMI_DEVID_PANEL_HD 0x0005001C
#define ASUS_WMI_DEVID_PANEL_OD 0x00050019
#define ASUS_WMI_DEVID_CAMERA 0x00060013
#define ASUS_WMI_DEVID_LID_FLIP 0x00060062
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (2 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 3/9] platform/x86: asus-armoury: add panel_hd_mode attribute Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-17 12:16 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 5/9] platform/x86: asus-armoury: add core count control Denis Benato
` (5 subsequent siblings)
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
Implement the APU memory size control under the asus-armoury module using
the fw_attributes class.
This allows the APU allocated memory size to be adjusted depending on
the users priority. A reboot is required after change.
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
---
drivers/platform/x86/asus-armoury.c | 81 ++++++++++++++++++++++
include/linux/platform_data/x86/asus-wmi.h | 2 +
2 files changed, 83 insertions(+)
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index 68ce2c159ae1..3b49a27e397d 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -394,6 +394,86 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj
WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
+/* Device memory available to APU */
+
+/* Values map for APU memory: some looks out of order but are actually correct */
+static u32 apu_mem_map[] = {
+ [0] = 0x000, /* called "AUTO" on the BIOS, is the minimum available */
+ [1] = 0x102,
+ [2] = 0x103,
+ [3] = 0x104,
+ [4] = 0x105,
+ [5] = 0x107,
+ [6] = 0x108,
+ [7] = 0x109,
+ [8] = 0x106,
+};
+
+static ssize_t apu_mem_current_value_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ int err;
+ u32 mem;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
+ if (err)
+ return err;
+
+ if ((mem & ASUS_WMI_DSTS_PRESENCE_BIT) == 0)
+ return -ENODEV;
+
+ mem &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+
+ /* After 0x000 is set, a read will return 0x100 */
+ if (mem == 0x100)
+ return sysfs_emit(buf, "0\n");
+
+ for (unsigned int i = 0; i < ARRAY_SIZE(apu_mem_map); i++) {
+ if (apu_mem_map[i] == mem)
+ return sysfs_emit(buf, "%u\n", i);
+ }
+
+ pr_warn("Unrecognised value for APU mem 0x%08x\n", mem);
+ return sysfs_emit(buf, "%u\n", mem);
+}
+
+static ssize_t apu_mem_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ int result, err;
+ u32 requested, mem;
+
+ result = kstrtou32(buf, 10, &requested);
+ if (result)
+ return result;
+
+ if (requested >= ARRAY_SIZE(apu_mem_map))
+ return -EINVAL;
+
+ mem = apu_mem_map[requested];
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
+ if (err) {
+ pr_warn("Failed to set apu_mem: %d\n", err);
+ return err;
+ }
+
+ pr_info("APU memory changed to %uGB, reboot required\n", requested+1);
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ asus_set_reboot_and_signal_event();
+
+ return count;
+}
+
+static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ BUILD_BUG_ON(ARRAY_SIZE(apu_mem_map) != 9);
+ return sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");
+}
+ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
+
/* Simple attribute creation */
ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
"Show the current mode of charging");
@@ -414,6 +494,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
{ &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
{ &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
+ { &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
{ &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
{ &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 10acd5d52e38..a4f6bab93a6f 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -137,6 +137,8 @@
/* dgpu on/off */
#define ASUS_WMI_DEVID_DGPU 0x00090020
+#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
+
/* gpu mux switch, 0 = dGPU, 1 = Optimus */
#define ASUS_WMI_DEVID_GPU_MUX 0x00090016
#define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (3 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-15 14:11 ` Ilpo Järvinen
2025-10-17 12:48 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 6/9] platform/x86: asus-armoury: add screen auto-brightness toggle Denis Benato
` (4 subsequent siblings)
9 siblings, 2 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
Implement Intel core enablement under the asus-armoury module using the
fw_attributes class.
This allows users to enable or disable preformance or efficiency cores
depending on their requirements. After change a reboot is required.
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
---
drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
drivers/platform/x86/asus-armoury.h | 28 +++
include/linux/platform_data/x86/asus-wmi.h | 5 +
3 files changed, 290 insertions(+), 1 deletion(-)
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index 3b49a27e397d..3d963025d84e 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -45,13 +45,49 @@
#define ASUS_MINI_LED_2024_STRONG 0x01
#define ASUS_MINI_LED_2024_OFF 0x02
+#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
+#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
+
+enum cpu_core_type {
+ CPU_CORE_PERF = 0,
+ CPU_CORE_POWER,
+};
+
+enum cpu_core_value {
+ CPU_CORE_DEFAULT = 0,
+ CPU_CORE_MIN,
+ CPU_CORE_MAX,
+ CPU_CORE_CURRENT,
+};
+
+#define CPU_PERF_CORE_COUNT_MIN 4
+#define CPU_POWR_CORE_COUNT_MIN 0
+
+/* Tunables provided by ASUS for gaming laptops */
+struct cpu_cores {
+ u32 cur_perf_cores;
+ u32 min_perf_cores;
+ u32 max_perf_cores;
+ u32 cur_power_cores;
+ u32 min_power_cores;
+ u32 max_power_cores;
+};
+
static struct asus_armoury_priv {
struct device *fw_attr_dev;
struct kset *fw_attr_kset;
+ struct cpu_cores *cpu_cores;
u32 mini_led_dev_id;
u32 gpu_mux_dev_id;
-} asus_armoury;
+ /*
+ * Mutex to prevent big/little core count changes writing to same
+ * endpoint at the same time. Must lock during attr store.
+ */
+ struct mutex cpu_core_mutex;
+} asus_armoury = {
+ .cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex)
+};
struct fw_attrs_group {
bool pending_reboot;
@@ -93,6 +129,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
{
return !strcmp(attr->attr.name, "gpu_mux_mode") ||
+ !strcmp(attr->attr.name, "cores_performance") ||
+ !strcmp(attr->attr.name, "cores_efficiency") ||
!strcmp(attr->attr.name, "panel_hd_mode");
}
@@ -171,6 +209,12 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
return sysfs_emit(buf, "enumeration\n");
}
+static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ return sysfs_emit(buf, "integer\n");
+}
+
/* Mini-LED mode **************************************************************/
static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
@@ -474,6 +518,207 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
}
ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
+static int init_max_cpu_cores(void)
+{
+ u32 cores;
+ int err;
+
+ asus_armoury.cpu_cores = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
+ if (!asus_armoury.cpu_cores)
+ return -ENOMEM;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
+ if (err)
+ return err;
+
+ if ((cores & ASUS_WMI_DSTS_PRESENCE_BIT) == 0) {
+ pr_err("ACPI does not support CPU core count control\n");
+ err = -ENODEV;
+ goto init_max_cpu_cores_err;
+ }
+
+ asus_armoury.cpu_cores->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
+ asus_armoury.cpu_cores->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
+ if (err) {
+ pr_err("Could not get CPU core count: error %d\n", err);
+ goto init_max_cpu_cores_err;
+ }
+
+ asus_armoury.cpu_cores->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
+ asus_armoury.cpu_cores->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
+
+ asus_armoury.cpu_cores->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
+ asus_armoury.cpu_cores->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
+
+ return 0;
+
+init_max_cpu_cores_err:
+ kfree(asus_armoury.cpu_cores);
+ return err;
+}
+
+static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
+ enum cpu_core_type core_type, enum cpu_core_value core_value)
+{
+ u32 cores;
+
+ switch (core_value) {
+ case CPU_CORE_DEFAULT:
+ case CPU_CORE_MAX:
+ if (core_type == CPU_CORE_PERF)
+ return sysfs_emit(buf, "%u\n",
+ asus_armoury.cpu_cores->max_perf_cores);
+ else
+ return sysfs_emit(buf, "%u\n",
+ asus_armoury.cpu_cores->max_power_cores);
+ case CPU_CORE_MIN:
+ if (core_type == CPU_CORE_PERF)
+ return sysfs_emit(buf, "%u\n",
+ asus_armoury.cpu_cores->min_perf_cores);
+ else
+ return sysfs_emit(buf, "%u\n",
+ asus_armoury.cpu_cores->min_power_cores);
+ default:
+ break;
+ }
+
+ if (core_type == CPU_CORE_PERF)
+ cores = asus_armoury.cpu_cores->cur_perf_cores;
+ else
+ cores = asus_armoury.cpu_cores->cur_power_cores;
+
+ return sysfs_emit(buf, "%u\n", cores);
+}
+
+static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
+ const char *buf, enum cpu_core_type core_type)
+{
+ u32 new_cores, perf_cores, power_cores, out_val, min, max;
+ int result, err;
+
+ result = kstrtou32(buf, 10, &new_cores);
+ if (result)
+ return result;
+
+ scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
+ if (core_type == CPU_CORE_PERF) {
+ perf_cores = new_cores;
+ power_cores = asus_armoury.cpu_cores->cur_power_cores;
+ min = asus_armoury.cpu_cores->min_perf_cores;
+ max = asus_armoury.cpu_cores->max_perf_cores;
+ } else {
+ perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
+ power_cores = new_cores;
+ min = asus_armoury.cpu_cores->min_power_cores;
+ max = asus_armoury.cpu_cores->max_power_cores;
+ }
+
+ if (new_cores < min || new_cores > max)
+ return -EINVAL;
+
+ out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
+ FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
+ if (err) {
+ pr_warn("Failed to set CPU core count: %d\n", err);
+ return err;
+ }
+
+ if (result > 1) {
+ pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
+ return -EIO;
+ }
+ }
+
+ pr_info("CPU core count changed, reboot required\n");
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+ asus_set_reboot_and_signal_event();
+
+ return 0;
+}
+
+static ssize_t cores_performance_min_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
+}
+
+static ssize_t cores_performance_max_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
+}
+
+static ssize_t cores_performance_default_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_performance_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_performance_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ int err;
+
+ err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
+ if (err)
+ return err;
+
+ return count;
+}
+ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
+ "Set the max available performance cores");
+
+static ssize_t cores_efficiency_min_value_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
+}
+
+static ssize_t cores_efficiency_max_value_show(struct kobject *kobj, struct kobj_attribute *attr,
+ char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
+}
+
+static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int err;
+
+ err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
+ if (err)
+ return err;
+
+ return count;
+}
+ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
+ "Set the max available efficiency cores");
+
/* Simple attribute creation */
ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
"Show the current mode of charging");
@@ -495,6 +740,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
{ &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
{ &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
+ { &cores_efficiency_attr_group, ASUS_WMI_DEVID_CORES_MAX },
+ { &cores_performance_attr_group, ASUS_WMI_DEVID_CORES_MAX },
{ &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
{ &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
@@ -598,6 +845,7 @@ static int asus_fw_attr_add(void)
static int __init asus_fw_init(void)
{
char *wmi_uid;
+ int err;
wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
if (!wmi_uid)
@@ -610,6 +858,14 @@ static int __init asus_fw_init(void)
if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
return -ENODEV;
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_CORES_MAX)) {
+ err = init_max_cpu_cores();
+ if (err) {
+ pr_err("Could not initialise CPU core control %d\n", err);
+ return err;
+ }
+ }
+
return asus_fw_attr_add();
}
diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
index 61675e7b5a60..a6c4caefdef9 100644
--- a/drivers/platform/x86/asus-armoury.h
+++ b/drivers/platform/x86/asus-armoury.h
@@ -161,4 +161,32 @@
.name = _fsname, .attrs = _attrname##_attrs \
}
+/* CPU core attributes need a little different in setup */
+#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname) \
+ __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value); \
+ static struct kobj_attribute attr_##_attrname##_default_value = \
+ __ASUS_ATTR_RO(_attrname, default_value); \
+ static struct kobj_attribute attr_##_attrname##_min_value = \
+ __ASUS_ATTR_RO(_attrname, min_value); \
+ static struct kobj_attribute attr_##_attrname##_max_value = \
+ __ASUS_ATTR_RO(_attrname, max_value); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, int_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_default_value.attr, \
+ &attr_##_attrname##_min_value.attr, \
+ &attr_##_attrname##_max_value.attr, \
+ &attr_##_attrname##_scalar_increment.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
#endif /* _ASUS_ARMOURY_H_ */
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index a4f6bab93a6f..9a79dae97adf 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -137,6 +137,11 @@
/* dgpu on/off */
#define ASUS_WMI_DEVID_DGPU 0x00090020
+/* Intel E-core and P-core configuration in a format 0x0[E]0[P] */
+#define ASUS_WMI_DEVID_CORES 0x001200D2
+ /* Maximum Intel E-core and P-core availability */
+#define ASUS_WMI_DEVID_CORES_MAX 0x001200D3
+
#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
/* gpu mux switch, 0 = dGPU, 1 = Optimus */
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 6/9] platform/x86: asus-armoury: add screen auto-brightness toggle
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (4 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 5/9] platform/x86: asus-armoury: add core count control Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-15 1:47 ` [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features Denis Benato
` (3 subsequent siblings)
9 siblings, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
From: "Luke D. Jones" <luke@ljones.dev>
Add screen_auto_brightness toggle supported on some laptops.
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
---
drivers/platform/x86/asus-armoury.c | 4 ++++
include/linux/platform_data/x86/asus-wmi.h | 1 +
2 files changed, 5 insertions(+)
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index 3d963025d84e..e27f964aebf8 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -731,6 +731,9 @@ ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
"Set the panel refresh overdrive");
ATTR_GROUP_BOOL_RW(panel_hd_mode, "panel_hd_mode", ASUS_WMI_DEVID_PANEL_HD,
"Set the panel HD mode to UHD<0> or FHD<1>");
+ATTR_GROUP_BOOL_RW(screen_auto_brightness, "screen_auto_brightness",
+ ASUS_WMI_DEVID_SCREEN_AUTO_BRIGHTNESS,
+ "Set the panel brightness to Off<0> or On<1>");
ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
"Show the eGPU connection status");
@@ -748,6 +751,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
{ &panel_od_attr_group, ASUS_WMI_DEVID_PANEL_OD },
{ &panel_hd_mode_attr_group, ASUS_WMI_DEVID_PANEL_HD },
+ { &screen_auto_brightness_attr_group, ASUS_WMI_DEVID_SCREEN_AUTO_BRIGHTNESS },
};
static int asus_fw_attr_add(void)
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 9a79dae97adf..260796fee301 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -83,6 +83,7 @@
#define ASUS_WMI_DEVID_LID_FLIP_ROG 0x00060077
#define ASUS_WMI_DEVID_MINI_LED_MODE 0x0005001E
#define ASUS_WMI_DEVID_MINI_LED_MODE2 0x0005002E
+#define ASUS_WMI_DEVID_SCREEN_AUTO_BRIGHTNESS 0x0005002A
/* Storage */
#define ASUS_WMI_DEVID_CARDREADER 0x00080013
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (5 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 6/9] platform/x86: asus-armoury: add screen auto-brightness toggle Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-17 12:54 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT Denis Benato
` (2 subsequent siblings)
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
With the existence of the asus-armoury module the attributes no longer
need to live under the /sys/devices/platform/asus-nb-wmi/ path.
Deprecate all those that were implemented in asus-bioscfg with the goal
of removing them fully in the next LTS cycle.
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Tested-by: Denis Benato <benato.denis96@gmail.com>
---
.../ABI/testing/sysfs-platform-asus-wmi | 17 +++
drivers/platform/x86/Kconfig | 11 ++
drivers/platform/x86/asus-wmi.c | 121 ++++++++++++++----
3 files changed, 124 insertions(+), 25 deletions(-)
diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi
index 28144371a0f1..765d50b0d9df 100644
--- a/Documentation/ABI/testing/sysfs-platform-asus-wmi
+++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi
@@ -63,6 +63,7 @@ Date: Aug 2022
KernelVersion: 6.1
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Switch the GPU hardware MUX mode. Laptops with this feature can
can be toggled to boot with only the dGPU (discrete mode) or in
standard Optimus/Hybrid mode. On switch a reboot is required:
@@ -75,6 +76,7 @@ Date: Aug 2022
KernelVersion: 5.17
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Disable discrete GPU:
* 0 - Enable dGPU,
* 1 - Disable dGPU
@@ -84,6 +86,7 @@ Date: Aug 2022
KernelVersion: 5.17
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Enable the external GPU paired with ROG X-Flow laptops.
Toggling this setting will also trigger ACPI to disable the dGPU:
@@ -95,6 +98,7 @@ Date: Aug 2022
KernelVersion: 5.17
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Enable an LCD response-time boost to reduce or remove ghosting:
* 0 - Disable,
* 1 - Enable
@@ -104,6 +108,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Get the current charging mode being used:
* 1 - Barrel connected charger,
* 2 - USB-C charging
@@ -114,6 +119,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Show if the egpu (XG Mobile) is correctly connected:
* 0 - False,
* 1 - True
@@ -123,6 +129,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Change the mini-LED mode:
* 0 - Single-zone,
* 1 - Multi-zone
@@ -133,6 +140,7 @@ Date: Apr 2024
KernelVersion: 6.10
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
List the available mini-led modes.
What: /sys/devices/platform/<platform>/ppt_pl1_spl
@@ -140,6 +148,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the Package Power Target total of CPU: PL1 on Intel, SPL on AMD.
Shown on Intel+Nvidia or AMD+Nvidia based systems:
@@ -150,6 +159,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the Slow Package Power Tracking Limit of CPU: PL2 on Intel, SPPT,
on AMD. Shown on Intel+Nvidia or AMD+Nvidia based systems:
@@ -160,6 +170,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the Fast Package Power Tracking Limit of CPU. AMD+Nvidia only:
* min=5, max=250
@@ -168,6 +179,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the APU SPPT limit. Shown on full AMD systems only:
* min=5, max=130
@@ -176,6 +188,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the platform SPPT limit. Shown on full AMD systems only:
* min=5, max=130
@@ -184,6 +197,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the dynamic boost limit of the Nvidia dGPU:
* min=5, max=25
@@ -192,6 +206,7 @@ Date: Jun 2023
KernelVersion: 6.5
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set the target temperature limit of the Nvidia dGPU:
* min=75, max=87
@@ -200,6 +215,7 @@ Date: Apr 2024
KernelVersion: 6.10
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set if the BIOS POST sound is played on boot.
* 0 - False,
* 1 - True
@@ -209,6 +225,7 @@ Date: Apr 2024
KernelVersion: 6.10
Contact: "Luke Jones" <luke@ljones.dev>
Description:
+ DEPRECATED, WILL BE REMOVED SOON
Set if the MCU can go in to low-power mode on system sleep
* 0 - False,
* 1 - True
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 8b827680754c..a17288401746 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -296,6 +296,17 @@ config ASUS_WMI
To compile this driver as a module, choose M here: the module will
be called asus-wmi.
+config ASUS_WMI_DEPRECATED_ATTRS
+ bool "BIOS option support in WMI platform (DEPRECATED)"
+ depends on ASUS_WMI
+ default y
+ help
+ Say Y to expose the configurable BIOS options through the asus-wmi
+ driver.
+
+ This can be used with or without the asus-armoury driver which
+ has the same attributes, but more, and better features.
+
config ASUS_NB_WMI
tristate "Asus Notebook WMI Driver"
depends on ASUS_WMI
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 0d0c84a37ad8..3727ae00133d 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -337,6 +337,13 @@ struct asus_wmi {
/* Global to allow setting externally without requiring driver data */
static enum asus_ally_mcu_hack use_ally_mcu_hack = ASUS_WMI_ALLY_MCU_HACK_INIT;
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
+static void asus_wmi_show_deprecated(void)
+{
+ pr_notice_once("Accessing attributes through /sys/bus/platform/asus_wmi is deprecated and will be removed in a future release. Please switch over to /sys/class/firmware_attributes.\n");
+}
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
+
/* WMI ************************************************************************/
static int asus_wmi_evaluate_method3(u32 method_id,
@@ -723,6 +730,7 @@ static void asus_wmi_tablet_mode_get_state(struct asus_wmi *asus)
}
/* Charging mode, 1=Barrel, 2=USB ******************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t charge_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -733,12 +741,16 @@ static ssize_t charge_mode_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", value & 0xff);
}
static DEVICE_ATTR_RO(charge_mode);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* dGPU ********************************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t dgpu_disable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -749,6 +761,8 @@ static ssize_t dgpu_disable_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -802,8 +816,10 @@ static ssize_t dgpu_disable_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(dgpu_disable);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* eGPU ********************************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t egpu_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -814,6 +830,8 @@ static ssize_t egpu_enable_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -870,8 +888,10 @@ static ssize_t egpu_enable_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(egpu_enable);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Is eGPU connected? *********************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t egpu_connected_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -882,12 +902,16 @@ static ssize_t egpu_connected_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
static DEVICE_ATTR_RO(egpu_connected);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* gpu mux switch *************************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t gpu_mux_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -898,6 +922,8 @@ static ssize_t gpu_mux_mode_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -956,6 +982,7 @@ static ssize_t gpu_mux_mode_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(gpu_mux_mode);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* TUF Laptop Keyboard RGB Modes **********************************************/
static ssize_t kbd_rgb_mode_store(struct device *dev,
@@ -1079,6 +1106,7 @@ static const struct attribute_group *kbd_rgb_mode_groups[] = {
};
/* Tunable: PPT: Intel=PL1, AMD=SPPT *****************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t ppt_pl2_sppt_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
@@ -1117,6 +1145,8 @@ static ssize_t ppt_pl2_sppt_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->ppt_pl2_sppt);
}
static DEVICE_ATTR_RW(ppt_pl2_sppt);
@@ -1159,6 +1189,8 @@ static ssize_t ppt_pl1_spl_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->ppt_pl1_spl);
}
static DEVICE_ATTR_RW(ppt_pl1_spl);
@@ -1202,6 +1234,8 @@ static ssize_t ppt_fppt_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->ppt_fppt);
}
static DEVICE_ATTR_RW(ppt_fppt);
@@ -1245,6 +1279,8 @@ static ssize_t ppt_apu_sppt_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->ppt_apu_sppt);
}
static DEVICE_ATTR_RW(ppt_apu_sppt);
@@ -1288,6 +1324,8 @@ static ssize_t ppt_platform_sppt_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->ppt_platform_sppt);
}
static DEVICE_ATTR_RW(ppt_platform_sppt);
@@ -1331,6 +1369,8 @@ static ssize_t nv_dynamic_boost_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->nv_dynamic_boost);
}
static DEVICE_ATTR_RW(nv_dynamic_boost);
@@ -1374,9 +1414,12 @@ static ssize_t nv_temp_target_show(struct device *dev,
{
struct asus_wmi *asus = dev_get_drvdata(dev);
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%u\n", asus->nv_temp_target);
}
static DEVICE_ATTR_RW(nv_temp_target);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Ally MCU Powersave ********************************************************/
@@ -1417,6 +1460,7 @@ void set_ally_mcu_powersave(bool enabled)
}
EXPORT_SYMBOL_NS_GPL(set_ally_mcu_powersave, "ASUS_WMI");
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t mcu_powersave_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -1427,6 +1471,8 @@ static ssize_t mcu_powersave_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -1462,6 +1508,7 @@ static ssize_t mcu_powersave_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(mcu_powersave);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Battery ********************************************************************/
@@ -2335,6 +2382,7 @@ static int asus_wmi_rfkill_init(struct asus_wmi *asus)
}
/* Panel Overdrive ************************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t panel_od_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -2345,6 +2393,8 @@ static ssize_t panel_od_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -2381,9 +2431,10 @@ static ssize_t panel_od_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(panel_od);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Bootup sound ***************************************************************/
-
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t boot_sound_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -2394,6 +2445,8 @@ static ssize_t boot_sound_show(struct device *dev,
if (result < 0)
return result;
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", result);
}
@@ -2429,8 +2482,10 @@ static ssize_t boot_sound_store(struct device *dev,
return count;
}
static DEVICE_ATTR_RW(boot_sound);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Mini-LED mode **************************************************************/
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t mini_led_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -2461,6 +2516,8 @@ static ssize_t mini_led_mode_show(struct device *dev,
}
}
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "%d\n", value);
}
@@ -2531,10 +2588,13 @@ static ssize_t available_mini_led_mode_show(struct device *dev,
return sysfs_emit(buf, "0 1 2\n");
}
+ asus_wmi_show_deprecated();
+
return sysfs_emit(buf, "0\n");
}
static DEVICE_ATTR_RO(available_mini_led_mode);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Quirks *********************************************************************/
@@ -3822,6 +3882,7 @@ static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
return throttle_thermal_policy_write(asus);
}
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
static ssize_t throttle_thermal_policy_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -3865,6 +3926,7 @@ static ssize_t throttle_thermal_policy_store(struct device *dev,
* Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
*/
static DEVICE_ATTR_RW(throttle_thermal_policy);
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
/* Platform profile ***********************************************************/
static int asus_wmi_platform_profile_get(struct device *dev,
@@ -4466,27 +4528,29 @@ static struct attribute *platform_attributes[] = {
&dev_attr_camera.attr,
&dev_attr_cardr.attr,
&dev_attr_touchpad.attr,
- &dev_attr_charge_mode.attr,
- &dev_attr_egpu_enable.attr,
- &dev_attr_egpu_connected.attr,
- &dev_attr_dgpu_disable.attr,
- &dev_attr_gpu_mux_mode.attr,
&dev_attr_lid_resume.attr,
&dev_attr_als_enable.attr,
&dev_attr_fan_boost_mode.attr,
- &dev_attr_throttle_thermal_policy.attr,
- &dev_attr_ppt_pl2_sppt.attr,
- &dev_attr_ppt_pl1_spl.attr,
- &dev_attr_ppt_fppt.attr,
- &dev_attr_ppt_apu_sppt.attr,
- &dev_attr_ppt_platform_sppt.attr,
- &dev_attr_nv_dynamic_boost.attr,
- &dev_attr_nv_temp_target.attr,
- &dev_attr_mcu_powersave.attr,
- &dev_attr_boot_sound.attr,
- &dev_attr_panel_od.attr,
- &dev_attr_mini_led_mode.attr,
- &dev_attr_available_mini_led_mode.attr,
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
+ &dev_attr_charge_mode.attr,
+ &dev_attr_egpu_enable.attr,
+ &dev_attr_egpu_connected.attr,
+ &dev_attr_dgpu_disable.attr,
+ &dev_attr_gpu_mux_mode.attr,
+ &dev_attr_ppt_pl2_sppt.attr,
+ &dev_attr_ppt_pl1_spl.attr,
+ &dev_attr_ppt_fppt.attr,
+ &dev_attr_ppt_apu_sppt.attr,
+ &dev_attr_ppt_platform_sppt.attr,
+ &dev_attr_nv_dynamic_boost.attr,
+ &dev_attr_nv_temp_target.attr,
+ &dev_attr_mcu_powersave.attr,
+ &dev_attr_boot_sound.attr,
+ &dev_attr_panel_od.attr,
+ &dev_attr_mini_led_mode.attr,
+ &dev_attr_available_mini_led_mode.attr,
+ &dev_attr_throttle_thermal_policy.attr,
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
NULL
};
@@ -4508,7 +4572,11 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
devid = ASUS_WMI_DEVID_LID_RESUME;
else if (attr == &dev_attr_als_enable.attr)
devid = ASUS_WMI_DEVID_ALS_ENABLE;
- else if (attr == &dev_attr_charge_mode.attr)
+ else if (attr == &dev_attr_fan_boost_mode.attr)
+ ok = asus->fan_boost_mode_available;
+
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
+ if (attr == &dev_attr_charge_mode.attr)
devid = ASUS_WMI_DEVID_CHARGE_MODE;
else if (attr == &dev_attr_egpu_enable.attr)
ok = asus->egpu_enable_available;
@@ -4546,6 +4614,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
ok = asus->mini_led_dev_id != 0;
else if (attr == &dev_attr_available_mini_led_mode.attr)
ok = asus->mini_led_dev_id != 0;
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
if (devid != -1) {
ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
@@ -4801,6 +4870,7 @@ static int asus_wmi_add(struct platform_device *pdev)
}
/* ensure defaults for tunables */
+#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
asus->ppt_pl2_sppt = 5;
asus->ppt_pl1_spl = 5;
asus->ppt_apu_sppt = 5;
@@ -4823,17 +4893,18 @@ static int asus_wmi_add(struct platform_device *pdev)
asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX;
else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX_VIVO))
asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX_VIVO;
-
- if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE))
- asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE;
- else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2))
- asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2;
+#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY))
asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY;
else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO))
asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO;
+ if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE))
+ asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE;
+ else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2))
+ asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2;
+
err = fan_boost_mode_check_present(asus);
if (err)
goto fail_fan_boost_mode;
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (6 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-17 12:59 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs Denis Benato
2025-10-15 5:13 ` [PATCH v14 0/9] platform/x86: Add asus-armoury driver Mario Limonciello
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
As pointed out in [1], in order to maintain a naming consistency with
ASUS_WMI_DEVID_PPT_PL2_SPPT and ASUS_WMI_DEVID_PPT_PL1_SPL
rename ASUS_WMI_DEVID_PPT_FPPT to ASUS_WMI_DEVID_PPT_PL3_FPPT.
[1] https://lore.kernel.org/all/cad7b458-5a7a-4975-94a1-d0c74f6f3de5@oracle.com/
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
---
drivers/platform/x86/asus-wmi.c | 4 ++--
include/linux/platform_data/x86/asus-wmi.h | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 3727ae00133d..8b5ac4636623 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -1211,7 +1211,7 @@ static ssize_t ppt_fppt_store(struct device *dev,
if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
return -EINVAL;
- err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_FPPT, value, &result);
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL3_FPPT, value, &result);
if (err) {
pr_warn("Failed to set ppt_fppt: %d\n", err);
return err;
@@ -4595,7 +4595,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
else if (attr == &dev_attr_ppt_pl1_spl.attr)
devid = ASUS_WMI_DEVID_PPT_PL1_SPL;
else if (attr == &dev_attr_ppt_fppt.attr)
- devid = ASUS_WMI_DEVID_PPT_FPPT;
+ devid = ASUS_WMI_DEVID_PPT_PL3_FPPT;
else if (attr == &dev_attr_ppt_apu_sppt.attr)
devid = ASUS_WMI_DEVID_PPT_APU_SPPT;
else if (attr == &dev_attr_ppt_platform_sppt.attr)
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 260796fee301..3d236f8498d8 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -108,7 +108,7 @@
#define ASUS_WMI_DEVID_PPT_PL1_SPL 0x001200A3
#define ASUS_WMI_DEVID_PPT_APU_SPPT 0x001200B0
#define ASUS_WMI_DEVID_PPT_PLAT_SPPT 0x001200B1
-#define ASUS_WMI_DEVID_PPT_FPPT 0x001200C1
+#define ASUS_WMI_DEVID_PPT_PL3_FPPT 0x001200C1
#define ASUS_WMI_DEVID_NV_DYN_BOOST 0x001200C0
#define ASUS_WMI_DEVID_NV_THERM_TARGET 0x001200C2
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (7 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT Denis Benato
@ 2025-10-15 1:47 ` Denis Benato
2025-10-17 13:09 ` Ilpo Järvinen
2025-10-15 5:13 ` [PATCH v14 0/9] platform/x86: Add asus-armoury driver Mario Limonciello
9 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 1:47 UTC (permalink / raw)
To: linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Limonciello, Mario, Luke D . Jones, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828, Denis Benato
From: "Luke D. Jones" <luke@ljones.dev>
Adds the ppt_* and nv_* tuning knobs that are available via WMI methods
and adds proper min/max levels plus defaults.
The min/max are defined by ASUS and typically gained by looking at what
they allow in the ASUS Armoury Crate application - ASUS does not share
the values outside of this. It could also be possible to gain the AMD
values by use of ryzenadj and testing for the minimum stable value.
The general rule of thumb for adding to the match table is that if the
model range has a single CPU used throughout, then the DMI match can
omit the last letter of the model number as this is the GPU model.
If a min or max value is not provided it is assumed that the particular
setting is not supported. for example ppt_pl2_sppt_min/max is not set.
If a <ppt_setting>_def is not set then the default is assumed to be
<ppt_setting>_max
It is assumed that at least AC settings are available so that the
firmware attributes will be created - if no DC table is available
and power is on DC, then reading the attributes is -ENODEV.
Signed-off-by: Denis Benato <benato.denis96@gmail.com>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
Tested-by: Mateusz Schyboll <dragonn@op.pl>
Tested-by: Porfet Lillian <porfet828@gmail.com>
---
drivers/platform/x86/asus-armoury.c | 294 ++++-
drivers/platform/x86/asus-armoury.h | 1210 ++++++++++++++++++++
include/linux/platform_data/x86/asus-wmi.h | 3 +
3 files changed, 1501 insertions(+), 6 deletions(-)
diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index e27f964aebf8..43a1e7017d16 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -27,6 +27,7 @@
#include <linux/mutex.h>
#include <linux/platform_data/x86/asus-wmi.h>
#include <linux/printk.h>
+#include <linux/power_supply.h>
#include <linux/types.h>
#include "asus-armoury.h"
@@ -45,6 +46,17 @@
#define ASUS_MINI_LED_2024_STRONG 0x01
#define ASUS_MINI_LED_2024_OFF 0x02
+/* Power tunable attribute name defines */
+#define ATTR_PPT_PL1_SPL "ppt_pl1_spl"
+#define ATTR_PPT_PL2_SPPT "ppt_pl2_sppt"
+#define ATTR_PPT_PL3_FPPT "ppt_pl3_fppt"
+#define ATTR_PPT_APU_SPPT "ppt_apu_sppt"
+#define ATTR_PPT_PLATFORM_SPPT "ppt_platform_sppt"
+#define ATTR_NV_DYNAMIC_BOOST "nv_dynamic_boost"
+#define ATTR_NV_TEMP_TARGET "nv_temp_target"
+#define ATTR_NV_BASE_TGP "nv_base_tgp"
+#define ATTR_NV_TGP "nv_tgp"
+
#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
@@ -73,11 +85,26 @@ struct cpu_cores {
u32 max_power_cores;
};
+struct rog_tunables {
+ const struct power_limits *power_limits;
+ u32 ppt_pl1_spl; // cpu
+ u32 ppt_pl2_sppt; // cpu
+ u32 ppt_pl3_fppt; // cpu
+ u32 ppt_apu_sppt; // plat
+ u32 ppt_platform_sppt; // plat
+
+ u32 nv_dynamic_boost;
+ u32 nv_temp_target;
+ u32 nv_tgp;
+};
+
static struct asus_armoury_priv {
struct device *fw_attr_dev;
struct kset *fw_attr_kset;
struct cpu_cores *cpu_cores;
+ /* Index 0 for DC, 1 for AC */
+ struct rog_tunables *rog_tunables[2];
u32 mini_led_dev_id;
u32 gpu_mux_dev_id;
/*
@@ -719,7 +746,34 @@ static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
"Set the max available efficiency cores");
+/* Define helper to access the current power mode tunable values */
+static inline struct rog_tunables *get_current_tunables(void)
+{
+ return asus_armoury
+ .rog_tunables[power_supply_is_system_supplied() ? 1 : 0];
+}
+
/* Simple attribute creation */
+ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, ATTR_PPT_PL1_SPL, ASUS_WMI_DEVID_PPT_PL1_SPL,
+ "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_pl2_sppt, ATTR_PPT_PL2_SPPT, ASUS_WMI_DEVID_PPT_PL2_SPPT,
+ "Set the CPU fast package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_pl3_fppt, ATTR_PPT_PL3_FPPT, ASUS_WMI_DEVID_PPT_PL3_FPPT,
+ "Set the CPU fastest package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_apu_sppt, ATTR_PPT_APU_SPPT, ASUS_WMI_DEVID_PPT_APU_SPPT,
+ "Set the APU package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_platform_sppt, ATTR_PPT_PLATFORM_SPPT, ASUS_WMI_DEVID_PPT_PLAT_SPPT,
+ "Set the platform package limit");
+ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, ATTR_NV_DYNAMIC_BOOST, ASUS_WMI_DEVID_NV_DYN_BOOST,
+ "Set the Nvidia dynamic boost limit");
+ATTR_GROUP_ROG_TUNABLE(nv_temp_target, ATTR_NV_TEMP_TARGET, ASUS_WMI_DEVID_NV_THERM_TARGET,
+ "Set the Nvidia max thermal limit");
+ATTR_GROUP_ROG_TUNABLE(nv_tgp, "nv_tgp", ASUS_WMI_DEVID_DGPU_SET_TGP,
+ "Set the additional TGP on top of the base TGP");
+ATTR_GROUP_INT_VALUE_ONLY_RO(nv_base_tgp, ATTR_NV_BASE_TGP, ASUS_WMI_DEVID_DGPU_BASE_TGP,
+ "Read the base TGP value");
+
+
ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
"Show the current mode of charging");
@@ -746,6 +800,16 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &cores_efficiency_attr_group, ASUS_WMI_DEVID_CORES_MAX },
{ &cores_performance_attr_group, ASUS_WMI_DEVID_CORES_MAX },
+ { &ppt_pl1_spl_attr_group, ASUS_WMI_DEVID_PPT_PL1_SPL },
+ { &ppt_pl2_sppt_attr_group, ASUS_WMI_DEVID_PPT_PL2_SPPT },
+ { &ppt_pl3_fppt_attr_group, ASUS_WMI_DEVID_PPT_PL3_FPPT },
+ { &ppt_apu_sppt_attr_group, ASUS_WMI_DEVID_PPT_APU_SPPT },
+ { &ppt_platform_sppt_attr_group, ASUS_WMI_DEVID_PPT_PLAT_SPPT },
+ { &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
+ { &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
+ { &nv_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
+ { &nv_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
+
{ &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
{ &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
{ &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
@@ -754,8 +818,75 @@ static const struct asus_attr_group armoury_attr_groups[] = {
{ &screen_auto_brightness_attr_group, ASUS_WMI_DEVID_SCREEN_AUTO_BRIGHTNESS },
};
+/**
+ * is_power_tunable_attr - Determines if an attribute is a power-related tunable
+ * @name: The name of the attribute to check
+ *
+ * This function checks if the given attribute name is related to power tuning.
+ *
+ * Return: true if the attribute is a power-related tunable, false otherwise
+ */
+static bool is_power_tunable_attr(const char *name)
+{
+ static const char * const power_tunable_attrs[] = {
+ ATTR_PPT_PL1_SPL, ATTR_PPT_PL2_SPPT,
+ ATTR_PPT_PL3_FPPT, ATTR_PPT_APU_SPPT,
+ ATTR_PPT_PLATFORM_SPPT, ATTR_NV_DYNAMIC_BOOST,
+ ATTR_NV_TEMP_TARGET, ATTR_NV_BASE_TGP,
+ ATTR_NV_TGP
+ };
+
+ for (unsigned int i = 0; i < ARRAY_SIZE(power_tunable_attrs); i++) {
+ if (!strcmp(name, power_tunable_attrs[i]))
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * has_valid_limit - Checks if a power-related attribute has a valid limit value
+ * @name: The name of the attribute to check
+ * @limits: Pointer to the power_limits structure containing limit values
+ *
+ * This function checks if a power-related attribute has a valid limit value.
+ * It returns false if limits is NULL or if the corresponding limit value is zero.
+ *
+ * Return: true if the attribute has a valid limit value, false otherwise
+ */
+static bool has_valid_limit(const char *name, const struct power_limits *limits)
+{
+ u32 limit_value = 0;
+
+ if (!limits)
+ return false;
+
+ if (!strcmp(name, ATTR_PPT_PL1_SPL))
+ limit_value = limits->ppt_pl1_spl_max;
+ else if (!strcmp(name, ATTR_PPT_PL2_SPPT))
+ limit_value = limits->ppt_pl2_sppt_max;
+ else if (!strcmp(name, ATTR_PPT_PL3_FPPT))
+ limit_value = limits->ppt_pl3_fppt_max;
+ else if (!strcmp(name, ATTR_PPT_APU_SPPT))
+ limit_value = limits->ppt_apu_sppt_max;
+ else if (!strcmp(name, ATTR_PPT_PLATFORM_SPPT))
+ limit_value = limits->ppt_platform_sppt_max;
+ else if (!strcmp(name, ATTR_NV_DYNAMIC_BOOST))
+ limit_value = limits->nv_dynamic_boost_max;
+ else if (!strcmp(name, ATTR_NV_TEMP_TARGET))
+ limit_value = limits->nv_temp_target_max;
+ else if (!strcmp(name, ATTR_NV_BASE_TGP) ||
+ !strcmp(name, ATTR_NV_TGP))
+ limit_value = limits->nv_tgp_max;
+
+ return limit_value > 0;
+}
+
static int asus_fw_attr_add(void)
{
+ const struct power_limits *limits;
+ bool should_create;
+ const char *name;
int err, i;
asus_armoury.fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
@@ -812,12 +943,28 @@ static int asus_fw_attr_add(void)
if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
continue;
- err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
- armoury_attr_groups[i].attr_group);
- if (err) {
- pr_err("Failed to create sysfs-group for %s\n",
- armoury_attr_groups[i].attr_group->name);
- goto err_remove_groups;
+ /* Always create by default, unless PPT is not present */
+ should_create = true;
+ name = armoury_attr_groups[i].attr_group->name;
+
+ /* Check if this is a power-related tunable requiring limits */
+ if (asus_armoury.rog_tunables[1] && asus_armoury.rog_tunables[1]->power_limits &&
+ is_power_tunable_attr(name)) {
+ limits = asus_armoury.rog_tunables[1]->power_limits;
+ /* Check only AC, if DC is not present then AC won't be either */
+ should_create = has_valid_limit(name, limits);
+ if (!should_create)
+ pr_debug("Missing max value for tunable %s\n", name);
+ }
+
+ if (should_create) {
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ armoury_attr_groups[i].attr_group);
+ if (err) {
+ pr_err("Failed to create sysfs-group for %s\n",
+ armoury_attr_groups[i].attr_group->name);
+ goto err_remove_groups;
+ }
}
}
@@ -846,6 +993,135 @@ static int asus_fw_attr_add(void)
/* Init / exit ****************************************************************/
+/* Set up the min/max and defaults for ROG tunables */
+static void init_rog_tunables(void)
+{
+ const struct power_limits *ac_limits, *dc_limits;
+ const struct power_data *power_data;
+ const struct dmi_system_id *dmi_id;
+ bool ac_initialized = false, dc_initialized = false;
+
+ /* Match the system against the power_limits table */
+ dmi_id = dmi_first_match(power_limits);
+ if (!dmi_id) {
+ pr_warn("No matching power limits found for this system\n");
+ return;
+ }
+
+ /* Get the power data for this system */
+ power_data = dmi_id->driver_data;
+ if (!power_data) {
+ pr_info("No power data available for this system\n");
+ return;
+ }
+
+ /* Initialize AC power tunables */
+ ac_limits = power_data->ac_data;
+ if (ac_limits) {
+ asus_armoury.rog_tunables[1] =
+ kzalloc(sizeof(*asus_armoury.rog_tunables[1]), GFP_KERNEL);
+ if (!asus_armoury.rog_tunables[1])
+ goto err_nomem;
+
+ asus_armoury.rog_tunables[1]->power_limits = ac_limits;
+
+ /* Set initial AC values */
+ asus_armoury.rog_tunables[1]->ppt_pl1_spl =
+ ac_limits->ppt_pl1_spl_def ?
+ ac_limits->ppt_pl1_spl_def :
+ ac_limits->ppt_pl1_spl_max;
+
+ asus_armoury.rog_tunables[1]->ppt_pl2_sppt =
+ ac_limits->ppt_pl2_sppt_def ?
+ ac_limits->ppt_pl2_sppt_def :
+ ac_limits->ppt_pl2_sppt_max;
+
+ asus_armoury.rog_tunables[1]->ppt_pl3_fppt =
+ ac_limits->ppt_pl3_fppt_def ?
+ ac_limits->ppt_pl3_fppt_def :
+ ac_limits->ppt_pl3_fppt_max;
+
+ asus_armoury.rog_tunables[1]->ppt_apu_sppt =
+ ac_limits->ppt_apu_sppt_def ?
+ ac_limits->ppt_apu_sppt_def :
+ ac_limits->ppt_apu_sppt_max;
+
+ asus_armoury.rog_tunables[1]->ppt_platform_sppt =
+ ac_limits->ppt_platform_sppt_def ?
+ ac_limits->ppt_platform_sppt_def :
+ ac_limits->ppt_platform_sppt_max;
+
+ asus_armoury.rog_tunables[1]->nv_dynamic_boost =
+ ac_limits->nv_dynamic_boost_max;
+ asus_armoury.rog_tunables[1]->nv_temp_target =
+ ac_limits->nv_temp_target_max;
+ asus_armoury.rog_tunables[1]->nv_tgp = ac_limits->nv_tgp_max;
+
+ ac_initialized = true;
+ pr_debug("AC power limits initialized for %s\n", dmi_id->matches[0].substr);
+ }
+
+ /* Initialize DC power tunables */
+ dc_limits = power_data->dc_data;
+ if (dc_limits) {
+ asus_armoury.rog_tunables[0] =
+ kzalloc(sizeof(*asus_armoury.rog_tunables[0]), GFP_KERNEL);
+ if (!asus_armoury.rog_tunables[0]) {
+ if (ac_initialized)
+ kfree(asus_armoury.rog_tunables[1]);
+ goto err_nomem;
+ }
+
+ asus_armoury.rog_tunables[0]->power_limits = dc_limits;
+
+ /* Set initial DC values */
+ asus_armoury.rog_tunables[0]->ppt_pl1_spl =
+ dc_limits->ppt_pl1_spl_def ?
+ dc_limits->ppt_pl1_spl_def :
+ dc_limits->ppt_pl1_spl_max;
+
+ asus_armoury.rog_tunables[0]->ppt_pl2_sppt =
+ dc_limits->ppt_pl2_sppt_def ?
+ dc_limits->ppt_pl2_sppt_def :
+ dc_limits->ppt_pl2_sppt_max;
+
+ asus_armoury.rog_tunables[0]->ppt_pl3_fppt =
+ dc_limits->ppt_pl3_fppt_def ?
+ dc_limits->ppt_pl3_fppt_def :
+ dc_limits->ppt_pl3_fppt_max;
+
+ asus_armoury.rog_tunables[0]->ppt_apu_sppt =
+ dc_limits->ppt_apu_sppt_def ?
+ dc_limits->ppt_apu_sppt_def :
+ dc_limits->ppt_apu_sppt_max;
+
+ asus_armoury.rog_tunables[0]->ppt_platform_sppt =
+ dc_limits->ppt_platform_sppt_def ?
+ dc_limits->ppt_platform_sppt_def :
+ dc_limits->ppt_platform_sppt_max;
+
+ asus_armoury.rog_tunables[0]->nv_dynamic_boost =
+ dc_limits->nv_dynamic_boost_max;
+ asus_armoury.rog_tunables[0]->nv_temp_target =
+ dc_limits->nv_temp_target_max;
+ asus_armoury.rog_tunables[0]->nv_tgp = dc_limits->nv_tgp_max;
+
+ dc_initialized = true;
+ pr_debug("DC power limits initialized for %s\n", dmi_id->matches[0].substr);
+ }
+
+ if (!ac_initialized)
+ pr_debug("No AC PPT limits defined\n");
+
+ if (!dc_initialized)
+ pr_debug("No DC PPT limits defined\n");
+
+ return;
+
+err_nomem:
+ pr_err("Failed to allocate memory for tunables\n");
+}
+
static int __init asus_fw_init(void)
{
char *wmi_uid;
@@ -870,6 +1146,9 @@ static int __init asus_fw_init(void)
}
}
+ init_rog_tunables();
+
+ /* Must always be last step to ensure data is available */
return asus_fw_attr_add();
}
@@ -878,6 +1157,9 @@ static void __exit asus_fw_exit(void)
sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
kset_unregister(asus_armoury.fw_attr_kset);
device_destroy(&firmware_attributes_class, MKDEV(0, 0));
+
+ kfree(asus_armoury.rog_tunables[0]);
+ kfree(asus_armoury.rog_tunables[1]);
}
module_init(asus_fw_init);
diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
index a6c4caefdef9..d99db5f5f6a0 100644
--- a/drivers/platform/x86/asus-armoury.h
+++ b/drivers/platform/x86/asus-armoury.h
@@ -8,6 +8,7 @@
#ifndef _ASUS_ARMOURY_H_
#define _ASUS_ARMOURY_H_
+#include <linux/dmi.h>
#include <linux/types.h>
#include <linux/platform_device.h>
@@ -189,4 +190,1213 @@
.name = _fsname, .attrs = _attrname##_attrs \
}
+#define ATTR_GROUP_INT_VALUE_ONLY_RO(_attrname, _fsname, _wmi, _dispname) \
+ WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RO(_attrname, current_value); \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, int_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_type.attr, NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+/*
+ * ROG PPT attributes need a little different in setup as they
+ * require rog_tunables members.
+ */
+
+#define __ROG_TUNABLE_SHOW(_prop, _attrname, _val) \
+ static ssize_t _attrname##_##_prop##_show( \
+ struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
+ { \
+ struct rog_tunables *tunables = get_current_tunables(); \
+ \
+ if (!tunables || !tunables->power_limits) \
+ return -ENODEV; \
+ \
+ return sysfs_emit(buf, "%d\n", tunables->power_limits->_val); \
+ } \
+ static struct kobj_attribute attr_##_attrname##_##_prop = \
+ __ASUS_ATTR_RO(_attrname, _prop)
+
+#define __ROG_TUNABLE_SHOW_DEFAULT(_attrname) \
+ static ssize_t _attrname##_default_value_show( \
+ struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
+ { \
+ struct rog_tunables *tunables = get_current_tunables(); \
+ \
+ if (!tunables || !tunables->power_limits) \
+ return -ENODEV; \
+ \
+ return sysfs_emit( \
+ buf, "%d\n", \
+ tunables->power_limits->_attrname##_def ? \
+ tunables->power_limits->_attrname##_def : \
+ tunables->power_limits->_attrname##_max); \
+ } \
+ static struct kobj_attribute attr_##_attrname##_default_value = \
+ __ASUS_ATTR_RO(_attrname, default_value)
+
+#define __ROG_TUNABLE_RW(_attr, _wmi) \
+ static ssize_t _attr##_current_value_store( \
+ struct kobject *kobj, struct kobj_attribute *attr, \
+ const char *buf, size_t count) \
+ { \
+ struct rog_tunables *tunables = get_current_tunables(); \
+ \
+ if (!tunables || !tunables->power_limits) \
+ return -ENODEV; \
+ \
+ return attr_uint_store(kobj, attr, buf, count, \
+ tunables->power_limits->_attr##_min, \
+ tunables->power_limits->_attr##_max, \
+ &tunables->_attr, _wmi); \
+ } \
+ static ssize_t _attr##_current_value_show( \
+ struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
+ { \
+ struct rog_tunables *tunables = get_current_tunables(); \
+ \
+ if (!tunables) \
+ return -ENODEV; \
+ \
+ return sysfs_emit(buf, "%u\n", tunables->_attr); \
+ } \
+ static struct kobj_attribute attr_##_attr##_current_value = \
+ __ASUS_ATTR_RW(_attr, current_value)
+
+#define ATTR_GROUP_ROG_TUNABLE(_attrname, _fsname, _wmi, _dispname) \
+ __ROG_TUNABLE_RW(_attrname, _wmi); \
+ __ROG_TUNABLE_SHOW_DEFAULT(_attrname); \
+ __ROG_TUNABLE_SHOW(min_value, _attrname, _attrname##_min); \
+ __ROG_TUNABLE_SHOW(max_value, _attrname, _attrname##_max); \
+ __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+ static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, int_type_show); \
+ static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_default_value.attr, \
+ &attr_##_attrname##_min_value.attr, \
+ &attr_##_attrname##_max_value.attr, \
+ &attr_##_attrname##_scalar_increment.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+ }; \
+ static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, .attrs = _attrname##_attrs \
+ }
+
+/* Default is always the maximum value unless *_def is specified */
+struct power_limits {
+ u8 ppt_pl1_spl_min;
+ u8 ppt_pl1_spl_def;
+ u8 ppt_pl1_spl_max;
+ u8 ppt_pl2_sppt_min;
+ u8 ppt_pl2_sppt_def;
+ u8 ppt_pl2_sppt_max;
+ u8 ppt_pl3_fppt_min;
+ u8 ppt_pl3_fppt_def;
+ u8 ppt_pl3_fppt_max;
+ u8 ppt_apu_sppt_min;
+ u8 ppt_apu_sppt_def;
+ u8 ppt_apu_sppt_max;
+ u8 ppt_platform_sppt_min;
+ u8 ppt_platform_sppt_def;
+ u8 ppt_platform_sppt_max;
+ /* Nvidia GPU specific, default is always max */
+ u8 nv_dynamic_boost_def; // unused. exists for macro
+ u8 nv_dynamic_boost_min;
+ u8 nv_dynamic_boost_max;
+ u8 nv_temp_target_def; // unused. exists for macro
+ u8 nv_temp_target_min;
+ u8 nv_temp_target_max;
+ u8 nv_tgp_def; // unused. exists for macro
+ u8 nv_tgp_min;
+ u8 nv_tgp_max;
+};
+
+struct power_data {
+ const struct power_limits *ac_data;
+ const struct power_limits *dc_data;
+ bool requires_fan_curve;
+};
+
+/*
+ * For each available attribute there must be a min and a max.
+ * _def is not required and will be assumed to be default == max if missing.
+ */
+static const struct dmi_system_id power_limits[] = {
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA401W"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 75,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 30,
+ .ppt_pl2_sppt_min = 31,
+ .ppt_pl2_sppt_max = 44,
+ .ppt_pl3_fppt_min = 45,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA507N"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 45,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA507R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80
+ },
+ .dc_data = NULL
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA507X"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 85,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 45,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA507Z"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 105,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 15,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 85,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 45,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 60,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA607P"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 30,
+ .ppt_pl1_spl_def = 100,
+ .ppt_pl1_spl_max = 135,
+ .ppt_pl2_sppt_min = 30,
+ .ppt_pl2_sppt_def = 115,
+ .ppt_pl2_sppt_max = 135,
+ .ppt_pl3_fppt_min = 30,
+ .ppt_pl3_fppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 115,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_def = 45,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_def = 60,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 25,
+ .ppt_pl3_fppt_max = 80,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA608WI"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 90,
+ .ppt_pl1_spl_max = 90,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 90,
+ .ppt_pl2_sppt_max = 90,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 90,
+ .ppt_pl3_fppt_max = 90,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 115,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 45,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 65,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA617NS"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 15,
+ .ppt_apu_sppt_max = 80,
+ .ppt_platform_sppt_min = 30,
+ .ppt_platform_sppt_max = 120
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 25,
+ .ppt_apu_sppt_max = 35,
+ .ppt_platform_sppt_min = 45,
+ .ppt_platform_sppt_max = 100
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA617NT"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 15,
+ .ppt_apu_sppt_max = 80,
+ .ppt_platform_sppt_min = 30,
+ .ppt_platform_sppt_max = 115
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 15,
+ .ppt_apu_sppt_max = 45,
+ .ppt_platform_sppt_min = 30,
+ .ppt_platform_sppt_max = 50
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FA617XS"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 15,
+ .ppt_apu_sppt_max = 80,
+ .ppt_platform_sppt_min = 30,
+ .ppt_platform_sppt_max = 120,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 25,
+ .ppt_apu_sppt_max = 35,
+ .ppt_platform_sppt_min = 45,
+ .ppt_platform_sppt_max = 100,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FX507VI"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 135,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 45,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 60,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "FX507Z"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 90,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 15,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 45,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 60,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA401Q"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_max = 80,
+ },
+ .dc_data = NULL
+ },
+ },
+ {
+ .matches = {
+ // This model is full AMD. No Nvidia dGPU.
+ DMI_MATCH(DMI_BOARD_NAME, "GA402R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 15,
+ .ppt_apu_sppt_max = 80,
+ .ppt_platform_sppt_min = 30,
+ .ppt_platform_sppt_max = 115,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_apu_sppt_min = 25,
+ .ppt_apu_sppt_def = 30,
+ .ppt_apu_sppt_max = 45,
+ .ppt_platform_sppt_min = 40,
+ .ppt_platform_sppt_max = 60,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA402X"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 35,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_def = 65,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 35,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 65,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 35,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA503R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 35,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 65,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 25,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 60,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GA605W"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 85,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 31,
+ .ppt_pl2_sppt_max = 44,
+ .ppt_pl3_fppt_min = 45,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GU603Z"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 60,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 135,
+ /* Only allowed in AC mode */
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 40,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 40,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GU604V"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 65,
+ .ppt_pl1_spl_max = 120,
+ .ppt_pl2_sppt_min = 65,
+ .ppt_pl2_sppt_max = 150,
+ /* Only allowed in AC mode */
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 40,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 40,
+ .ppt_pl2_sppt_max = 60,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GU605CW"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 45,
+ .ppt_pl1_spl_max = 85,
+ .ppt_pl2_sppt_min = 56,
+ .ppt_pl2_sppt_max = 110,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 80,
+ .nv_tgp_def = 90,
+ .nv_tgp_max = 110,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 85,
+ .ppt_pl2_sppt_min = 32,
+ .ppt_pl2_sppt_max = 110,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 90,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 38,
+ .ppt_pl2_sppt_max = 53,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GV301Q"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 45,
+ .ppt_pl2_sppt_min = 65,
+ .ppt_pl2_sppt_max = 80,
+ },
+ .dc_data = NULL
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GV301R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 45,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 54,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 35,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GV601R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 35,
+ .ppt_pl1_spl_max = 90,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 100,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 80,
+ .ppt_pl3_fppt_max = 125,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 28,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 54,
+ .ppt_pl2_sppt_max = 60,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 80,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GV601V"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_def = 100,
+ .ppt_pl1_spl_max = 110,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 40,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 40,
+ .ppt_pl2_sppt_max = 60,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "GX650P"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 110,
+ .ppt_pl1_spl_max = 130,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 125,
+ .ppt_pl2_sppt_max = 130,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 125,
+ .ppt_pl3_fppt_max = 135,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_def = 25,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_def = 35,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_def = 42,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G513I"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ /* Yes this laptop is very limited */
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_max = 80,
+ },
+ .dc_data = NULL,
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G513QM"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ /* Yes this laptop is very limited */
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 100,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_max = 190,
+ },
+ .dc_data = NULL,
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G513R"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 35,
+ .ppt_pl1_spl_max = 90,
+ .ppt_pl2_sppt_min = 54,
+ .ppt_pl2_sppt_max = 100,
+ .ppt_pl3_fppt_min = 54,
+ .ppt_pl3_fppt_max = 125,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 50,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 50,
+ .ppt_pl3_fppt_min = 28,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G614J"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 140,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 175,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 55,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 70,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G634J"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 140,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 175,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 55,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 70,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G713PV"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 30,
+ .ppt_pl1_spl_def = 120,
+ .ppt_pl1_spl_max = 130,
+ .ppt_pl2_sppt_min = 65,
+ .ppt_pl2_sppt_def = 125,
+ .ppt_pl2_sppt_max = 130,
+ .ppt_pl3_fppt_min = 65,
+ .ppt_pl3_fppt_def = 125,
+ .ppt_pl3_fppt_max = 130,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 75,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G733C"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 170,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 175,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 35,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G733P"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 30,
+ .ppt_pl1_spl_def = 100,
+ .ppt_pl1_spl_max = 130,
+ .ppt_pl2_sppt_min = 65,
+ .ppt_pl2_sppt_def = 125,
+ .ppt_pl2_sppt_max = 130,
+ .ppt_pl3_fppt_min = 65,
+ .ppt_pl3_fppt_def = 125,
+ .ppt_pl3_fppt_max = 130,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 65,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 65,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 75,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G814J"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 140,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 140,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 55,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 70,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "G834J"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 28,
+ .ppt_pl1_spl_max = 140,
+ .ppt_pl2_sppt_min = 28,
+ .ppt_pl2_sppt_max = 175,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 25,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 55,
+ .ppt_pl2_sppt_min = 25,
+ .ppt_pl2_sppt_max = 70,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ },
+ .requires_fan_curve = true,
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "H7606W"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 15,
+ .ppt_pl1_spl_max = 80,
+ .ppt_pl2_sppt_min = 35,
+ .ppt_pl2_sppt_max = 80,
+ .ppt_pl3_fppt_min = 35,
+ .ppt_pl3_fppt_max = 80,
+ .nv_dynamic_boost_min = 5,
+ .nv_dynamic_boost_max = 20,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ .nv_tgp_min = 55,
+ .nv_tgp_max = 85,
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 25,
+ .ppt_pl1_spl_max = 35,
+ .ppt_pl2_sppt_min = 31,
+ .ppt_pl2_sppt_max = 44,
+ .ppt_pl3_fppt_min = 45,
+ .ppt_pl3_fppt_max = 65,
+ .nv_temp_target_min = 75,
+ .nv_temp_target_max = 87,
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "RC71"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 7,
+ .ppt_pl1_spl_max = 30,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_max = 43,
+ .ppt_pl3_fppt_min = 15,
+ .ppt_pl3_fppt_max = 53
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 7,
+ .ppt_pl1_spl_def = 15,
+ .ppt_pl1_spl_max = 25,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_def = 20,
+ .ppt_pl2_sppt_max = 30,
+ .ppt_pl3_fppt_min = 15,
+ .ppt_pl3_fppt_def = 25,
+ .ppt_pl3_fppt_max = 35
+ }
+ },
+ },
+ {
+ .matches = {
+ DMI_MATCH(DMI_BOARD_NAME, "RC72"),
+ },
+ .driver_data = &(struct power_data) {
+ .ac_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 7,
+ .ppt_pl1_spl_max = 30,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_max = 43,
+ .ppt_pl3_fppt_min = 15,
+ .ppt_pl3_fppt_max = 53
+ },
+ .dc_data = &(struct power_limits) {
+ .ppt_pl1_spl_min = 7,
+ .ppt_pl1_spl_def = 17,
+ .ppt_pl1_spl_max = 25,
+ .ppt_pl2_sppt_min = 15,
+ .ppt_pl2_sppt_def = 24,
+ .ppt_pl2_sppt_max = 30,
+ .ppt_pl3_fppt_min = 15,
+ .ppt_pl3_fppt_def = 30,
+ .ppt_pl3_fppt_max = 35
+ }
+ },
+ },
+ {}
+};
+
#endif /* _ASUS_ARMOURY_H_ */
diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
index 3d236f8498d8..8fedf818563f 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -145,6 +145,9 @@
#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
+#define ASUS_WMI_DEVID_DGPU_BASE_TGP 0x00120099
+#define ASUS_WMI_DEVID_DGPU_SET_TGP 0x00120098
+
/* gpu mux switch, 0 = dGPU, 1 = Optimus */
#define ASUS_WMI_DEVID_GPU_MUX 0x00090016
#define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026
--
2.51.0
^ permalink raw reply related [flat|nested] 30+ messages in thread
* Re: [PATCH v14 0/9] platform/x86: Add asus-armoury driver
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
` (8 preceding siblings ...)
2025-10-15 1:47 ` [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs Denis Benato
@ 2025-10-15 5:13 ` Mario Limonciello
2025-10-15 9:38 ` Ilpo Järvinen
9 siblings, 1 reply; 30+ messages in thread
From: Mario Limonciello @ 2025-10-15 5:13 UTC (permalink / raw)
To: Denis Benato, linux-kernel
Cc: platform-driver-x86, Hans de Goede, Ilpo Järvinen,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On 10/14/2025 8:47 PM, Denis Benato wrote:
> Hi all,
>
> the TL;DR:
> 1. Introduce new module to contain bios attributes, using fw_attributes_class
> 2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
> 3. Remove those in the next LTS cycle
>
> The idea for this originates from a conversation with Mario Limonciello
> https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
>
> It is without a doubt much cleaner to use, easier to discover, and the
> API is well defined as opposed to the random clutter of attributes I had
> been placing in the platform sysfs. Given that Derek is also working on a
> similar approach to Lenovo in part based on my initial work I'd like to think
> that the overall approach is good and may become standardised for these types
> of things.
>
> Regarding PPT: it is intended to add support for "custom" platform profile
> soon. If it's a blocker for this patch series being accepted I will drop the
> platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
> separately to avoid holding the bulk of the series up. Ideally I would like
> to get the safe limits in so users don't fully lose functionality or continue
> to be exposed to potential instability from setting too low, or be mislead
> in to thinking they can set limits higher than actual limit.
>
> The bulk of the PPT patch is data, the actual functional part is relatively
> small and similar to the last version.
>
> Unfortunately I've been rather busy over the months and may not cover
> everything in the v7 changelog but I've tried to be as comprehensive as I can.
>
> Regards,
> Luke
As a general comment that applies to a few patches in the series.
The S-o-b means that YOU sign off on them, it's like a chain of custody.
Any patches that you're sending need your own S-o-B, even if they're
100% the same as the original from Luke.
>
> Changelog:
> - v1
> - Initial submission
> - v2
> - Too many changes to list, but all concerns raised in previous submission addressed.
> - History: https://lore.kernel.org/platform-driver-x86/20240716051612.64842-1-luke@ljones.dev/
> - v3
> - All concerns addressed.
> - History: https://lore.kernel.org/platform-driver-x86/20240806020747.365042-1-luke@ljones.dev/
> - v4
> - Use EXPORT_SYMBOL_NS_GPL() for the symbols required in this patch series
> - Add patch for hid-asus due to the use of EXPORT_SYMBOL_NS_GPL()
> - Split the PPT knobs out to a separate patch
> - Split the hd_panel setting out to a new patch
> - Clarify some of APU MEM configuration and convert int to hex
> - Rename deprecated Kconfig option to ASUS_WMI_DEPRECATED_ATTRS
> - Fixup cyclic dependency in Kconfig
> - v5
> - deprecate patch: cleanup ``#if`, ``#endif` statements, edit kconfig detail, edit commit msg
> - cleanup ppt* tuning patch
> - proper error handling in module init, plus pr_err()
> - ppt tunables have a notice if there is no match to get defaults
> - better error handling in cpu core handling
> - don't continue if failure
> - use the mutex to gate WMI writes
> - V6
> - correctly cleanup/unwind if module init fails
> - V7
> - Remove review tags where the code changed significantly
> - Add auto_screen_brightness WMI attribute support
> - Move PPT patch to end
> - Add support min/max PPT values for 36 laptops (and two handhelds)
> - reword commit for "asus-wmi: export symbols used for read/write WMI"
> - asus-armoury: move existing tunings to asus-armoury
> - Correction to license header
> - Remove the (initial) mutex use (added for core count only in that patch)
> - Clarify some doc comments (attr_int_store)
> - Cleanup pr_warn in dgpu/egpu/mux functions
> - Restructure logic in asus_fw_attr_add()
> - Check gpu_mux_dev_id and mini_led_dev_id before remove attrs
> - asus-armoury: add core count control:
> - add mutex to prevent possible concurrent write to the core
> count WMI due to separated bit/little attributes
> - asus-armoury: add ppt_* and nv_* tuning knobs:
> - Move to end of series
> - Refactor to use a table of allowed min/max values to
> ensure safe settings
> - General code cleanup
> - Ensure checkpatch.pl returns clean for all
> - V8
> - asus-armoury: move existing tunings to asus-armoury module
> - Further cleanup: https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m72e203f64a5a28c9c21672406b2e9f554a8a8e38
> - asus-armoury: add ppt_* and nv_* tuning knobs
> - Address concerns in https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m77971b5c1e7f018954c16354e623fc06522c5e41
> - Refactor struct asus_armoury_priv to record both AC and DC settings
> - Tidy macros and functions affected by the above to be clearer as a result
> - Move repeated strings such as "ppt_pl1_spl" to #defines
> - Split should_create_tunable_attr() in to two functions to better clarify:
> - is_power_tunable_attr()
> - has_valid_limit()
> - Restructure init_rog_tunables() to initialise AC and DC in a
> way that makes more sense.
> - Ensure that if DC setting table is not available then attributes
> return -ENODEV only if on DC mode.
> - V9
> - asus-armoury: move existing tunings to asus-armoury module
> - return -EBUSY when eGPU/dGPU cannot be deactivated
> - asus-armoury: add apu-mem control support
> - discard the WMI presence bit fixing the functionality
> - asus-armoury: add core count control
> - replace mutex lock/unlock with guard
> - move core count alloc for initialization in init_max_cpu_cores()
> - v10
> - platform/x86: asus-wmi: export symbols used for read/write WMI
> - fix error with redefinition of asus_wmi_set_devstate
> - asus-armoury: move existing tunings to asus-armoury module
> - hwmon or other -> hwmon or others
> - fix wrong function name in documentation (attr_uint_store)
> - use kstrtouint where appropriate
> - (*) fix unreachable code warning: the fix turned out to be partial
> - improve return values in case of error in egpu_enable_current_value_store
> - asus-armoury: asus-armoury: add screen auto-brightness toggle
> - actually register screen_auto_brightness attribute
> - v11
> - cover-letter:
> - reorganize the changelog of v10
> - asus-armoury: move existing tunings to asus-armoury module
> - move the DMIs list in its own include, fixing (*) for good
> - asus-armoury: add ppt_* and nv_* tuning knobs
> - fix warning about redefinition of ppt_pl2_sppt_def for GV601R
> - v12
> - asus-armoury: add ppt_* and nv_* tuning knobs
> - add min/max values for FA608WI and FX507VI
> - v13
> - asus-armoury: add ppt_* and nv_* tuning knobs
> - fix a typo in a comment about _def attributes
> - add min/max values for GU605CW and G713PV
> - asus-armoury: add apu-mem control support
> - fix a possible out-of-bounds read in apu_mem_current_value_store
> - v14
> - platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
> - added patch to rename the symbol for consistency
> - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> - remove the unchecked usage of dmi_get_system_info while
> also increasing consistency with other messages
>
> Denis Benato (1):
> platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
>
> Luke D. Jones (8):
> platform/x86: asus-wmi: export symbols used for read/write WMI
> platform/x86: asus-armoury: move existing tunings to asus-armoury
> module
> platform/x86: asus-armoury: add panel_hd_mode attribute
> platform/x86: asus-armoury: add apu-mem control support
> platform/x86: asus-armoury: add core count control
> platform/x86: asus-armoury: add screen auto-brightness toggle
> platform/x86: asus-wmi: deprecate bios features
> platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>
> .../ABI/testing/sysfs-platform-asus-wmi | 17 +
> drivers/hid/hid-asus.c | 1 +
> drivers/platform/x86/Kconfig | 23 +
> drivers/platform/x86/Makefile | 1 +
> drivers/platform/x86/asus-armoury.c | 1172 ++++++++++++++
> drivers/platform/x86/asus-armoury.h | 1402 +++++++++++++++++
> drivers/platform/x86/asus-wmi.c | 170 +-
> .../platform_data/x86/asus-wmi-leds-ids.h | 50 +
> include/linux/platform_data/x86/asus-wmi.h | 62 +-
> 9 files changed, 2823 insertions(+), 75 deletions(-)
> create mode 100644 drivers/platform/x86/asus-armoury.c
> create mode 100644 drivers/platform/x86/asus-armoury.h
> create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 0/9] platform/x86: Add asus-armoury driver
2025-10-15 5:13 ` [PATCH v14 0/9] platform/x86: Add asus-armoury driver Mario Limonciello
@ 2025-10-15 9:38 ` Ilpo Järvinen
2025-10-15 12:00 ` Denis Benato
0 siblings, 1 reply; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-15 9:38 UTC (permalink / raw)
To: Mario Limonciello
Cc: Denis Benato, LKML, platform-driver-x86, Hans de Goede,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Mario Limonciello wrote:
> On 10/14/2025 8:47 PM, Denis Benato wrote:
> > Hi all,
> >
> > the TL;DR:
> > 1. Introduce new module to contain bios attributes, using
> > fw_attributes_class
> > 2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
> > 3. Remove those in the next LTS cycle
> >
> > The idea for this originates from a conversation with Mario Limonciello
> > https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
> >
> > It is without a doubt much cleaner to use, easier to discover, and the
> > API is well defined as opposed to the random clutter of attributes I had
> > been placing in the platform sysfs. Given that Derek is also working on a
> > similar approach to Lenovo in part based on my initial work I'd like to
> > think
> > that the overall approach is good and may become standardised for these
> > types
> > of things.
> >
> > Regarding PPT: it is intended to add support for "custom" platform profile
> > soon. If it's a blocker for this patch series being accepted I will drop the
> > platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
> > separately to avoid holding the bulk of the series up. Ideally I would like
> > to get the safe limits in so users don't fully lose functionality or
> > continue
> > to be exposed to potential instability from setting too low, or be mislead
> > in to thinking they can set limits higher than actual limit.
> >
> > The bulk of the PPT patch is data, the actual functional part is relatively
> > small and similar to the last version.
> >
> > Unfortunately I've been rather busy over the months and may not cover
> > everything in the v7 changelog but I've tried to be as comprehensive as I
> > can.
> >
> > Regards,
> > Luke
>
> As a general comment that applies to a few patches in the series.
>
> The S-o-b means that YOU sign off on them, it's like a chain of custody.
>
> Any patches that you're sending need your own S-o-B, even if they're 100% the
> same as the original from Luke.
There's also Co-developed-by tag which may be appropriate in cases where
both have touched the patch.
--
i.
> >
> > Changelog:
> > - v1
> > - Initial submission
> > - v2
> > - Too many changes to list, but all concerns raised in previous
> > submission addressed.
> > - History:
> > https://lore.kernel.org/platform-driver-x86/20240716051612.64842-1-luke@ljones.dev/
> > - v3
> > - All concerns addressed.
> > - History:
> > https://lore.kernel.org/platform-driver-x86/20240806020747.365042-1-luke@ljones.dev/
> > - v4
> > - Use EXPORT_SYMBOL_NS_GPL() for the symbols required in this patch
> > series
> > - Add patch for hid-asus due to the use of EXPORT_SYMBOL_NS_GPL()
> > - Split the PPT knobs out to a separate patch
> > - Split the hd_panel setting out to a new patch
> > - Clarify some of APU MEM configuration and convert int to hex
> > - Rename deprecated Kconfig option to ASUS_WMI_DEPRECATED_ATTRS
> > - Fixup cyclic dependency in Kconfig
> > - v5
> > - deprecate patch: cleanup ``#if`, ``#endif` statements, edit kconfig
> > detail, edit commit msg
> > - cleanup ppt* tuning patch
> > - proper error handling in module init, plus pr_err()
> > - ppt tunables have a notice if there is no match to get defaults
> > - better error handling in cpu core handling
> > - don't continue if failure
> > - use the mutex to gate WMI writes
> > - V6
> > - correctly cleanup/unwind if module init fails
> > - V7
> > - Remove review tags where the code changed significantly
> > - Add auto_screen_brightness WMI attribute support
> > - Move PPT patch to end
> > - Add support min/max PPT values for 36 laptops (and two handhelds)
> > - reword commit for "asus-wmi: export symbols used for read/write WMI"
> > - asus-armoury: move existing tunings to asus-armoury
> > - Correction to license header
> > - Remove the (initial) mutex use (added for core count only in that
> > patch)
> > - Clarify some doc comments (attr_int_store)
> > - Cleanup pr_warn in dgpu/egpu/mux functions
> > - Restructure logic in asus_fw_attr_add()
> > - Check gpu_mux_dev_id and mini_led_dev_id before remove attrs
> > - asus-armoury: add core count control:
> > - add mutex to prevent possible concurrent write to the core
> > count WMI due to separated bit/little attributes
> > - asus-armoury: add ppt_* and nv_* tuning knobs:
> > - Move to end of series
> > - Refactor to use a table of allowed min/max values to
> > ensure safe settings
> > - General code cleanup
> > - Ensure checkpatch.pl returns clean for all
> > - V8
> > - asus-armoury: move existing tunings to asus-armoury module
> > - Further cleanup:
> > https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m72e203f64a5a28c9c21672406b2e9f554a8a8e38
> > - asus-armoury: add ppt_* and nv_* tuning knobs
> > - Address concerns in
> > https://lore.kernel.org/platform-driver-x86/20250316230724.100165-2-luke@ljones.dev/T/#m77971b5c1e7f018954c16354e623fc06522c5e41
> > - Refactor struct asus_armoury_priv to record both AC and DC settings
> > - Tidy macros and functions affected by the above to be clearer as a
> > result
> > - Move repeated strings such as "ppt_pl1_spl" to #defines
> > - Split should_create_tunable_attr() in to two functions to better
> > clarify:
> > - is_power_tunable_attr()
> > - has_valid_limit()
> > - Restructure init_rog_tunables() to initialise AC and DC in a
> > way that makes more sense.
> > - Ensure that if DC setting table is not available then attributes
> > return -ENODEV only if on DC mode.
> > - V9
> > - asus-armoury: move existing tunings to asus-armoury module
> > - return -EBUSY when eGPU/dGPU cannot be deactivated
> > - asus-armoury: add apu-mem control support
> > - discard the WMI presence bit fixing the functionality
> > - asus-armoury: add core count control
> > - replace mutex lock/unlock with guard
> > - move core count alloc for initialization in init_max_cpu_cores()
> > - v10
> > - platform/x86: asus-wmi: export symbols used for read/write WMI
> > - fix error with redefinition of asus_wmi_set_devstate
> > - asus-armoury: move existing tunings to asus-armoury module
> > - hwmon or other -> hwmon or others
> > - fix wrong function name in documentation (attr_uint_store)
> > - use kstrtouint where appropriate
> > - (*) fix unreachable code warning: the fix turned out to be partial
> > - improve return values in case of error in
> > egpu_enable_current_value_store
> > - asus-armoury: asus-armoury: add screen auto-brightness toggle
> > - actually register screen_auto_brightness attribute
> > - v11
> > - cover-letter:
> > - reorganize the changelog of v10
> > - asus-armoury: move existing tunings to asus-armoury module
> > - move the DMIs list in its own include, fixing (*) for good
> > - asus-armoury: add ppt_* and nv_* tuning knobs
> > - fix warning about redefinition of ppt_pl2_sppt_def for GV601R
> > - v12
> > - asus-armoury: add ppt_* and nv_* tuning knobs
> > - add min/max values for FA608WI and FX507VI
> > - v13
> > - asus-armoury: add ppt_* and nv_* tuning knobs
> > - fix a typo in a comment about _def attributes
> > - add min/max values for GU605CW and G713PV
> > - asus-armoury: add apu-mem control support
> > - fix a possible out-of-bounds read in apu_mem_current_value_store
> > - v14
> > - platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
> > - added patch to rename the symbol for consistency
> > - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> > - remove the unchecked usage of dmi_get_system_info while
> > also increasing consistency with other messages
> >
> > Denis Benato (1):
> > platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
> >
> > Luke D. Jones (8):
> > platform/x86: asus-wmi: export symbols used for read/write WMI
> > platform/x86: asus-armoury: move existing tunings to asus-armoury
> > module
> > platform/x86: asus-armoury: add panel_hd_mode attribute
> > platform/x86: asus-armoury: add apu-mem control support
> > platform/x86: asus-armoury: add core count control
> > platform/x86: asus-armoury: add screen auto-brightness toggle
> > platform/x86: asus-wmi: deprecate bios features
> > platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >
> > .../ABI/testing/sysfs-platform-asus-wmi | 17 +
> > drivers/hid/hid-asus.c | 1 +
> > drivers/platform/x86/Kconfig | 23 +
> > drivers/platform/x86/Makefile | 1 +
> > drivers/platform/x86/asus-armoury.c | 1172 ++++++++++++++
> > drivers/platform/x86/asus-armoury.h | 1402 +++++++++++++++++
> > drivers/platform/x86/asus-wmi.c | 170 +-
> > .../platform_data/x86/asus-wmi-leds-ids.h | 50 +
> > include/linux/platform_data/x86/asus-wmi.h | 62 +-
> > 9 files changed, 2823 insertions(+), 75 deletions(-)
> > create mode 100644 drivers/platform/x86/asus-armoury.c
> > create mode 100644 drivers/platform/x86/asus-armoury.h
> > create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
> >
>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 0/9] platform/x86: Add asus-armoury driver
2025-10-15 9:38 ` Ilpo Järvinen
@ 2025-10-15 12:00 ` Denis Benato
2025-10-15 12:06 ` Ilpo Järvinen
0 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-15 12:00 UTC (permalink / raw)
To: Ilpo Järvinen, Mario Limonciello
Cc: LKML, platform-driver-x86, Hans de Goede, Luke D . Jones,
Alok Tiwari, Derek John Clark, Mateusz Schyboll, porfet828
On 10/15/25 11:38, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Mario Limonciello wrote:
>> On 10/14/2025 8:47 PM, Denis Benato wrote:
>>> Hi all,
>>>
>>> the TL;DR:
>>> 1. Introduce new module to contain bios attributes, using
>>> fw_attributes_class
>>> 2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
>>> 3. Remove those in the next LTS cycle
>>>
>>> The idea for this originates from a conversation with Mario Limonciello
>>> https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
>>>
>>> It is without a doubt much cleaner to use, easier to discover, and the
>>> API is well defined as opposed to the random clutter of attributes I had
>>> been placing in the platform sysfs. Given that Derek is also working on a
>>> similar approach to Lenovo in part based on my initial work I'd like to
>>> think
>>> that the overall approach is good and may become standardised for these
>>> types
>>> of things.
>>>
>>> Regarding PPT: it is intended to add support for "custom" platform profile
>>> soon. If it's a blocker for this patch series being accepted I will drop the
>>> platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
>>> separately to avoid holding the bulk of the series up. Ideally I would like
>>> to get the safe limits in so users don't fully lose functionality or
>>> continue
>>> to be exposed to potential instability from setting too low, or be mislead
>>> in to thinking they can set limits higher than actual limit.
>>>
>>> The bulk of the PPT patch is data, the actual functional part is relatively
>>> small and similar to the last version.
>>>
>>> Unfortunately I've been rather busy over the months and may not cover
>>> everything in the v7 changelog but I've tried to be as comprehensive as I
>>> can.
>>>
>>> Regards,
>>> Luke
>> As a general comment that applies to a few patches in the series.
>>
>> The S-o-b means that YOU sign off on them, it's like a chain of custody.
>>
>> Any patches that you're sending need your own S-o-B, even if they're 100% the
>> same as the original from Luke.
> There's also Co-developed-by tag which may be appropriate in cases where
> both have touched the patch.
>
I have re-read the submission documentation and confirmed I need at least
S-o-b for all of them. Is it acceptable if I simply answer to the email with my S-o-b
and Co-developed-by (on patches I have touched) or do I need to resend
the whole patchset creating a v15?
Thanks,
Denis
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 0/9] platform/x86: Add asus-armoury driver
2025-10-15 12:00 ` Denis Benato
@ 2025-10-15 12:06 ` Ilpo Järvinen
2025-10-15 12:27 ` Denis Benato
0 siblings, 1 reply; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-15 12:06 UTC (permalink / raw)
To: Denis Benato
Cc: Mario Limonciello, LKML, platform-driver-x86, Hans de Goede,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
[-- Attachment #1: Type: text/plain, Size: 2959 bytes --]
On Wed, 15 Oct 2025, Denis Benato wrote:
>
> On 10/15/25 11:38, Ilpo Järvinen wrote:
> > On Wed, 15 Oct 2025, Mario Limonciello wrote:
> >> On 10/14/2025 8:47 PM, Denis Benato wrote:
> >>> Hi all,
> >>>
> >>> the TL;DR:
> >>> 1. Introduce new module to contain bios attributes, using
> >>> fw_attributes_class
> >>> 2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
> >>> 3. Remove those in the next LTS cycle
> >>>
> >>> The idea for this originates from a conversation with Mario Limonciello
> >>> https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
> >>>
> >>> It is without a doubt much cleaner to use, easier to discover, and the
> >>> API is well defined as opposed to the random clutter of attributes I had
> >>> been placing in the platform sysfs. Given that Derek is also working on a
> >>> similar approach to Lenovo in part based on my initial work I'd like to
> >>> think
> >>> that the overall approach is good and may become standardised for these
> >>> types
> >>> of things.
> >>>
> >>> Regarding PPT: it is intended to add support for "custom" platform profile
> >>> soon. If it's a blocker for this patch series being accepted I will drop the
> >>> platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
> >>> separately to avoid holding the bulk of the series up. Ideally I would like
> >>> to get the safe limits in so users don't fully lose functionality or
> >>> continue
> >>> to be exposed to potential instability from setting too low, or be mislead
> >>> in to thinking they can set limits higher than actual limit.
> >>>
> >>> The bulk of the PPT patch is data, the actual functional part is relatively
> >>> small and similar to the last version.
> >>>
> >>> Unfortunately I've been rather busy over the months and may not cover
> >>> everything in the v7 changelog but I've tried to be as comprehensive as I
> >>> can.
> >>>
> >>> Regards,
> >>> Luke
> >> As a general comment that applies to a few patches in the series.
> >>
> >> The S-o-b means that YOU sign off on them, it's like a chain of custody.
> >>
> >> Any patches that you're sending need your own S-o-B, even if they're 100% the
> >> same as the original from Luke.
> > There's also Co-developed-by tag which may be appropriate in cases where
> > both have touched the patch.
> >
> I have re-read the submission documentation and confirmed I need at least
> S-o-b for all of them. Is it acceptable if I simply answer to the email with my S-o-b
> and Co-developed-by (on patches I have touched) or do I need to resend
> the whole patchset creating a v15?
Hi Denis,
Please wait a bit with v15, I'll try to take a look at this series
hopefully before the end of this week and I suspect there will be more
changes needed as a result (not to doubt your effort but it's long time
since I've looked at it).
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 0/9] platform/x86: Add asus-armoury driver
2025-10-15 12:06 ` Ilpo Järvinen
@ 2025-10-15 12:27 ` Denis Benato
0 siblings, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-15 12:27 UTC (permalink / raw)
To: Ilpo Järvinen
Cc: Mario Limonciello, LKML, platform-driver-x86, Hans de Goede,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On 10/15/25 14:06, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Denis Benato wrote:
>
>> On 10/15/25 11:38, Ilpo Järvinen wrote:
>>> On Wed, 15 Oct 2025, Mario Limonciello wrote:
>>>> On 10/14/2025 8:47 PM, Denis Benato wrote:
>>>>> Hi all,
>>>>>
>>>>> the TL;DR:
>>>>> 1. Introduce new module to contain bios attributes, using
>>>>> fw_attributes_class
>>>>> 2. Deprecate all possible attributes from asus-wmi that were added ad-hoc
>>>>> 3. Remove those in the next LTS cycle
>>>>>
>>>>> The idea for this originates from a conversation with Mario Limonciello
>>>>> https://lore.kernel.org/platform-driver-x86/371d4109-a3bb-4c3b-802f-4ec27a945c99@amd.com/
>>>>>
>>>>> It is without a doubt much cleaner to use, easier to discover, and the
>>>>> API is well defined as opposed to the random clutter of attributes I had
>>>>> been placing in the platform sysfs. Given that Derek is also working on a
>>>>> similar approach to Lenovo in part based on my initial work I'd like to
>>>>> think
>>>>> that the overall approach is good and may become standardised for these
>>>>> types
>>>>> of things.
>>>>>
>>>>> Regarding PPT: it is intended to add support for "custom" platform profile
>>>>> soon. If it's a blocker for this patch series being accepted I will drop the
>>>>> platform-x86-asus-armoury-add-ppt_-and-nv_-tuning.patch and get that done
>>>>> separately to avoid holding the bulk of the series up. Ideally I would like
>>>>> to get the safe limits in so users don't fully lose functionality or
>>>>> continue
>>>>> to be exposed to potential instability from setting too low, or be mislead
>>>>> in to thinking they can set limits higher than actual limit.
>>>>>
>>>>> The bulk of the PPT patch is data, the actual functional part is relatively
>>>>> small and similar to the last version.
>>>>>
>>>>> Unfortunately I've been rather busy over the months and may not cover
>>>>> everything in the v7 changelog but I've tried to be as comprehensive as I
>>>>> can.
>>>>>
>>>>> Regards,
>>>>> Luke
>>>> As a general comment that applies to a few patches in the series.
>>>>
>>>> The S-o-b means that YOU sign off on them, it's like a chain of custody.
>>>>
>>>> Any patches that you're sending need your own S-o-B, even if they're 100% the
>>>> same as the original from Luke.
>>> There's also Co-developed-by tag which may be appropriate in cases where
>>> both have touched the patch.
>>>
>> I have re-read the submission documentation and confirmed I need at least
>> S-o-b for all of them. Is it acceptable if I simply answer to the email with my S-o-b
>> and Co-developed-by (on patches I have touched) or do I need to resend
>> the whole patchset creating a v15?
> Hi Denis,
>
> Please wait a bit with v15, I'll try to take a look at this series
> hopefully before the end of this week and I suspect there will be more
> changes needed as a result (not to doubt your effort but it's long time
> since I've looked at it).
>
Sure! I will fix everything that needs fixing! I'm just happy seeing progress
since this is a work that is both extensively used (valve and other distros)
and very requested.
Thanks for your time!
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI
2025-10-15 1:47 ` [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI Denis Benato
@ 2025-10-15 13:03 ` Ilpo Järvinen
0 siblings, 0 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-15 13:03 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> Export symbols for reading/writing WMI symbols using a namespace.
> Existing functions:
> - asus_wmi_evaluate_method
> - asus_wmi_set_devstate
> New function:
> - asus_wmi_get_devstate_dsts
>
> The new function is intended for use with DSTS WMI method only and
> avoids requiring the asus_wmi driver data to select the WMI method.
>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
> ---
> drivers/platform/x86/asus-wmi.c | 40 ++++++++++++++++++++--
> include/linux/platform_data/x86/asus-wmi.h | 5 +++
> 2 files changed, 42 insertions(+), 3 deletions(-)
>
> diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
> index e72a2b5d158e..38ab5306e05a 100644
> --- a/drivers/platform/x86/asus-wmi.c
> +++ b/drivers/platform/x86/asus-wmi.c
> @@ -390,7 +390,7 @@ int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
> {
> return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
> }
> -EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
> +EXPORT_SYMBOL_NS_GPL(asus_wmi_evaluate_method, "ASUS_WMI");
>
> static int asus_wmi_evaluate_method5(u32 method_id,
> u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
> @@ -554,12 +554,46 @@ static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
> return 0;
> }
>
> -int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
> - u32 *retval)
> +/**
> + * asus_wmi_get_devstate_dsts() - Get the WMI function state.
> + * @dev_id: The WMI method ID to call.
> + * @retval: A pointer to where to store the value returned from WMI.
Please add empty line here (or just * to be precise).
> + * @return: 0 on success and retval is filled.
> + * @return: -ENODEV if the method ID is unsupported.
%0
%-ENODEV
Return:
I've never seen it used for more than one line. It's possible (I think) to
get the multi-line formatting with * *, please see
Documentation/doc-guide/kernel-doc.rst
> + * @return: everything else is an error from WMI call.
> + */
> +int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
> +{
> + int err;
> +
> + err = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, retval);
> + if (err)
> + return err;
> +
> + if (*retval == ASUS_WMI_UNSUPPORTED_METHOD)
> + return -ENODEV;
> +
> + return 0;
> +}
> +EXPORT_SYMBOL_NS_GPL(asus_wmi_get_devstate_dsts, "ASUS_WMI");
> +
> +/**
> + * asus_wmi_set_devstate() - Set the WMI function state.
> + * @dev_id: The WMI function to call.
> + * @ctrl_param: The argument to be used for this WMI function.
> + * @retval: A pointer to where to store the value returned from WMI.
> + * @return: 0 on success and retval is filled.
> + * @return: everything else is an error from WMI call.
> + *
> + * A asus_wmi_set_devstate() call must be paired with a
> + * asus_wmi_get_devstate_dsts() to check if the WMI function is supported.
Please put Return: as last (again, separating with an empty line from
the description).
> + */
> +int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
> {
> return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
> ctrl_param, retval);
> }
> +EXPORT_SYMBOL_NS_GPL(asus_wmi_set_devstate, "ASUS_WMI");
>
> /* Helper for special devices with magic return codes */
> static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index 8a515179113d..dbd44d9fbb6f 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -166,6 +166,7 @@ enum asus_ally_mcu_hack {
> #if IS_REACHABLE(CONFIG_ASUS_WMI)
> void set_ally_mcu_hack(enum asus_ally_mcu_hack status);
> void set_ally_mcu_powersave(bool enabled);
> +int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval);
> int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval);
> int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval);
> #else
> @@ -179,6 +180,10 @@ static inline int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
> {
> return -ENODEV;
> }
> +static inline int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
> +{
> + return -ENODEV;
> +}
> static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
> u32 *retval)
> {
>
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module
2025-10-15 1:47 ` [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module Denis Benato
@ 2025-10-15 13:56 ` Ilpo Järvinen
2025-10-16 1:28 ` Denis Benato
0 siblings, 1 reply; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-15 13:56 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
[-- Attachment #1: Type: text/plain, Size: 35391 bytes --]
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> The fw_attributes_class provides a much cleaner interface to all of the
> attributes introduced to asus-wmi. This patch moves all of these extra
> attributes over to fw_attributes_class, and shifts the bulk of these
> definitions to a new kernel module to reduce the clutter of asus-wmi
> with the intention of deprecating the asus-wmi attributes in future.
>
> The work applies only to WMI methods which don't have a clearly defined
> place within the sysfs and as a result ended up lumped together in
> /sys/devices/platform/asus-nb-wmi/ with no standard API.
>
> Where possible the fw attrs now implement defaults, min, max, scalar,
> choices, etc. As en example dgpu_disable becomes:
>
> /sys/class/firmware-attributes/asus-armoury/attributes/dgpu_disable/
> ├── current_value
> ├── display_name
> ├── possible_values
> └── type
>
> as do other attributes.
>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
> ---
> drivers/hid/hid-asus.c | 1 +
> drivers/platform/x86/Kconfig | 12 +
> drivers/platform/x86/Makefile | 1 +
> drivers/platform/x86/asus-armoury.c | 545 ++++++++++++++++++
> drivers/platform/x86/asus-armoury.h | 164 ++++++
> drivers/platform/x86/asus-wmi.c | 5 +-
> .../platform_data/x86/asus-wmi-leds-ids.h | 50 ++
> include/linux/platform_data/x86/asus-wmi.h | 43 +-
> 8 files changed, 777 insertions(+), 44 deletions(-)
> create mode 100644 drivers/platform/x86/asus-armoury.c
> create mode 100644 drivers/platform/x86/asus-armoury.h
> create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
>
> diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c
> index a444d41e53b6..472bca54642b 100644
> --- a/drivers/hid/hid-asus.c
> +++ b/drivers/hid/hid-asus.c
> @@ -27,6 +27,7 @@
> #include <linux/hid.h>
> #include <linux/module.h>
> #include <linux/platform_data/x86/asus-wmi.h>
> +#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
> #include <linux/input/mt.h>
> #include <linux/usb.h> /* For to_usb_interface for T100 touchpad intf check */
> #include <linux/power_supply.h>
> diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
> index 46e62feeda3c..8b827680754c 100644
> --- a/drivers/platform/x86/Kconfig
> +++ b/drivers/platform/x86/Kconfig
> @@ -262,6 +262,18 @@ config ASUS_WIRELESS
> If you choose to compile this driver as a module the module will be
> called asus-wireless.
>
> +config ASUS_ARMOURY
> + tristate "ASUS Armoury driver"
> + depends on ASUS_WMI
> + select FW_ATTR_CLASS
> + help
> + Say Y here if you have a WMI aware Asus machine and would like to use the
> + firmware_attributes API to control various settings typically exposed in
> + the ASUS Armoury Crate application available on Windows.
> +
> + To compile this driver as a module, choose M here: the module will
> + be called asus-armoury.
> +
> config ASUS_WMI
> tristate "ASUS WMI Driver"
> depends on ACPI_WMI
> diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
> index c7db2a88c11a..4b1220f9b194 100644
> --- a/drivers/platform/x86/Makefile
> +++ b/drivers/platform/x86/Makefile
> @@ -33,6 +33,7 @@ obj-$(CONFIG_APPLE_GMUX) += apple-gmux.o
> # ASUS
> obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
> obj-$(CONFIG_ASUS_WIRELESS) += asus-wireless.o
> +obj-$(CONFIG_ASUS_ARMOURY) += asus-armoury.o
> obj-$(CONFIG_ASUS_WMI) += asus-wmi.o
> obj-$(CONFIG_ASUS_NB_WMI) += asus-nb-wmi.o
> obj-$(CONFIG_ASUS_TF103C_DOCK) += asus-tf103c-dock.o
> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> new file mode 100644
> index 000000000000..57ed9449ec5f
> --- /dev/null
> +++ b/drivers/platform/x86/asus-armoury.c
> @@ -0,0 +1,545 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Asus Armoury (WMI) attributes driver.
> + *
> + * This driver uses the fw_attributes class to expose various WMI functions
> + * that are present in many gaming and some non-gaming ASUS laptops.
> + *
> + * These typically don't fit anywhere else in the sysfs such as under LED class,
> + * hwmon or others, and are set in Windows using the ASUS Armoury Crate tool.
> + *
> + * Copyright(C) 2024 Luke Jones <luke@ljones.dev>
> + */
> +
> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> +
> +#include <linux/acpi.h>
> +#include <linux/array_size.h>
> +#include <linux/bitfield.h>
> +#include <linux/device.h>
> +#include <linux/dmi.h>
> +#include <linux/errno.h>
> +#include <linux/fs.h>
> +#include <linux/kernel.h>
> +#include <linux/kmod.h>
> +#include <linux/kobject.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/platform_data/x86/asus-wmi.h>
> +#include <linux/printk.h>
> +#include <linux/types.h>
> +
> +#include "asus-armoury.h"
> +#include "firmware_attributes_class.h"
> +
> +#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
> +
> +#define ASUS_MINI_LED_MODE_MASK 0x03
GENMASK() + add its include. Consider if _MASK is necessary as it doesn't
provide much value and results in just longer lines.
BTW, before I go further, with my reviews there's no need to "ack" each
and every feedback item you're going to apply to your patches, I trust you
make those changes you don't contest. That way we can both save some time
by focusing on parts that need further discussion. :-)
> +/* Standard modes for devices with only on/off */
> +#define ASUS_MINI_LED_OFF 0x00
> +#define ASUS_MINI_LED_ON 0x01
> +/* Like "on" but the effect is more vibrant or brighter */
> +#define ASUS_MINI_LED_STRONG_MODE 0x02
> +/* New modes for devices with 3 mini-led mode types */
> +#define ASUS_MINI_LED_2024_WEAK 0x00
> +#define ASUS_MINI_LED_2024_STRONG 0x01
> +#define ASUS_MINI_LED_2024_OFF 0x02
> +
> +static struct asus_armoury_priv {
> + struct device *fw_attr_dev;
> + struct kset *fw_attr_kset;
> +
> + u32 mini_led_dev_id;
> + u32 gpu_mux_dev_id;
> +} asus_armoury;
I suggest put this to own line:
static struct asus_armoury_priv asus_armoury;
...as the current arrangement awkwardly separates things far away (e.g.
the "static").
> +struct fw_attrs_group {
> + bool pending_reboot;
> +};
> +
> +static struct fw_attrs_group fw_attrs = {
> + .pending_reboot = false,
> +};
> +
> +struct asus_attr_group {
> + const struct attribute_group *attr_group;
> + u32 wmi_devid;
> +};
> +
> +static bool asus_wmi_is_present(u32 dev_id)
> +{
> + u32 retval;
> + int status;
> +
> + status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, &retval);
> + pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
> +
> + return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
> +}
> +
> +static void asus_set_reboot_and_signal_event(void)
> +{
> + fw_attrs.pending_reboot = true;
> + kobject_uevent(&asus_armoury.fw_attr_dev->kobj, KOBJ_CHANGE);
> +}
> +
> +static ssize_t pending_reboot_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
> +{
> + return sysfs_emit(buf, "%d\n", fw_attrs.pending_reboot);
Add include.
> +}
> +
> +static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
> +
> +static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
> +{
> + return !strcmp(attr->attr.name, "gpu_mux_mode");
> +}
> +
> +static int armoury_wmi_set_devstate(struct kobj_attribute *attr, u32 value, u32 wmi_dev)
> +{
> + u32 result;
> + int err;
> +
> + err = asus_wmi_set_devstate(wmi_dev, value, &result);
> + if (err) {
> + pr_err("Failed to set %s: %d\n", attr->attr.name, err);
> + return err;
> + }
> + /*
> + * !1 is usually considered a fail by ASUS, but some WMI methods do use > 1
> + * to return a status code or similar.
> + */
> + if (result < 1) {
== 0 ?
> + pr_err("Failed to set %s: (result): 0x%x\n", attr->attr.name, result);
> + return -EIO;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * attr_uint_store() - Send an uint to wmi method, checks if within min/max exclusive.
> + * @kobj: Pointer to the driver object.
> + * @attr: Pointer to the attribute calling this function.
> + * @buf: The buffer to read from, this is parsed to `uint` type.
> + * @count: Required by sysfs attribute macros, pass in from the callee attr.
> + * @min: Minimum accepted value. Below this returns -EINVAL.
> + * @max: Maximum accepted value. Above this returns -EINVAL.
> + * @store_value: Pointer to where the parsed value should be stored.
> + * @wmi_dev: The WMI function ID to use.
> + *
> + * This function is intended to be generic so it can be called from any "_store"
> + * attribute which works only with integers. The integer to be sent to the WMI method
> + * is range checked and an error returned if out of range.
> + *
> + * If the value is valid and WMI is success, then the sysfs attribute is notified
> + * and if asus_bios_requires_reboot() is true then reboot attribute is also notified.
In general, please fold comment text to 80 characters as it's easier to
read shorter lines of text (long lines do require eye movement).
Also note this 80 character limits is only meant for comments, in code
exceeding 80 is fine where it makes sense.
> + *
> + * Returns: Either count, or an error.
> + */
> +static ssize_t attr_uint_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf,
> + size_t count, u32 min, u32 max, u32 *store_value, u32 wmi_dev)
> +{
> + u32 value;
> + int err;
> +
> + err = kstrtouint(buf, 10, &value);
> + if (err)
> + return err;
> +
> + if (value < min || value > max)
> + return -EINVAL;
> +
> + err = armoury_wmi_set_devstate(attr, value, wmi_dev);
> + if (err)
> + return err;
> +
> + if (store_value != NULL)
> + *store_value = value;
> + sysfs_notify(kobj, NULL, attr->attr.name);
> +
> + if (asus_bios_requires_reboot(attr))
> + asus_set_reboot_and_signal_event();
> +
> + return count;
> +}
> +
> +static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return sysfs_emit(buf, "enumeration\n");
> +}
> +
> +/* Mini-LED mode **************************************************************/
> +static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + u32 value;
> + int err;
> +
> + err = asus_wmi_get_devstate_dsts(asus_armoury.mini_led_dev_id, &value);
> + if (err)
> + return err;
> +
> + value &= ASUS_MINI_LED_MODE_MASK;
FIELD_GET() (mainly for consistency as shift is 0 here anyway)
> +
> + /*
> + * Remap the mode values to match previous generation mini-LED. The last gen
> + * WMI 0 == off, while on this version WMI 2 == off (flipped).
> + */
> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
> + switch (value) {
> + case ASUS_MINI_LED_2024_WEAK:
> + value = ASUS_MINI_LED_ON;
> + break;
> + case ASUS_MINI_LED_2024_STRONG:
> + value = ASUS_MINI_LED_STRONG_MODE;
> + break;
> + case ASUS_MINI_LED_2024_OFF:
> + value = ASUS_MINI_LED_OFF;
> + break;
> + }
> + }
> +
> + return sysfs_emit(buf, "%u\n", value);
> +}
> +
> +static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + u32 mode;
> + int err;
> +
> + err = kstrtou32(buf, 10, &mode);
> + if (err)
> + return err;
> +
> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
> + mode > ASUS_MINI_LED_ON)
> + return -EINVAL;
> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
> + mode > ASUS_MINI_LED_STRONG_MODE)
> + return -EINVAL;
> +
> + /*
> + * Remap the mode values so expected behaviour is the same as the last
> + * generation of mini-LED with 0 == off, 1 == on.
> + */
> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
> + switch (mode) {
> + case ASUS_MINI_LED_OFF:
> + mode = ASUS_MINI_LED_2024_OFF;
> + break;
> + case ASUS_MINI_LED_ON:
> + mode = ASUS_MINI_LED_2024_WEAK;
> + break;
> + case ASUS_MINI_LED_STRONG_MODE:
> + mode = ASUS_MINI_LED_2024_STRONG;
> + break;
> + }
> + }
Combine these into a single switch/case.
> +
> + err = armoury_wmi_set_devstate(attr, mode, asus_armoury.mini_led_dev_id);
> + if (err)
> + return err;
> +
> + sysfs_notify(kobj, NULL, attr->attr.name);
> +
> + return count;
> +}
> +
> +static ssize_t mini_led_mode_possible_values_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + switch (asus_armoury.mini_led_dev_id) {
> + case ASUS_WMI_DEVID_MINI_LED_MODE:
> + return sysfs_emit(buf, "0;1\n");
> + case ASUS_WMI_DEVID_MINI_LED_MODE2:
> + return sysfs_emit(buf, "0;1;2\n");
> + default:
> + return -ENODEV;
> + }
> +}
> +
> +ATTR_GROUP_ENUM_CUSTOM(mini_led_mode, "mini_led_mode", "Set the mini-LED backlight mode");
Remove the empty line before this.
I'm little worried about using such a generic names in macros specific
to this driver. Maybe the use of "CUSTOM" will save you from collisions
but a prefix also helps when reading code to know what is driver specific
and what is provided by the core. Maybe changing it to:
I think ASUS_ATTR_GROUP_ENUM() already indicates it's "custom" thing, I
don't know to which aspect the customness exactly tries to refer to in
this macro.
> +static ssize_t gpu_mux_mode_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr, const char *buf,
> + size_t count)
> +{
> + int result, err;
> + u32 optimus;
> +
> + err = kstrtou32(buf, 10, &optimus);
Why the other function used kstrtouint and this kstrtou32 ?? Please check
all these.
> + if (err)
> + return err;
> +
> + if (optimus > 1)
> + return -EINVAL;
> +
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_DGPU)) {
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_DGPU, &result);
> + if (err)
> + return err;
> + if (result && !optimus) {
> + pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %02X %02X\n",
> + result, optimus);
> + return -ENODEV;
> + }
> + }
> +
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_EGPU)) {
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU, &result);
> + if (err)
> + return err;
> + if (result && !optimus) {
> + pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled\n");
> + return -EBUSY;
> + }
> + }
> +
> + err = armoury_wmi_set_devstate(attr, optimus, asus_armoury.gpu_mux_dev_id);
> + if (err)
> + return err;
> +
> + sysfs_notify(kobj, NULL, attr->attr.name);
> + asus_set_reboot_and_signal_event();
> +
> + return count;
> +}
> +WMI_SHOW_INT(gpu_mux_mode_current_value, "%u\n", asus_armoury.gpu_mux_dev_id);
> +ATTR_GROUP_BOOL_CUSTOM(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
> +
> +/*
> + * A user may be required to store the value twice, typical store first, then
> + * rescan PCI bus to activate power, then store a second time to save correctly.
Could this be automated?
> + */
> +static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr, const char *buf,
> + size_t count)
> +{
> + int result, err;
> + u32 disable;
> +
> + err = kstrtou32(buf, 10, &disable);
> + if (err)
> + return err;
> +
> + if (disable > 1)
"disable" sounds like it is boolean for which there's kstrtobool ?
Also, I was not sure about optimus > 1 thing above if it too would
actually be bool.
> + return -EINVAL;
> +
> + if (asus_armoury.gpu_mux_dev_id) {
> + err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
> + if (err)
> + return err;
> + if (!result && disable) {
> + pr_warn("Can not disable dGPU when the MUX is in dGPU mode\n");
> + return -EBUSY;
> + }
> + }
> +
> + err = armoury_wmi_set_devstate(attr, disable, ASUS_WMI_DEVID_DGPU);
> + if (err)
> + return err;
> +
> + sysfs_notify(kobj, NULL, attr->attr.name);
> +
> + return count;
> +}
> +WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
ASUS_WMI_SHOW_INT()
> +ATTR_GROUP_BOOL_CUSTOM(dgpu_disable, "dgpu_disable", "Disable the dGPU");
> +
> +/* The ACPI call to enable the eGPU also disables the internal dGPU */
> +static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + int result, err;
> + u32 enable;
> +
> + err = kstrtou32(buf, 10, &enable);
> + if (err)
> + return err;
> +
> + if (enable > 1)
kstrtobool() ?
> + return -EINVAL;
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU_CONNECTED, &result);
> + if (err) {
> + pr_warn("Failed to get eGPU connection status: %d\n", err);
> + return err;
> + }
> +
> + if (asus_armoury.gpu_mux_dev_id) {
> + err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
> + if (err) {
> + pr_warn("Failed to get GPU MUX status: %d\n", result);
> + return err;
> + }
> + if (!result && enable) {
> + pr_warn("Can not enable eGPU when the MUX is in dGPU mode\n");
> + return -ENODEV;
> + }
> + }
> +
> + err = armoury_wmi_set_devstate(attr, enable, ASUS_WMI_DEVID_EGPU);
> + if (err)
> + return err;
> +
> + sysfs_notify(kobj, NULL, attr->attr.name);
> +
> + return count;
> +}
> +WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
> +ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
> +
> +/* Simple attribute creation */
> +ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
> + "Show the current mode of charging");
> +
> +ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
> + "Set the boot POST sound");
> +ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
> + "Set MCU powersaving mode");
> +ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
> + "Set the panel refresh overdrive");
> +ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
> + "Show the eGPU connection status");
> +
> +/* If an attribute does not require any special case handling add it here */
> +static const struct asus_attr_group armoury_attr_groups[] = {
> + { &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
> + { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
> + { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
> +
> + { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
> + { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
> + { &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
> + { &panel_od_attr_group, ASUS_WMI_DEVID_PANEL_OD },
> +};
> +
> +static int asus_fw_attr_add(void)
> +{
> + int err, i;
> +
> + asus_armoury.fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
> + NULL, "%s", DRIVER_NAME);
> + if (IS_ERR(asus_armoury.fw_attr_dev)) {
Add include.
> + err = PTR_ERR(asus_armoury.fw_attr_dev);
> + goto fail_class_get;
> + }
> +
> + asus_armoury.fw_attr_kset = kset_create_and_add("attributes", NULL,
> + &asus_armoury.fw_attr_dev->kobj);
> + if (!asus_armoury.fw_attr_kset) {
> + err = -ENOMEM;
> + goto err_destroy_classdev;
> + }
> +
> + err = sysfs_create_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
> + if (err) {
> + pr_err("Failed to create sysfs level attributes\n");
> + goto err_destroy_kset;
> + }
> +
> + asus_armoury.mini_led_dev_id = 0;
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE))
> + asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
> + else if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE2))
> + asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
> +
> + if (asus_armoury.mini_led_dev_id) {
> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
> + &mini_led_mode_attr_group);
> + if (err) {
> + pr_err("Failed to create sysfs-group for mini_led\n");
> + goto err_remove_file;
> + }
> + }
> +
> + asus_armoury.gpu_mux_dev_id = 0;
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX))
> + asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
> + else if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX_VIVO))
> + asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX_VIVO;
> +
> + if (asus_armoury.gpu_mux_dev_id) {
> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
> + &gpu_mux_mode_attr_group);
> + if (err) {
> + pr_err("Failed to create sysfs-group for gpu_mux\n");
> + goto err_remove_mini_led_group;
> + }
> + }
> +
> + for (i = 0; i < ARRAY_SIZE(armoury_attr_groups); i++) {
> + if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
> + continue;
> +
> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
> + armoury_attr_groups[i].attr_group);
> + if (err) {
> + pr_err("Failed to create sysfs-group for %s\n",
> + armoury_attr_groups[i].attr_group->name);
> + goto err_remove_groups;
> + }
> + }
> +
> + return 0;
> +
> +err_remove_groups:
> + while (i--) {
> + if (asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj,
> + armoury_attr_groups[i].attr_group);
> + }
> + if (asus_armoury.gpu_mux_dev_id)
> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &gpu_mux_mode_attr_group);
> +err_remove_mini_led_group:
> + if (asus_armoury.mini_led_dev_id)
> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &mini_led_mode_attr_group);
> +err_remove_file:
> + sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
> +err_destroy_kset:
> + kset_unregister(asus_armoury.fw_attr_kset);
> +err_destroy_classdev:
> +fail_class_get:
> + device_destroy(&firmware_attributes_class, MKDEV(0, 0));
> + return err;
> +}
> +
> +/* Init / exit ****************************************************************/
> +
> +static int __init asus_fw_init(void)
> +{
> + char *wmi_uid;
> +
> + wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
> + if (!wmi_uid)
> + return -ENODEV;
> +
> + /*
> + * if equal to "ASUSWMI" then it's DCTS that can't be used for this
> + * driver, DSTS is required.
> + */
> + if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
> + return -ENODEV;
> +
> + return asus_fw_attr_add();
> +}
> +
> +static void __exit asus_fw_exit(void)
> +{
> + sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
Why does the rollback path in asus_fw_attr_add() differ from these?
> + kset_unregister(asus_armoury.fw_attr_kset);
> + device_destroy(&firmware_attributes_class, MKDEV(0, 0));
> +}
> +
> +module_init(asus_fw_init);
> +module_exit(asus_fw_exit);
> +
> +MODULE_IMPORT_NS("ASUS_WMI");
> +MODULE_AUTHOR("Luke Jones <luke@ljones.dev>");
> +MODULE_DESCRIPTION("ASUS BIOS Configuration Driver");
> +MODULE_LICENSE("GPL");
> +MODULE_ALIAS("wmi:" ASUS_NB_WMI_EVENT_GUID);
> diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
> new file mode 100644
> index 000000000000..61675e7b5a60
> --- /dev/null
> +++ b/drivers/platform/x86/asus-armoury.h
> @@ -0,0 +1,164 @@
> +/* SPDX-License-Identifier: GPL-2.0
> + *
> + * Definitions for kernel modules using asus-armoury driver
> + *
> + * Copyright (c) 2024 Luke Jones <luke@ljones.dev>
> + */
> +
> +#ifndef _ASUS_ARMOURY_H_
> +#define _ASUS_ARMOURY_H_
> +
> +#include <linux/types.h>
> +#include <linux/platform_device.h>
> +
> +#define DRIVER_NAME "asus-armoury"
> +
> +#define __ASUS_ATTR_RO(_func, _name) \
> + { \
> + .attr = { .name = __stringify(_name), .mode = 0444 }, \
> + .show = _func##_##_name##_show, \
> + }
> +
> +#define __ASUS_ATTR_RO_AS(_name, _show) \
> + { \
> + .attr = { .name = __stringify(_name), .mode = 0444 }, \
> + .show = _show, \
> + }
> +
> +#define __ASUS_ATTR_RW(_func, _name) \
> + __ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store)
> +
> +#define __WMI_STORE_INT(_attr, _min, _max, _wmi) \
> + static ssize_t _attr##_store(struct kobject *kobj, \
> + struct kobj_attribute *attr, \
> + const char *buf, size_t count) \
> + { \
> + return attr_uint_store(kobj, attr, buf, count, _min, \
> + _max, NULL, _wmi); \
> + }
> +
> +#define WMI_SHOW_INT(_attr, _fmt, _wmi) \
> + static ssize_t _attr##_show(struct kobject *kobj, \
> + struct kobj_attribute *attr, char *buf) \
> + { \
> + u32 result; \
> + int err; \
> + \
> + err = asus_wmi_get_devstate_dsts(_wmi, &result); \
> + if (err) \
> + return err; \
> + return sysfs_emit(buf, _fmt, \
> + result & ~ASUS_WMI_DSTS_PRESENCE_BIT); \
> + }
> +
> +/* Create functions and attributes for use in other macros or on their own */
> +
> +/* Shows a formatted static variable */
> +#define __ATTR_SHOW_FMT(_prop, _attrname, _fmt, _val) \
> + static ssize_t _attrname##_##_prop##_show( \
> + struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
> + { \
> + return sysfs_emit(buf, _fmt, _val); \
> + } \
> + static struct kobj_attribute attr_##_attrname##_##_prop = \
> + __ASUS_ATTR_RO(_attrname, _prop)
> +
> +#define __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)\
> + WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RO(_attrname, current_value); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_possible_values.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +#define __ATTR_RW_INT_GROUP_ENUM(_attrname, _minv, _maxv, _wmi, _fsname,\
> + _possible, _dispname) \
> + __WMI_STORE_INT(_attrname##_current_value, _minv, _maxv, _wmi); \
> + WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RW(_attrname, current_value); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_possible_values.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +/* Boolean style enumeration, base macro. Requires adding show/store */
> +#define __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname) \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_possible_values.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +#define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
> + __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, "0;1", _dispname)
> +
> +
> +#define ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname) \
> + __ATTR_RW_INT_GROUP_ENUM(_attrname, 0, 1, _wmi, _fsname, "0;1", _dispname)
> +
> +#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
> + __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)
> +
> +/*
> + * Requires <name>_current_value_show(), <name>_current_value_show()
> + */
> +#define ATTR_GROUP_BOOL_CUSTOM(_attrname, _fsname, _dispname) \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RW(_attrname, current_value); \
> + __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
> +
> +/*
> + * Requires <name>_current_value_show(), <name>_current_value_show()
> + * and <name>_possible_values_show()
> + */
> +#define ATTR_GROUP_ENUM_CUSTOM(_attrname, _fsname, _dispname) \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RW(_attrname, current_value); \
> + static struct kobj_attribute attr_##_attrname##_possible_values = \
> + __ASUS_ATTR_RO(_attrname, possible_values); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_possible_values.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +#endif /* _ASUS_ARMOURY_H_ */
> diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
> index 38ab5306e05a..0d0c84a37ad8 100644
> --- a/drivers/platform/x86/asus-wmi.c
> +++ b/drivers/platform/x86/asus-wmi.c
> @@ -30,6 +30,7 @@
> #include <linux/pci.h>
> #include <linux/pci_hotplug.h>
> #include <linux/platform_data/x86/asus-wmi.h>
> +#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
> #include <linux/platform_device.h>
> #include <linux/platform_profile.h>
> #include <linux/power_supply.h>
> @@ -55,8 +56,6 @@ module_param(fnlock_default, bool, 0444);
> #define to_asus_wmi_driver(pdrv) \
> (container_of((pdrv), struct asus_wmi_driver, platform_driver))
>
> -#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
> -
> #define NOTIFY_BRNUP_MIN 0x11
> #define NOTIFY_BRNUP_MAX 0x1f
> #define NOTIFY_BRNDOWN_MIN 0x20
> @@ -105,8 +104,6 @@ module_param(fnlock_default, bool, 0444);
> #define USB_INTEL_XUSB2PR 0xD0
> #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31
>
> -#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
> -
> #define WMI_EVENT_MASK 0xFFFF
>
> #define FAN_CURVE_POINTS 8
> diff --git a/include/linux/platform_data/x86/asus-wmi-leds-ids.h b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
> new file mode 100644
> index 000000000000..281b98ba0ca7
> --- /dev/null
> +++ b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
> @@ -0,0 +1,50 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#ifndef __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
> +#define __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
> +
> +#include <linux/types.h>
Unnecessary, AFAICT.
> +#include <linux/dmi.h>
> +
> +/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
> +#if IS_REACHABLE(CONFIG_ASUS_WMI) || IS_REACHABLE(CONFIG_HID_ASUS)
> +static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
Are you aware that by placing this into a header file it ends up
getting duplicated to anything including this file? I suppose there's no
good way around it without some pretty complex trickery and it doesn't
look very large so I guess we can leave it here for now.
> + {
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
> + },
> + },
> + { },
> +};
> +#endif
> +
> +#endif /* __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H */
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index dbd44d9fbb6f..71c68425b3b9 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -6,6 +6,9 @@
> #include <linux/types.h>
> #include <linux/dmi.h>
>
> +#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
> +#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
> +
> /* WMI Methods */
> #define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
> #define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
> @@ -191,44 +194,4 @@ static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
> }
> #endif
>
> -/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
> -static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
> - {
> - .matches = {
> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
> - },
> - },
> - {
> - .matches = {
> - DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
> - },
> - },
> - { },
> -};
> -
> #endif /* __PLATFORM_DATA_X86_ASUS_WMI_H */
>
I don't have more time for further reviews.
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-15 1:47 ` [PATCH v14 5/9] platform/x86: asus-armoury: add core count control Denis Benato
@ 2025-10-15 14:11 ` Ilpo Järvinen
2025-10-17 12:48 ` Ilpo Järvinen
1 sibling, 0 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-15 14:11 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> Implement Intel core enablement under the asus-armoury module using the
> fw_attributes class.
>
> This allows users to enable or disable preformance or efficiency cores
> depending on their requirements. After change a reboot is required.
>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> ---
> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
> drivers/platform/x86/asus-armoury.h | 28 +++
> include/linux/platform_data/x86/asus-wmi.h | 5 +
> 3 files changed, 290 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> index 3b49a27e397d..3d963025d84e 100644
> --- a/drivers/platform/x86/asus-armoury.c
> +++ b/drivers/platform/x86/asus-armoury.c
> @@ -45,13 +45,49 @@
> #define ASUS_MINI_LED_2024_STRONG 0x01
> #define ASUS_MINI_LED_2024_OFF 0x02
>
> +#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
> +#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
> +
> +enum cpu_core_type {
> + CPU_CORE_PERF = 0,
> + CPU_CORE_POWER,
> +};
> +
> +enum cpu_core_value {
> + CPU_CORE_DEFAULT = 0,
> + CPU_CORE_MIN,
> + CPU_CORE_MAX,
> + CPU_CORE_CURRENT,
> +};
> +
> +#define CPU_PERF_CORE_COUNT_MIN 4
> +#define CPU_POWR_CORE_COUNT_MIN 0
> +
> +/* Tunables provided by ASUS for gaming laptops */
> +struct cpu_cores {
> + u32 cur_perf_cores;
> + u32 min_perf_cores;
> + u32 max_perf_cores;
> + u32 cur_power_cores;
> + u32 min_power_cores;
> + u32 max_power_cores;
> +};
> +
> static struct asus_armoury_priv {
> struct device *fw_attr_dev;
> struct kset *fw_attr_kset;
>
> + struct cpu_cores *cpu_cores;
> u32 mini_led_dev_id;
> u32 gpu_mux_dev_id;
> -} asus_armoury;
> + /*
> + * Mutex to prevent big/little core count changes writing to same
> + * endpoint at the same time. Must lock during attr store.
> + */
> + struct mutex cpu_core_mutex;
> +} asus_armoury = {
> + .cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex)
> +};
>
> struct fw_attrs_group {
> bool pending_reboot;
> @@ -93,6 +129,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
> static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
> {
> return !strcmp(attr->attr.name, "gpu_mux_mode") ||
> + !strcmp(attr->attr.name, "cores_performance") ||
> + !strcmp(attr->attr.name, "cores_efficiency") ||
> !strcmp(attr->attr.name, "panel_hd_mode");
> }
>
> @@ -171,6 +209,12 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
> return sysfs_emit(buf, "enumeration\n");
> }
>
> +static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return sysfs_emit(buf, "integer\n");
> +}
> +
> /* Mini-LED mode **************************************************************/
> static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
> struct kobj_attribute *attr, char *buf)
> @@ -474,6 +518,207 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
> }
> ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
>
> +static int init_max_cpu_cores(void)
> +{
> + u32 cores;
> + int err;
> +
> + asus_armoury.cpu_cores = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
> + if (!asus_armoury.cpu_cores)
> + return -ENOMEM;
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
> + if (err)
> + return err;
> +
> + if ((cores & ASUS_WMI_DSTS_PRESENCE_BIT) == 0) {
This pattern seems to happen more than once, I wonder if there should be
an interface that returns error when the presence bit is not there (and
returns the value without ASUS_WMI_DSTS_PRESENCE_BIT so the caller doesn't
need to clear it like apu_mem_current_value_show() does).
--
i.
> + pr_err("ACPI does not support CPU core count control\n");
> + err = -ENODEV;
> + goto init_max_cpu_cores_err;
> + }
> +
> + asus_armoury.cpu_cores->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
> + asus_armoury.cpu_cores->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
> + if (err) {
> + pr_err("Could not get CPU core count: error %d\n", err);
> + goto init_max_cpu_cores_err;
> + }
> +
> + asus_armoury.cpu_cores->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
> + asus_armoury.cpu_cores->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
> +
> + asus_armoury.cpu_cores->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
> + asus_armoury.cpu_cores->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
> +
> + return 0;
> +
> +init_max_cpu_cores_err:
> + kfree(asus_armoury.cpu_cores);
> + return err;
> +}
> +
> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
> + enum cpu_core_type core_type, enum cpu_core_value core_value)
> +{
> + u32 cores;
> +
> + switch (core_value) {
> + case CPU_CORE_DEFAULT:
> + case CPU_CORE_MAX:
> + if (core_type == CPU_CORE_PERF)
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->max_perf_cores);
> + else
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->max_power_cores);
> + case CPU_CORE_MIN:
> + if (core_type == CPU_CORE_PERF)
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->min_perf_cores);
> + else
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->min_power_cores);
> + default:
> + break;
> + }
> +
> + if (core_type == CPU_CORE_PERF)
> + cores = asus_armoury.cpu_cores->cur_perf_cores;
> + else
> + cores = asus_armoury.cpu_cores->cur_power_cores;
> +
> + return sysfs_emit(buf, "%u\n", cores);
> +}
> +
> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
> + const char *buf, enum cpu_core_type core_type)
> +{
> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
> + int result, err;
> +
> + result = kstrtou32(buf, 10, &new_cores);
> + if (result)
> + return result;
> +
> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
> + if (core_type == CPU_CORE_PERF) {
> + perf_cores = new_cores;
> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
> + min = asus_armoury.cpu_cores->min_perf_cores;
> + max = asus_armoury.cpu_cores->max_perf_cores;
> + } else {
> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
> + power_cores = new_cores;
> + min = asus_armoury.cpu_cores->min_power_cores;
> + max = asus_armoury.cpu_cores->max_power_cores;
> + }
> +
> + if (new_cores < min || new_cores > max)
> + return -EINVAL;
> +
> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
> +
> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
> + if (err) {
> + pr_warn("Failed to set CPU core count: %d\n", err);
> + return err;
> + }
> +
> + if (result > 1) {
> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
> + return -EIO;
> + }
> + }
> +
> + pr_info("CPU core count changed, reboot required\n");
> +
> + sysfs_notify(kobj, NULL, attr->attr.name);
> + asus_set_reboot_and_signal_event();
> +
> + return 0;
> +}
> +
> +static ssize_t cores_performance_min_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
> +}
> +
> +static ssize_t cores_performance_max_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
> +}
> +
> +static ssize_t cores_performance_default_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
> +}
> +
> +static ssize_t cores_performance_current_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
> +}
> +
> +static ssize_t cores_performance_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + int err;
> +
> + err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
> + if (err)
> + return err;
> +
> + return count;
> +}
> +ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
> + "Set the max available performance cores");
> +
> +static ssize_t cores_efficiency_min_value_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
> +}
> +
> +static ssize_t cores_efficiency_max_value_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
> +}
> +
> +static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
> +}
> +
> +static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
> +}
> +
> +static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr, const char *buf,
> + size_t count)
> +{
> + int err;
> +
> + err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
> + if (err)
> + return err;
> +
> + return count;
> +}
> +ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
> + "Set the max available efficiency cores");
> +
> /* Simple attribute creation */
> ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
> "Show the current mode of charging");
> @@ -495,6 +740,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
> { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
> { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
> { &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
> + { &cores_efficiency_attr_group, ASUS_WMI_DEVID_CORES_MAX },
> + { &cores_performance_attr_group, ASUS_WMI_DEVID_CORES_MAX },
>
> { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
> { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
> @@ -598,6 +845,7 @@ static int asus_fw_attr_add(void)
> static int __init asus_fw_init(void)
> {
> char *wmi_uid;
> + int err;
>
> wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
> if (!wmi_uid)
> @@ -610,6 +858,14 @@ static int __init asus_fw_init(void)
> if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
> return -ENODEV;
>
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_CORES_MAX)) {
> + err = init_max_cpu_cores();
> + if (err) {
> + pr_err("Could not initialise CPU core control %d\n", err);
> + return err;
> + }
> + }
> +
> return asus_fw_attr_add();
> }
>
> diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
> index 61675e7b5a60..a6c4caefdef9 100644
> --- a/drivers/platform/x86/asus-armoury.h
> +++ b/drivers/platform/x86/asus-armoury.h
> @@ -161,4 +161,32 @@
> .name = _fsname, .attrs = _attrname##_attrs \
> }
>
> +/* CPU core attributes need a little different in setup */
> +#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname) \
> + __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RW(_attrname, current_value); \
> + static struct kobj_attribute attr_##_attrname##_default_value = \
> + __ASUS_ATTR_RO(_attrname, default_value); \
> + static struct kobj_attribute attr_##_attrname##_min_value = \
> + __ASUS_ATTR_RO(_attrname, min_value); \
> + static struct kobj_attribute attr_##_attrname##_max_value = \
> + __ASUS_ATTR_RO(_attrname, max_value); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, int_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_default_value.attr, \
> + &attr_##_attrname##_min_value.attr, \
> + &attr_##_attrname##_max_value.attr, \
> + &attr_##_attrname##_scalar_increment.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> #endif /* _ASUS_ARMOURY_H_ */
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index a4f6bab93a6f..9a79dae97adf 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -137,6 +137,11 @@
> /* dgpu on/off */
> #define ASUS_WMI_DEVID_DGPU 0x00090020
>
> +/* Intel E-core and P-core configuration in a format 0x0[E]0[P] */
> +#define ASUS_WMI_DEVID_CORES 0x001200D2
> + /* Maximum Intel E-core and P-core availability */
> +#define ASUS_WMI_DEVID_CORES_MAX 0x001200D3
> +
> #define ASUS_WMI_DEVID_APU_MEM 0x000600C1
>
> /* gpu mux switch, 0 = dGPU, 1 = Optimus */
>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module
2025-10-15 13:56 ` Ilpo Järvinen
@ 2025-10-16 1:28 ` Denis Benato
0 siblings, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-16 1:28 UTC (permalink / raw)
To: Ilpo Järvinen
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On 10/15/25 15:56, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Denis Benato wrote:
>
>> From: "Luke D. Jones" <luke@ljones.dev>
>>
>> The fw_attributes_class provides a much cleaner interface to all of the
>> attributes introduced to asus-wmi. This patch moves all of these extra
>> attributes over to fw_attributes_class, and shifts the bulk of these
>> definitions to a new kernel module to reduce the clutter of asus-wmi
>> with the intention of deprecating the asus-wmi attributes in future.
>>
>> The work applies only to WMI methods which don't have a clearly defined
>> place within the sysfs and as a result ended up lumped together in
>> /sys/devices/platform/asus-nb-wmi/ with no standard API.
>>
>> Where possible the fw attrs now implement defaults, min, max, scalar,
>> choices, etc. As en example dgpu_disable becomes:
>>
>> /sys/class/firmware-attributes/asus-armoury/attributes/dgpu_disable/
>> ├── current_value
>> ├── display_name
>> ├── possible_values
>> └── type
>>
>> as do other attributes.
>>
>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>> Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
>> ---
>> drivers/hid/hid-asus.c | 1 +
>> drivers/platform/x86/Kconfig | 12 +
>> drivers/platform/x86/Makefile | 1 +
>> drivers/platform/x86/asus-armoury.c | 545 ++++++++++++++++++
>> drivers/platform/x86/asus-armoury.h | 164 ++++++
>> drivers/platform/x86/asus-wmi.c | 5 +-
>> .../platform_data/x86/asus-wmi-leds-ids.h | 50 ++
>> include/linux/platform_data/x86/asus-wmi.h | 43 +-
>> 8 files changed, 777 insertions(+), 44 deletions(-)
>> create mode 100644 drivers/platform/x86/asus-armoury.c
>> create mode 100644 drivers/platform/x86/asus-armoury.h
>> create mode 100644 include/linux/platform_data/x86/asus-wmi-leds-ids.h
>>
>> diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c
>> index a444d41e53b6..472bca54642b 100644
>> --- a/drivers/hid/hid-asus.c
>> +++ b/drivers/hid/hid-asus.c
>> @@ -27,6 +27,7 @@
>> #include <linux/hid.h>
>> #include <linux/module.h>
>> #include <linux/platform_data/x86/asus-wmi.h>
>> +#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
>> #include <linux/input/mt.h>
>> #include <linux/usb.h> /* For to_usb_interface for T100 touchpad intf check */
>> #include <linux/power_supply.h>
>> diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
>> index 46e62feeda3c..8b827680754c 100644
>> --- a/drivers/platform/x86/Kconfig
>> +++ b/drivers/platform/x86/Kconfig
>> @@ -262,6 +262,18 @@ config ASUS_WIRELESS
>> If you choose to compile this driver as a module the module will be
>> called asus-wireless.
>>
>> +config ASUS_ARMOURY
>> + tristate "ASUS Armoury driver"
>> + depends on ASUS_WMI
>> + select FW_ATTR_CLASS
>> + help
>> + Say Y here if you have a WMI aware Asus machine and would like to use the
>> + firmware_attributes API to control various settings typically exposed in
>> + the ASUS Armoury Crate application available on Windows.
>> +
>> + To compile this driver as a module, choose M here: the module will
>> + be called asus-armoury.
>> +
>> config ASUS_WMI
>> tristate "ASUS WMI Driver"
>> depends on ACPI_WMI
>> diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
>> index c7db2a88c11a..4b1220f9b194 100644
>> --- a/drivers/platform/x86/Makefile
>> +++ b/drivers/platform/x86/Makefile
>> @@ -33,6 +33,7 @@ obj-$(CONFIG_APPLE_GMUX) += apple-gmux.o
>> # ASUS
>> obj-$(CONFIG_ASUS_LAPTOP) += asus-laptop.o
>> obj-$(CONFIG_ASUS_WIRELESS) += asus-wireless.o
>> +obj-$(CONFIG_ASUS_ARMOURY) += asus-armoury.o
>> obj-$(CONFIG_ASUS_WMI) += asus-wmi.o
>> obj-$(CONFIG_ASUS_NB_WMI) += asus-nb-wmi.o
>> obj-$(CONFIG_ASUS_TF103C_DOCK) += asus-tf103c-dock.o
>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>> new file mode 100644
>> index 000000000000..57ed9449ec5f
>> --- /dev/null
>> +++ b/drivers/platform/x86/asus-armoury.c
>> @@ -0,0 +1,545 @@
>> +// SPDX-License-Identifier: GPL-2.0-or-later
>> +/*
>> + * Asus Armoury (WMI) attributes driver.
>> + *
>> + * This driver uses the fw_attributes class to expose various WMI functions
>> + * that are present in many gaming and some non-gaming ASUS laptops.
>> + *
>> + * These typically don't fit anywhere else in the sysfs such as under LED class,
>> + * hwmon or others, and are set in Windows using the ASUS Armoury Crate tool.
>> + *
>> + * Copyright(C) 2024 Luke Jones <luke@ljones.dev>
>> + */
>> +
>> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
>> +
>> +#include <linux/acpi.h>
>> +#include <linux/array_size.h>
>> +#include <linux/bitfield.h>
>> +#include <linux/device.h>
>> +#include <linux/dmi.h>
>> +#include <linux/errno.h>
>> +#include <linux/fs.h>
>> +#include <linux/kernel.h>
>> +#include <linux/kmod.h>
>> +#include <linux/kobject.h>
>> +#include <linux/module.h>
>> +#include <linux/mutex.h>
>> +#include <linux/platform_data/x86/asus-wmi.h>
>> +#include <linux/printk.h>
>> +#include <linux/types.h>
>> +
>> +#include "asus-armoury.h"
>> +#include "firmware_attributes_class.h"
>> +
>> +#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
>> +
>> +#define ASUS_MINI_LED_MODE_MASK 0x03
> GENMASK() + add its include. Consider if _MASK is necessary as it doesn't
> provide much value and results in just longer lines.
>
> BTW, before I go further, with my reviews there's no need to "ack" each
> and every feedback item you're going to apply to your patches, I trust you
> make those changes you don't contest. That way we can both save some time
> by focusing on parts that need further discussion. :-)
unironically ack :)
I will mention things that change a fair bit of code or logic/runtime changes.
>> +/* Standard modes for devices with only on/off */
>> +#define ASUS_MINI_LED_OFF 0x00
>> +#define ASUS_MINI_LED_ON 0x01
>> +/* Like "on" but the effect is more vibrant or brighter */
>> +#define ASUS_MINI_LED_STRONG_MODE 0x02
>> +/* New modes for devices with 3 mini-led mode types */
>> +#define ASUS_MINI_LED_2024_WEAK 0x00
>> +#define ASUS_MINI_LED_2024_STRONG 0x01
>> +#define ASUS_MINI_LED_2024_OFF 0x02
>> +
>> +static struct asus_armoury_priv {
>> + struct device *fw_attr_dev;
>> + struct kset *fw_attr_kset;
>> +
>> + u32 mini_led_dev_id;
>> + u32 gpu_mux_dev_id;
>> +} asus_armoury;
> I suggest put this to own line:
>
> static struct asus_armoury_priv asus_armoury;
>
> ...as the current arrangement awkwardly separates things far away (e.g.
> the "static").
>
>> +struct fw_attrs_group {
>> + bool pending_reboot;
>> +};
>> +
>> +static struct fw_attrs_group fw_attrs = {
>> + .pending_reboot = false,
>> +};
>> +
>> +struct asus_attr_group {
>> + const struct attribute_group *attr_group;
>> + u32 wmi_devid;
>> +};
>> +
>> +static bool asus_wmi_is_present(u32 dev_id)
>> +{
>> + u32 retval;
>> + int status;
>> +
>> + status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, &retval);
>> + pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
>> +
>> + return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
>> +}
>> +
>> +static void asus_set_reboot_and_signal_event(void)
>> +{
>> + fw_attrs.pending_reboot = true;
>> + kobject_uevent(&asus_armoury.fw_attr_dev->kobj, KOBJ_CHANGE);
>> +}
>> +
>> +static ssize_t pending_reboot_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
>> +{
>> + return sysfs_emit(buf, "%d\n", fw_attrs.pending_reboot);
> Add include.
>
>> +}
>> +
>> +static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
>> +
>> +static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
>> +{
>> + return !strcmp(attr->attr.name, "gpu_mux_mode");
>> +}
>> +
>> +static int armoury_wmi_set_devstate(struct kobj_attribute *attr, u32 value, u32 wmi_dev)
>> +{
>> + u32 result;
>> + int err;
>> +
>> + err = asus_wmi_set_devstate(wmi_dev, value, &result);
>> + if (err) {
>> + pr_err("Failed to set %s: %d\n", attr->attr.name, err);
>> + return err;
>> + }
>> + /*
>> + * !1 is usually considered a fail by ASUS, but some WMI methods do use > 1
>> + * to return a status code or similar.
>> + */
>> + if (result < 1) {
> == 0 ?
>
>> + pr_err("Failed to set %s: (result): 0x%x\n", attr->attr.name, result);
>> + return -EIO;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +/**
>> + * attr_uint_store() - Send an uint to wmi method, checks if within min/max exclusive.
>> + * @kobj: Pointer to the driver object.
>> + * @attr: Pointer to the attribute calling this function.
>> + * @buf: The buffer to read from, this is parsed to `uint` type.
>> + * @count: Required by sysfs attribute macros, pass in from the callee attr.
>> + * @min: Minimum accepted value. Below this returns -EINVAL.
>> + * @max: Maximum accepted value. Above this returns -EINVAL.
>> + * @store_value: Pointer to where the parsed value should be stored.
>> + * @wmi_dev: The WMI function ID to use.
>> + *
>> + * This function is intended to be generic so it can be called from any "_store"
>> + * attribute which works only with integers. The integer to be sent to the WMI method
>> + * is range checked and an error returned if out of range.
>> + *
>> + * If the value is valid and WMI is success, then the sysfs attribute is notified
>> + * and if asus_bios_requires_reboot() is true then reboot attribute is also notified.
> In general, please fold comment text to 80 characters as it's easier to
> read shorter lines of text (long lines do require eye movement).
>
> Also note this 80 character limits is only meant for comments, in code
> exceeding 80 is fine where it makes sense.
>
>> + *
>> + * Returns: Either count, or an error.
>> + */
>> +static ssize_t attr_uint_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf,
>> + size_t count, u32 min, u32 max, u32 *store_value, u32 wmi_dev)
>> +{
>> + u32 value;
>> + int err;
>> +
>> + err = kstrtouint(buf, 10, &value);
>> + if (err)
>> + return err;
>> +
>> + if (value < min || value > max)
>> + return -EINVAL;
>> +
>> + err = armoury_wmi_set_devstate(attr, value, wmi_dev);
>> + if (err)
>> + return err;
>> +
>> + if (store_value != NULL)
>> + *store_value = value;
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> +
>> + if (asus_bios_requires_reboot(attr))
>> + asus_set_reboot_and_signal_event();
>> +
>> + return count;
>> +}
>> +
>> +static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
>> + char *buf)
>> +{
>> + return sysfs_emit(buf, "enumeration\n");
>> +}
>> +
>> +/* Mini-LED mode **************************************************************/
>> +static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
>> + struct kobj_attribute *attr, char *buf)
>> +{
>> + u32 value;
>> + int err;
>> +
>> + err = asus_wmi_get_devstate_dsts(asus_armoury.mini_led_dev_id, &value);
>> + if (err)
>> + return err;
>> +
>> + value &= ASUS_MINI_LED_MODE_MASK;
> FIELD_GET() (mainly for consistency as shift is 0 here anyway)
>
>> +
>> + /*
>> + * Remap the mode values to match previous generation mini-LED. The last gen
>> + * WMI 0 == off, while on this version WMI 2 == off (flipped).
>> + */
>> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
>> + switch (value) {
>> + case ASUS_MINI_LED_2024_WEAK:
>> + value = ASUS_MINI_LED_ON;
>> + break;
>> + case ASUS_MINI_LED_2024_STRONG:
>> + value = ASUS_MINI_LED_STRONG_MODE;
>> + break;
>> + case ASUS_MINI_LED_2024_OFF:
>> + value = ASUS_MINI_LED_OFF;
>> + break;
>> + }
>> + }
>> +
>> + return sysfs_emit(buf, "%u\n", value);
>> +}
>> +
>> +static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
>> + struct kobj_attribute *attr,
>> + const char *buf, size_t count)
>> +{
>> + u32 mode;
>> + int err;
>> +
>> + err = kstrtou32(buf, 10, &mode);
>> + if (err)
>> + return err;
>> +
>> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
>> + mode > ASUS_MINI_LED_ON)
>> + return -EINVAL;
>> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
>> + mode > ASUS_MINI_LED_STRONG_MODE)
>> + return -EINVAL;
>> +
>> + /*
>> + * Remap the mode values so expected behaviour is the same as the last
>> + * generation of mini-LED with 0 == off, 1 == on.
>> + */
>> + if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
>> + switch (mode) {
>> + case ASUS_MINI_LED_OFF:
>> + mode = ASUS_MINI_LED_2024_OFF;
>> + break;
>> + case ASUS_MINI_LED_ON:
>> + mode = ASUS_MINI_LED_2024_WEAK;
>> + break;
>> + case ASUS_MINI_LED_STRONG_MODE:
>> + mode = ASUS_MINI_LED_2024_STRONG;
>> + break;
>> + }
>> + }
> Combine these into a single switch/case.
>
>> +
>> + err = armoury_wmi_set_devstate(attr, mode, asus_armoury.mini_led_dev_id);
>> + if (err)
>> + return err;
>> +
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> +
>> + return count;
>> +}
>> +
>> +static ssize_t mini_led_mode_possible_values_show(struct kobject *kobj,
>> + struct kobj_attribute *attr, char *buf)
>> +{
>> + switch (asus_armoury.mini_led_dev_id) {
>> + case ASUS_WMI_DEVID_MINI_LED_MODE:
>> + return sysfs_emit(buf, "0;1\n");
>> + case ASUS_WMI_DEVID_MINI_LED_MODE2:
>> + return sysfs_emit(buf, "0;1;2\n");
>> + default:
>> + return -ENODEV;
>> + }
>> +}
>> +
>> +ATTR_GROUP_ENUM_CUSTOM(mini_led_mode, "mini_led_mode", "Set the mini-LED backlight mode");
> Remove the empty line before this.
>
> I'm little worried about using such a generic names in macros specific
> to this driver. Maybe the use of "CUSTOM" will save you from collisions
> but a prefix also helps when reading code to know what is driver specific
> and what is provided by the core. Maybe changing it to:
>
> I think ASUS_ATTR_GROUP_ENUM() already indicates it's "custom" thing, I
> don't know to which aspect the customness exactly tries to refer to in
> this macro.
>
>> +static ssize_t gpu_mux_mode_current_value_store(struct kobject *kobj,
>> + struct kobj_attribute *attr, const char *buf,
>> + size_t count)
>> +{
>> + int result, err;
>> + u32 optimus;
>> +
>> + err = kstrtou32(buf, 10, &optimus);
> Why the other function used kstrtouint and this kstrtou32 ?? Please check
> all these.
>
>> + if (err)
>> + return err;
>> +
>> + if (optimus > 1)
>> + return -EINVAL;
>> +
>> + if (asus_wmi_is_present(ASUS_WMI_DEVID_DGPU)) {
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_DGPU, &result);
>> + if (err)
>> + return err;
>> + if (result && !optimus) {
>> + pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %02X %02X\n",
>> + result, optimus);
>> + return -ENODEV;
>> + }
>> + }
>> +
>> + if (asus_wmi_is_present(ASUS_WMI_DEVID_EGPU)) {
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU, &result);
>> + if (err)
>> + return err;
>> + if (result && !optimus) {
>> + pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled\n");
>> + return -EBUSY;
>> + }
>> + }
>> +
>> + err = armoury_wmi_set_devstate(attr, optimus, asus_armoury.gpu_mux_dev_id);
>> + if (err)
>> + return err;
>> +
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> + asus_set_reboot_and_signal_event();
>> +
>> + return count;
>> +}
>> +WMI_SHOW_INT(gpu_mux_mode_current_value, "%u\n", asus_armoury.gpu_mux_dev_id);
>> +ATTR_GROUP_BOOL_CUSTOM(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
>> +
>> +/*
>> + * A user may be required to store the value twice, typical store first, then
>> + * rescan PCI bus to activate power, then store a second time to save correctly.
> Could this be automated?
this can (have developed already) a way to automate this, including the pci rescan,
and it is what I was referring when I said "xg mobile" here:
https://lore.kernel.org/all/8128cd6b-50e3-464c-90c2-781f61c3963e@gmail.com/
that code has never been reviewed before and I was hoping to postpone it to avoid
holding back this series, but given the fact there is now a request for it and
that in this patch egpu can only be on/off (like a bool) but there are three distinct
ways to activate the egpu and I don't want to make this a bool or having to deal with
said property changing from bool to int later on I think I will blend in that other patch.
>
>> + */
>> +static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
>> + struct kobj_attribute *attr, const char *buf,
>> + size_t count)
>> +{
>> + int result, err;
>> + u32 disable;
>> +
>> + err = kstrtou32(buf, 10, &disable);
>> + if (err)
>> + return err;
>> +
>> + if (disable > 1)
> "disable" sounds like it is boolean for which there's kstrtobool ?
> Also, I was not sure about optimus > 1 thing above if it too would
> actually be bool.
basically see considerations in the previous paragraph.
The acpi can take in three different values to activate the xg mobile.
I think those corresponds to the three different xg mobile docks asus
has released over the years because for example nv_dynamic_boost
(and others) exposed via WMI can instead be used to control the egpu.
But one model was AMD and nv_dynamic_boost won't work on that,
hence the need to diversify commands used to activate the egpu
(an operation that can take about a minute) and also certain models
appears to have the physical bus (?) in common between the soldered
dgpu and the egpu, so here things gets difficult because those accessories
are hard to find (at least where I live), costs a fair amount of money and
are not common.
Samples of laptop+xgm I have seen are about 6 at most, so there is a
demand of having this working well, but little pool of device to extract
info from.
Most of what I know is pure observation, ACPI guesswork, testing one myself
(I have one at my disposal, but only one specific model) and trial and
errors with some user over a chat for the models I don't have.
>
>> + return -EINVAL;
>> +
>> + if (asus_armoury.gpu_mux_dev_id) {
>> + err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
>> + if (err)
>> + return err;
>> + if (!result && disable) {
>> + pr_warn("Can not disable dGPU when the MUX is in dGPU mode\n");
>> + return -EBUSY;
>> + }
>> + }
>> +
>> + err = armoury_wmi_set_devstate(attr, disable, ASUS_WMI_DEVID_DGPU);
>> + if (err)
>> + return err;
>> +
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> +
>> + return count;
>> +}
>> +WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
> ASUS_WMI_SHOW_INT()
>
>> +ATTR_GROUP_BOOL_CUSTOM(dgpu_disable, "dgpu_disable", "Disable the dGPU");
>> +
>> +/* The ACPI call to enable the eGPU also disables the internal dGPU */
>> +static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>> + const char *buf, size_t count)
>> +{
>> + int result, err;
>> + u32 enable;
>> +
>> + err = kstrtou32(buf, 10, &enable);
>> + if (err)
>> + return err;
>> +
>> + if (enable > 1)
> kstrtobool() ?
>
>> + return -EINVAL;
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU_CONNECTED, &result);
>> + if (err) {
>> + pr_warn("Failed to get eGPU connection status: %d\n", err);
>> + return err;
>> + }
>> +
>> + if (asus_armoury.gpu_mux_dev_id) {
>> + err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
>> + if (err) {
>> + pr_warn("Failed to get GPU MUX status: %d\n", result);
>> + return err;
>> + }
>> + if (!result && enable) {
>> + pr_warn("Can not enable eGPU when the MUX is in dGPU mode\n");
>> + return -ENODEV;
>> + }
>> + }
>> +
>> + err = armoury_wmi_set_devstate(attr, enable, ASUS_WMI_DEVID_EGPU);
>> + if (err)
>> + return err;
>> +
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> +
>> + return count;
>> +}
>> +WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
>> +ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
>> +
>> +/* Simple attribute creation */
>> +ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
>> + "Show the current mode of charging");
>> +
>> +ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
>> + "Set the boot POST sound");
>> +ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
>> + "Set MCU powersaving mode");
>> +ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
>> + "Set the panel refresh overdrive");
>> +ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
>> + "Show the eGPU connection status");
>> +
>> +/* If an attribute does not require any special case handling add it here */
>> +static const struct asus_attr_group armoury_attr_groups[] = {
>> + { &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
>> + { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
>> + { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
>> +
>> + { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
>> + { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
>> + { &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
>> + { &panel_od_attr_group, ASUS_WMI_DEVID_PANEL_OD },
>> +};
>> +
>> +static int asus_fw_attr_add(void)
>> +{
>> + int err, i;
>> +
>> + asus_armoury.fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
>> + NULL, "%s", DRIVER_NAME);
>> + if (IS_ERR(asus_armoury.fw_attr_dev)) {
> Add include.
>
>> + err = PTR_ERR(asus_armoury.fw_attr_dev);
>> + goto fail_class_get;
>> + }
>> +
>> + asus_armoury.fw_attr_kset = kset_create_and_add("attributes", NULL,
>> + &asus_armoury.fw_attr_dev->kobj);
>> + if (!asus_armoury.fw_attr_kset) {
>> + err = -ENOMEM;
>> + goto err_destroy_classdev;
>> + }
>> +
>> + err = sysfs_create_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
>> + if (err) {
>> + pr_err("Failed to create sysfs level attributes\n");
>> + goto err_destroy_kset;
>> + }
>> +
>> + asus_armoury.mini_led_dev_id = 0;
>> + if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE))
>> + asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
>> + else if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE2))
>> + asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
>> +
>> + if (asus_armoury.mini_led_dev_id) {
>> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
>> + &mini_led_mode_attr_group);
>> + if (err) {
>> + pr_err("Failed to create sysfs-group for mini_led\n");
>> + goto err_remove_file;
>> + }
>> + }
>> +
>> + asus_armoury.gpu_mux_dev_id = 0;
>> + if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX))
>> + asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
>> + else if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX_VIVO))
>> + asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX_VIVO;
>> +
>> + if (asus_armoury.gpu_mux_dev_id) {
>> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
>> + &gpu_mux_mode_attr_group);
>> + if (err) {
>> + pr_err("Failed to create sysfs-group for gpu_mux\n");
>> + goto err_remove_mini_led_group;
>> + }
>> + }
>> +
>> + for (i = 0; i < ARRAY_SIZE(armoury_attr_groups); i++) {
>> + if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
>> + continue;
>> +
>> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
>> + armoury_attr_groups[i].attr_group);
>> + if (err) {
>> + pr_err("Failed to create sysfs-group for %s\n",
>> + armoury_attr_groups[i].attr_group->name);
>> + goto err_remove_groups;
>> + }
>> + }
>> +
>> + return 0;
>> +
>> +err_remove_groups:
>> + while (i--) {
>> + if (asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
>> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj,
>> + armoury_attr_groups[i].attr_group);
>> + }
>> + if (asus_armoury.gpu_mux_dev_id)
>> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &gpu_mux_mode_attr_group);
>> +err_remove_mini_led_group:
>> + if (asus_armoury.mini_led_dev_id)
>> + sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &mini_led_mode_attr_group);
>> +err_remove_file:
>> + sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
>> +err_destroy_kset:
>> + kset_unregister(asus_armoury.fw_attr_kset);
>> +err_destroy_classdev:
>> +fail_class_get:
>> + device_destroy(&firmware_attributes_class, MKDEV(0, 0));
>> + return err;
>> +}
>> +
>> +/* Init / exit ****************************************************************/
>> +
>> +static int __init asus_fw_init(void)
>> +{
>> + char *wmi_uid;
>> +
>> + wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
>> + if (!wmi_uid)
>> + return -ENODEV;
>> +
>> + /*
>> + * if equal to "ASUSWMI" then it's DCTS that can't be used for this
>> + * driver, DSTS is required.
>> + */
>> + if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
>> + return -ENODEV;
>> +
>> + return asus_fw_attr_add();
>> +}
>> +
>> +static void __exit asus_fw_exit(void)
>> +{
>> + sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
> Why does the rollback path in asus_fw_attr_add() differ from these?
I don't see and am not aware of any particular reason.
From what I can gather every added sysfs attribute had its own rollback
because on previous iterations the flow to loading certain attributes
and rolling back (without failing) was different from how it is now.
It is my understanding that kset_unregister will unregister the whole
set of registered sysfs, so I guess I can issue just one kset_unregister
in a single err_sysfs_attr and avoid mentioning specific sysfs one by one,
correct?
>> + kset_unregister(asus_armoury.fw_attr_kset);
>> + device_destroy(&firmware_attributes_class, MKDEV(0, 0));
>> +}
>> +
>> +module_init(asus_fw_init);
>> +module_exit(asus_fw_exit);
>> +
>> +MODULE_IMPORT_NS("ASUS_WMI");
>> +MODULE_AUTHOR("Luke Jones <luke@ljones.dev>");
>> +MODULE_DESCRIPTION("ASUS BIOS Configuration Driver");
>> +MODULE_LICENSE("GPL");
>> +MODULE_ALIAS("wmi:" ASUS_NB_WMI_EVENT_GUID);
>> diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
>> new file mode 100644
>> index 000000000000..61675e7b5a60
>> --- /dev/null
>> +++ b/drivers/platform/x86/asus-armoury.h
>> @@ -0,0 +1,164 @@
>> +/* SPDX-License-Identifier: GPL-2.0
>> + *
>> + * Definitions for kernel modules using asus-armoury driver
>> + *
>> + * Copyright (c) 2024 Luke Jones <luke@ljones.dev>
>> + */
>> +
>> +#ifndef _ASUS_ARMOURY_H_
>> +#define _ASUS_ARMOURY_H_
>> +
>> +#include <linux/types.h>
>> +#include <linux/platform_device.h>
>> +
>> +#define DRIVER_NAME "asus-armoury"
>> +
>> +#define __ASUS_ATTR_RO(_func, _name) \
>> + { \
>> + .attr = { .name = __stringify(_name), .mode = 0444 }, \
>> + .show = _func##_##_name##_show, \
>> + }
>> +
>> +#define __ASUS_ATTR_RO_AS(_name, _show) \
>> + { \
>> + .attr = { .name = __stringify(_name), .mode = 0444 }, \
>> + .show = _show, \
>> + }
>> +
>> +#define __ASUS_ATTR_RW(_func, _name) \
>> + __ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store)
>> +
>> +#define __WMI_STORE_INT(_attr, _min, _max, _wmi) \
>> + static ssize_t _attr##_store(struct kobject *kobj, \
>> + struct kobj_attribute *attr, \
>> + const char *buf, size_t count) \
>> + { \
>> + return attr_uint_store(kobj, attr, buf, count, _min, \
>> + _max, NULL, _wmi); \
>> + }
>> +
>> +#define WMI_SHOW_INT(_attr, _fmt, _wmi) \
>> + static ssize_t _attr##_show(struct kobject *kobj, \
>> + struct kobj_attribute *attr, char *buf) \
>> + { \
>> + u32 result; \
>> + int err; \
>> + \
>> + err = asus_wmi_get_devstate_dsts(_wmi, &result); \
>> + if (err) \
>> + return err; \
>> + return sysfs_emit(buf, _fmt, \
>> + result & ~ASUS_WMI_DSTS_PRESENCE_BIT); \
>> + }
>> +
>> +/* Create functions and attributes for use in other macros or on their own */
>> +
>> +/* Shows a formatted static variable */
>> +#define __ATTR_SHOW_FMT(_prop, _attrname, _fmt, _val) \
>> + static ssize_t _attrname##_##_prop##_show( \
>> + struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
>> + { \
>> + return sysfs_emit(buf, _fmt, _val); \
>> + } \
>> + static struct kobj_attribute attr_##_attrname##_##_prop = \
>> + __ASUS_ATTR_RO(_attrname, _prop)
>> +
>> +#define __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)\
>> + WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
>> + static struct kobj_attribute attr_##_attrname##_current_value = \
>> + __ASUS_ATTR_RO(_attrname, current_value); \
>> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
>> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
>> + static struct kobj_attribute attr_##_attrname##_type = \
>> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
>> + static struct attribute *_attrname##_attrs[] = { \
>> + &attr_##_attrname##_current_value.attr, \
>> + &attr_##_attrname##_display_name.attr, \
>> + &attr_##_attrname##_possible_values.attr, \
>> + &attr_##_attrname##_type.attr, \
>> + NULL \
>> + }; \
>> + static const struct attribute_group _attrname##_attr_group = { \
>> + .name = _fsname, .attrs = _attrname##_attrs \
>> + }
>> +
>> +#define __ATTR_RW_INT_GROUP_ENUM(_attrname, _minv, _maxv, _wmi, _fsname,\
>> + _possible, _dispname) \
>> + __WMI_STORE_INT(_attrname##_current_value, _minv, _maxv, _wmi); \
>> + WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
>> + static struct kobj_attribute attr_##_attrname##_current_value = \
>> + __ASUS_ATTR_RW(_attrname, current_value); \
>> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
>> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
>> + static struct kobj_attribute attr_##_attrname##_type = \
>> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
>> + static struct attribute *_attrname##_attrs[] = { \
>> + &attr_##_attrname##_current_value.attr, \
>> + &attr_##_attrname##_display_name.attr, \
>> + &attr_##_attrname##_possible_values.attr, \
>> + &attr_##_attrname##_type.attr, \
>> + NULL \
>> + }; \
>> + static const struct attribute_group _attrname##_attr_group = { \
>> + .name = _fsname, .attrs = _attrname##_attrs \
>> + }
>> +
>> +/* Boolean style enumeration, base macro. Requires adding show/store */
>> +#define __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname) \
>> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
>> + __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible); \
>> + static struct kobj_attribute attr_##_attrname##_type = \
>> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
>> + static struct attribute *_attrname##_attrs[] = { \
>> + &attr_##_attrname##_current_value.attr, \
>> + &attr_##_attrname##_display_name.attr, \
>> + &attr_##_attrname##_possible_values.attr, \
>> + &attr_##_attrname##_type.attr, \
>> + NULL \
>> + }; \
>> + static const struct attribute_group _attrname##_attr_group = { \
>> + .name = _fsname, .attrs = _attrname##_attrs \
>> + }
>> +
>> +#define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
>> + __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, "0;1", _dispname)
>> +
>> +
>> +#define ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname) \
>> + __ATTR_RW_INT_GROUP_ENUM(_attrname, 0, 1, _wmi, _fsname, "0;1", _dispname)
>> +
>> +#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
>> + __ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, _possible, _dispname)
>> +
>> +/*
>> + * Requires <name>_current_value_show(), <name>_current_value_show()
>> + */
>> +#define ATTR_GROUP_BOOL_CUSTOM(_attrname, _fsname, _dispname) \
>> + static struct kobj_attribute attr_##_attrname##_current_value = \
>> + __ASUS_ATTR_RW(_attrname, current_value); \
>> + __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
>> +
>> +/*
>> + * Requires <name>_current_value_show(), <name>_current_value_show()
>> + * and <name>_possible_values_show()
>> + */
>> +#define ATTR_GROUP_ENUM_CUSTOM(_attrname, _fsname, _dispname) \
>> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
>> + static struct kobj_attribute attr_##_attrname##_current_value = \
>> + __ASUS_ATTR_RW(_attrname, current_value); \
>> + static struct kobj_attribute attr_##_attrname##_possible_values = \
>> + __ASUS_ATTR_RO(_attrname, possible_values); \
>> + static struct kobj_attribute attr_##_attrname##_type = \
>> + __ASUS_ATTR_RO_AS(type, enum_type_show); \
>> + static struct attribute *_attrname##_attrs[] = { \
>> + &attr_##_attrname##_current_value.attr, \
>> + &attr_##_attrname##_display_name.attr, \
>> + &attr_##_attrname##_possible_values.attr, \
>> + &attr_##_attrname##_type.attr, \
>> + NULL \
>> + }; \
>> + static const struct attribute_group _attrname##_attr_group = { \
>> + .name = _fsname, .attrs = _attrname##_attrs \
>> + }
>> +
>> +#endif /* _ASUS_ARMOURY_H_ */
>> diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
>> index 38ab5306e05a..0d0c84a37ad8 100644
>> --- a/drivers/platform/x86/asus-wmi.c
>> +++ b/drivers/platform/x86/asus-wmi.c
>> @@ -30,6 +30,7 @@
>> #include <linux/pci.h>
>> #include <linux/pci_hotplug.h>
>> #include <linux/platform_data/x86/asus-wmi.h>
>> +#include <linux/platform_data/x86/asus-wmi-leds-ids.h>
>> #include <linux/platform_device.h>
>> #include <linux/platform_profile.h>
>> #include <linux/power_supply.h>
>> @@ -55,8 +56,6 @@ module_param(fnlock_default, bool, 0444);
>> #define to_asus_wmi_driver(pdrv) \
>> (container_of((pdrv), struct asus_wmi_driver, platform_driver))
>>
>> -#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
>> -
>> #define NOTIFY_BRNUP_MIN 0x11
>> #define NOTIFY_BRNUP_MAX 0x1f
>> #define NOTIFY_BRNDOWN_MIN 0x20
>> @@ -105,8 +104,6 @@ module_param(fnlock_default, bool, 0444);
>> #define USB_INTEL_XUSB2PR 0xD0
>> #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31
>>
>> -#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
>> -
>> #define WMI_EVENT_MASK 0xFFFF
>>
>> #define FAN_CURVE_POINTS 8
>> diff --git a/include/linux/platform_data/x86/asus-wmi-leds-ids.h b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
>> new file mode 100644
>> index 000000000000..281b98ba0ca7
>> --- /dev/null
>> +++ b/include/linux/platform_data/x86/asus-wmi-leds-ids.h
>> @@ -0,0 +1,50 @@
>> +/* SPDX-License-Identifier: GPL-2.0 */
>> +#ifndef __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
>> +#define __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H
>> +
>> +#include <linux/types.h>
> Unnecessary, AFAICT.
>
>> +#include <linux/dmi.h>
>> +
>> +/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
>> +#if IS_REACHABLE(CONFIG_ASUS_WMI) || IS_REACHABLE(CONFIG_HID_ASUS)
>> +static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
> Are you aware that by placing this into a header file it ends up
> getting duplicated to anything including this file? I suppose there's no
> good way around it without some pretty complex trickery and it doesn't
> look very large so I guess we can leave it here for now.
I am well aware given the fact I had to move around that table to avoid
compiler warnings with certain configurations and it took me two revisions
to make those go away.
Luckily for us if the hid-asus patchset from Antheas [1] will work without
surprises across all affected ASUS hardware this table will get removed,
and honestly that would make me quite happy.
[1] https://lore.kernel.org/all/20251015014736.1402045-1-benato.denis96@gmail.com/
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
>> + },
>> + },
>> + {
>> + .matches = {
>> + DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
>> + },
>> + },
>> + { },
>> +};
>> +#endif
>> +
>> +#endif /* __PLATFORM_DATA_X86_ASUS_WMI_LEDS_IDS_H */
>> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
>> index dbd44d9fbb6f..71c68425b3b9 100644
>> --- a/include/linux/platform_data/x86/asus-wmi.h
>> +++ b/include/linux/platform_data/x86/asus-wmi.h
>> @@ -6,6 +6,9 @@
>> #include <linux/types.h>
>> #include <linux/dmi.h>
>>
>> +#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
>> +#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
>> +
>> /* WMI Methods */
>> #define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
>> #define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
>> @@ -191,44 +194,4 @@ static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
>> }
>> #endif
>>
>> -/* To be used by both hid-asus and asus-wmi to determine which controls kbd_brightness */
>> -static const struct dmi_system_id asus_use_hid_led_dmi_ids[] = {
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Zephyrus"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Strix"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ROG Flow"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_PRODUCT_FAMILY, "ProArt P16"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
>> - },
>> - },
>> - {
>> - .matches = {
>> - DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
>> - },
>> - },
>> - { },
>> -};
>> -
>> #endif /* __PLATFORM_DATA_X86_ASUS_WMI_H */
>>
> I don't have more time for further reviews.
>
The xgm new code will need a review. I am pretty new to all of this
and I need guidance: I have gone from average user to maintainer in
about three years and therefore don't have much experience.
Thanks for your time and understanding,
Denis
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support
2025-10-15 1:47 ` [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support Denis Benato
@ 2025-10-17 12:16 ` Ilpo Järvinen
2025-10-18 1:23 ` Denis Benato
0 siblings, 1 reply; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-17 12:16 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> Implement the APU memory size control under the asus-armoury module using
> the fw_attributes class.
>
> This allows the APU allocated memory size to be adjusted depending on
> the users priority. A reboot is required after change.
>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> ---
> drivers/platform/x86/asus-armoury.c | 81 ++++++++++++++++++++++
> include/linux/platform_data/x86/asus-wmi.h | 2 +
> 2 files changed, 83 insertions(+)
>
> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> index 68ce2c159ae1..3b49a27e397d 100644
> --- a/drivers/platform/x86/asus-armoury.c
> +++ b/drivers/platform/x86/asus-armoury.c
> @@ -394,6 +394,86 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj
> WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
> ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
>
> +/* Device memory available to APU */
> +
> +/* Values map for APU memory: some looks out of order but are actually correct */
> +static u32 apu_mem_map[] = {
> + [0] = 0x000, /* called "AUTO" on the BIOS, is the minimum available */
> + [1] = 0x102,
> + [2] = 0x103,
> + [3] = 0x104,
> + [4] = 0x105,
> + [5] = 0x107,
> + [6] = 0x108,
> + [7] = 0x109,
> + [8] = 0x106,
Is BIT(8) actually telling non-AUTO here? I mean, it's not set for the
AUTO case. If it has this special meaning, maybe that should be left out
of this array and handled by the show/store functions as it seems
different for the auto depending on which way the information is being
passed.
> +};
> +
> +static ssize_t apu_mem_current_value_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + int err;
> + u32 mem;
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
> + if (err)
> + return err;
> +
> + if ((mem & ASUS_WMI_DSTS_PRESENCE_BIT) == 0)
> + return -ENODEV;
> +
> + mem &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
> +
> + /* After 0x000 is set, a read will return 0x100 */
> + if (mem == 0x100)
> + return sysfs_emit(buf, "0\n");
> +
> + for (unsigned int i = 0; i < ARRAY_SIZE(apu_mem_map); i++) {
> + if (apu_mem_map[i] == mem)
> + return sysfs_emit(buf, "%u\n", i);
> + }
> +
> + pr_warn("Unrecognised value for APU mem 0x%08x\n", mem);
> + return sysfs_emit(buf, "%u\n", mem);
??
Should this return -EIO or something like that instead. It definitely
looks wrong to first log it as %x and then output to sysfs as %u.
> +}
> +
> +static ssize_t apu_mem_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + int result, err;
> + u32 requested, mem;
> +
> + result = kstrtou32(buf, 10, &requested);
> + if (result)
> + return result;
> +
> + if (requested >= ARRAY_SIZE(apu_mem_map))
> + return -EINVAL;
> +
> + mem = apu_mem_map[requested];
> +
> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
> + if (err) {
> + pr_warn("Failed to set apu_mem: %d\n", err);
> + return err;
> + }
> +
> + pr_info("APU memory changed to %uGB, reboot required\n", requested+1);
requested + 1
Please mention GB up where the array is.
> + sysfs_notify(kobj, NULL, attr->attr.name);
> +
> + asus_set_reboot_and_signal_event();
> +
> + return count;
> +}
> +
> +static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + BUILD_BUG_ON(ARRAY_SIZE(apu_mem_map) != 9);
> + return sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");
You could make this future proof with a for loop and sysfs_emit_at() and
drop the BUILD_BUG_ON(). Maybe all these multi-valued show functions could
share a helper which does that.
> +}
> +ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
> +
> /* Simple attribute creation */
> ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
> "Show the current mode of charging");
> @@ -414,6 +494,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
> { &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
> { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
> { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
> + { &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
>
> { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
> { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index 10acd5d52e38..a4f6bab93a6f 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -137,6 +137,8 @@
> /* dgpu on/off */
> #define ASUS_WMI_DEVID_DGPU 0x00090020
>
> +#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
> +
> /* gpu mux switch, 0 = dGPU, 1 = Optimus */
> #define ASUS_WMI_DEVID_GPU_MUX 0x00090016
> #define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026
>
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-15 1:47 ` [PATCH v14 5/9] platform/x86: asus-armoury: add core count control Denis Benato
2025-10-15 14:11 ` Ilpo Järvinen
@ 2025-10-17 12:48 ` Ilpo Järvinen
2025-10-18 1:43 ` Denis Benato
2025-10-19 16:53 ` Denis Benato
1 sibling, 2 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-17 12:48 UTC (permalink / raw)
To: Mario Limonciello, Hans de Goede, Denis Benato, Mark Pearson,
Luke D . Jones
Cc: LKML, platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> Implement Intel core enablement under the asus-armoury module using the
> fw_attributes class.
>
> This allows users to enable or disable preformance or efficiency cores
> depending on their requirements. After change a reboot is required.
>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> ---
> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
> drivers/platform/x86/asus-armoury.h | 28 +++
> include/linux/platform_data/x86/asus-wmi.h | 5 +
> 3 files changed, 290 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> index 3b49a27e397d..3d963025d84e 100644
> --- a/drivers/platform/x86/asus-armoury.c
> +++ b/drivers/platform/x86/asus-armoury.c
> @@ -45,13 +45,49 @@
> #define ASUS_MINI_LED_2024_STRONG 0x01
> #define ASUS_MINI_LED_2024_OFF 0x02
>
> +#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
> +#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
> +
> +enum cpu_core_type {
> + CPU_CORE_PERF = 0,
> + CPU_CORE_POWER,
> +};
> +
> +enum cpu_core_value {
> + CPU_CORE_DEFAULT = 0,
This could be mapped in the sysfs _show function as there's no real
backing value for it.
> + CPU_CORE_MIN,
> + CPU_CORE_MAX,
> + CPU_CORE_CURRENT,
> +};
> +
> +#define CPU_PERF_CORE_COUNT_MIN 4
> +#define CPU_POWR_CORE_COUNT_MIN 0
> +
> +/* Tunables provided by ASUS for gaming laptops */
> +struct cpu_cores {
> + u32 cur_perf_cores;
> + u32 min_perf_cores;
> + u32 max_perf_cores;
> + u32 cur_power_cores;
> + u32 min_power_cores;
> + u32 max_power_cores;
> +};
> +
> static struct asus_armoury_priv {
> struct device *fw_attr_dev;
> struct kset *fw_attr_kset;
>
> + struct cpu_cores *cpu_cores;
> u32 mini_led_dev_id;
> u32 gpu_mux_dev_id;
> -} asus_armoury;
> + /*
> + * Mutex to prevent big/little core count changes writing to same
> + * endpoint at the same time. Must lock during attr store.
> + */
> + struct mutex cpu_core_mutex;
> +} asus_armoury = {
> + .cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex)
> +};
>
> struct fw_attrs_group {
> bool pending_reboot;
> @@ -93,6 +129,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
> static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
> {
> return !strcmp(attr->attr.name, "gpu_mux_mode") ||
> + !strcmp(attr->attr.name, "cores_performance") ||
> + !strcmp(attr->attr.name, "cores_efficiency") ||
> !strcmp(attr->attr.name, "panel_hd_mode");
> }
>
> @@ -171,6 +209,12 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
> return sysfs_emit(buf, "enumeration\n");
> }
>
> +static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return sysfs_emit(buf, "integer\n");
> +}
> +
> /* Mini-LED mode **************************************************************/
> static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
> struct kobj_attribute *attr, char *buf)
> @@ -474,6 +518,207 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
> }
> ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
>
> +static int init_max_cpu_cores(void)
> +{
> + u32 cores;
> + int err;
> +
> + asus_armoury.cpu_cores = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
> + if (!asus_armoury.cpu_cores)
> + return -ENOMEM;
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
> + if (err)
> + return err;
> +
> + if ((cores & ASUS_WMI_DSTS_PRESENCE_BIT) == 0) {
> + pr_err("ACPI does not support CPU core count control\n");
> + err = -ENODEV;
> + goto init_max_cpu_cores_err;
Please use __free() and return immediately.
Only assign from local variable to asus_armoury.cpu_cores with
no_free_ptr() at the end.
> + }
> +
> + asus_armoury.cpu_cores->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
> + asus_armoury.cpu_cores->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
> +
> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
> + if (err) {
> + pr_err("Could not get CPU core count: error %d\n", err);
> + goto init_max_cpu_cores_err;
> + }
> +
> + asus_armoury.cpu_cores->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
> + asus_armoury.cpu_cores->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
> +
> + asus_armoury.cpu_cores->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
> + asus_armoury.cpu_cores->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
Should these be bounds checked with max?
> + return 0;
> +
> +init_max_cpu_cores_err:
> + kfree(asus_armoury.cpu_cores);
> + return err;
> +}
> +
> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
> + enum cpu_core_type core_type, enum cpu_core_value core_value)
> +{
> + u32 cores;
> +
> + switch (core_value) {
> + case CPU_CORE_DEFAULT:
> + case CPU_CORE_MAX:
> + if (core_type == CPU_CORE_PERF)
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->max_perf_cores);
> + else
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->max_power_cores);
> + case CPU_CORE_MIN:
> + if (core_type == CPU_CORE_PERF)
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->min_perf_cores);
> + else
> + return sysfs_emit(buf, "%u\n",
> + asus_armoury.cpu_cores->min_power_cores);
> + default:
> + break;
> + }
> +
> + if (core_type == CPU_CORE_PERF)
> + cores = asus_armoury.cpu_cores->cur_perf_cores;
> + else
> + cores = asus_armoury.cpu_cores->cur_power_cores;
Why isn't this inside the switch?? The logic in this function looks very
mixed up.
If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
multi-dimensional array. It would make this just bounds checks and one
line to get the data.
> + return sysfs_emit(buf, "%u\n", cores);
> +}
> +
> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
> + const char *buf, enum cpu_core_type core_type)
> +{
> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
> + int result, err;
> +
> + result = kstrtou32(buf, 10, &new_cores);
> + if (result)
> + return result;
> +
> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
> + if (core_type == CPU_CORE_PERF) {
> + perf_cores = new_cores;
> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
> + min = asus_armoury.cpu_cores->min_perf_cores;
> + max = asus_armoury.cpu_cores->max_perf_cores;
> + } else {
> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
> + power_cores = new_cores;
> + min = asus_armoury.cpu_cores->min_power_cores;
> + max = asus_armoury.cpu_cores->max_power_cores;
> + }
> +
> + if (new_cores < min || new_cores > max)
> + return -EINVAL;
> +
> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
> +
> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
> + if (err) {
> + pr_warn("Failed to set CPU core count: %d\n", err);
> + return err;
> + }
> +
> + if (result > 1) {
> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
> + return -EIO;
> + }
> + }
> +
> + pr_info("CPU core count changed, reboot required\n");
This interface has a problematic behavior. If user wants to adjust both
core counts one after another (without reboot in between), the new value
of the first core count will be overwritten on the second store.
You might have to store also the value that will be used after the next
boot to solve it but how the divergence should be presented to user is
another question to which I don't have a good answer.
This seems a more general problem, that is, how to represent values which
are only enacted after booting (current vs to-be-current) as it doesn't
fit to the current, min, max, possible_values, type model.
--
i.
> + sysfs_notify(kobj, NULL, attr->attr.name);
> + asus_set_reboot_and_signal_event();
> +
> + return 0;
> +}
> +
> +static ssize_t cores_performance_min_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
> +}
> +
> +static ssize_t cores_performance_max_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
> +}
> +
> +static ssize_t cores_performance_default_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
> +}
> +
> +static ssize_t cores_performance_current_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
> +}
> +
> +static ssize_t cores_performance_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + int err;
> +
> + err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
> + if (err)
> + return err;
> +
> + return count;
> +}
> +ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
> + "Set the max available performance cores");
> +
> +static ssize_t cores_efficiency_min_value_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
> +}
> +
> +static ssize_t cores_efficiency_max_value_show(struct kobject *kobj, struct kobj_attribute *attr,
> + char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
> +}
> +
> +static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
> +}
> +
> +static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
> +}
> +
> +static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
> + struct kobj_attribute *attr, const char *buf,
> + size_t count)
> +{
> + int err;
> +
> + err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
> + if (err)
> + return err;
> +
> + return count;
> +}
> +ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
> + "Set the max available efficiency cores");
> +
> /* Simple attribute creation */
> ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
> "Show the current mode of charging");
> @@ -495,6 +740,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
> { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
> { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
> { &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
> + { &cores_efficiency_attr_group, ASUS_WMI_DEVID_CORES_MAX },
> + { &cores_performance_attr_group, ASUS_WMI_DEVID_CORES_MAX },
>
> { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
> { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
> @@ -598,6 +845,7 @@ static int asus_fw_attr_add(void)
> static int __init asus_fw_init(void)
> {
> char *wmi_uid;
> + int err;
>
> wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
> if (!wmi_uid)
> @@ -610,6 +858,14 @@ static int __init asus_fw_init(void)
> if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
> return -ENODEV;
>
> + if (asus_wmi_is_present(ASUS_WMI_DEVID_CORES_MAX)) {
> + err = init_max_cpu_cores();
> + if (err) {
> + pr_err("Could not initialise CPU core control %d\n", err);
> + return err;
> + }
> + }
> +
> return asus_fw_attr_add();
> }
>
> diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
> index 61675e7b5a60..a6c4caefdef9 100644
> --- a/drivers/platform/x86/asus-armoury.h
> +++ b/drivers/platform/x86/asus-armoury.h
> @@ -161,4 +161,32 @@
> .name = _fsname, .attrs = _attrname##_attrs \
> }
>
> +/* CPU core attributes need a little different in setup */
> +#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname) \
> + __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RW(_attrname, current_value); \
> + static struct kobj_attribute attr_##_attrname##_default_value = \
> + __ASUS_ATTR_RO(_attrname, default_value); \
> + static struct kobj_attribute attr_##_attrname##_min_value = \
> + __ASUS_ATTR_RO(_attrname, min_value); \
> + static struct kobj_attribute attr_##_attrname##_max_value = \
> + __ASUS_ATTR_RO(_attrname, max_value); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, int_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_default_value.attr, \
> + &attr_##_attrname##_min_value.attr, \
> + &attr_##_attrname##_max_value.attr, \
> + &attr_##_attrname##_scalar_increment.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> #endif /* _ASUS_ARMOURY_H_ */
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index a4f6bab93a6f..9a79dae97adf 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -137,6 +137,11 @@
> /* dgpu on/off */
> #define ASUS_WMI_DEVID_DGPU 0x00090020
>
> +/* Intel E-core and P-core configuration in a format 0x0[E]0[P] */
> +#define ASUS_WMI_DEVID_CORES 0x001200D2
> + /* Maximum Intel E-core and P-core availability */
> +#define ASUS_WMI_DEVID_CORES_MAX 0x001200D3
> +
> #define ASUS_WMI_DEVID_APU_MEM 0x000600C1
>
> /* gpu mux switch, 0 = dGPU, 1 = Optimus */
>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features
2025-10-15 1:47 ` [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features Denis Benato
@ 2025-10-17 12:54 ` Ilpo Järvinen
0 siblings, 0 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-17 12:54 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> With the existence of the asus-armoury module the attributes no longer
> need to live under the /sys/devices/platform/asus-nb-wmi/ path.
>
> Deprecate all those that were implemented in asus-bioscfg with the goal
> of removing them fully in the next LTS cycle.
>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
> Tested-by: Denis Benato <benato.denis96@gmail.com>
> ---
> .../ABI/testing/sysfs-platform-asus-wmi | 17 +++
> drivers/platform/x86/Kconfig | 11 ++
> drivers/platform/x86/asus-wmi.c | 121 ++++++++++++++----
> 3 files changed, 124 insertions(+), 25 deletions(-)
>
> diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi
> index 28144371a0f1..765d50b0d9df 100644
> --- a/Documentation/ABI/testing/sysfs-platform-asus-wmi
> +++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi
> @@ -63,6 +63,7 @@ Date: Aug 2022
> KernelVersion: 6.1
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
Could these include also "please use ..." to direct the reader to correct
direction.
--
i.
> Switch the GPU hardware MUX mode. Laptops with this feature can
> can be toggled to boot with only the dGPU (discrete mode) or in
> standard Optimus/Hybrid mode. On switch a reboot is required:
> @@ -75,6 +76,7 @@ Date: Aug 2022
> KernelVersion: 5.17
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Disable discrete GPU:
> * 0 - Enable dGPU,
> * 1 - Disable dGPU
> @@ -84,6 +86,7 @@ Date: Aug 2022
> KernelVersion: 5.17
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Enable the external GPU paired with ROG X-Flow laptops.
> Toggling this setting will also trigger ACPI to disable the dGPU:
>
> @@ -95,6 +98,7 @@ Date: Aug 2022
> KernelVersion: 5.17
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Enable an LCD response-time boost to reduce or remove ghosting:
> * 0 - Disable,
> * 1 - Enable
> @@ -104,6 +108,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Get the current charging mode being used:
> * 1 - Barrel connected charger,
> * 2 - USB-C charging
> @@ -114,6 +119,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Show if the egpu (XG Mobile) is correctly connected:
> * 0 - False,
> * 1 - True
> @@ -123,6 +129,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Change the mini-LED mode:
> * 0 - Single-zone,
> * 1 - Multi-zone
> @@ -133,6 +140,7 @@ Date: Apr 2024
> KernelVersion: 6.10
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> List the available mini-led modes.
>
> What: /sys/devices/platform/<platform>/ppt_pl1_spl
> @@ -140,6 +148,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the Package Power Target total of CPU: PL1 on Intel, SPL on AMD.
> Shown on Intel+Nvidia or AMD+Nvidia based systems:
>
> @@ -150,6 +159,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the Slow Package Power Tracking Limit of CPU: PL2 on Intel, SPPT,
> on AMD. Shown on Intel+Nvidia or AMD+Nvidia based systems:
>
> @@ -160,6 +170,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the Fast Package Power Tracking Limit of CPU. AMD+Nvidia only:
> * min=5, max=250
>
> @@ -168,6 +179,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the APU SPPT limit. Shown on full AMD systems only:
> * min=5, max=130
>
> @@ -176,6 +188,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the platform SPPT limit. Shown on full AMD systems only:
> * min=5, max=130
>
> @@ -184,6 +197,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the dynamic boost limit of the Nvidia dGPU:
> * min=5, max=25
>
> @@ -192,6 +206,7 @@ Date: Jun 2023
> KernelVersion: 6.5
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set the target temperature limit of the Nvidia dGPU:
> * min=75, max=87
>
> @@ -200,6 +215,7 @@ Date: Apr 2024
> KernelVersion: 6.10
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set if the BIOS POST sound is played on boot.
> * 0 - False,
> * 1 - True
> @@ -209,6 +225,7 @@ Date: Apr 2024
> KernelVersion: 6.10
> Contact: "Luke Jones" <luke@ljones.dev>
> Description:
> + DEPRECATED, WILL BE REMOVED SOON
> Set if the MCU can go in to low-power mode on system sleep
> * 0 - False,
> * 1 - True
> diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
> index 8b827680754c..a17288401746 100644
> --- a/drivers/platform/x86/Kconfig
> +++ b/drivers/platform/x86/Kconfig
> @@ -296,6 +296,17 @@ config ASUS_WMI
> To compile this driver as a module, choose M here: the module will
> be called asus-wmi.
>
> +config ASUS_WMI_DEPRECATED_ATTRS
> + bool "BIOS option support in WMI platform (DEPRECATED)"
> + depends on ASUS_WMI
> + default y
> + help
> + Say Y to expose the configurable BIOS options through the asus-wmi
> + driver.
> +
> + This can be used with or without the asus-armoury driver which
> + has the same attributes, but more, and better features.
> +
> config ASUS_NB_WMI
> tristate "Asus Notebook WMI Driver"
> depends on ASUS_WMI
> diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
> index 0d0c84a37ad8..3727ae00133d 100644
> --- a/drivers/platform/x86/asus-wmi.c
> +++ b/drivers/platform/x86/asus-wmi.c
> @@ -337,6 +337,13 @@ struct asus_wmi {
> /* Global to allow setting externally without requiring driver data */
> static enum asus_ally_mcu_hack use_ally_mcu_hack = ASUS_WMI_ALLY_MCU_HACK_INIT;
>
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> +static void asus_wmi_show_deprecated(void)
> +{
> + pr_notice_once("Accessing attributes through /sys/bus/platform/asus_wmi is deprecated and will be removed in a future release. Please switch over to /sys/class/firmware_attributes.\n");
> +}
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
> +
> /* WMI ************************************************************************/
>
> static int asus_wmi_evaluate_method3(u32 method_id,
> @@ -723,6 +730,7 @@ static void asus_wmi_tablet_mode_get_state(struct asus_wmi *asus)
> }
>
> /* Charging mode, 1=Barrel, 2=USB ******************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t charge_mode_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -733,12 +741,16 @@ static ssize_t charge_mode_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", value & 0xff);
> }
>
> static DEVICE_ATTR_RO(charge_mode);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* dGPU ********************************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t dgpu_disable_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -749,6 +761,8 @@ static ssize_t dgpu_disable_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -802,8 +816,10 @@ static ssize_t dgpu_disable_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(dgpu_disable);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* eGPU ********************************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t egpu_enable_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -814,6 +830,8 @@ static ssize_t egpu_enable_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -870,8 +888,10 @@ static ssize_t egpu_enable_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(egpu_enable);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Is eGPU connected? *********************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t egpu_connected_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -882,12 +902,16 @@ static ssize_t egpu_connected_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> static DEVICE_ATTR_RO(egpu_connected);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* gpu mux switch *************************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t gpu_mux_mode_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -898,6 +922,8 @@ static ssize_t gpu_mux_mode_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -956,6 +982,7 @@ static ssize_t gpu_mux_mode_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(gpu_mux_mode);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* TUF Laptop Keyboard RGB Modes **********************************************/
> static ssize_t kbd_rgb_mode_store(struct device *dev,
> @@ -1079,6 +1106,7 @@ static const struct attribute_group *kbd_rgb_mode_groups[] = {
> };
>
> /* Tunable: PPT: Intel=PL1, AMD=SPPT *****************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t ppt_pl2_sppt_store(struct device *dev,
> struct device_attribute *attr,
> const char *buf, size_t count)
> @@ -1117,6 +1145,8 @@ static ssize_t ppt_pl2_sppt_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->ppt_pl2_sppt);
> }
> static DEVICE_ATTR_RW(ppt_pl2_sppt);
> @@ -1159,6 +1189,8 @@ static ssize_t ppt_pl1_spl_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->ppt_pl1_spl);
> }
> static DEVICE_ATTR_RW(ppt_pl1_spl);
> @@ -1202,6 +1234,8 @@ static ssize_t ppt_fppt_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->ppt_fppt);
> }
> static DEVICE_ATTR_RW(ppt_fppt);
> @@ -1245,6 +1279,8 @@ static ssize_t ppt_apu_sppt_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->ppt_apu_sppt);
> }
> static DEVICE_ATTR_RW(ppt_apu_sppt);
> @@ -1288,6 +1324,8 @@ static ssize_t ppt_platform_sppt_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->ppt_platform_sppt);
> }
> static DEVICE_ATTR_RW(ppt_platform_sppt);
> @@ -1331,6 +1369,8 @@ static ssize_t nv_dynamic_boost_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->nv_dynamic_boost);
> }
> static DEVICE_ATTR_RW(nv_dynamic_boost);
> @@ -1374,9 +1414,12 @@ static ssize_t nv_temp_target_show(struct device *dev,
> {
> struct asus_wmi *asus = dev_get_drvdata(dev);
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%u\n", asus->nv_temp_target);
> }
> static DEVICE_ATTR_RW(nv_temp_target);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Ally MCU Powersave ********************************************************/
>
> @@ -1417,6 +1460,7 @@ void set_ally_mcu_powersave(bool enabled)
> }
> EXPORT_SYMBOL_NS_GPL(set_ally_mcu_powersave, "ASUS_WMI");
>
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t mcu_powersave_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -1427,6 +1471,8 @@ static ssize_t mcu_powersave_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -1462,6 +1508,7 @@ static ssize_t mcu_powersave_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(mcu_powersave);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Battery ********************************************************************/
>
> @@ -2335,6 +2382,7 @@ static int asus_wmi_rfkill_init(struct asus_wmi *asus)
> }
>
> /* Panel Overdrive ************************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t panel_od_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -2345,6 +2393,8 @@ static ssize_t panel_od_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -2381,9 +2431,10 @@ static ssize_t panel_od_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(panel_od);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Bootup sound ***************************************************************/
> -
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t boot_sound_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -2394,6 +2445,8 @@ static ssize_t boot_sound_show(struct device *dev,
> if (result < 0)
> return result;
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", result);
> }
>
> @@ -2429,8 +2482,10 @@ static ssize_t boot_sound_store(struct device *dev,
> return count;
> }
> static DEVICE_ATTR_RW(boot_sound);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Mini-LED mode **************************************************************/
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t mini_led_mode_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -2461,6 +2516,8 @@ static ssize_t mini_led_mode_show(struct device *dev,
> }
> }
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "%d\n", value);
> }
>
> @@ -2531,10 +2588,13 @@ static ssize_t available_mini_led_mode_show(struct device *dev,
> return sysfs_emit(buf, "0 1 2\n");
> }
>
> + asus_wmi_show_deprecated();
> +
> return sysfs_emit(buf, "0\n");
> }
>
> static DEVICE_ATTR_RO(available_mini_led_mode);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Quirks *********************************************************************/
>
> @@ -3822,6 +3882,7 @@ static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
> return throttle_thermal_policy_write(asus);
> }
>
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> static ssize_t throttle_thermal_policy_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -3865,6 +3926,7 @@ static ssize_t throttle_thermal_policy_store(struct device *dev,
> * Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
> */
> static DEVICE_ATTR_RW(throttle_thermal_policy);
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> /* Platform profile ***********************************************************/
> static int asus_wmi_platform_profile_get(struct device *dev,
> @@ -4466,27 +4528,29 @@ static struct attribute *platform_attributes[] = {
> &dev_attr_camera.attr,
> &dev_attr_cardr.attr,
> &dev_attr_touchpad.attr,
> - &dev_attr_charge_mode.attr,
> - &dev_attr_egpu_enable.attr,
> - &dev_attr_egpu_connected.attr,
> - &dev_attr_dgpu_disable.attr,
> - &dev_attr_gpu_mux_mode.attr,
> &dev_attr_lid_resume.attr,
> &dev_attr_als_enable.attr,
> &dev_attr_fan_boost_mode.attr,
> - &dev_attr_throttle_thermal_policy.attr,
> - &dev_attr_ppt_pl2_sppt.attr,
> - &dev_attr_ppt_pl1_spl.attr,
> - &dev_attr_ppt_fppt.attr,
> - &dev_attr_ppt_apu_sppt.attr,
> - &dev_attr_ppt_platform_sppt.attr,
> - &dev_attr_nv_dynamic_boost.attr,
> - &dev_attr_nv_temp_target.attr,
> - &dev_attr_mcu_powersave.attr,
> - &dev_attr_boot_sound.attr,
> - &dev_attr_panel_od.attr,
> - &dev_attr_mini_led_mode.attr,
> - &dev_attr_available_mini_led_mode.attr,
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> + &dev_attr_charge_mode.attr,
> + &dev_attr_egpu_enable.attr,
> + &dev_attr_egpu_connected.attr,
> + &dev_attr_dgpu_disable.attr,
> + &dev_attr_gpu_mux_mode.attr,
> + &dev_attr_ppt_pl2_sppt.attr,
> + &dev_attr_ppt_pl1_spl.attr,
> + &dev_attr_ppt_fppt.attr,
> + &dev_attr_ppt_apu_sppt.attr,
> + &dev_attr_ppt_platform_sppt.attr,
> + &dev_attr_nv_dynamic_boost.attr,
> + &dev_attr_nv_temp_target.attr,
> + &dev_attr_mcu_powersave.attr,
> + &dev_attr_boot_sound.attr,
> + &dev_attr_panel_od.attr,
> + &dev_attr_mini_led_mode.attr,
> + &dev_attr_available_mini_led_mode.attr,
> + &dev_attr_throttle_thermal_policy.attr,
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
> NULL
> };
>
> @@ -4508,7 +4572,11 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
> devid = ASUS_WMI_DEVID_LID_RESUME;
> else if (attr == &dev_attr_als_enable.attr)
> devid = ASUS_WMI_DEVID_ALS_ENABLE;
> - else if (attr == &dev_attr_charge_mode.attr)
> + else if (attr == &dev_attr_fan_boost_mode.attr)
> + ok = asus->fan_boost_mode_available;
> +
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> + if (attr == &dev_attr_charge_mode.attr)
> devid = ASUS_WMI_DEVID_CHARGE_MODE;
> else if (attr == &dev_attr_egpu_enable.attr)
> ok = asus->egpu_enable_available;
> @@ -4546,6 +4614,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
> ok = asus->mini_led_dev_id != 0;
> else if (attr == &dev_attr_available_mini_led_mode.attr)
> ok = asus->mini_led_dev_id != 0;
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> if (devid != -1) {
> ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
> @@ -4801,6 +4870,7 @@ static int asus_wmi_add(struct platform_device *pdev)
> }
>
> /* ensure defaults for tunables */
> +#if IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS)
> asus->ppt_pl2_sppt = 5;
> asus->ppt_pl1_spl = 5;
> asus->ppt_apu_sppt = 5;
> @@ -4823,17 +4893,18 @@ static int asus_wmi_add(struct platform_device *pdev)
> asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX;
> else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX_VIVO))
> asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX_VIVO;
> -
> - if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE))
> - asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE;
> - else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2))
> - asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2;
> +#endif /* IS_ENABLED(CONFIG_ASUS_WMI_DEPRECATED_ATTRS) */
>
> if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY))
> asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY;
> else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO))
> asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO;
>
> + if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE))
> + asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE;
> + else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2))
> + asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2;
> +
> err = fan_boost_mode_check_present(asus);
> if (err)
> goto fail_fan_boost_mode;
>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT
2025-10-15 1:47 ` [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT Denis Benato
@ 2025-10-17 12:59 ` Ilpo Järvinen
0 siblings, 0 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-17 12:59 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> As pointed out in [1], in order to maintain a naming consistency with
Please rephrase without that part before comma. That is, just state what
this change does, the Link tag will be there for those who want to read
extra details about how it came to be.
> ASUS_WMI_DEVID_PPT_PL2_SPPT and ASUS_WMI_DEVID_PPT_PL1_SPL
> rename ASUS_WMI_DEVID_PPT_FPPT to ASUS_WMI_DEVID_PPT_PL3_FPPT.
>
> [1] https://lore.kernel.org/all/cad7b458-5a7a-4975-94a1-d0c74f6f3de5@oracle.com/
Please change to:
Link: https://.../
You may want to also add:
Suggested-by: ALOK TIWARI <alok.a.tiwari@oracle.com>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> ---
> drivers/platform/x86/asus-wmi.c | 4 ++--
> include/linux/platform_data/x86/asus-wmi.h | 2 +-
> 2 files changed, 3 insertions(+), 3 deletions(-)
>
> diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
> index 3727ae00133d..8b5ac4636623 100644
> --- a/drivers/platform/x86/asus-wmi.c
> +++ b/drivers/platform/x86/asus-wmi.c
> @@ -1211,7 +1211,7 @@ static ssize_t ppt_fppt_store(struct device *dev,
> if (value < PPT_TOTAL_MIN || value > PPT_TOTAL_MAX)
> return -EINVAL;
>
> - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_FPPT, value, &result);
> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PPT_PL3_FPPT, value, &result);
> if (err) {
> pr_warn("Failed to set ppt_fppt: %d\n", err);
> return err;
> @@ -4595,7 +4595,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj,
> else if (attr == &dev_attr_ppt_pl1_spl.attr)
> devid = ASUS_WMI_DEVID_PPT_PL1_SPL;
> else if (attr == &dev_attr_ppt_fppt.attr)
> - devid = ASUS_WMI_DEVID_PPT_FPPT;
> + devid = ASUS_WMI_DEVID_PPT_PL3_FPPT;
> else if (attr == &dev_attr_ppt_apu_sppt.attr)
> devid = ASUS_WMI_DEVID_PPT_APU_SPPT;
> else if (attr == &dev_attr_ppt_platform_sppt.attr)
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index 260796fee301..3d236f8498d8 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -108,7 +108,7 @@
> #define ASUS_WMI_DEVID_PPT_PL1_SPL 0x001200A3
> #define ASUS_WMI_DEVID_PPT_APU_SPPT 0x001200B0
> #define ASUS_WMI_DEVID_PPT_PLAT_SPPT 0x001200B1
> -#define ASUS_WMI_DEVID_PPT_FPPT 0x001200C1
> +#define ASUS_WMI_DEVID_PPT_PL3_FPPT 0x001200C1
> #define ASUS_WMI_DEVID_NV_DYN_BOOST 0x001200C0
> #define ASUS_WMI_DEVID_NV_THERM_TARGET 0x001200C2
>
>
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
2025-10-15 1:47 ` [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs Denis Benato
@ 2025-10-17 13:09 ` Ilpo Järvinen
0 siblings, 0 replies; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-17 13:09 UTC (permalink / raw)
To: Denis Benato
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On Wed, 15 Oct 2025, Denis Benato wrote:
> From: "Luke D. Jones" <luke@ljones.dev>
>
> Adds the ppt_* and nv_* tuning knobs that are available via WMI methods
> and adds proper min/max levels plus defaults.
>
> The min/max are defined by ASUS and typically gained by looking at what
> they allow in the ASUS Armoury Crate application - ASUS does not share
> the values outside of this. It could also be possible to gain the AMD
> values by use of ryzenadj and testing for the minimum stable value.
>
> The general rule of thumb for adding to the match table is that if the
> model range has a single CPU used throughout, then the DMI match can
> omit the last letter of the model number as this is the GPU model.
>
> If a min or max value is not provided it is assumed that the particular
> setting is not supported. for example ppt_pl2_sppt_min/max is not set.
> If a <ppt_setting>_def is not set then the default is assumed to be
> <ppt_setting>_max
>
> It is assumed that at least AC settings are available so that the
> firmware attributes will be created - if no DC table is available
> and power is on DC, then reading the attributes is -ENODEV.
>
> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
> Tested-by: Mateusz Schyboll <dragonn@op.pl>
> Tested-by: Porfet Lillian <porfet828@gmail.com>
> ---
> drivers/platform/x86/asus-armoury.c | 294 ++++-
> drivers/platform/x86/asus-armoury.h | 1210 ++++++++++++++++++++
> include/linux/platform_data/x86/asus-wmi.h | 3 +
> 3 files changed, 1501 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> index e27f964aebf8..43a1e7017d16 100644
> --- a/drivers/platform/x86/asus-armoury.c
> +++ b/drivers/platform/x86/asus-armoury.c
> @@ -27,6 +27,7 @@
> #include <linux/mutex.h>
> #include <linux/platform_data/x86/asus-wmi.h>
> #include <linux/printk.h>
> +#include <linux/power_supply.h>
> #include <linux/types.h>
>
> #include "asus-armoury.h"
> @@ -45,6 +46,17 @@
> #define ASUS_MINI_LED_2024_STRONG 0x01
> #define ASUS_MINI_LED_2024_OFF 0x02
>
> +/* Power tunable attribute name defines */
> +#define ATTR_PPT_PL1_SPL "ppt_pl1_spl"
> +#define ATTR_PPT_PL2_SPPT "ppt_pl2_sppt"
> +#define ATTR_PPT_PL3_FPPT "ppt_pl3_fppt"
> +#define ATTR_PPT_APU_SPPT "ppt_apu_sppt"
> +#define ATTR_PPT_PLATFORM_SPPT "ppt_platform_sppt"
> +#define ATTR_NV_DYNAMIC_BOOST "nv_dynamic_boost"
> +#define ATTR_NV_TEMP_TARGET "nv_temp_target"
> +#define ATTR_NV_BASE_TGP "nv_base_tgp"
> +#define ATTR_NV_TGP "nv_tgp"
> +
> #define ASUS_POWER_CORE_MASK GENMASK(15, 8)
> #define ASUS_PERF_CORE_MASK GENMASK(7, 0)
>
> @@ -73,11 +85,26 @@ struct cpu_cores {
> u32 max_power_cores;
> };
>
> +struct rog_tunables {
> + const struct power_limits *power_limits;
> + u32 ppt_pl1_spl; // cpu
> + u32 ppt_pl2_sppt; // cpu
> + u32 ppt_pl3_fppt; // cpu
> + u32 ppt_apu_sppt; // plat
> + u32 ppt_platform_sppt; // plat
> +
> + u32 nv_dynamic_boost;
> + u32 nv_temp_target;
> + u32 nv_tgp;
> +};
> +
> static struct asus_armoury_priv {
> struct device *fw_attr_dev;
> struct kset *fw_attr_kset;
>
> struct cpu_cores *cpu_cores;
> + /* Index 0 for DC, 1 for AC */
> + struct rog_tunables *rog_tunables[2];
> u32 mini_led_dev_id;
> u32 gpu_mux_dev_id;
> /*
> @@ -719,7 +746,34 @@ static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
> ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
> "Set the max available efficiency cores");
>
> +/* Define helper to access the current power mode tunable values */
> +static inline struct rog_tunables *get_current_tunables(void)
> +{
> + return asus_armoury
> + .rog_tunables[power_supply_is_system_supplied() ? 1 : 0];
Please name these indexes.
You can split this to multiple statements so it can be more favorably
indented.
> +}
> +
> /* Simple attribute creation */
> +ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, ATTR_PPT_PL1_SPL, ASUS_WMI_DEVID_PPT_PL1_SPL,
> + "Set the CPU slow package limit");
> +ATTR_GROUP_ROG_TUNABLE(ppt_pl2_sppt, ATTR_PPT_PL2_SPPT, ASUS_WMI_DEVID_PPT_PL2_SPPT,
> + "Set the CPU fast package limit");
> +ATTR_GROUP_ROG_TUNABLE(ppt_pl3_fppt, ATTR_PPT_PL3_FPPT, ASUS_WMI_DEVID_PPT_PL3_FPPT,
> + "Set the CPU fastest package limit");
> +ATTR_GROUP_ROG_TUNABLE(ppt_apu_sppt, ATTR_PPT_APU_SPPT, ASUS_WMI_DEVID_PPT_APU_SPPT,
> + "Set the APU package limit");
> +ATTR_GROUP_ROG_TUNABLE(ppt_platform_sppt, ATTR_PPT_PLATFORM_SPPT, ASUS_WMI_DEVID_PPT_PLAT_SPPT,
> + "Set the platform package limit");
> +ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, ATTR_NV_DYNAMIC_BOOST, ASUS_WMI_DEVID_NV_DYN_BOOST,
> + "Set the Nvidia dynamic boost limit");
> +ATTR_GROUP_ROG_TUNABLE(nv_temp_target, ATTR_NV_TEMP_TARGET, ASUS_WMI_DEVID_NV_THERM_TARGET,
> + "Set the Nvidia max thermal limit");
> +ATTR_GROUP_ROG_TUNABLE(nv_tgp, "nv_tgp", ASUS_WMI_DEVID_DGPU_SET_TGP,
> + "Set the additional TGP on top of the base TGP");
> +ATTR_GROUP_INT_VALUE_ONLY_RO(nv_base_tgp, ATTR_NV_BASE_TGP, ASUS_WMI_DEVID_DGPU_BASE_TGP,
> + "Read the base TGP value");
> +
> +
> ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
> "Show the current mode of charging");
>
> @@ -746,6 +800,16 @@ static const struct asus_attr_group armoury_attr_groups[] = {
> { &cores_efficiency_attr_group, ASUS_WMI_DEVID_CORES_MAX },
> { &cores_performance_attr_group, ASUS_WMI_DEVID_CORES_MAX },
>
> + { &ppt_pl1_spl_attr_group, ASUS_WMI_DEVID_PPT_PL1_SPL },
> + { &ppt_pl2_sppt_attr_group, ASUS_WMI_DEVID_PPT_PL2_SPPT },
> + { &ppt_pl3_fppt_attr_group, ASUS_WMI_DEVID_PPT_PL3_FPPT },
> + { &ppt_apu_sppt_attr_group, ASUS_WMI_DEVID_PPT_APU_SPPT },
> + { &ppt_platform_sppt_attr_group, ASUS_WMI_DEVID_PPT_PLAT_SPPT },
> + { &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
> + { &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
> + { &nv_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
> + { &nv_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
> +
> { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
> { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
> { &mcu_powersave_attr_group, ASUS_WMI_DEVID_MCU_POWERSAVE },
> @@ -754,8 +818,75 @@ static const struct asus_attr_group armoury_attr_groups[] = {
> { &screen_auto_brightness_attr_group, ASUS_WMI_DEVID_SCREEN_AUTO_BRIGHTNESS },
> };
>
> +/**
> + * is_power_tunable_attr - Determines if an attribute is a power-related tunable
> + * @name: The name of the attribute to check
> + *
> + * This function checks if the given attribute name is related to power tuning.
> + *
> + * Return: true if the attribute is a power-related tunable, false otherwise
> + */
> +static bool is_power_tunable_attr(const char *name)
> +{
> + static const char * const power_tunable_attrs[] = {
> + ATTR_PPT_PL1_SPL, ATTR_PPT_PL2_SPPT,
> + ATTR_PPT_PL3_FPPT, ATTR_PPT_APU_SPPT,
> + ATTR_PPT_PLATFORM_SPPT, ATTR_NV_DYNAMIC_BOOST,
> + ATTR_NV_TEMP_TARGET, ATTR_NV_BASE_TGP,
> + ATTR_NV_TGP
> + };
> +
> + for (unsigned int i = 0; i < ARRAY_SIZE(power_tunable_attrs); i++) {
> + if (!strcmp(name, power_tunable_attrs[i]))
> + return true;
> + }
> +
> + return false;
> +}
> +
> +/**
> + * has_valid_limit - Checks if a power-related attribute has a valid limit value
> + * @name: The name of the attribute to check
> + * @limits: Pointer to the power_limits structure containing limit values
> + *
> + * This function checks if a power-related attribute has a valid limit value.
> + * It returns false if limits is NULL or if the corresponding limit value is zero.
> + *
> + * Return: true if the attribute has a valid limit value, false otherwise
> + */
> +static bool has_valid_limit(const char *name, const struct power_limits *limits)
> +{
> + u32 limit_value = 0;
> +
> + if (!limits)
> + return false;
> +
> + if (!strcmp(name, ATTR_PPT_PL1_SPL))
> + limit_value = limits->ppt_pl1_spl_max;
> + else if (!strcmp(name, ATTR_PPT_PL2_SPPT))
> + limit_value = limits->ppt_pl2_sppt_max;
> + else if (!strcmp(name, ATTR_PPT_PL3_FPPT))
> + limit_value = limits->ppt_pl3_fppt_max;
> + else if (!strcmp(name, ATTR_PPT_APU_SPPT))
> + limit_value = limits->ppt_apu_sppt_max;
> + else if (!strcmp(name, ATTR_PPT_PLATFORM_SPPT))
> + limit_value = limits->ppt_platform_sppt_max;
> + else if (!strcmp(name, ATTR_NV_DYNAMIC_BOOST))
> + limit_value = limits->nv_dynamic_boost_max;
> + else if (!strcmp(name, ATTR_NV_TEMP_TARGET))
> + limit_value = limits->nv_temp_target_max;
> + else if (!strcmp(name, ATTR_NV_BASE_TGP) ||
> + !strcmp(name, ATTR_NV_TGP))
> + limit_value = limits->nv_tgp_max;
> +
> + return limit_value > 0;
> +}
> +
> static int asus_fw_attr_add(void)
> {
> + const struct power_limits *limits;
> + bool should_create;
> + const char *name;
> int err, i;
>
> asus_armoury.fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
> @@ -812,12 +943,28 @@ static int asus_fw_attr_add(void)
> if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
> continue;
>
> - err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
> - armoury_attr_groups[i].attr_group);
> - if (err) {
> - pr_err("Failed to create sysfs-group for %s\n",
> - armoury_attr_groups[i].attr_group->name);
> - goto err_remove_groups;
> + /* Always create by default, unless PPT is not present */
> + should_create = true;
> + name = armoury_attr_groups[i].attr_group->name;
> +
> + /* Check if this is a power-related tunable requiring limits */
> + if (asus_armoury.rog_tunables[1] && asus_armoury.rog_tunables[1]->power_limits &&
> + is_power_tunable_attr(name)) {
> + limits = asus_armoury.rog_tunables[1]->power_limits;
> + /* Check only AC, if DC is not present then AC won't be either */
> + should_create = has_valid_limit(name, limits);
> + if (!should_create)
> + pr_debug("Missing max value for tunable %s\n", name);
> + }
> +
> + if (should_create) {
> + err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
> + armoury_attr_groups[i].attr_group);
Misindented.
> + if (err) {
> + pr_err("Failed to create sysfs-group for %s\n",
> + armoury_attr_groups[i].attr_group->name);
> + goto err_remove_groups;
> + }
> }
> }
>
> @@ -846,6 +993,135 @@ static int asus_fw_attr_add(void)
>
> /* Init / exit ****************************************************************/
>
> +/* Set up the min/max and defaults for ROG tunables */
> +static void init_rog_tunables(void)
> +{
> + const struct power_limits *ac_limits, *dc_limits;
> + const struct power_data *power_data;
> + const struct dmi_system_id *dmi_id;
> + bool ac_initialized = false, dc_initialized = false;
> +
> + /* Match the system against the power_limits table */
> + dmi_id = dmi_first_match(power_limits);
> + if (!dmi_id) {
> + pr_warn("No matching power limits found for this system\n");
> + return;
> + }
> +
> + /* Get the power data for this system */
> + power_data = dmi_id->driver_data;
> + if (!power_data) {
> + pr_info("No power data available for this system\n");
> + return;
> + }
> +
> + /* Initialize AC power tunables */
> + ac_limits = power_data->ac_data;
> + if (ac_limits) {
> + asus_armoury.rog_tunables[1] =
> + kzalloc(sizeof(*asus_armoury.rog_tunables[1]), GFP_KERNEL);
> + if (!asus_armoury.rog_tunables[1])
> + goto err_nomem;
> +
> + asus_armoury.rog_tunables[1]->power_limits = ac_limits;
Please add a local variable for asus_armoury.rog_tunables[1] (which
should be using that named index anyway making it even longer if done
w/o local var).
> +
> + /* Set initial AC values */
> + asus_armoury.rog_tunables[1]->ppt_pl1_spl =
> + ac_limits->ppt_pl1_spl_def ?
> + ac_limits->ppt_pl1_spl_def :
> + ac_limits->ppt_pl1_spl_max;
> +
> + asus_armoury.rog_tunables[1]->ppt_pl2_sppt =
> + ac_limits->ppt_pl2_sppt_def ?
> + ac_limits->ppt_pl2_sppt_def :
> + ac_limits->ppt_pl2_sppt_max;
> +
> + asus_armoury.rog_tunables[1]->ppt_pl3_fppt =
> + ac_limits->ppt_pl3_fppt_def ?
> + ac_limits->ppt_pl3_fppt_def :
> + ac_limits->ppt_pl3_fppt_max;
> +
> + asus_armoury.rog_tunables[1]->ppt_apu_sppt =
> + ac_limits->ppt_apu_sppt_def ?
> + ac_limits->ppt_apu_sppt_def :
> + ac_limits->ppt_apu_sppt_max;
> +
> + asus_armoury.rog_tunables[1]->ppt_platform_sppt =
> + ac_limits->ppt_platform_sppt_def ?
> + ac_limits->ppt_platform_sppt_def :
> + ac_limits->ppt_platform_sppt_max;
> +
> + asus_armoury.rog_tunables[1]->nv_dynamic_boost =
> + ac_limits->nv_dynamic_boost_max;
> + asus_armoury.rog_tunables[1]->nv_temp_target =
> + ac_limits->nv_temp_target_max;
> + asus_armoury.rog_tunables[1]->nv_tgp = ac_limits->nv_tgp_max;
> +
> + ac_initialized = true;
> + pr_debug("AC power limits initialized for %s\n", dmi_id->matches[0].substr);
> + }
> +
> + /* Initialize DC power tunables */
> + dc_limits = power_data->dc_data;
> + if (dc_limits) {
> + asus_armoury.rog_tunables[0] =
> + kzalloc(sizeof(*asus_armoury.rog_tunables[0]), GFP_KERNEL);
> + if (!asus_armoury.rog_tunables[0]) {
> + if (ac_initialized)
> + kfree(asus_armoury.rog_tunables[1]);
> + goto err_nomem;
> + }
> +
> + asus_armoury.rog_tunables[0]->power_limits = dc_limits;
Ditto.
> +
> + /* Set initial DC values */
> + asus_armoury.rog_tunables[0]->ppt_pl1_spl =
> + dc_limits->ppt_pl1_spl_def ?
> + dc_limits->ppt_pl1_spl_def :
> + dc_limits->ppt_pl1_spl_max;
> +
> + asus_armoury.rog_tunables[0]->ppt_pl2_sppt =
> + dc_limits->ppt_pl2_sppt_def ?
> + dc_limits->ppt_pl2_sppt_def :
> + dc_limits->ppt_pl2_sppt_max;
> +
> + asus_armoury.rog_tunables[0]->ppt_pl3_fppt =
> + dc_limits->ppt_pl3_fppt_def ?
> + dc_limits->ppt_pl3_fppt_def :
> + dc_limits->ppt_pl3_fppt_max;
> +
> + asus_armoury.rog_tunables[0]->ppt_apu_sppt =
> + dc_limits->ppt_apu_sppt_def ?
> + dc_limits->ppt_apu_sppt_def :
> + dc_limits->ppt_apu_sppt_max;
> +
> + asus_armoury.rog_tunables[0]->ppt_platform_sppt =
> + dc_limits->ppt_platform_sppt_def ?
> + dc_limits->ppt_platform_sppt_def :
> + dc_limits->ppt_platform_sppt_max;
> +
> + asus_armoury.rog_tunables[0]->nv_dynamic_boost =
> + dc_limits->nv_dynamic_boost_max;
> + asus_armoury.rog_tunables[0]->nv_temp_target =
> + dc_limits->nv_temp_target_max;
> + asus_armoury.rog_tunables[0]->nv_tgp = dc_limits->nv_tgp_max;
> +
> + dc_initialized = true;
> + pr_debug("DC power limits initialized for %s\n", dmi_id->matches[0].substr);
> + }
> +
> + if (!ac_initialized)
> + pr_debug("No AC PPT limits defined\n");
These can be moved into else blocks, no?
> +
> + if (!dc_initialized)
> + pr_debug("No DC PPT limits defined\n");
> +
> + return;
> +
> +err_nomem:
> + pr_err("Failed to allocate memory for tunables\n");
> +}
> +
> static int __init asus_fw_init(void)
> {
> char *wmi_uid;
> @@ -870,6 +1146,9 @@ static int __init asus_fw_init(void)
> }
> }
>
> + init_rog_tunables();
> +
> + /* Must always be last step to ensure data is available */
> return asus_fw_attr_add();
> }
>
> @@ -878,6 +1157,9 @@ static void __exit asus_fw_exit(void)
> sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
> kset_unregister(asus_armoury.fw_attr_kset);
> device_destroy(&firmware_attributes_class, MKDEV(0, 0));
> +
> + kfree(asus_armoury.rog_tunables[0]);
> + kfree(asus_armoury.rog_tunables[1]);
Reverse order to match the order on the init side.
> }
>
> module_init(asus_fw_init);
> diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
> index a6c4caefdef9..d99db5f5f6a0 100644
> --- a/drivers/platform/x86/asus-armoury.h
> +++ b/drivers/platform/x86/asus-armoury.h
> @@ -8,6 +8,7 @@
> #ifndef _ASUS_ARMOURY_H_
> #define _ASUS_ARMOURY_H_
>
> +#include <linux/dmi.h>
> #include <linux/types.h>
> #include <linux/platform_device.h>
>
> @@ -189,4 +190,1213 @@
> .name = _fsname, .attrs = _attrname##_attrs \
> }
>
> +#define ATTR_GROUP_INT_VALUE_ONLY_RO(_attrname, _fsname, _wmi, _dispname) \
> + WMI_SHOW_INT(_attrname##_current_value, "%d\n", _wmi); \
> + static struct kobj_attribute attr_##_attrname##_current_value = \
> + __ASUS_ATTR_RO(_attrname, current_value); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, int_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_type.attr, NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +/*
> + * ROG PPT attributes need a little different in setup as they
> + * require rog_tunables members.
> + */
> +
> +#define __ROG_TUNABLE_SHOW(_prop, _attrname, _val) \
> + static ssize_t _attrname##_##_prop##_show( \
> + struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
> + { \
> + struct rog_tunables *tunables = get_current_tunables(); \
> + \
> + if (!tunables || !tunables->power_limits) \
> + return -ENODEV; \
> + \
> + return sysfs_emit(buf, "%d\n", tunables->power_limits->_val); \
> + } \
> + static struct kobj_attribute attr_##_attrname##_##_prop = \
> + __ASUS_ATTR_RO(_attrname, _prop)
> +
> +#define __ROG_TUNABLE_SHOW_DEFAULT(_attrname) \
> + static ssize_t _attrname##_default_value_show( \
> + struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
> + { \
> + struct rog_tunables *tunables = get_current_tunables(); \
> + \
> + if (!tunables || !tunables->power_limits) \
> + return -ENODEV; \
> + \
> + return sysfs_emit( \
> + buf, "%d\n", \
> + tunables->power_limits->_attrname##_def ? \
> + tunables->power_limits->_attrname##_def : \
> + tunables->power_limits->_attrname##_max); \
> + } \
> + static struct kobj_attribute attr_##_attrname##_default_value = \
> + __ASUS_ATTR_RO(_attrname, default_value)
> +
> +#define __ROG_TUNABLE_RW(_attr, _wmi) \
> + static ssize_t _attr##_current_value_store( \
> + struct kobject *kobj, struct kobj_attribute *attr, \
> + const char *buf, size_t count) \
> + { \
> + struct rog_tunables *tunables = get_current_tunables(); \
> + \
> + if (!tunables || !tunables->power_limits) \
> + return -ENODEV; \
> + \
> + return attr_uint_store(kobj, attr, buf, count, \
> + tunables->power_limits->_attr##_min, \
> + tunables->power_limits->_attr##_max, \
> + &tunables->_attr, _wmi); \
> + } \
> + static ssize_t _attr##_current_value_show( \
> + struct kobject *kobj, struct kobj_attribute *attr, char *buf) \
> + { \
> + struct rog_tunables *tunables = get_current_tunables(); \
> + \
> + if (!tunables) \
> + return -ENODEV; \
> + \
> + return sysfs_emit(buf, "%u\n", tunables->_attr); \
> + } \
> + static struct kobj_attribute attr_##_attr##_current_value = \
> + __ASUS_ATTR_RW(_attr, current_value)
> +
> +#define ATTR_GROUP_ROG_TUNABLE(_attrname, _fsname, _wmi, _dispname) \
> + __ROG_TUNABLE_RW(_attrname, _wmi); \
> + __ROG_TUNABLE_SHOW_DEFAULT(_attrname); \
> + __ROG_TUNABLE_SHOW(min_value, _attrname, _attrname##_min); \
> + __ROG_TUNABLE_SHOW(max_value, _attrname, _attrname##_max); \
> + __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
> + __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
> + static struct kobj_attribute attr_##_attrname##_type = \
> + __ASUS_ATTR_RO_AS(type, int_type_show); \
> + static struct attribute *_attrname##_attrs[] = { \
> + &attr_##_attrname##_current_value.attr, \
> + &attr_##_attrname##_default_value.attr, \
> + &attr_##_attrname##_min_value.attr, \
> + &attr_##_attrname##_max_value.attr, \
> + &attr_##_attrname##_scalar_increment.attr, \
> + &attr_##_attrname##_display_name.attr, \
> + &attr_##_attrname##_type.attr, \
> + NULL \
> + }; \
> + static const struct attribute_group _attrname##_attr_group = { \
> + .name = _fsname, .attrs = _attrname##_attrs \
> + }
> +
> +/* Default is always the maximum value unless *_def is specified */
> +struct power_limits {
> + u8 ppt_pl1_spl_min;
> + u8 ppt_pl1_spl_def;
> + u8 ppt_pl1_spl_max;
> + u8 ppt_pl2_sppt_min;
> + u8 ppt_pl2_sppt_def;
> + u8 ppt_pl2_sppt_max;
> + u8 ppt_pl3_fppt_min;
> + u8 ppt_pl3_fppt_def;
> + u8 ppt_pl3_fppt_max;
> + u8 ppt_apu_sppt_min;
> + u8 ppt_apu_sppt_def;
> + u8 ppt_apu_sppt_max;
> + u8 ppt_platform_sppt_min;
> + u8 ppt_platform_sppt_def;
> + u8 ppt_platform_sppt_max;
> + /* Nvidia GPU specific, default is always max */
> + u8 nv_dynamic_boost_def; // unused. exists for macro
> + u8 nv_dynamic_boost_min;
> + u8 nv_dynamic_boost_max;
> + u8 nv_temp_target_def; // unused. exists for macro
> + u8 nv_temp_target_min;
> + u8 nv_temp_target_max;
> + u8 nv_tgp_def; // unused. exists for macro
> + u8 nv_tgp_min;
> + u8 nv_tgp_max;
> +};
> +
> +struct power_data {
> + const struct power_limits *ac_data;
> + const struct power_limits *dc_data;
> + bool requires_fan_curve;
> +};
> +
> +/*
> + * For each available attribute there must be a min and a max.
> + * _def is not required and will be assumed to be default == max if missing.
> + */
> +static const struct dmi_system_id power_limits[] = {
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA401W"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 75,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 30,
> + .ppt_pl2_sppt_min = 31,
> + .ppt_pl2_sppt_max = 44,
> + .ppt_pl3_fppt_min = 45,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA507N"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 45,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA507R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80
> + },
> + .dc_data = NULL
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA507X"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 85,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 45,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA507Z"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 105,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 15,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 85,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 45,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 60,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA607P"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 30,
> + .ppt_pl1_spl_def = 100,
> + .ppt_pl1_spl_max = 135,
> + .ppt_pl2_sppt_min = 30,
> + .ppt_pl2_sppt_def = 115,
> + .ppt_pl2_sppt_max = 135,
> + .ppt_pl3_fppt_min = 30,
> + .ppt_pl3_fppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 115,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_def = 45,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_def = 60,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 25,
> + .ppt_pl3_fppt_max = 80,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA608WI"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 90,
> + .ppt_pl1_spl_max = 90,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 90,
> + .ppt_pl2_sppt_max = 90,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 90,
> + .ppt_pl3_fppt_max = 90,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 115,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 45,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 65,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA617NS"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 15,
> + .ppt_apu_sppt_max = 80,
> + .ppt_platform_sppt_min = 30,
> + .ppt_platform_sppt_max = 120
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 25,
> + .ppt_apu_sppt_max = 35,
> + .ppt_platform_sppt_min = 45,
> + .ppt_platform_sppt_max = 100
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA617NT"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 15,
> + .ppt_apu_sppt_max = 80,
> + .ppt_platform_sppt_min = 30,
> + .ppt_platform_sppt_max = 115
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 15,
> + .ppt_apu_sppt_max = 45,
> + .ppt_platform_sppt_min = 30,
> + .ppt_platform_sppt_max = 50
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FA617XS"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 15,
> + .ppt_apu_sppt_max = 80,
> + .ppt_platform_sppt_min = 30,
> + .ppt_platform_sppt_max = 120,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 25,
> + .ppt_apu_sppt_max = 35,
> + .ppt_platform_sppt_min = 45,
> + .ppt_platform_sppt_max = 100,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FX507VI"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 135,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 45,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 60,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "FX507Z"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 90,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 15,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 45,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 60,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA401Q"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_max = 80,
> + },
> + .dc_data = NULL
> + },
> + },
> + {
> + .matches = {
> + // This model is full AMD. No Nvidia dGPU.
> + DMI_MATCH(DMI_BOARD_NAME, "GA402R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 15,
> + .ppt_apu_sppt_max = 80,
> + .ppt_platform_sppt_min = 30,
> + .ppt_platform_sppt_max = 115,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_apu_sppt_min = 25,
> + .ppt_apu_sppt_def = 30,
> + .ppt_apu_sppt_max = 45,
> + .ppt_platform_sppt_min = 40,
> + .ppt_platform_sppt_max = 60,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA402X"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 35,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_def = 65,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 35,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA403U"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 65,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 35,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA503R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 35,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 65,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 25,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 60,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GA605W"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 85,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 31,
> + .ppt_pl2_sppt_max = 44,
> + .ppt_pl3_fppt_min = 45,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GU603Z"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 60,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 135,
> + /* Only allowed in AC mode */
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 40,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 40,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GU604V"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 65,
> + .ppt_pl1_spl_max = 120,
> + .ppt_pl2_sppt_min = 65,
> + .ppt_pl2_sppt_max = 150,
> + /* Only allowed in AC mode */
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 40,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 40,
> + .ppt_pl2_sppt_max = 60,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GU605CW"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 45,
> + .ppt_pl1_spl_max = 85,
> + .ppt_pl2_sppt_min = 56,
> + .ppt_pl2_sppt_max = 110,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 80,
> + .nv_tgp_def = 90,
> + .nv_tgp_max = 110,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 85,
> + .ppt_pl2_sppt_min = 32,
> + .ppt_pl2_sppt_max = 110,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GU605M"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 90,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 38,
> + .ppt_pl2_sppt_max = 53,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GV301Q"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 45,
> + .ppt_pl2_sppt_min = 65,
> + .ppt_pl2_sppt_max = 80,
> + },
> + .dc_data = NULL
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GV301R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 45,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 54,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 35,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GV601R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 35,
> + .ppt_pl1_spl_max = 90,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 100,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 80,
> + .ppt_pl3_fppt_max = 125,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 28,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 54,
> + .ppt_pl2_sppt_max = 60,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 80,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GV601V"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_def = 100,
> + .ppt_pl1_spl_max = 110,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 40,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 40,
> + .ppt_pl2_sppt_max = 60,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "GX650P"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 110,
> + .ppt_pl1_spl_max = 130,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 125,
> + .ppt_pl2_sppt_max = 130,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 125,
> + .ppt_pl3_fppt_max = 135,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_def = 25,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_def = 35,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_def = 42,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G513I"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + /* Yes this laptop is very limited */
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_max = 80,
> + },
> + .dc_data = NULL,
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G513QM"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + /* Yes this laptop is very limited */
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 100,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_max = 190,
> + },
> + .dc_data = NULL,
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G513R"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 35,
> + .ppt_pl1_spl_max = 90,
> + .ppt_pl2_sppt_min = 54,
> + .ppt_pl2_sppt_max = 100,
> + .ppt_pl3_fppt_min = 54,
> + .ppt_pl3_fppt_max = 125,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 50,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 50,
> + .ppt_pl3_fppt_min = 28,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G614J"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 140,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 175,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 55,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 70,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G634J"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 140,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 175,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 55,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 70,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G713PV"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 30,
> + .ppt_pl1_spl_def = 120,
> + .ppt_pl1_spl_max = 130,
> + .ppt_pl2_sppt_min = 65,
> + .ppt_pl2_sppt_def = 125,
> + .ppt_pl2_sppt_max = 130,
> + .ppt_pl3_fppt_min = 65,
> + .ppt_pl3_fppt_def = 125,
> + .ppt_pl3_fppt_max = 130,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 75,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G733C"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 170,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 175,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 35,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G733P"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 30,
> + .ppt_pl1_spl_def = 100,
> + .ppt_pl1_spl_max = 130,
> + .ppt_pl2_sppt_min = 65,
> + .ppt_pl2_sppt_def = 125,
> + .ppt_pl2_sppt_max = 130,
> + .ppt_pl3_fppt_min = 65,
> + .ppt_pl3_fppt_def = 125,
> + .ppt_pl3_fppt_max = 130,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 65,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 65,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 75,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G814J"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 140,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 140,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 55,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 70,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "G834J"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 28,
> + .ppt_pl1_spl_max = 140,
> + .ppt_pl2_sppt_min = 28,
> + .ppt_pl2_sppt_max = 175,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 25,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 55,
> + .ppt_pl2_sppt_min = 25,
> + .ppt_pl2_sppt_max = 70,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + },
> + .requires_fan_curve = true,
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "H7606W"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 15,
> + .ppt_pl1_spl_max = 80,
> + .ppt_pl2_sppt_min = 35,
> + .ppt_pl2_sppt_max = 80,
> + .ppt_pl3_fppt_min = 35,
> + .ppt_pl3_fppt_max = 80,
> + .nv_dynamic_boost_min = 5,
> + .nv_dynamic_boost_max = 20,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + .nv_tgp_min = 55,
> + .nv_tgp_max = 85,
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 25,
> + .ppt_pl1_spl_max = 35,
> + .ppt_pl2_sppt_min = 31,
> + .ppt_pl2_sppt_max = 44,
> + .ppt_pl3_fppt_min = 45,
> + .ppt_pl3_fppt_max = 65,
> + .nv_temp_target_min = 75,
> + .nv_temp_target_max = 87,
> + }
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "RC71"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 7,
> + .ppt_pl1_spl_max = 30,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_max = 43,
> + .ppt_pl3_fppt_min = 15,
> + .ppt_pl3_fppt_max = 53
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 7,
> + .ppt_pl1_spl_def = 15,
> + .ppt_pl1_spl_max = 25,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_def = 20,
> + .ppt_pl2_sppt_max = 30,
> + .ppt_pl3_fppt_min = 15,
> + .ppt_pl3_fppt_def = 25,
> + .ppt_pl3_fppt_max = 35
> + }
Please check you've a comma in any non-terminator entry.
> + },
> + },
> + {
> + .matches = {
> + DMI_MATCH(DMI_BOARD_NAME, "RC72"),
> + },
> + .driver_data = &(struct power_data) {
> + .ac_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 7,
> + .ppt_pl1_spl_max = 30,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_max = 43,
> + .ppt_pl3_fppt_min = 15,
> + .ppt_pl3_fppt_max = 53
> + },
> + .dc_data = &(struct power_limits) {
> + .ppt_pl1_spl_min = 7,
> + .ppt_pl1_spl_def = 17,
> + .ppt_pl1_spl_max = 25,
> + .ppt_pl2_sppt_min = 15,
> + .ppt_pl2_sppt_def = 24,
> + .ppt_pl2_sppt_max = 30,
> + .ppt_pl3_fppt_min = 15,
> + .ppt_pl3_fppt_def = 30,
> + .ppt_pl3_fppt_max = 35
> + }
> + },
> + },
> + {}
> +};
> +
> #endif /* _ASUS_ARMOURY_H_ */
> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
> index 3d236f8498d8..8fedf818563f 100644
> --- a/include/linux/platform_data/x86/asus-wmi.h
> +++ b/include/linux/platform_data/x86/asus-wmi.h
> @@ -145,6 +145,9 @@
>
> #define ASUS_WMI_DEVID_APU_MEM 0x000600C1
>
> +#define ASUS_WMI_DEVID_DGPU_BASE_TGP 0x00120099
> +#define ASUS_WMI_DEVID_DGPU_SET_TGP 0x00120098
> +
> /* gpu mux switch, 0 = dGPU, 1 = Optimus */
> #define ASUS_WMI_DEVID_GPU_MUX 0x00090016
> #define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026
>
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support
2025-10-17 12:16 ` Ilpo Järvinen
@ 2025-10-18 1:23 ` Denis Benato
0 siblings, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-18 1:23 UTC (permalink / raw)
To: Ilpo Järvinen
Cc: LKML, platform-driver-x86, Hans de Goede, Limonciello, Mario,
Luke D . Jones, Alok Tiwari, Derek John Clark, Mateusz Schyboll,
porfet828
On 10/17/25 14:16, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Denis Benato wrote:
>
>> From: "Luke D. Jones" <luke@ljones.dev>
>>
>> Implement the APU memory size control under the asus-armoury module using
>> the fw_attributes class.
>>
>> This allows the APU allocated memory size to be adjusted depending on
>> the users priority. A reboot is required after change.
>>
>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>> ---
>> drivers/platform/x86/asus-armoury.c | 81 ++++++++++++++++++++++
>> include/linux/platform_data/x86/asus-wmi.h | 2 +
>> 2 files changed, 83 insertions(+)
>>
>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>> index 68ce2c159ae1..3b49a27e397d 100644
>> --- a/drivers/platform/x86/asus-armoury.c
>> +++ b/drivers/platform/x86/asus-armoury.c
>> @@ -394,6 +394,86 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj
>> WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
>> ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
>>
>> +/* Device memory available to APU */
>> +
>> +/* Values map for APU memory: some looks out of order but are actually correct */
>> +static u32 apu_mem_map[] = {
>> + [0] = 0x000, /* called "AUTO" on the BIOS, is the minimum available */
>> + [1] = 0x102,
>> + [2] = 0x103,
>> + [3] = 0x104,
>> + [4] = 0x105,
>> + [5] = 0x107,
>> + [6] = 0x108,
>> + [7] = 0x109,
>> + [8] = 0x106,
> Is BIT(8) actually telling non-AUTO here? I mean, it's not set for the
> AUTO case. If it has this special meaning, maybe that should be left out
> of this array and handled by the show/store functions as it seems
> different for the auto depending on which way the information is being
> passed.
When 0x000 is set the interface will answer with value 0x100,
so it seems a bit confusing associating BIT(8) to "non-auto".
Honestly I don't see any particular pattern around these values.
I have tried to see if I could set 0x100 or 0x101 and my hardware
stopped booting until a hard reset was performed.
I am not seeing any particular reason to further modify code here.
>> +};
>> +
>> +static ssize_t apu_mem_current_value_show(struct kobject *kobj, struct kobj_attribute *attr,
>> + char *buf)
>> +{
>> + int err;
>> + u32 mem;
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
>> + if (err)
>> + return err;
>> +
>> + if ((mem & ASUS_WMI_DSTS_PRESENCE_BIT) == 0)
>> + return -ENODEV;
>> +
>> + mem &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
>> +
>> + /* After 0x000 is set, a read will return 0x100 */
>> + if (mem == 0x100)
>> + return sysfs_emit(buf, "0\n");
>> +
>> + for (unsigned int i = 0; i < ARRAY_SIZE(apu_mem_map); i++) {
>> + if (apu_mem_map[i] == mem)
>> + return sysfs_emit(buf, "%u\n", i);
>> + }
>> +
>> + pr_warn("Unrecognised value for APU mem 0x%08x\n", mem);
>> + return sysfs_emit(buf, "%u\n", mem);
> ??
>
> Should this return -EIO or something like that instead. It definitely
> looks wrong to first log it as %x and then output to sysfs as %u.
>
>> +}
>> +
>> +static ssize_t apu_mem_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>> + const char *buf, size_t count)
>> +{
>> + int result, err;
>> + u32 requested, mem;
>> +
>> + result = kstrtou32(buf, 10, &requested);
>> + if (result)
>> + return result;
>> +
>> + if (requested >= ARRAY_SIZE(apu_mem_map))
>> + return -EINVAL;
>> +
>> + mem = apu_mem_map[requested];
>> +
>> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
>> + if (err) {
>> + pr_warn("Failed to set apu_mem: %d\n", err);
>> + return err;
>> + }
>> +
>> + pr_info("APU memory changed to %uGB, reboot required\n", requested+1);
> requested + 1
>
> Please mention GB up where the array is.
>
>> + sysfs_notify(kobj, NULL, attr->attr.name);
>> +
>> + asus_set_reboot_and_signal_event();
>> +
>> + return count;
>> +}
>> +
>> +static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_attribute *attr,
>> + char *buf)
>> +{
>> + BUILD_BUG_ON(ARRAY_SIZE(apu_mem_map) != 9);
>> + return sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");
> You could make this future proof with a for loop and sysfs_emit_at() and
> drop the BUILD_BUG_ON(). Maybe all these multi-valued show functions could
> share a helper which does that.
Thanks, due to changes to egpu interface I will introduce such helper in 0/2.
>> +}
>> +ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
>> +
>> /* Simple attribute creation */
>> ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
>> "Show the current mode of charging");
>> @@ -414,6 +494,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
>> { &egpu_connected_attr_group, ASUS_WMI_DEVID_EGPU_CONNECTED },
>> { &egpu_enable_attr_group, ASUS_WMI_DEVID_EGPU },
>> { &dgpu_disable_attr_group, ASUS_WMI_DEVID_DGPU },
>> + { &apu_mem_attr_group, ASUS_WMI_DEVID_APU_MEM },
>>
>> { &charge_mode_attr_group, ASUS_WMI_DEVID_CHARGE_MODE },
>> { &boot_sound_attr_group, ASUS_WMI_DEVID_BOOT_SOUND },
>> diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h
>> index 10acd5d52e38..a4f6bab93a6f 100644
>> --- a/include/linux/platform_data/x86/asus-wmi.h
>> +++ b/include/linux/platform_data/x86/asus-wmi.h
>> @@ -137,6 +137,8 @@
>> /* dgpu on/off */
>> #define ASUS_WMI_DEVID_DGPU 0x00090020
>>
>> +#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
>> +
>> /* gpu mux switch, 0 = dGPU, 1 = Optimus */
>> #define ASUS_WMI_DEVID_GPU_MUX 0x00090016
>> #define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026
>>
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-17 12:48 ` Ilpo Järvinen
@ 2025-10-18 1:43 ` Denis Benato
2025-10-20 17:15 ` Ilpo Järvinen
2025-10-19 16:53 ` Denis Benato
1 sibling, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-18 1:43 UTC (permalink / raw)
To: Ilpo Järvinen, Mario Limonciello, Hans de Goede,
Mark Pearson, Luke D . Jones
Cc: LKML, platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
On 10/17/25 14:48, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Denis Benato wrote:
>
>> From: "Luke D. Jones" <luke@ljones.dev>
>>
>> Implement Intel core enablement under the asus-armoury module using the
>> fw_attributes class.
>>
>> This allows users to enable or disable preformance or efficiency cores
>> depending on their requirements. After change a reboot is required.
>>
>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>> ---
>> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
>> drivers/platform/x86/asus-armoury.h | 28 +++
>> include/linux/platform_data/x86/asus-wmi.h | 5 +
>> 3 files changed, 290 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>> index 3b49a27e397d..3d963025d84e 100644
>> --- a/drivers/platform/x86/asus-armoury.c
>> +++ b/drivers/platform/x86/asus-armoury.c
>> @@ -45,13 +45,49 @@
>> #define ASUS_MINI_LED_2024_STRONG 0x01
>> #define ASUS_MINI_LED_2024_OFF 0x02
>>
>> +#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
>> +#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
>> +
>> +enum cpu_core_type {
>> + CPU_CORE_PERF = 0,
>> + CPU_CORE_POWER,
>> +};
>> +
>> +enum cpu_core_value {
>> + CPU_CORE_DEFAULT = 0,
> This could be mapped in the sysfs _show function as there's no real
> backing value for it.
>
>> + CPU_CORE_MIN,
>> + CPU_CORE_MAX,
>> + CPU_CORE_CURRENT,
>> +};
>> +
>> +#define CPU_PERF_CORE_COUNT_MIN 4
>> +#define CPU_POWR_CORE_COUNT_MIN 0
>> +
>> +/* Tunables provided by ASUS for gaming laptops */
>> +struct cpu_cores {
>> + u32 cur_perf_cores;
>> + u32 min_perf_cores;
>> + u32 max_perf_cores;
>> + u32 cur_power_cores;
>> + u32 min_power_cores;
>> + u32 max_power_cores;
>> +};
>> +
>> static struct asus_armoury_priv {
>> struct device *fw_attr_dev;
>> struct kset *fw_attr_kset;
>>
>> + struct cpu_cores *cpu_cores;
>> u32 mini_led_dev_id;
>> u32 gpu_mux_dev_id;
>> -} asus_armoury;
>> + /*
>> + * Mutex to prevent big/little core count changes writing to same
>> + * endpoint at the same time. Must lock during attr store.
>> + */
>> + struct mutex cpu_core_mutex;
>> +} asus_armoury = {
>> + .cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex)
>> +};
>>
>> struct fw_attrs_group {
>> bool pending_reboot;
>> @@ -93,6 +129,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
>> static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
>> {
>> return !strcmp(attr->attr.name, "gpu_mux_mode") ||
>> + !strcmp(attr->attr.name, "cores_performance") ||
>> + !strcmp(attr->attr.name, "cores_efficiency") ||
>> !strcmp(attr->attr.name, "panel_hd_mode");
>> }
>>
>> @@ -171,6 +209,12 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
>> return sysfs_emit(buf, "enumeration\n");
>> }
>>
>> +static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr,
>> + char *buf)
>> +{
>> + return sysfs_emit(buf, "integer\n");
>> +}
>> +
>> /* Mini-LED mode **************************************************************/
>> static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
>> struct kobj_attribute *attr, char *buf)
>> @@ -474,6 +518,207 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
>> }
>> ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
>>
>> +static int init_max_cpu_cores(void)
>> +{
>> + u32 cores;
>> + int err;
>> +
>> + asus_armoury.cpu_cores = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
>> + if (!asus_armoury.cpu_cores)
>> + return -ENOMEM;
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
>> + if (err)
>> + return err;
>> +
>> + if ((cores & ASUS_WMI_DSTS_PRESENCE_BIT) == 0) {
>> + pr_err("ACPI does not support CPU core count control\n");
>> + err = -ENODEV;
>> + goto init_max_cpu_cores_err;
> Please use __free() and return immediately.
>
> Only assign from local variable to asus_armoury.cpu_cores with
> no_free_ptr() at the end.
>
>> + }
>> +
>> + asus_armoury.cpu_cores->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
>> + asus_armoury.cpu_cores->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
>> + if (err) {
>> + pr_err("Could not get CPU core count: error %d\n", err);
>> + goto init_max_cpu_cores_err;
>> + }
>> +
>> + asus_armoury.cpu_cores->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
>> + asus_armoury.cpu_cores->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
>> +
>> + asus_armoury.cpu_cores->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
>> + asus_armoury.cpu_cores->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
> Should these be bounds checked with max?
>
>> + return 0;
>> +
>> +init_max_cpu_cores_err:
>> + kfree(asus_armoury.cpu_cores);
>> + return err;
>> +}
>> +
>> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
>> + enum cpu_core_type core_type, enum cpu_core_value core_value)
>> +{
>> + u32 cores;
>> +
>> + switch (core_value) {
>> + case CPU_CORE_DEFAULT:
>> + case CPU_CORE_MAX:
>> + if (core_type == CPU_CORE_PERF)
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->max_perf_cores);
>> + else
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->max_power_cores);
>> + case CPU_CORE_MIN:
>> + if (core_type == CPU_CORE_PERF)
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->min_perf_cores);
>> + else
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->min_power_cores);
>> + default:
>> + break;
>> + }
>> +
>> + if (core_type == CPU_CORE_PERF)
>> + cores = asus_armoury.cpu_cores->cur_perf_cores;
>> + else
>> + cores = asus_armoury.cpu_cores->cur_power_cores;
> Why isn't this inside the switch?? The logic in this function looks very
> mixed up.
>
> If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
> multi-dimensional array. It would make this just bounds checks and one
> line to get the data.
Please note that this interface has the potential to brick in an irreversible
way laptops and it has happened.
Of all the code CPU core handling it the most delicate code of all since
a wrong value here means permanent irreversible damage.
I am more than happy making changes that can be easily verified,
but others more complex changes will put (at least) my own hardware
at risk.
If you think benefit outweighs risks I will try my best.
>> + return sysfs_emit(buf, "%u\n", cores);
>> +}
>> +
>> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>> + const char *buf, enum cpu_core_type core_type)
>> +{
>> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
>> + int result, err;
>> +
>> + result = kstrtou32(buf, 10, &new_cores);
>> + if (result)
>> + return result;
>> +
>> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
>> + if (core_type == CPU_CORE_PERF) {
>> + perf_cores = new_cores;
>> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
>> + min = asus_armoury.cpu_cores->min_perf_cores;
>> + max = asus_armoury.cpu_cores->max_perf_cores;
>> + } else {
>> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
>> + power_cores = new_cores;
>> + min = asus_armoury.cpu_cores->min_power_cores;
>> + max = asus_armoury.cpu_cores->max_power_cores;
>> + }
>> +
>> + if (new_cores < min || new_cores > max)
>> + return -EINVAL;
>> +
>> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
>> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
>> +
>> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
>> + if (err) {
>> + pr_warn("Failed to set CPU core count: %d\n", err);
>> + return err;
>> + }
>> +
>> + if (result > 1) {
>> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
>> + return -EIO;
>> + }
>> + }
>> +
>> + pr_info("CPU core count changed, reboot required\n");
> This interface has a problematic behavior. If user wants to adjust both
> core counts one after another (without reboot in between), the new value
> of the first core count will be overwritten on the second store.
>
> You might have to store also the value that will be used after the next
> boot to solve it but how the divergence should be presented to user is
> another question to which I don't have a good answer.
Given what I have written above I am thinking more along the lines of allowing
only one change at the time, giving absolute priority to the ability to demonstrate
not all P-cores can be disabled all at once, or after a reboot hardware will be
irreversibly lost. It cannot be recovered the same way as I did with APU mem.
To summarize I am more inclined in allowing only small changes,
or to postpone this patch entirely while we think to a better, safer solution.
> This seems a more general problem, that is, how to represent values which
> are only enacted after booting (current vs to-be-current) as it doesn't
> fit to the current, min, max, possible_values, type model.
>
Enabling eGPU on a laptop with a dGPU that is active makes the PCI-e
spam PCI AER uncorrectable errors and renders both GPUs unusable.
I have gone with storing the value at driver load time and treating it
as the boot value for 2/9 (eGPU), but I am very open to suggestions!
Thanks for your time,
Denis
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-17 12:48 ` Ilpo Järvinen
2025-10-18 1:43 ` Denis Benato
@ 2025-10-19 16:53 ` Denis Benato
1 sibling, 0 replies; 30+ messages in thread
From: Denis Benato @ 2025-10-19 16:53 UTC (permalink / raw)
To: Ilpo Järvinen, Mario Limonciello, Hans de Goede,
Mark Pearson, Luke D . Jones
Cc: LKML, platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
On 10/17/25 14:48, Ilpo Järvinen wrote:
> On Wed, 15 Oct 2025, Denis Benato wrote:
>
>> From: "Luke D. Jones" <luke@ljones.dev>
>>
>> Implement Intel core enablement under the asus-armoury module using the
>> fw_attributes class.
>>
>> This allows users to enable or disable preformance or efficiency cores
>> depending on their requirements. After change a reboot is required.
>>
>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>> ---
>> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
>> drivers/platform/x86/asus-armoury.h | 28 +++
>> include/linux/platform_data/x86/asus-wmi.h | 5 +
>> 3 files changed, 290 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>> index 3b49a27e397d..3d963025d84e 100644
>> --- a/drivers/platform/x86/asus-armoury.c
>> +++ b/drivers/platform/x86/asus-armoury.c
>> @@ -45,13 +45,49 @@
>> #define ASUS_MINI_LED_2024_STRONG 0x01
>> #define ASUS_MINI_LED_2024_OFF 0x02
>>
>> +#define ASUS_POWER_CORE_MASK GENMASK(15, 8)
>> +#define ASUS_PERF_CORE_MASK GENMASK(7, 0)
>> +
>> +enum cpu_core_type {
>> + CPU_CORE_PERF = 0,
>> + CPU_CORE_POWER,
>> +};
>> +
>> +enum cpu_core_value {
>> + CPU_CORE_DEFAULT = 0,
> This could be mapped in the sysfs _show function as there's no real
> backing value for it.
It is also used in a store function called by both _stores and
I wouldn't like the idea of transforming it in a u32 given
the importance of data to be correct in this specific interface.
The last thing I want is making device unbootable because
I missed a CPU_CORE_PERF vs CPU_CORE_POWER or because
I misremember while changing the code that CORE_PERF means
performance and CORE_POWER means efficiency
(and it took me a minute to get this spelled right in this email).
>> + CPU_CORE_MIN,
>> + CPU_CORE_MAX,
>> + CPU_CORE_CURRENT,
>> +};
>> +
>> +#define CPU_PERF_CORE_COUNT_MIN 4
>> +#define CPU_POWR_CORE_COUNT_MIN 0
>> +
>> +/* Tunables provided by ASUS for gaming laptops */
>> +struct cpu_cores {
>> + u32 cur_perf_cores;
>> + u32 min_perf_cores;
>> + u32 max_perf_cores;
>> + u32 cur_power_cores;
>> + u32 min_power_cores;
>> + u32 max_power_cores;
>> +};
>> +
>> static struct asus_armoury_priv {
>> struct device *fw_attr_dev;
>> struct kset *fw_attr_kset;
>>
>> + struct cpu_cores *cpu_cores;
>> u32 mini_led_dev_id;
>> u32 gpu_mux_dev_id;
>> -} asus_armoury;
>> + /*
>> + * Mutex to prevent big/little core count changes writing to same
>> + * endpoint at the same time. Must lock during attr store.
>> + */
>> + struct mutex cpu_core_mutex;
>> +} asus_armoury = {
>> + .cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex)
>> +};
>>
>> struct fw_attrs_group {
>> bool pending_reboot;
>> @@ -93,6 +129,8 @@ static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
>> static bool asus_bios_requires_reboot(struct kobj_attribute *attr)
>> {
>> return !strcmp(attr->attr.name, "gpu_mux_mode") ||
>> + !strcmp(attr->attr.name, "cores_performance") ||
>> + !strcmp(attr->attr.name, "cores_efficiency") ||
>> !strcmp(attr->attr.name, "panel_hd_mode");
>> }
>>
>> @@ -171,6 +209,12 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
>> return sysfs_emit(buf, "enumeration\n");
>> }
>>
>> +static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr,
>> + char *buf)
>> +{
>> + return sysfs_emit(buf, "integer\n");
>> +}
>> +
>> /* Mini-LED mode **************************************************************/
>> static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
>> struct kobj_attribute *attr, char *buf)
>> @@ -474,6 +518,207 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
>> }
>> ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
>>
>> +static int init_max_cpu_cores(void)
>> +{
>> + u32 cores;
>> + int err;
>> +
>> + asus_armoury.cpu_cores = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
>> + if (!asus_armoury.cpu_cores)
>> + return -ENOMEM;
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
>> + if (err)
>> + return err;
>> +
>> + if ((cores & ASUS_WMI_DSTS_PRESENCE_BIT) == 0) {
>> + pr_err("ACPI does not support CPU core count control\n");
>> + err = -ENODEV;
>> + goto init_max_cpu_cores_err;
> Please use __free() and return immediately.
>
> Only assign from local variable to asus_armoury.cpu_cores with
> no_free_ptr() at the end.
>
>> + }
>> +
>> + asus_armoury.cpu_cores->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
>> + asus_armoury.cpu_cores->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
>> +
>> + err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
>> + if (err) {
>> + pr_err("Could not get CPU core count: error %d\n", err);
>> + goto init_max_cpu_cores_err;
>> + }
>> +
>> + asus_armoury.cpu_cores->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
>> + asus_armoury.cpu_cores->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
>> +
>> + asus_armoury.cpu_cores->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
>> + asus_armoury.cpu_cores->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
> Should these be bounds checked with max?
>
>> + return 0;
>> +
>> +init_max_cpu_cores_err:
>> + kfree(asus_armoury.cpu_cores);
>> + return err;
>> +}
>> +
>> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
>> + enum cpu_core_type core_type, enum cpu_core_value core_value)
>> +{
>> + u32 cores;
>> +
>> + switch (core_value) {
>> + case CPU_CORE_DEFAULT:
>> + case CPU_CORE_MAX:
>> + if (core_type == CPU_CORE_PERF)
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->max_perf_cores);
>> + else
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->max_power_cores);
>> + case CPU_CORE_MIN:
>> + if (core_type == CPU_CORE_PERF)
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->min_perf_cores);
>> + else
>> + return sysfs_emit(buf, "%u\n",
>> + asus_armoury.cpu_cores->min_power_cores);
>> + default:
>> + break;
>> + }
>> +
>> + if (core_type == CPU_CORE_PERF)
>> + cores = asus_armoury.cpu_cores->cur_perf_cores;
>> + else
>> + cores = asus_armoury.cpu_cores->cur_power_cores;
> Why isn't this inside the switch?? The logic in this function looks very
> mixed up.
>
> If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
> multi-dimensional array. It would make this just bounds checks and one
> line to get the data.
>
>> + return sysfs_emit(buf, "%u\n", cores);
>> +}
>> +
>> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>> + const char *buf, enum cpu_core_type core_type)
>> +{
>> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
>> + int result, err;
>> +
>> + result = kstrtou32(buf, 10, &new_cores);
>> + if (result)
>> + return result;
>> +
>> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
>> + if (core_type == CPU_CORE_PERF) {
>> + perf_cores = new_cores;
>> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
>> + min = asus_armoury.cpu_cores->min_perf_cores;
>> + max = asus_armoury.cpu_cores->max_perf_cores;
>> + } else {
>> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
>> + power_cores = new_cores;
>> + min = asus_armoury.cpu_cores->min_power_cores;
>> + max = asus_armoury.cpu_cores->max_power_cores;
>> + }
>> +
>> + if (new_cores < min || new_cores > max)
>> + return -EINVAL;
>> +
>> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
>> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
>> +
>> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
>> + if (err) {
>> + pr_warn("Failed to set CPU core count: %d\n", err);
>> + return err;
>> + }
>> +
>> + if (result > 1) {
>> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
>> + return -EIO;
>> + }
>> + }
>> +
>> + pr_info("CPU core count changed, reboot required\n");
> This interface has a problematic behavior. If user wants to adjust both
> core counts one after another (without reboot in between), the new value
> of the first core count will be overwritten on the second store.
>
> You might have to store also the value that will be used after the next
> boot to solve it but how the divergence should be presented to user is
> another question to which I don't have a good answer.
>
> This seems a more general problem, that is, how to represent values which
> are only enacted after booting (current vs to-be-current) as it doesn't
> fit to the current, min, max, possible_values, type model.
>
>
I will propose a possible solution in v15 very soon that will hopefully
satisfy both kernel requirements and safety requirements.
Thank you,
Denis
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-18 1:43 ` Denis Benato
@ 2025-10-20 17:15 ` Ilpo Järvinen
2025-10-20 17:37 ` Denis Benato
0 siblings, 1 reply; 30+ messages in thread
From: Ilpo Järvinen @ 2025-10-20 17:15 UTC (permalink / raw)
To: Denis Benato
Cc: Mario Limonciello, Hans de Goede, Mark Pearson, Luke D . Jones,
LKML, platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
[-- Attachment #1: Type: text/plain, Size: 6480 bytes --]
On Sat, 18 Oct 2025, Denis Benato wrote:
> On 10/17/25 14:48, Ilpo Järvinen wrote:
> > On Wed, 15 Oct 2025, Denis Benato wrote:
> >
> >> From: "Luke D. Jones" <luke@ljones.dev>
> >>
> >> Implement Intel core enablement under the asus-armoury module using the
> >> fw_attributes class.
> >>
> >> This allows users to enable or disable preformance or efficiency cores
> >> depending on their requirements. After change a reboot is required.
> >>
> >> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
> >> Signed-off-by: Luke D. Jones <luke@ljones.dev>
> >> ---
> >> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
> >> drivers/platform/x86/asus-armoury.h | 28 +++
> >> include/linux/platform_data/x86/asus-wmi.h | 5 +
> >> 3 files changed, 290 insertions(+), 1 deletion(-)
> >>
> >> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
> >> index 3b49a27e397d..3d963025d84e 100644
> >> --- a/drivers/platform/x86/asus-armoury.c
> >> +++ b/drivers/platform/x86/asus-armoury.c
> >> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
> >> + enum cpu_core_type core_type, enum cpu_core_value core_value)
> >> +{
> >> + u32 cores;
> >> +
> >> + switch (core_value) {
> >> + case CPU_CORE_DEFAULT:
> >> + case CPU_CORE_MAX:
> >> + if (core_type == CPU_CORE_PERF)
> >> + return sysfs_emit(buf, "%u\n",
> >> + asus_armoury.cpu_cores->max_perf_cores);
> >> + else
> >> + return sysfs_emit(buf, "%u\n",
> >> + asus_armoury.cpu_cores->max_power_cores);
> >> + case CPU_CORE_MIN:
> >> + if (core_type == CPU_CORE_PERF)
> >> + return sysfs_emit(buf, "%u\n",
> >> + asus_armoury.cpu_cores->min_perf_cores);
> >> + else
> >> + return sysfs_emit(buf, "%u\n",
> >> + asus_armoury.cpu_cores->min_power_cores);
> >> + default:
> >> + break;
> >> + }
> >> +
> >> + if (core_type == CPU_CORE_PERF)
> >> + cores = asus_armoury.cpu_cores->cur_perf_cores;
> >> + else
> >> + cores = asus_armoury.cpu_cores->cur_power_cores;
> > Why isn't this inside the switch?? The logic in this function looks very
> > mixed up.
> >
> > If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
> > multi-dimensional array. It would make this just bounds checks and one
> > line to get the data.
>
> Please note that this interface has the potential to brick in an irreversible
> way laptops and it has happened.
This function only prints values held by kernel in its internal storage?
How can that brick something?
> Of all the code CPU core handling it the most delicate code of all since
> a wrong value here means permanent irreversible damage.
>
> I am more than happy making changes that can be easily verified,
> but others more complex changes will put (at least) my own hardware
> at risk.
Understood.
> If you think benefit outweighs risks I will try my best.
> >> + return sysfs_emit(buf, "%u\n", cores);
> >> +}
> >> +
> >> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
> >> + const char *buf, enum cpu_core_type core_type)
> >> +{
> >> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
> >> + int result, err;
> >> +
> >> + result = kstrtou32(buf, 10, &new_cores);
> >> + if (result)
> >> + return result;
> >> +
> >> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
> >> + if (core_type == CPU_CORE_PERF) {
> >> + perf_cores = new_cores;
> >> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
> >> + min = asus_armoury.cpu_cores->min_perf_cores;
> >> + max = asus_armoury.cpu_cores->max_perf_cores;
> >> + } else {
> >> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
> >> + power_cores = new_cores;
> >> + min = asus_armoury.cpu_cores->min_power_cores;
> >> + max = asus_armoury.cpu_cores->max_power_cores;
> >> + }
> >> +
> >> + if (new_cores < min || new_cores > max)
> >> + return -EINVAL;
> >> +
> >> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
> >> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
> >> +
> >> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
> >> + if (err) {
> >> + pr_warn("Failed to set CPU core count: %d\n", err);
> >> + return err;
> >> + }
> >> +
> >> + if (result > 1) {
> >> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
> >> + return -EIO;
> >> + }
> >> + }
> >> +
> >> + pr_info("CPU core count changed, reboot required\n");
> >
> > This interface has a problematic behavior. If user wants to adjust both
> > core counts one after another (without reboot in between), the new value
> > of the first core count will be overwritten on the second store.
> >
> > You might have to store also the value that will be used after the next
> > boot to solve it but how the divergence should be presented to user is
> > another question to which I don't have a good answer.
>
> Given what I have written above I am thinking more along the lines of allowing
> only one change at the time, giving absolute priority to the ability to demonstrate
> not all P-cores can be disabled all at once, or after a reboot hardware will be
> irreversibly lost. It cannot be recovered the same way as I did with APU mem.
>
> To summarize I am more inclined in allowing only small changes,
> or to postpone this patch entirely while we think to a better, safer solution.
Fair enough, please mention this as in the changelog as a justification
and to warn other messing with the code.
> > This seems a more general problem, that is, how to represent values which
> > are only enacted after booting (current vs to-be-current) as it doesn't
> > fit to the current, min, max, possible_values, type model.
> >
> Enabling eGPU on a laptop with a dGPU that is active makes the PCI-e
> spam PCI AER uncorrectable errors and renders both GPUs unusable.
>
> I have gone with storing the value at driver load time and treating it
> as the boot value for 2/9 (eGPU), but I am very open to suggestions!
I'm not entirely sure what you're trying to say here. My point is that
there's no way for user to know what value something will be changed to
(the "to-be-current" value) except through rebooting the system (when the
"to-be-current" value becomes the "current").
--
i.
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-20 17:15 ` Ilpo Järvinen
@ 2025-10-20 17:37 ` Denis Benato
2025-10-20 18:45 ` Mario Limonciello (AMD) (kernel.org)
0 siblings, 1 reply; 30+ messages in thread
From: Denis Benato @ 2025-10-20 17:37 UTC (permalink / raw)
To: Ilpo Järvinen
Cc: Mario Limonciello, Hans de Goede, Mark Pearson, Luke D . Jones,
LKML, platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
On 10/20/25 19:15, Ilpo Järvinen wrote:
> On Sat, 18 Oct 2025, Denis Benato wrote:
>> On 10/17/25 14:48, Ilpo Järvinen wrote:
>>> On Wed, 15 Oct 2025, Denis Benato wrote:
>>>
>>>> From: "Luke D. Jones" <luke@ljones.dev>
>>>>
>>>> Implement Intel core enablement under the asus-armoury module using the
>>>> fw_attributes class.
>>>>
>>>> This allows users to enable or disable preformance or efficiency cores
>>>> depending on their requirements. After change a reboot is required.
>>>>
>>>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>>>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>>>> ---
>>>> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
>>>> drivers/platform/x86/asus-armoury.h | 28 +++
>>>> include/linux/platform_data/x86/asus-wmi.h | 5 +
>>>> 3 files changed, 290 insertions(+), 1 deletion(-)
>>>>
>>>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>>>> index 3b49a27e397d..3d963025d84e 100644
>>>> --- a/drivers/platform/x86/asus-armoury.c
>>>> +++ b/drivers/platform/x86/asus-armoury.c
>>>> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
>>>> + enum cpu_core_type core_type, enum cpu_core_value core_value)
>>>> +{
>>>> + u32 cores;
>>>> +
>>>> + switch (core_value) {
>>>> + case CPU_CORE_DEFAULT:
>>>> + case CPU_CORE_MAX:
>>>> + if (core_type == CPU_CORE_PERF)
>>>> + return sysfs_emit(buf, "%u\n",
>>>> + asus_armoury.cpu_cores->max_perf_cores);
>>>> + else
>>>> + return sysfs_emit(buf, "%u\n",
>>>> + asus_armoury.cpu_cores->max_power_cores);
>>>> + case CPU_CORE_MIN:
>>>> + if (core_type == CPU_CORE_PERF)
>>>> + return sysfs_emit(buf, "%u\n",
>>>> + asus_armoury.cpu_cores->min_perf_cores);
>>>> + else
>>>> + return sysfs_emit(buf, "%u\n",
>>>> + asus_armoury.cpu_cores->min_power_cores);
>>>> + default:
>>>> + break;
>>>> + }
>>>> +
>>>> + if (core_type == CPU_CORE_PERF)
>>>> + cores = asus_armoury.cpu_cores->cur_perf_cores;
>>>> + else
>>>> + cores = asus_armoury.cpu_cores->cur_power_cores;
>>> Why isn't this inside the switch?? The logic in this function looks very
>>> mixed up.
>>>
>>> If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
>>> multi-dimensional array. It would make this just bounds checks and one
>>> line to get the data.
>> Please note that this interface has the potential to brick in an irreversible
>> way laptops and it has happened.
> This function only prints values held by kernel in its internal storage?
> How can that brick something?
>
>> Of all the code CPU core handling it the most delicate code of all since
>> a wrong value here means permanent irreversible damage.
>>
>> I am more than happy making changes that can be easily verified,
>> but others more complex changes will put (at least) my own hardware
>> at risk.
> Understood.
>
>> If you think benefit outweighs risks I will try my best.
>>>> + return sysfs_emit(buf, "%u\n", cores);
>>>> +}
>>>> +
>>>> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>>>> + const char *buf, enum cpu_core_type core_type)
>>>> +{
>>>> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
>>>> + int result, err;
>>>> +
>>>> + result = kstrtou32(buf, 10, &new_cores);
>>>> + if (result)
>>>> + return result;
>>>> +
>>>> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
>>>> + if (core_type == CPU_CORE_PERF) {
>>>> + perf_cores = new_cores;
>>>> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
>>>> + min = asus_armoury.cpu_cores->min_perf_cores;
>>>> + max = asus_armoury.cpu_cores->max_perf_cores;
>>>> + } else {
>>>> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
>>>> + power_cores = new_cores;
>>>> + min = asus_armoury.cpu_cores->min_power_cores;
>>>> + max = asus_armoury.cpu_cores->max_power_cores;
>>>> + }
>>>> +
>>>> + if (new_cores < min || new_cores > max)
>>>> + return -EINVAL;
>>>> +
>>>> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
>>>> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
>>>> +
>>>> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
>>>> + if (err) {
>>>> + pr_warn("Failed to set CPU core count: %d\n", err);
>>>> + return err;
>>>> + }
>>>> +
>>>> + if (result > 1) {
>>>> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
>>>> + return -EIO;
>>>> + }
>>>> + }
>>>> +
>>>> + pr_info("CPU core count changed, reboot required\n");
>>> This interface has a problematic behavior. If user wants to adjust both
>>> core counts one after another (without reboot in between), the new value
>>> of the first core count will be overwritten on the second store.
>>>
>>> You might have to store also the value that will be used after the next
>>> boot to solve it but how the divergence should be presented to user is
>>> another question to which I don't have a good answer.
>> Given what I have written above I am thinking more along the lines of allowing
>> only one change at the time, giving absolute priority to the ability to demonstrate
>> not all P-cores can be disabled all at once, or after a reboot hardware will be
>> irreversibly lost. It cannot be recovered the same way as I did with APU mem.
>>
>> To summarize I am more inclined in allowing only small changes,
>> or to postpone this patch entirely while we think to a better, safer solution.
> Fair enough, please mention this as in the changelog as a justification
> and to warn other messing with the code.
>
>>> This seems a more general problem, that is, how to represent values which
>>> are only enacted after booting (current vs to-be-current) as it doesn't
>>> fit to the current, min, max, possible_values, type model.
>>>
>> Enabling eGPU on a laptop with a dGPU that is active makes the PCI-e
>> spam PCI AER uncorrectable errors and renders both GPUs unusable.
>>
>> I have gone with storing the value at driver load time and treating it
>> as the boot value for 2/9 (eGPU), but I am very open to suggestions!
> I'm not entirely sure what you're trying to say here. My point is that
> there's no way for user to know what value something will be changed to
> (the "to-be-current" value) except through rebooting the system (when the
> "to-be-current" value becomes the "current").
>
Users do know what the value will be changed to because that is what the
WMI interface will tell: the issue is in reverse (knowing what settings were
applied when booting the laptop): one has to infer those looking at
the current state of things.
For example it is only possible to know if the next boot will have
sound or not, not if a sound was emitted at the current boot.
I haven't seen examples of devstates not returning the future value,
but I do have seen my ally returning dGPU property presence when
there is no dGPU in it and it appears to be a no-op, so I had to remove
(or rather avoid adding) a safeguard against possible PCI bus conflicts
that I had planned.
Thanks,
Denis
^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v14 5/9] platform/x86: asus-armoury: add core count control
2025-10-20 17:37 ` Denis Benato
@ 2025-10-20 18:45 ` Mario Limonciello (AMD) (kernel.org)
0 siblings, 0 replies; 30+ messages in thread
From: Mario Limonciello (AMD) (kernel.org) @ 2025-10-20 18:45 UTC (permalink / raw)
To: Denis Benato, Ilpo Järvinen
Cc: Hans de Goede, Mark Pearson, Luke D . Jones, LKML,
platform-driver-x86, Alok Tiwari, Derek John Clark,
Mateusz Schyboll, porfet828
On 10/20/2025 12:37 PM, Denis Benato wrote:
>
> On 10/20/25 19:15, Ilpo Järvinen wrote:
>> On Sat, 18 Oct 2025, Denis Benato wrote:
>>> On 10/17/25 14:48, Ilpo Järvinen wrote:
>>>> On Wed, 15 Oct 2025, Denis Benato wrote:
>>>>
>>>>> From: "Luke D. Jones" <luke@ljones.dev>
>>>>>
>>>>> Implement Intel core enablement under the asus-armoury module using the
>>>>> fw_attributes class.
>>>>>
>>>>> This allows users to enable or disable preformance or efficiency cores
>>>>> depending on their requirements. After change a reboot is required.
>>>>>
>>>>> Signed-off-by: Denis Benato <benato.denis96@gmail.com>
>>>>> Signed-off-by: Luke D. Jones <luke@ljones.dev>
>>>>> ---
>>>>> drivers/platform/x86/asus-armoury.c | 258 ++++++++++++++++++++-
>>>>> drivers/platform/x86/asus-armoury.h | 28 +++
>>>>> include/linux/platform_data/x86/asus-wmi.h | 5 +
>>>>> 3 files changed, 290 insertions(+), 1 deletion(-)
>>>>>
>>>>> diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
>>>>> index 3b49a27e397d..3d963025d84e 100644
>>>>> --- a/drivers/platform/x86/asus-armoury.c
>>>>> +++ b/drivers/platform/x86/asus-armoury.c
>>>>> +static ssize_t cores_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf,
>>>>> + enum cpu_core_type core_type, enum cpu_core_value core_value)
>>>>> +{
>>>>> + u32 cores;
>>>>> +
>>>>> + switch (core_value) {
>>>>> + case CPU_CORE_DEFAULT:
>>>>> + case CPU_CORE_MAX:
>>>>> + if (core_type == CPU_CORE_PERF)
>>>>> + return sysfs_emit(buf, "%u\n",
>>>>> + asus_armoury.cpu_cores->max_perf_cores);
>>>>> + else
>>>>> + return sysfs_emit(buf, "%u\n",
>>>>> + asus_armoury.cpu_cores->max_power_cores);
>>>>> + case CPU_CORE_MIN:
>>>>> + if (core_type == CPU_CORE_PERF)
>>>>> + return sysfs_emit(buf, "%u\n",
>>>>> + asus_armoury.cpu_cores->min_perf_cores);
>>>>> + else
>>>>> + return sysfs_emit(buf, "%u\n",
>>>>> + asus_armoury.cpu_cores->min_power_cores);
>>>>> + default:
>>>>> + break;
>>>>> + }
>>>>> +
>>>>> + if (core_type == CPU_CORE_PERF)
>>>>> + cores = asus_armoury.cpu_cores->cur_perf_cores;
>>>>> + else
>>>>> + cores = asus_armoury.cpu_cores->cur_power_cores;
>>>> Why isn't this inside the switch?? The logic in this function looks very
>>>> mixed up.
>>>>
>>>> If I'd be you, I'd consider converting the asus_armoury.cpu_cores to a
>>>> multi-dimensional array. It would make this just bounds checks and one
>>>> line to get the data.
>>> Please note that this interface has the potential to brick in an irreversible
>>> way laptops and it has happened.
>> This function only prints values held by kernel in its internal storage?
>> How can that brick something?
>>
>>> Of all the code CPU core handling it the most delicate code of all since
>>> a wrong value here means permanent irreversible damage.
>>>
>>> I am more than happy making changes that can be easily verified,
>>> but others more complex changes will put (at least) my own hardware
>>> at risk.
>> Understood.
>>
>>> If you think benefit outweighs risks I will try my best.
>>>>> + return sysfs_emit(buf, "%u\n", cores);
>>>>> +}
>>>>> +
>>>>> +static ssize_t cores_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
>>>>> + const char *buf, enum cpu_core_type core_type)
>>>>> +{
>>>>> + u32 new_cores, perf_cores, power_cores, out_val, min, max;
>>>>> + int result, err;
>>>>> +
>>>>> + result = kstrtou32(buf, 10, &new_cores);
>>>>> + if (result)
>>>>> + return result;
>>>>> +
>>>>> + scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
>>>>> + if (core_type == CPU_CORE_PERF) {
>>>>> + perf_cores = new_cores;
>>>>> + power_cores = asus_armoury.cpu_cores->cur_power_cores;
>>>>> + min = asus_armoury.cpu_cores->min_perf_cores;
>>>>> + max = asus_armoury.cpu_cores->max_perf_cores;
>>>>> + } else {
>>>>> + perf_cores = asus_armoury.cpu_cores->cur_perf_cores;
>>>>> + power_cores = new_cores;
>>>>> + min = asus_armoury.cpu_cores->min_power_cores;
>>>>> + max = asus_armoury.cpu_cores->max_power_cores;
>>>>> + }
>>>>> +
>>>>> + if (new_cores < min || new_cores > max)
>>>>> + return -EINVAL;
>>>>> +
>>>>> + out_val = FIELD_PREP(ASUS_PERF_CORE_MASK, perf_cores) |
>>>>> + FIELD_PREP(ASUS_POWER_CORE_MASK, power_cores);
>>>>> +
>>>>> + err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, out_val, &result);
>>>>> + if (err) {
>>>>> + pr_warn("Failed to set CPU core count: %d\n", err);
>>>>> + return err;
>>>>> + }
>>>>> +
>>>>> + if (result > 1) {
>>>>> + pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
>>>>> + return -EIO;
>>>>> + }
>>>>> + }
>>>>> +
>>>>> + pr_info("CPU core count changed, reboot required\n");
>>>> This interface has a problematic behavior. If user wants to adjust both
>>>> core counts one after another (without reboot in between), the new value
>>>> of the first core count will be overwritten on the second store.
>>>>
>>>> You might have to store also the value that will be used after the next
>>>> boot to solve it but how the divergence should be presented to user is
>>>> another question to which I don't have a good answer.
>>> Given what I have written above I am thinking more along the lines of allowing
>>> only one change at the time, giving absolute priority to the ability to demonstrate
>>> not all P-cores can be disabled all at once, or after a reboot hardware will be
>>> irreversibly lost. It cannot be recovered the same way as I did with APU mem.
>>>
>>> To summarize I am more inclined in allowing only small changes,
>>> or to postpone this patch entirely while we think to a better, safer solution.
>> Fair enough, please mention this as in the changelog as a justification
>> and to warn other messing with the code.
>>
>>>> This seems a more general problem, that is, how to represent values which
>>>> are only enacted after booting (current vs to-be-current) as it doesn't
>>>> fit to the current, min, max, possible_values, type model.
>>>>
>>> Enabling eGPU on a laptop with a dGPU that is active makes the PCI-e
>>> spam PCI AER uncorrectable errors and renders both GPUs unusable.
>>>
>>> I have gone with storing the value at driver load time and treating it
>>> as the boot value for 2/9 (eGPU), but I am very open to suggestions!
>> I'm not entirely sure what you're trying to say here. My point is that
>> there's no way for user to know what value something will be changed to
>> (the "to-be-current" value) except through rebooting the system (when the
>> "to-be-current" value becomes the "current").
>>
> Users do know what the value will be changed to because that is what the
> WMI interface will tell: the issue is in reverse (knowing what settings were
> applied when booting the laptop): one has to infer those looking at
> the current state of things.
>
> For example it is only possible to know if the next boot will have
> sound or not, not if a sound was emitted at the current boot.
>
> I haven't seen examples of devstates not returning the future value,
> but I do have seen my ally returning dGPU property presence when
> there is no dGPU in it and it appears to be a no-op, so I had to remove
> (or rather avoid adding) a safeguard against possible PCI bus conflicts
> that I had planned.
>
> Thanks,
>
> Denis
>
There is a concept in the firmware attributes spec
(sysfs-class-firmware-attributes) for "pending_reboot".
I think setting this to 1 should indicate there are changes that will
happen on next boot.
^ permalink raw reply [flat|nested] 30+ messages in thread
end of thread, other threads:[~2025-10-20 18:45 UTC | newest]
Thread overview: 30+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-10-15 1:47 [PATCH v14 0/9] platform/x86: Add asus-armoury driver Denis Benato
2025-10-15 1:47 ` [PATCH v14 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI Denis Benato
2025-10-15 13:03 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module Denis Benato
2025-10-15 13:56 ` Ilpo Järvinen
2025-10-16 1:28 ` Denis Benato
2025-10-15 1:47 ` [PATCH v14 3/9] platform/x86: asus-armoury: add panel_hd_mode attribute Denis Benato
2025-10-15 1:47 ` [PATCH v14 4/9] platform/x86: asus-armoury: add apu-mem control support Denis Benato
2025-10-17 12:16 ` Ilpo Järvinen
2025-10-18 1:23 ` Denis Benato
2025-10-15 1:47 ` [PATCH v14 5/9] platform/x86: asus-armoury: add core count control Denis Benato
2025-10-15 14:11 ` Ilpo Järvinen
2025-10-17 12:48 ` Ilpo Järvinen
2025-10-18 1:43 ` Denis Benato
2025-10-20 17:15 ` Ilpo Järvinen
2025-10-20 17:37 ` Denis Benato
2025-10-20 18:45 ` Mario Limonciello (AMD) (kernel.org)
2025-10-19 16:53 ` Denis Benato
2025-10-15 1:47 ` [PATCH v14 6/9] platform/x86: asus-armoury: add screen auto-brightness toggle Denis Benato
2025-10-15 1:47 ` [PATCH v14 7/9] platform/x86: asus-wmi: deprecate bios features Denis Benato
2025-10-17 12:54 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT Denis Benato
2025-10-17 12:59 ` Ilpo Järvinen
2025-10-15 1:47 ` [PATCH v14 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs Denis Benato
2025-10-17 13:09 ` Ilpo Järvinen
2025-10-15 5:13 ` [PATCH v14 0/9] platform/x86: Add asus-armoury driver Mario Limonciello
2025-10-15 9:38 ` Ilpo Järvinen
2025-10-15 12:00 ` Denis Benato
2025-10-15 12:06 ` Ilpo Järvinen
2025-10-15 12:27 ` Denis Benato
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox