[PATCH v17 0/9] platform/x86: Add asus-armoury driver

[PATCH v17 0/9] platform/x86: Add asus-armoury driver

[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
- v15
  - platform/x86: asus-wmi: export symbols used for read/write WMI
    - fix kernel doc
  - platform/x86: asus-armoury: move existing tunings to asus-armoury module
    - avoid direct calls to asus-wmi and provide helpers instead
    - rework xg mobile activation logic
    - add helper for enum allowed attributes
    - improve mini_led_mode_current_value_store
    - improved usage of kstrtouint, kstrtou32 and kstrtobool
    - unload attributes in reverse order of loading
  - platform/x86: asus-armoury: add apu-mem control support
    - fix return value in apu_mem_current_value_show
  - platform/x86: asus-armoury: add core count control
    - put more safeguards in place against possible bricking of laptops
    - improve loading logic
  - platform/x86: asus-wmi: deprecate bios features
    - modified deprecation message
  - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
    - make _store(s) to interfaces unusable in DC to fail,
      instead of accepting 0 as a value (0 is also invalid)
    - make it easier to understand AC vs DC logic
    - improved init_rog_tunables() logic
    - commas after every field in the table for consistency
    - add support for RC73 handheld
-v16
  - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
    - add support for GU605CX
-v17
  - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
    - fix RC73 -> RC73AX as another RC73 exists
  - platform/x86: asus-armoury: add core count control
    - be more tolerant on out-or-range current CPU cores count
  - platform/x86: asus-armoury: move existing tunings to asus-armoury module
    - fix usage of undeclared static functions in macros

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           | 1441 ++++++++++++++++
 drivers/platform/x86/asus-armoury.h           | 1495 +++++++++++++++++
 drivers/platform/x86/asus-wmi.c               |  177 +-
 .../platform_data/x86/asus-wmi-leds-ids.h     |   50 +
 include/linux/platform_data/x86/asus-wmi.h    |   63 +-
 9 files changed, 3192 insertions(+), 76 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.2

[PATCH v17 1/9] platform/x86: asus-wmi: export symbols used for read/write WMI

[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.

Co-developed-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.com>
---
 drivers/platform/x86/asus-wmi.c            | 46 ++++++++++++++++++++--
 include/linux/platform_data/x86/asus-wmi.h |  5 +++
 2 files changed, 48 insertions(+), 3 deletions(-)

diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index e72a2b5d158e..c3e90517ce0f 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,52 @@ 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.
+ *
+ * Returns:
+ * * %-ENODEV	- method ID is unsupported.
+ * * %0			- successful and retval is filled.
+ * * %other		- 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_DSTS_PRESENCE_BIT) == 0x00)
+		return -ENODEV;
+
+	return 0;
+}
+EXPORT_SYMBOL_NS_GPL(asus_wmi_get_devstate_dsts, "ASUS_WMI");
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ *
+ * Note: an asus_wmi_set_devstate() call must be paired with a
+ * asus_wmi_get_devstate_dsts() to check if the WMI function is supported.
+ *
+ * @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.
+ *
+ * Returns:
+ * * %-ENODEV	- method ID is unsupported.
+ * * %0			- successful and retval is filled.
+ * * %other		- error from WMI call.
+ */
+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.2

[PATCH v17 2/9] platform/x86: asus-armoury: move existing tunings to asus-armoury module

[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.

Co-developed-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
---
 drivers/hid/hid-asus.c                        |   1 +
 drivers/platform/x86/Kconfig                  |  12 +
 drivers/platform/x86/Makefile                 |   1 +
 drivers/platform/x86/asus-armoury.c           | 763 ++++++++++++++++++
 drivers/platform/x86/asus-armoury.h           | 200 +++++
 drivers/platform/x86/asus-wmi.c               |  10 +-
 .../platform_data/x86/asus-wmi-leds-ids.h     |  50 ++
 include/linux/platform_data/x86/asus-wmi.h    |  44 +-
 8 files changed, 1034 insertions(+), 47 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 c122016d82f1..06ea761be25f 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..8294fc8dcdd0
--- /dev/null
+++ b/drivers/platform/x86/asus-armoury.c
@@ -0,0 +1,763 @@
+// 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/err.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/kmod.h>
+#include <linux/kobject.h>
+#include <linux/kstrtox.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/pci.h>
+#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/printk.h>
+#include <linux/sysfs.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   GENMASK(1, 0)
+/* 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
+
+struct asus_armoury_priv {
+	struct device *fw_attr_dev;
+	struct kset *fw_attr_kset;
+
+	/*
+	 * Mutex to protect eGPU activation/deactivation
+	 * sequences and dGPU connection status:
+	 * do not allow concurrent changes or changes
+	 * before a reboot if dGPU got disabled.
+	 */
+	struct mutex egpu_mutex;
+
+	u32 mini_led_dev_id;
+	u32 gpu_mux_dev_id;
+};
+
+static struct asus_armoury_priv asus_armoury = {
+	.egpu_mutex = __MUTEX_INITIALIZER(asus_armoury.egpu_mutex),
+};
+
+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 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");
+}
+
+/**
+ * armoury_has_devstate() - Check presence of the WMI function state.
+ *
+ * @dev_id: The WMI method ID to check for presence.
+ *
+ * Returns: true iif method is supported.
+ */
+static bool armoury_has_devstate(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);
+}
+
+/**
+ * armoury_get_devstate() - Get the WMI function state.
+ * @attr: NULL or the kobj_attribute associated to called WMI function.
+ * @dev_id: The WMI method ID to call.
+ * @retval:
+ * * non-NULL pointer to where to store the value returned from WMI
+ * * with the function presence bit cleared.
+ *
+ * Intended usage is from sysfs attribute checking associated WMI function.
+ *
+ * Returns:
+ * * %-ENODEV	- method ID is unsupported.
+ * * %0		- successful and retval is filled.
+ * * %other	- error from WMI call.
+ */
+static int armoury_get_devstate(struct kobj_attribute *attr, u32 *retval, u32 dev_id)
+{
+	int err;
+
+	err = asus_wmi_get_devstate_dsts(dev_id, retval);
+	if (err) {
+		if (attr)
+			pr_err("Failed to get %s: %d\n", attr->attr.name, err);
+		else
+			pr_err("Failed to get devstate for 0x%x: %d\n", dev_id, err);
+
+		return err;
+	}
+
+	/*
+	 * asus_wmi_get_devstate_dsts will populate retval with WMI return, but
+	 * the true value is expressed when ASUS_WMI_DSTS_PRESENCE_BIT is clear.
+	 */
+	*retval &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+
+	return 0;
+}
+
+/**
+ * armoury_set_devstate() - Set the WMI function state.
+ * @attr: The kobj_attribute associated to called WMI function.
+ * @dev_id: The WMI method ID to call.
+ * @value: The new value to be set.
+ * @retval: Where to store the value returned from WMI or NULL.
+ *
+ * Intended usage is from sysfs attribute setting associated WMI function.
+ * Before calling the presence of the function should be checked.
+ *
+ * Every WMI write MUST go through this function to enforce safety checks.
+ *
+ * Results !1 is usually considered a fail by ASUS, but some WMI methods
+ * (like eGPU or CPU cores) do use > 1 to return a status code or similar:
+ * in these cases caller is interested in the actual return value
+ * and should perform relevant checks.
+ *
+ * Returns:
+ * * %-EIO	- WMI function returned an error.
+ * * %0		- successful and retval is filled.
+ * * %other	- error from WMI call.
+ */
+static int armoury_set_devstate(struct kobj_attribute *attr,
+				     u32 value, u32 *retval, u32 dev_id)
+{
+	u32 result;
+	int err;
+
+	err = asus_wmi_set_devstate(dev_id, value, retval ? retval : &result);
+	if (err) {
+		if (attr)
+			pr_err("Failed to set %s: %d\n", attr->attr.name, err);
+		else
+			pr_err("Failed to set devstate for 0x%x: %d\n", dev_id, err);
+
+		return err;
+	}
+
+	/*
+	 * If retval == NULL caller is uninterested in return value:
+	 * perform the most common result check here.
+	 */
+	if ((retval == NULL) && (result == 0)) {
+		pr_err("Failed to set %s: (result): 0x%x\n", attr->attr.name, result);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int armoury_attr_enum_list(char *buf, size_t enum_values)
+{
+	size_t i;
+	int len = 0;
+
+	for (i = 0; i < enum_values; i++) {
+		if (i == 0)
+			len += sysfs_emit_at(buf, len, "%zu", i);
+		else
+			len += sysfs_emit_at(buf, len, ";%zu", i);
+	}
+	len += sysfs_emit_at(buf, len, "\n");
+
+	return len;
+}
+
+ssize_t armoury_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 = kstrtou32(buf, 10, &value);
+	if (err)
+		return err;
+
+	if (value < min || value > max)
+		return -EINVAL;
+
+	err = armoury_set_devstate(attr, value, NULL, 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;
+}
+
+ssize_t armoury_attr_uint_show(struct kobject *kobj, struct kobj_attribute *attr,
+				char *buf, u32 wmi_dev)
+{
+	u32 result;
+	int err;
+
+	err = armoury_get_devstate(attr, &result, wmi_dev);
+	if (err)
+		return err;
+
+	return sysfs_emit(buf, "%u\n", result);
+}
+
+static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
+			      char *buf)
+{
+	return sysfs_emit(buf, "enumeration\n");
+}
+
+/* Mini-LED mode **************************************************************/
+
+/* Values map for mini-led modes on 2023 and earlier models. */
+static u32 mini_led_mode1_map[] = {
+	[0] = ASUS_MINI_LED_OFF,
+	[1] = ASUS_MINI_LED_ON,
+};
+
+/* Values map for mini-led modes on 2024 and later models. */
+static u32 mini_led_mode2_map[] = {
+	[0] = ASUS_MINI_LED_2024_OFF,
+	[1] = ASUS_MINI_LED_2024_WEAK,
+	[2] = ASUS_MINI_LED_2024_STRONG,
+};
+
+static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,
+						struct kobj_attribute *attr, char *buf)
+{
+	u32 *mini_led_mode_map;
+	size_t mini_led_mode_map_size;
+	u32 i, mode;
+	int err;
+
+	switch (asus_armoury.mini_led_dev_id) {
+	case ASUS_WMI_DEVID_MINI_LED_MODE:
+		mini_led_mode_map = mini_led_mode1_map;
+		mini_led_mode_map_size = ARRAY_SIZE(mini_led_mode1_map);
+		break;
+
+	case ASUS_WMI_DEVID_MINI_LED_MODE2:
+		mini_led_mode_map = mini_led_mode2_map;
+		mini_led_mode_map_size = ARRAY_SIZE(mini_led_mode2_map);
+		break;
+
+	default:
+		pr_err("Unrecognized mini-LED device: %u\n", asus_armoury.mini_led_dev_id);
+		return -ENODEV;
+	}
+
+	err = armoury_get_devstate(attr, &mode, asus_armoury.mini_led_dev_id);
+	if (err)
+		return err;
+
+	mode = FIELD_GET(ASUS_MINI_LED_MODE_MASK, 0);
+
+	for (i = 0; i < mini_led_mode_map_size; i++)
+		return sysfs_emit(buf, "%u\n", mini_led_mode_map[i]);
+
+	pr_warn("Unrecognized mini-LED mode: %u", mode);
+	return -EINVAL;
+}
+
+static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
+						 struct kobj_attribute *attr,
+						 const char *buf, size_t count)
+{
+	u32 *mini_led_mode_map;
+	size_t mini_led_mode_map_size;
+	u32 mode;
+	int err;
+
+	err = kstrtou32(buf, 10, &mode);
+	if (err)
+		return err;
+
+	switch (asus_armoury.mini_led_dev_id) {
+	case ASUS_WMI_DEVID_MINI_LED_MODE:
+		mini_led_mode_map = mini_led_mode1_map;
+		mini_led_mode_map_size = ARRAY_SIZE(mini_led_mode1_map);
+		break;
+
+	case ASUS_WMI_DEVID_MINI_LED_MODE2:
+		mini_led_mode_map = mini_led_mode2_map;
+		mini_led_mode_map_size = ARRAY_SIZE(mini_led_mode2_map);
+		break;
+
+	default:
+		pr_err("Unrecognized mini-LED devid: %u\n", asus_armoury.mini_led_dev_id);
+		return -EINVAL;
+	}
+
+	if (mode >= mini_led_mode_map_size) {
+		return pr_warn("mini-LED mode unrecognized device: %u\n", mode);
+		return -ENODEV;
+	}
+
+	return armoury_attr_uint_store(kobj, attr, buf, count,
+				       0, mini_led_mode_map[mode],
+				       NULL, asus_armoury.mini_led_dev_id);
+}
+
+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 armoury_attr_enum_list(buf, ARRAY_SIZE(mini_led_mode1_map));
+	case ASUS_WMI_DEVID_MINI_LED_MODE2:
+		return armoury_attr_enum_list(buf, ARRAY_SIZE(mini_led_mode2_map));
+	default:
+		return -ENODEV;
+	}
+}
+ASUS_ATTR_GROUP_ENUM(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;
+	bool optimus;
+
+	err = kstrtobool(buf, &optimus);
+	if (err)
+		return err;
+
+	if (armoury_has_devstate(ASUS_WMI_DEVID_DGPU)) {
+		err = armoury_get_devstate(NULL, &result, ASUS_WMI_DEVID_DGPU);
+		if (err)
+			return err;
+		if (result && !optimus) {
+			pr_warn("Cannot switch MUX to dGPU mode when dGPU is disabled: %02X\n",
+				result);
+			return -ENODEV;
+		}
+	}
+
+	if (armoury_has_devstate(ASUS_WMI_DEVID_EGPU)) {
+		err = armoury_get_devstate(NULL, &result, ASUS_WMI_DEVID_EGPU);
+		if (err)
+			return err;
+		if (result && !optimus) {
+			pr_warn("Cannot switch MUX to dGPU mode when eGPU is enabled\n");
+			return -EBUSY;
+		}
+	}
+
+	err = armoury_set_devstate(attr, optimus ? 1 : 0, NULL, 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;
+}
+ASUS_WMI_SHOW_INT(gpu_mux_mode_current_value, "%u\n", asus_armoury.gpu_mux_dev_id);
+ASUS_ATTR_GROUP_BOOL(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
+
+static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
+						struct kobj_attribute *attr, const char *buf,
+						size_t count)
+{
+	int result, err;
+	bool disable;
+
+	err = kstrtobool(buf, &disable);
+	if (err)
+		return err;
+
+	if (asus_armoury.gpu_mux_dev_id) {
+		err = armoury_get_devstate(NULL, &result, asus_armoury.gpu_mux_dev_id);
+		if (err)
+			return err;
+		if (!result && disable) {
+			pr_warn("Cannot disable dGPU when the MUX is in dGPU mode\n");
+			return -EBUSY;
+		}
+	}
+
+	scoped_guard(mutex, &asus_armoury.egpu_mutex) {
+		err = armoury_set_devstate(attr, disable ? 1 : 0, NULL, ASUS_WMI_DEVID_DGPU);
+		if (err)
+			return err;
+	}
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+ASUS_WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
+ASUS_ATTR_GROUP_BOOL(dgpu_disable, "dgpu_disable", "Disable the dGPU");
+
+/* Values map for eGPU activation requests. */
+static u32 egpu_status_map[] = {
+	[0] = 0x00000000U,
+	[1] = 0x00000001U,
+	[2] = 0x00000101U,
+	[3] = 0x00000201U,
+};
+
+/*
+ * armoury_pci_rescan() - Performs a PCI rescan
+ *
+ * Bring up any GPU that has been hotplugged in the system.
+ */
+static void armoury_pci_rescan(void)
+{
+	struct pci_bus *b = NULL;
+
+	pci_lock_rescan_remove();
+	while ((b = pci_find_next_bus(b)) != NULL)
+		pci_rescan_bus(b);
+	pci_unlock_rescan_remove();
+}
+
+/*
+ * The ACPI call to enable the eGPU might also disable the internal dGPU,
+ * but this is not always the case and on certain models enabling the eGPU
+ * when the dGPU is either still active or has been disabled without rebooting
+ * will make both GPUs malfunction and the kernel will detect many
+ * PCI AER unrecoverable errors.
+ */
+static ssize_t egpu_enable_current_value_store(struct kobject *kobj, struct kobj_attribute *attr,
+							const char *buf, size_t count)
+{
+	int err;
+	u32 requested, enable, result;
+
+	err = kstrtou32(buf, 10, &requested);
+	if (err)
+		return err;
+
+	if (requested >= ARRAY_SIZE(egpu_status_map))
+		return -EINVAL;
+	enable = egpu_status_map[requested];
+
+	scoped_guard(mutex, &asus_armoury.egpu_mutex) {
+		/* Ensure the eGPU is connected before attempting to activate it. */
+		if (enable) {
+			err = armoury_get_devstate(NULL, &result, ASUS_WMI_DEVID_EGPU_CONNECTED);
+			if (err) {
+				pr_warn("Failed to get eGPU connection status: %d\n", err);
+				return err;
+			}
+			if (!result) {
+				pr_warn("Cannot activate eGPU while undetected\n");
+				return -ENOENT;
+			}
+		}
+
+		if (asus_armoury.gpu_mux_dev_id) {
+			err = armoury_get_devstate(NULL, &result, asus_armoury.gpu_mux_dev_id);
+			if (err)
+				return err;
+
+			if (!result && enable) {
+				pr_warn("Cannot enable eGPU when the MUX is in dGPU mode\n");
+				return -ENODEV;
+			}
+		}
+
+		err = armoury_set_devstate(attr, enable, &result, ASUS_WMI_DEVID_EGPU);
+		if (err) {
+			pr_err("Failed to set %s: %d\n", attr->attr.name, err);
+			return err;
+		}
+
+		/*
+		 * ACPI returns value 0x01 on success and 0x02 on a partial activation:
+		 * performing a pci rescan will bring up the device in pci-e 3.0 speed,
+		 * after a reboot the device will work at full speed.
+		 */
+		switch (result) {
+		case 0x01:
+			/*
+			 * When a GPU is in use it does not get disconnected even if
+			 * the ACPI call returns a success.
+			 */
+			if (!enable) {
+				err = armoury_get_devstate(attr, &result, ASUS_WMI_DEVID_EGPU);
+				if (err) {
+					pr_warn("Failed to ensure eGPU is deactivated: %d\n", err);
+					return err;
+				}
+
+				if (result != 0)
+					return -EBUSY;
+			}
+
+			pr_debug("Success changing the eGPU status\n");
+			break;
+		case 0x02:
+			pr_info("Success changing the eGPU status, a reboot is strongly advised\n");
+			asus_set_reboot_and_signal_event();
+			break;
+		default:
+			pr_err("Failed to change the eGPU status: wmi result is 0x%x\n", result);
+			return -EIO;
+		}
+	}
+
+	/*
+	 * Perform a PCI rescan: on every tested model this is necessary
+	 * to make the eGPU visible on the bus without rebooting.
+	 */
+	armoury_pci_rescan();
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+
+static ssize_t egpu_enable_current_value_show(struct kobject *kobj, struct kobj_attribute *attr,
+						char *buf)
+{
+	int i, err;
+	u32 status;
+
+	scoped_guard(mutex, &asus_armoury.egpu_mutex) {
+		err = armoury_get_devstate(attr, &status, ASUS_WMI_DEVID_EGPU);
+		if (err)
+			return err;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(egpu_status_map); i++) {
+		if (egpu_status_map[i] == status)
+			return sysfs_emit(buf, "%u\n", i);
+	}
+
+	return -EIO;
+}
+
+static ssize_t egpu_enable_possible_values_show(struct kobject *kobj, struct kobj_attribute *attr,
+						char *buf)
+{
+	return armoury_attr_enum_list(buf, ARRAY_SIZE(egpu_status_map));
+}
+ASUS_ATTR_GROUP_ENUM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
+
+/* Simple attribute creation */
+ASUS_ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2\n",
+			    "Show the current mode of charging");
+ASUS_ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
+			"Set the boot POST sound");
+ASUS_ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
+			"Set MCU powersaving mode");
+ASUS_ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
+			"Set the panel refresh overdrive");
+ASUS_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 (armoury_has_devstate(ASUS_WMI_DEVID_MINI_LED_MODE))
+		asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
+	else if (armoury_has_devstate(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 (armoury_has_devstate(ASUS_WMI_DEVID_GPU_MUX))
+		asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
+	else if (armoury_has_devstate(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 (!armoury_has_devstate(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 (armoury_has_devstate(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)
+{
+	int i;
+
+	for (i = ARRAY_SIZE(armoury_attr_groups) - 1; i >= 0; i--) {
+		if (armoury_has_devstate(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);
+
+	if (asus_armoury.mini_led_dev_id)
+		sysfs_remove_group(&asus_armoury.fw_attr_kset->kobj, &mini_led_mode_attr_group);
+
+	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..05d484d32244
--- /dev/null
+++ b/drivers/platform/x86/asus-armoury.h
@@ -0,0 +1,200 @@
+/* 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/sysfs.h>
+#include <linux/types.h>
+#include <linux/platform_device.h>
+
+#define DRIVER_NAME "asus-armoury"
+
+/**
+ * armoury_attr_uint_store() - Send an uint to WMI method if within min/max.
+ * @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.
+ *
+ * Integers to be sent to the WMI method is inclusive 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.
+ */
+ssize_t armoury_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);
+
+/**
+ * armoury_attr_uint_show() - Receive an uint from a WMI method.
+ * @kobj: Pointer to the driver object.
+ * @attr: Pointer to the attribute calling this function.
+ * @buf: The buffer to write to, as an `uint` type.
+ * @wmi_dev: The WMI function ID to use.
+ *
+ * This function is intended to be generic so it can be called from any "_show"
+ * attribute which works only with integers.
+ *
+ * Returns: Either count, or an error.
+ */
+ssize_t armoury_attr_uint_show(struct kobject *kobj, struct kobj_attribute *attr,
+				char *buf, u32 wmi_dev);
+
+#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 armoury_attr_uint_store(kobj, attr, buf, count, _min,	\
+					_max, NULL, _wmi);			\
+	}
+
+#define ASUS_WMI_SHOW_INT(_attr, _fmt, _wmi)					\
+	static ssize_t _attr##_show(struct kobject *kobj,			\
+				    struct kobj_attribute *attr, char *buf)	\
+	{									\
+		return armoury_attr_uint_show(kobj, attr, buf, _wmi);		\
+	}
+
+/* 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)\
+	ASUS_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);	\
+	ASUS_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 ASUS_ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname)	\
+	__ATTR_RO_INT_GROUP_ENUM(_attrname, _wmi, _fsname, "0;1", _dispname)
+
+
+#define ASUS_ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname)	\
+	__ATTR_RW_INT_GROUP_ENUM(_attrname, 0, 1, _wmi, _fsname, "0;1", _dispname)
+
+#define ASUS_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 ASUS_ATTR_GROUP_BOOL(_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 ASUS_ATTR_GROUP_ENUM(_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 c3e90517ce0f..ff98267e5981 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -15,6 +15,7 @@
 
 #include <linux/acpi.h>
 #include <linux/backlight.h>
+#include <linux/bits.h>
 #include <linux/debugfs.h>
 #include <linux/delay.h>
 #include <linux/dmi.h>
@@ -30,6 +31,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 +57,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 +105,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
@@ -561,8 +559,8 @@ static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
  *
  * Returns:
  * * %-ENODEV	- method ID is unsupported.
- * * %0			- successful and retval is filled.
- * * %other		- error from WMI call.
+ * * %0		- successful and retval is filled.
+ * * %other	- error from WMI call.
  */
 int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
 {
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..8ea8925a0fc5 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -4,7 +4,9 @@
 
 #include <linux/errno.h>
 #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 */
@@ -191,44 +193,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.2

[PATCH v17 3/9] platform/x86: asus-armoury: add panel_hd_mode attribute

[Denis Benato]

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: Denis Benato <denis.benato@linux.dev>
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 8294fc8dcdd0..a6b86968fa37 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -96,7 +96,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");
 }
 
 /**
@@ -607,6 +608,8 @@ ASUS_ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWER
 			"Set MCU powersaving mode");
 ASUS_ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
 			"Set the panel refresh overdrive");
+ASUS_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>");
 ASUS_ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
 			"Show the eGPU connection status");
 
@@ -620,6 +623,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 8ea8925a0fc5..3cc235b20be4 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -75,6 +75,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.2

[PATCH v17 4/9] platform/x86: asus-armoury: add apu-mem control support

[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.

Co-developed-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
---
 drivers/platform/x86/asus-armoury.c        | 98 ++++++++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |  2 +
 2 files changed, 100 insertions(+)

diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index a6b86968fa37..75fead6091cb 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -174,6 +174,7 @@ static int armoury_get_devstate(struct kobj_attribute *attr, u32 *retval, u32 de
  * and should perform relevant checks.
  *
  * Returns:
+ * * %-EINVAL	- attempt to set a dangerous or unsupported value.
  * * %-EIO	- WMI function returned an error.
  * * %0		- successful and retval is filled.
  * * %other	- error from WMI call.
@@ -184,6 +185,26 @@ static int armoury_set_devstate(struct kobj_attribute *attr,
 	u32 result;
 	int err;
 
+	/*
+	 * Prevent developers from bricking devices or issuing dangerous
+	 * commands that can be difficult or impossible to recover from.
+	 */
+	switch (dev_id) {
+	case ASUS_WMI_DEVID_APU_MEM:
+		/*
+		 * A hard reset might suffice to save the device,
+		 * but there is no value in sending these commands.
+		 */
+		if (value == 0x100 || value == 0x101) {
+			pr_err("Refusing to set APU memory to unsafe value: 0x%x\n", value);
+			return -EINVAL;
+		}
+		break;
+	default:
+		/* No known problems are known for this dev_id */
+		break;
+	}
+
 	err = asus_wmi_set_devstate(dev_id, value, retval ? retval : &result);
 	if (err) {
 		if (attr)
@@ -599,6 +620,82 @@ static ssize_t egpu_enable_possible_values_show(struct kobject *kobj, struct kob
 }
 ASUS_ATTR_GROUP_ENUM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
 
+/* Device memory available to APU */
+
+/*
+ * Values map for APU reserved memory (index + 1 number of GB).
+ * 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 = armoury_get_devstate(attr, &mem, ASUS_WMI_DEVID_APU_MEM);
+	if (err)
+		return err;
+
+	/* 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 -EIO;
+}
+
+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 = armoury_set_devstate(attr, mem, NULL, ASUS_WMI_DEVID_APU_MEM);
+	if (err) {
+		pr_warn("Failed to set apu_mem 0x%x: %d\n", mem, 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)
+{
+	return armoury_attr_enum_list(buf, ARRAY_SIZE(apu_mem_map));
+}
+ASUS_ATTR_GROUP_ENUM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
+
 /* Simple attribute creation */
 ASUS_ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2\n",
 			    "Show the current mode of charging");
@@ -618,6 +715,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 3cc235b20be4..9a6433d08973 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -136,6 +136,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.2

[PATCH v17 5/9] platform/x86: asus-armoury: add core count control

[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.

Co-developed-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
---
 drivers/platform/x86/asus-armoury.c        | 288 +++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        |  28 ++
 include/linux/platform_data/x86/asus-wmi.h |   5 +
 3 files changed, 321 insertions(+)

diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index 75fead6091cb..161700207435 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -48,6 +48,36 @@
 #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,
+};
+
+/* Minimum number of performance cores (P-cores) */
+#define CPU_PERF_CORE_COUNT_MIN 4
+/* Minimum number of efficiency cores (E-cores) */
+#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;
+};
+
 struct asus_armoury_priv {
 	struct device *fw_attr_dev;
 	struct kset *fw_attr_kset;
@@ -60,12 +90,22 @@ struct asus_armoury_priv {
 	 */
 	struct mutex egpu_mutex;
 
+	/*
+	 * 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;
+	struct cpu_cores *cpu_cores;
+	bool cpu_cores_changeable;
+
 	u32 mini_led_dev_id;
 	u32 gpu_mux_dev_id;
 };
 
 static struct asus_armoury_priv asus_armoury = {
 	.egpu_mutex = __MUTEX_INITIALIZER(asus_armoury.egpu_mutex),
+
+	.cpu_core_mutex = __MUTEX_INITIALIZER(asus_armoury.cpu_core_mutex),
 };
 
 struct fw_attrs_group {
@@ -97,6 +137,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");
 }
 
@@ -200,6 +242,18 @@ static int armoury_set_devstate(struct kobj_attribute *attr,
 			return -EINVAL;
 		}
 		break;
+	case ASUS_WMI_DEVID_CORES:
+		/*
+		 * Prevent risk disabling cores essential for booting the system
+		 * up to a point where system settings can be reset:
+		 * this has already caused unrecoverable bricks in the past.
+		 */
+		if ((FIELD_GET(ASUS_POWER_CORE_MASK, value) < CPU_POWR_CORE_COUNT_MIN) ||
+		    (FIELD_GET(ASUS_PERF_CORE_MASK, value) < CPU_PERF_CORE_COUNT_MIN)) {
+			pr_err("Refusing to set CPU cores to unsafe value: 0x%x\n", value);
+			return -EINVAL;
+		}
+		break;
 	default:
 		/* No known problems are known for this dev_id */
 		break;
@@ -290,6 +344,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 **************************************************************/
 
 /* Values map for mini-led modes on 2023 and earlier models. */
@@ -696,6 +756,217 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj, struct kobj_at
 }
 ASUS_ATTR_GROUP_ENUM(apu_mem, "apu_mem", "Set available system RAM (in GB) for the APU to use");
 
+static struct cpu_cores *init_cpu_cores_ctrl(void)
+{
+	u32 cores;
+	int err;
+	struct cpu_cores *cores_p __free(kfree) = NULL;
+
+	cores_p = kzalloc(sizeof(struct cpu_cores), GFP_KERNEL);
+	if (!cores_p)
+		return ERR_PTR(-ENOMEM);
+
+	err = armoury_get_devstate(NULL, &cores, ASUS_WMI_DEVID_CORES_MAX);
+	if (err) {
+		pr_err("ACPI does not support CPU core count control\n");
+		return ERR_PTR(-ENODEV);
+	}
+
+	cores_p->max_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
+	cores_p->max_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
+
+	err = armoury_get_devstate(NULL, &cores, ASUS_WMI_DEVID_CORES);
+	if (err) {
+		pr_err("Could not get CPU core count: error %d\n", err);
+		return ERR_PTR(-EIO);
+	}
+
+	cores_p->cur_power_cores = FIELD_GET(ASUS_POWER_CORE_MASK, cores);
+	cores_p->cur_perf_cores = FIELD_GET(ASUS_PERF_CORE_MASK, cores);
+
+	cores_p->min_power_cores = CPU_POWR_CORE_COUNT_MIN;
+	cores_p->min_perf_cores = CPU_PERF_CORE_COUNT_MIN;
+
+	if ((cores_p->min_perf_cores > cores_p->max_perf_cores) ||
+	    (cores_p->min_power_cores > cores_p->max_power_cores)
+	) {
+		pr_err("Invalid CPU cores count detected: interface is not safe to be used.\n");
+		return ERR_PTR(-EINVAL);
+	}
+
+	if ((cores_p->cur_perf_cores > cores_p->max_perf_cores) ||
+		(cores_p->cur_power_cores > cores_p->max_power_cores) ||
+		(cores_p->cur_perf_cores < cores_p->min_perf_cores) ||
+		(cores_p->cur_power_cores < cores_p->min_power_cores)
+	) {
+		pr_warn("Current CPU cores count are outside safe limits.\n");
+	}
+
+	return no_free_ptr(cores_p);
+}
+
+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 cpu_core_value;
+
+	switch (core_value) {
+	case CPU_CORE_DEFAULT:
+	case CPU_CORE_MAX:
+		cpu_core_value = (core_type == CPU_CORE_PERF) ?
+			asus_armoury.cpu_cores->max_perf_cores :
+			asus_armoury.cpu_cores->max_power_cores;
+		break;
+	case CPU_CORE_MIN:
+		cpu_core_value = (core_type == CPU_CORE_PERF) ?
+			asus_armoury.cpu_cores->min_perf_cores :
+			asus_armoury.cpu_cores->min_power_cores;
+		break;
+	case CPU_CORE_CURRENT:
+		cpu_core_value = (core_type == CPU_CORE_PERF) ?
+			asus_armoury.cpu_cores->cur_perf_cores :
+			asus_armoury.cpu_cores->cur_power_cores;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return sysfs_emit(buf, "%u\n", cpu_core_value);
+}
+
+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, result;
+	int err;
+
+	result = kstrtou32(buf, 10, &new_cores);
+	if (result)
+		return result;
+
+	scoped_guard(mutex, &asus_armoury.cpu_core_mutex) {
+		if (!asus_armoury.cpu_cores_changeable) {
+			pr_warn("CPU core count change not allowed until reboot\n");
+			return -EBUSY;
+		}
+
+		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);
+
+		asus_armoury.cpu_cores_changeable = false;
+		err = armoury_set_devstate(attr, out_val, &result, ASUS_WMI_DEVID_CORES);
+		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;
+}
+ASUS_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;
+}
+ASUS_ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
+		    "Set the max available efficiency cores");
+
 /* Simple attribute creation */
 ASUS_ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2\n",
 			    "Show the current mode of charging");
@@ -716,6 +987,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 },
@@ -819,6 +1092,8 @@ static int asus_fw_attr_add(void)
 static int __init asus_fw_init(void)
 {
 	char *wmi_uid;
+	struct cpu_cores *cpu_cores_ctrl;
+	int err;
 
 	wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
 	if (!wmi_uid)
@@ -831,6 +1106,19 @@ static int __init asus_fw_init(void)
 	if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI))
 		return -ENODEV;
 
+	asus_armoury.cpu_cores_changeable = false;
+	if (armoury_has_devstate(ASUS_WMI_DEVID_CORES_MAX)) {
+		cpu_cores_ctrl = init_cpu_cores_ctrl();
+		if (IS_ERR(cpu_cores_ctrl)) {
+			err = PTR_ERR(cpu_cores_ctrl);
+			pr_err("Could not initialise CPU core control: %d\n", err);
+			return err;
+		}
+
+		asus_armoury.cpu_cores = cpu_cores_ctrl;
+		asus_armoury.cpu_cores_changeable = true;
+	}
+
 	return asus_fw_attr_add();
 }
 
diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
index 05d484d32244..9b5fedc083b0 100644
--- a/drivers/platform/x86/asus-armoury.h
+++ b/drivers/platform/x86/asus-armoury.h
@@ -197,4 +197,32 @@ ssize_t armoury_attr_uint_show(struct kobject *kobj, struct kobj_attribute *attr
 		.name = _fsname, .attrs = _attrname##_attrs			\
 	}
 
+/* CPU core attributes need a little different in setup */
+#define ASUS_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 9a6433d08973..b7ea25986c0d 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -136,6 +136,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.2

[PATCH v17 6/9] platform/x86: asus-armoury: add screen auto-brightness toggle

[Denis Benato]

From: "Luke D. Jones" <luke@ljones.dev>

Add screen_auto_brightness toggle supported on some laptops.

Signed-off-by: Denis Benato <denis.benato@linux.dev>
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 161700207435..b5a9783548a6 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -978,6 +978,9 @@ ASUS_ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
 			"Set the panel refresh overdrive");
 ASUS_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>");
+ASUS_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>");
 ASUS_ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
 			"Show the eGPU connection status");
 
@@ -995,6 +998,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 b7ea25986c0d..a906dfb834ab 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -82,6 +82,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.2

[PATCH v17 7/9] platform/x86: asus-wmi: deprecate bios features

[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: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Luke D. Jones <luke@ljones.dev>
Reviewed-by: Mario Limonciello <mario.limonciello@amd.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..89acb6638df8 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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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: please use asus-armoury
 		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 06ea761be25f..aef7e8a746fa 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 ff98267e5981..6de633d4a748 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -338,6 +338,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,
@@ -730,6 +737,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)
 {
@@ -740,12 +748,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)
 {
@@ -756,6 +768,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);
 }
 
@@ -809,8 +823,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)
 {
@@ -821,6 +837,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);
 }
 
@@ -877,8 +895,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)
 {
@@ -889,12 +909,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)
 {
@@ -905,6 +929,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);
 }
 
@@ -963,6 +989,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,
@@ -1086,6 +1113,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)
@@ -1124,6 +1152,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);
@@ -1166,6 +1196,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);
@@ -1209,6 +1241,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);
@@ -1252,6 +1286,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);
@@ -1295,6 +1331,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);
@@ -1338,6 +1376,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);
@@ -1381,9 +1421,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 ********************************************************/
 
@@ -1424,6 +1467,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)
 {
@@ -1434,6 +1478,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);
 }
 
@@ -1469,6 +1515,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 ********************************************************************/
 
@@ -2342,6 +2389,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)
 {
@@ -2352,6 +2400,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);
 }
 
@@ -2388,9 +2438,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)
 {
@@ -2401,6 +2452,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);
 }
 
@@ -2436,8 +2489,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)
 {
@@ -2468,6 +2523,8 @@ static ssize_t mini_led_mode_show(struct device *dev,
 		}
 	}
 
+	asus_wmi_show_deprecated();
+
 	return sysfs_emit(buf, "%d\n", value);
 }
 
@@ -2538,10 +2595,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 *********************************************************************/
 
@@ -3829,6 +3889,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)
 {
@@ -3872,6 +3933,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,
@@ -4473,27 +4535,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
 };
 
@@ -4515,7 +4579,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;
@@ -4553,6 +4621,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);
@@ -4808,6 +4877,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;
@@ -4830,17 +4900,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.2

[PATCH v17 8/9] platform/x86: asus-wmi: rename ASUS_WMI_DEVID_PPT_FPPT

[Denis Benato]

Maintain power-related WMI macros naming consistency:
rename ASUS_WMI_DEVID_PPT_FPPT to ASUS_WMI_DEVID_PPT_PL3_FPPT.

Link: https://lore.kernel.org/all/cad7b458-5a7a-4975-94a1-d0c74f6f3de5@oracle.com/

Suggested-by: ALOK TIWARI <alok.a.tiwari@oracle.com>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
---
 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 6de633d4a748..64cfc0bf98dd 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -1218,7 +1218,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;
@@ -4602,7 +4602,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 a906dfb834ab..2bda18bc4103 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -107,7 +107,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.2

[PATCH v17 9/9] platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs

[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.

Co-developed-by: Denis Benato <denis.benato@linux.dev>
Signed-off-by: Denis Benato <denis.benato@linux.dev>
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        |  296 ++++-
 drivers/platform/x86/asus-armoury.h        | 1267 ++++++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |    3 +
 3 files changed, 1560 insertions(+), 6 deletions(-)

diff --git a/drivers/platform/x86/asus-armoury.c b/drivers/platform/x86/asus-armoury.c
index b5a9783548a6..d57fbb5dc3d3 100644
--- a/drivers/platform/x86/asus-armoury.c
+++ b/drivers/platform/x86/asus-armoury.c
@@ -30,6 +30,7 @@
 #include <linux/pci.h>
 #include <linux/platform_data/x86/asus-wmi.h>
 #include <linux/printk.h>
+#include <linux/power_supply.h>
 #include <linux/sysfs.h>
 
 #include "asus-armoury.h"
@@ -48,9 +49,23 @@
 #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)
 
+#define ASUS_ROG_TUNABLE_DC 0
+#define ASUS_ROG_TUNABLE_AC 1
+
 enum cpu_core_type {
 	CPU_CORE_PERF = 0,
 	CPU_CORE_POWER,
@@ -78,6 +93,19 @@ 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;
+};
+
 struct asus_armoury_priv {
 	struct device *fw_attr_dev;
 	struct kset *fw_attr_kset;
@@ -98,6 +126,9 @@ struct asus_armoury_priv {
 	struct cpu_cores *cpu_cores;
 	bool cpu_cores_changeable;
 
+	/* Index 0 for DC, 1 for AC */
+	struct rog_tunables *rog_tunables[2];
+
 	u32 mini_led_dev_id;
 	u32 gpu_mux_dev_id;
 };
@@ -928,6 +959,15 @@ static ssize_t cores_performance_current_value_store(struct kobject *kobj,
 ASUS_ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
 			 "Set the max available performance cores");
 
+/* Define helper to access the current power mode tunable values */
+static inline struct rog_tunables *get_current_tunables(void)
+{
+	if (power_supply_is_system_supplied())
+		return asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_AC];
+
+	return asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC];
+}
+
 static ssize_t cores_efficiency_min_value_show(struct kobject *kobj, struct kobj_attribute *attr,
 					       char *buf)
 {
@@ -983,6 +1023,24 @@ ASUS_ATTR_GROUP_BOOL_RW(screen_auto_brightness, "screen_auto_brightness",
 			"Set the panel brightness to Off<0> or On<1>");
 ASUS_ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
 			"Show the eGPU connection status");
+ASUS_ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, ATTR_PPT_PL1_SPL, ASUS_WMI_DEVID_PPT_PL1_SPL,
+			    "Set the CPU slow package limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(ppt_pl2_sppt, ATTR_PPT_PL2_SPPT, ASUS_WMI_DEVID_PPT_PL2_SPPT,
+			    "Set the CPU fast package limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(ppt_pl3_fppt, ATTR_PPT_PL3_FPPT, ASUS_WMI_DEVID_PPT_PL3_FPPT,
+			    "Set the CPU fastest package limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(ppt_apu_sppt, ATTR_PPT_APU_SPPT, ASUS_WMI_DEVID_PPT_APU_SPPT,
+			    "Set the APU package limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(ppt_platform_sppt, ATTR_PPT_PLATFORM_SPPT, ASUS_WMI_DEVID_PPT_PLAT_SPPT,
+			    "Set the platform package limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, ATTR_NV_DYNAMIC_BOOST, ASUS_WMI_DEVID_NV_DYN_BOOST,
+			    "Set the Nvidia dynamic boost limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(nv_temp_target, ATTR_NV_TEMP_TARGET, ASUS_WMI_DEVID_NV_THERM_TARGET,
+			    "Set the Nvidia max thermal limit");
+ASUS_ATTR_GROUP_ROG_TUNABLE(nv_tgp, "nv_tgp", ASUS_WMI_DEVID_DGPU_SET_TGP,
+			    "Set the additional TGP on top of the base TGP");
+ASUS_ATTR_GROUP_INT_VALUE_ONLY_RO(nv_base_tgp, ATTR_NV_BASE_TGP, ASUS_WMI_DEVID_DGPU_BASE_TGP,
+				  "Read the base TGP value");
 
 /* If an attribute does not require any special case handling add it here */
 static const struct asus_attr_group armoury_attr_groups[] = {
@@ -993,6 +1051,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 },
@@ -1001,8 +1069,76 @@ 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 rog_tunables *const ac_rog_tunables = asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC];
+	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),
@@ -1059,12 +1195,28 @@ static int asus_fw_attr_add(void)
 		if (!armoury_has_devstate(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 (ac_rog_tunables && ac_rog_tunables->power_limits &&
+		    is_power_tunable_attr(name)) {
+			limits = ac_rog_tunables->power_limits;
+			/* Check only AC: if not present then DC 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;
+			}
 		}
 	}
 
@@ -1093,6 +1245,132 @@ 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;
+	struct rog_tunables *ac_rog_tunables = NULL, *dc_rog_tunables = NULL;
+	const struct power_data *power_data;
+	const struct dmi_system_id *dmi_id;
+
+	/* 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) {
+		ac_rog_tunables = kzalloc(sizeof(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_AC]),
+				GFP_KERNEL);
+		if (!ac_rog_tunables)
+			goto err_nomem;
+
+		asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_AC] = ac_rog_tunables;
+		ac_rog_tunables->power_limits = ac_limits;
+
+		/* Set initial AC values */
+		ac_rog_tunables->ppt_pl1_spl =
+			ac_limits->ppt_pl1_spl_def ?
+				ac_limits->ppt_pl1_spl_def :
+				ac_limits->ppt_pl1_spl_max;
+
+		ac_rog_tunables->ppt_pl2_sppt =
+			ac_limits->ppt_pl2_sppt_def ?
+				ac_limits->ppt_pl2_sppt_def :
+				ac_limits->ppt_pl2_sppt_max;
+
+		ac_rog_tunables->ppt_pl3_fppt =
+			ac_limits->ppt_pl3_fppt_def ?
+				ac_limits->ppt_pl3_fppt_def :
+				ac_limits->ppt_pl3_fppt_max;
+
+		ac_rog_tunables->ppt_apu_sppt =
+			ac_limits->ppt_apu_sppt_def ?
+				ac_limits->ppt_apu_sppt_def :
+				ac_limits->ppt_apu_sppt_max;
+
+		ac_rog_tunables->ppt_platform_sppt =
+			ac_limits->ppt_platform_sppt_def ?
+				ac_limits->ppt_platform_sppt_def :
+				ac_limits->ppt_platform_sppt_max;
+
+		ac_rog_tunables->nv_dynamic_boost =
+			ac_limits->nv_dynamic_boost_max;
+		ac_rog_tunables->nv_temp_target =
+			ac_limits->nv_temp_target_max;
+		ac_rog_tunables->nv_tgp = ac_limits->nv_tgp_max;
+
+		pr_debug("AC power limits initialized for %s\n", dmi_id->matches[0].substr);
+	} else {
+		pr_debug("No AC PPT limits defined\n");
+	}
+
+	/* Initialize DC power tunables */
+	dc_limits = power_data->dc_data;
+	if (dc_limits) {
+		dc_rog_tunables = kzalloc(sizeof(*asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC]),
+					  GFP_KERNEL);
+		if (!dc_rog_tunables) {
+			kfree(ac_rog_tunables);
+			goto err_nomem;
+		}
+
+		asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC] = dc_rog_tunables;
+		dc_rog_tunables->power_limits = dc_limits;
+
+		/* Set initial DC values */
+		dc_rog_tunables->ppt_pl1_spl =
+			dc_limits->ppt_pl1_spl_def ?
+				dc_limits->ppt_pl1_spl_def :
+				dc_limits->ppt_pl1_spl_max;
+
+		dc_rog_tunables->ppt_pl2_sppt =
+			dc_limits->ppt_pl2_sppt_def ?
+				dc_limits->ppt_pl2_sppt_def :
+				dc_limits->ppt_pl2_sppt_max;
+
+		dc_rog_tunables->ppt_pl3_fppt =
+			dc_limits->ppt_pl3_fppt_def ?
+				dc_limits->ppt_pl3_fppt_def :
+				dc_limits->ppt_pl3_fppt_max;
+
+		dc_rog_tunables->ppt_apu_sppt =
+			dc_limits->ppt_apu_sppt_def ?
+				dc_limits->ppt_apu_sppt_def :
+				dc_limits->ppt_apu_sppt_max;
+
+		dc_rog_tunables->ppt_platform_sppt =
+			dc_limits->ppt_platform_sppt_def ?
+				dc_limits->ppt_platform_sppt_def :
+				dc_limits->ppt_platform_sppt_max;
+
+		dc_rog_tunables->nv_dynamic_boost =
+			dc_limits->nv_dynamic_boost_max;
+		dc_rog_tunables->nv_temp_target =
+			dc_limits->nv_temp_target_max;
+		dc_rog_tunables->nv_tgp = dc_limits->nv_tgp_max;
+
+		pr_debug("DC power limits initialized for %s\n", dmi_id->matches[0].substr);
+	} else {
+		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;
@@ -1123,6 +1401,9 @@ static int __init asus_fw_init(void)
 		asus_armoury.cpu_cores_changeable = true;
 	}
 
+	init_rog_tunables();
+
+	/* Must always be last step to ensure data is available */
 	return asus_fw_attr_add();
 }
 
@@ -1145,6 +1426,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[ASUS_ROG_TUNABLE_AC]);
+	kfree(asus_armoury.rog_tunables[ASUS_ROG_TUNABLE_DC]);
 }
 
 module_init(asus_fw_init);
diff --git a/drivers/platform/x86/asus-armoury.h b/drivers/platform/x86/asus-armoury.h
index 9b5fedc083b0..24b68990e2ee 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/sysfs.h>
 #include <linux/types.h>
 #include <linux/platform_device.h>
@@ -225,4 +226,1270 @@ ssize_t armoury_attr_uint_show(struct kobject *kobj, struct kobj_attribute *attr
 		.name = _fsname, .attrs = _attrname##_attrs		\
 	}
 
+#define ASUS_ATTR_GROUP_INT_VALUE_ONLY_RO(_attrname, _fsname, _wmi, _dispname)	\
+	ASUS_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;						\
+										\
+		if (tunables->power_limits->_attr##_min ==			\
+		    tunables->power_limits->_attr##_max)			\
+			return -EINVAL;						\
+										\
+		return armoury_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 ASUS_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,
+				.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,
+				.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, "GU605CX"),
+		},
+		.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 = 7,
+				.nv_temp_target_max = 87,
+				.nv_tgp_min = 95,
+				.nv_tgp_def = 100,
+				.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,
+			},
+		},
+	},
+	{
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "RC73XA"),
+		},
+		.driver_data = &(struct power_data) {
+			.ac_data = &(struct power_limits) {
+				.ppt_pl1_spl_min = 7,
+				.ppt_pl1_spl_max = 35,
+				.ppt_pl2_sppt_min = 14,
+				.ppt_pl2_sppt_max = 45,
+				.ppt_pl3_fppt_min = 19,
+				.ppt_pl3_fppt_max = 55,
+			},
+			.dc_data = &(struct power_limits) {
+				.ppt_pl1_spl_min = 7,
+				.ppt_pl1_spl_def = 17,
+				.ppt_pl1_spl_max = 35,
+				.ppt_pl2_sppt_min = 13,
+				.ppt_pl2_sppt_def = 21,
+				.ppt_pl2_sppt_max = 45,
+				.ppt_pl3_fppt_min = 19,
+				.ppt_pl3_fppt_def = 26,
+				.ppt_pl3_fppt_max = 55,
+			},
+		},
+	},
+	{}
+};
+
 #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 2bda18bc4103..51b7ccddbdaf 100644
--- a/include/linux/platform_data/x86/asus-wmi.h
+++ b/include/linux/platform_data/x86/asus-wmi.h
@@ -144,6 +144,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.2

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Ilpo Järvinen]

On Sun, 2 Nov 2025, 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
> 
> 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
> - v15
>   - platform/x86: asus-wmi: export symbols used for read/write WMI
>     - fix kernel doc
>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>     - avoid direct calls to asus-wmi and provide helpers instead
>     - rework xg mobile activation logic
>     - add helper for enum allowed attributes
>     - improve mini_led_mode_current_value_store
>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
>     - unload attributes in reverse order of loading
>   - platform/x86: asus-armoury: add apu-mem control support
>     - fix return value in apu_mem_current_value_show
>   - platform/x86: asus-armoury: add core count control
>     - put more safeguards in place against possible bricking of laptops
>     - improve loading logic
>   - platform/x86: asus-wmi: deprecate bios features
>     - modified deprecation message
>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>     - make _store(s) to interfaces unusable in DC to fail,
>       instead of accepting 0 as a value (0 is also invalid)
>     - make it easier to understand AC vs DC logic
>     - improved init_rog_tunables() logic
>     - commas after every field in the table for consistency
>     - add support for RC73 handheld
> -v16
>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>     - add support for GU605CX
> -v17
>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>     - fix RC73 -> RC73AX as another RC73 exists
>   - platform/x86: asus-armoury: add core count control
>     - be more tolerant on out-or-range current CPU cores count
>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>     - fix usage of undeclared static functions in macros

I've applied this to the review-ilpo-next branch. I'm still not entirely 
happy with how the cpu cores change does store values without arrays but 
it's not an end of the world (and could be fixed in tree).

I had to reorder a few includes to make the order alphabetical which 
luckily worked out without causing conflicts within the subsequent 
patches (and a need to respin the series). Please try to remember to
keep those in the alphabetical order.

-- 
 i.

> 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           | 1441 ++++++++++++++++
>  drivers/platform/x86/asus-armoury.h           | 1495 +++++++++++++++++
>  drivers/platform/x86/asus-wmi.c               |  177 +-
>  .../platform_data/x86/asus-wmi-leds-ids.h     |   50 +
>  include/linux/platform_data/x86/asus-wmi.h    |   63 +-
>  9 files changed, 3192 insertions(+), 76 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
> 
> 

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/10/25 16:17, Ilpo Järvinen wrote:
> On Sun, 2 Nov 2025, 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
>>
>> 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
>> - v15
>>   - platform/x86: asus-wmi: export symbols used for read/write WMI
>>     - fix kernel doc
>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>     - avoid direct calls to asus-wmi and provide helpers instead
>>     - rework xg mobile activation logic
>>     - add helper for enum allowed attributes
>>     - improve mini_led_mode_current_value_store
>>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>     - unload attributes in reverse order of loading
>>   - platform/x86: asus-armoury: add apu-mem control support
>>     - fix return value in apu_mem_current_value_show
>>   - platform/x86: asus-armoury: add core count control
>>     - put more safeguards in place against possible bricking of laptops
>>     - improve loading logic
>>   - platform/x86: asus-wmi: deprecate bios features
>>     - modified deprecation message
>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>     - make _store(s) to interfaces unusable in DC to fail,
>>       instead of accepting 0 as a value (0 is also invalid)
>>     - make it easier to understand AC vs DC logic
>>     - improved init_rog_tunables() logic
>>     - commas after every field in the table for consistency
>>     - add support for RC73 handheld
>> -v16
>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>     - add support for GU605CX
>> -v17
>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>     - fix RC73 -> RC73AX as another RC73 exists
>>   - platform/x86: asus-armoury: add core count control
>>     - be more tolerant on out-or-range current CPU cores count
>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>     - fix usage of undeclared static functions in macros
> I've applied this to the review-ilpo-next branch. I'm still not entirely 
> happy with how the cpu cores change does store values without arrays but 
> it's not an end of the world (and could be fixed in tree).
Hello and thanks.

You would make me very happy applying things as Luke wrote them
so that successive modifications are more easily compared to
what those were doing before I changed them...

Also if you have some more hints on how I could change that
interface (while avoiding bad surprises due to index mismatch)
I will try my best... without destroying any laptop...
perhaps... Hopefully? Wish me luck.

> I had to reorder a few includes to make the order alphabetical which 
> luckily worked out without causing conflicts within the subsequent 
> patches (and a need to respin the series). Please try to remember to
> keep those in the alphabetical order.

I have noticed a pair of warnings in this v17 I would like to solve:
one line is too long, I should break it and one macro has an
unused parameter.

No semantic changes.

I have seen one of those unordered includes in asus-armoury.h...
That branch is public in your git tree: this means I can respin
a v18 from a git format-path, correct?

Is your repo the one in
https://git.kernel.org/pub/scm/linux/kernel/git/ij/linux.git/ ?
I see from the web interface that the last modification was
2 years ago?

Thanks for you patience,
Denis

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Ilpo Järvinen]

[-- Attachment #1: Type: text/plain, Size: 11958 bytes --]

On Mon, 10 Nov 2025, Denis Benato wrote:
> On 11/10/25 16:17, Ilpo Järvinen wrote:
> > On Sun, 2 Nov 2025, 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
> >>
> >> 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
> >> - v15
> >>   - platform/x86: asus-wmi: export symbols used for read/write WMI
> >>     - fix kernel doc
> >>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
> >>     - avoid direct calls to asus-wmi and provide helpers instead
> >>     - rework xg mobile activation logic
> >>     - add helper for enum allowed attributes
> >>     - improve mini_led_mode_current_value_store
> >>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
> >>     - unload attributes in reverse order of loading
> >>   - platform/x86: asus-armoury: add apu-mem control support
> >>     - fix return value in apu_mem_current_value_show
> >>   - platform/x86: asus-armoury: add core count control
> >>     - put more safeguards in place against possible bricking of laptops
> >>     - improve loading logic
> >>   - platform/x86: asus-wmi: deprecate bios features
> >>     - modified deprecation message
> >>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>     - make _store(s) to interfaces unusable in DC to fail,
> >>       instead of accepting 0 as a value (0 is also invalid)
> >>     - make it easier to understand AC vs DC logic
> >>     - improved init_rog_tunables() logic
> >>     - commas after every field in the table for consistency
> >>     - add support for RC73 handheld
> >> -v16
> >>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>     - add support for GU605CX
> >> -v17
> >>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>     - fix RC73 -> RC73AX as another RC73 exists
> >>   - platform/x86: asus-armoury: add core count control
> >>     - be more tolerant on out-or-range current CPU cores count
> >>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
> >>     - fix usage of undeclared static functions in macros
> > I've applied this to the review-ilpo-next branch. I'm still not entirely 
> > happy with how the cpu cores change does store values without arrays but 
> > it's not an end of the world (and could be fixed in tree).
> Hello and thanks.
> 
> You would make me very happy applying things as Luke wrote them
> so that successive modifications are more easily compared to
> what those were doing before I changed them...

I just took them as they were so you should be "happy" now :-)

...Even if I didn't like having all those as separate variables requiring 
if statements here and there, which could be avoided if core type would be 
an array index so one could simply do:

	...
	case CPU_CORE_MAX:
		cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
		break;
	...

Doing that transformation incrementally looks simple enough it should be 
low risk after a careful review.

> Also if you have some more hints on how I could change that
> interface (while avoiding bad surprises due to index mismatch)
> I will try my best... without destroying any laptop...
> perhaps... Hopefully? Wish me luck.
> 
> > I had to reorder a few includes to make the order alphabetical which 
> > luckily worked out without causing conflicts within the subsequent 
> > patches (and a need to respin the series). Please try to remember to
> > keep those in the alphabetical order.
> 
> I have noticed a pair of warnings in this v17 I would like to solve:
> one line is too long, I should break it and one macro has an
> unused parameter.
> 
> No semantic changes.
> 
> I have seen one of those unordered includes in asus-armoury.h...
> That branch is public in your git tree: this means I can respin
> a v18 from a git format-path, correct?

While I could replace the previous series with a new version, it would 
probably just be better to send incremental patches and I can see myself 
if I fold them into the existing patches or not.

> Is your repo the one in
> https://git.kernel.org/pub/scm/linux/kernel/git/ij/linux.git/ ?
> I see from the web interface that the last modification was
> 2 years ago?

That's pretty much unused repo.

Platform drivers repo is here:

https://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git

-- 
 i.

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/11/25 11:38, Ilpo Järvinen wrote:
> On Mon, 10 Nov 2025, Denis Benato wrote:
>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>> On Sun, 2 Nov 2025, 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
>>>>
>>>> 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
>>>> - v15
>>>>   - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>     - fix kernel doc
>>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>     - avoid direct calls to asus-wmi and provide helpers instead
>>>>     - rework xg mobile activation logic
>>>>     - add helper for enum allowed attributes
>>>>     - improve mini_led_mode_current_value_store
>>>>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>     - unload attributes in reverse order of loading
>>>>   - platform/x86: asus-armoury: add apu-mem control support
>>>>     - fix return value in apu_mem_current_value_show
>>>>   - platform/x86: asus-armoury: add core count control
>>>>     - put more safeguards in place against possible bricking of laptops
>>>>     - improve loading logic
>>>>   - platform/x86: asus-wmi: deprecate bios features
>>>>     - modified deprecation message
>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>     - make _store(s) to interfaces unusable in DC to fail,
>>>>       instead of accepting 0 as a value (0 is also invalid)
>>>>     - make it easier to understand AC vs DC logic
>>>>     - improved init_rog_tunables() logic
>>>>     - commas after every field in the table for consistency
>>>>     - add support for RC73 handheld
>>>> -v16
>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>     - add support for GU605CX
>>>> -v17
>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>     - fix RC73 -> RC73AX as another RC73 exists
>>>>   - platform/x86: asus-armoury: add core count control
>>>>     - be more tolerant on out-or-range current CPU cores count
>>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>     - fix usage of undeclared static functions in macros
>>> I've applied this to the review-ilpo-next branch. I'm still not entirely 
>>> happy with how the cpu cores change does store values without arrays but 
>>> it's not an end of the world (and could be fixed in tree).
>> Hello and thanks.
>>
>> You would make me very happy applying things as Luke wrote them
>> so that successive modifications are more easily compared to
>> what those were doing before I changed them...
> I just took them as they were so you should be "happy" now :-)
>
> ...Even if I didn't like having all those as separate variables requiring 
> if statements here and there, which could be avoided if core type would be 
> an array index so one could simply do:
>
> 	...
> 	case CPU_CORE_MAX:
> 		cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
> 		break;
> 	...
>
> Doing that transformation incrementally looks simple enough it should be 
> low risk after a careful review.
>
>
Apparently one of the two new handhelds from asus reports
weird numbers for core count so that area requires a bit of work
anyway. I will soon move to investigate that hardware.
>> Also if you have some more hints on how I could change that
>> interface (while avoiding bad surprises due to index mismatch)
>> I will try my best... without destroying any laptop...
>> perhaps... Hopefully? Wish me luck.
>>
>>> I had to reorder a few includes to make the order alphabetical which 
>>> luckily worked out without causing conflicts within the subsequent 
>>> patches (and a need to respin the series). Please try to remember to
>>> keep those in the alphabetical order.
>> I have noticed a pair of warnings in this v17 I would like to solve:
>> one line is too long, I should break it and one macro has an
>> unused parameter.
>>
>> No semantic changes.
>>
>> I have seen one of those unordered includes in asus-armoury.h...
>> That branch is public in your git tree: this means I can respin
>> a v18 from a git format-path, correct?
> While I could replace the previous series with a new version, it would 
> probably just be better to send incremental patches and I can see myself 
> if I fold them into the existing patches or not.
Ah forgive me, I am not used to the process and understood
something totally different. All good, patches sent, thanks!

Would you also want to break the long assignment line?
Is it better if it's just one long line for clarity?

```
const struct rog_tunables *const ac_rog_runables = ....
```

>> Is your repo the one in
>> https://git.kernel.org/pub/scm/linux/kernel/git/ij/linux.git/ ?
>> I see from the web interface that the last modification was
>> 2 years ago?
> That's pretty much unused repo.
Poor repo :'(
> Platform drivers repo is here:
>
> https://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
>

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Ilpo Järvinen]

[-- Attachment #1: Type: text/plain, Size: 13172 bytes --]

On Tue, 11 Nov 2025, Denis Benato wrote:
> On 11/11/25 11:38, Ilpo Järvinen wrote:
> > On Mon, 10 Nov 2025, Denis Benato wrote:
> >> On 11/10/25 16:17, Ilpo Järvinen wrote:
> >>> On Sun, 2 Nov 2025, Denis Benato wrote:
> >>>
> >>>> 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
> >>>> - v15
> >>>>   - platform/x86: asus-wmi: export symbols used for read/write WMI
> >>>>     - fix kernel doc
> >>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
> >>>>     - avoid direct calls to asus-wmi and provide helpers instead
> >>>>     - rework xg mobile activation logic
> >>>>     - add helper for enum allowed attributes
> >>>>     - improve mini_led_mode_current_value_store
> >>>>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
> >>>>     - unload attributes in reverse order of loading
> >>>>   - platform/x86: asus-armoury: add apu-mem control support
> >>>>     - fix return value in apu_mem_current_value_show
> >>>>   - platform/x86: asus-armoury: add core count control
> >>>>     - put more safeguards in place against possible bricking of laptops
> >>>>     - improve loading logic
> >>>>   - platform/x86: asus-wmi: deprecate bios features
> >>>>     - modified deprecation message
> >>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>>>     - make _store(s) to interfaces unusable in DC to fail,
> >>>>       instead of accepting 0 as a value (0 is also invalid)
> >>>>     - make it easier to understand AC vs DC logic
> >>>>     - improved init_rog_tunables() logic
> >>>>     - commas after every field in the table for consistency
> >>>>     - add support for RC73 handheld
> >>>> -v16
> >>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>>>     - add support for GU605CX
> >>>> -v17
> >>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
> >>>>     - fix RC73 -> RC73AX as another RC73 exists
> >>>>   - platform/x86: asus-armoury: add core count control
> >>>>     - be more tolerant on out-or-range current CPU cores count
> >>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
> >>>>     - fix usage of undeclared static functions in macros
> >>> I've applied this to the review-ilpo-next branch. I'm still not entirely 
> >>> happy with how the cpu cores change does store values without arrays but 
> >>> it's not an end of the world (and could be fixed in tree).
> >> Hello and thanks.
> >>
> >> You would make me very happy applying things as Luke wrote them
> >> so that successive modifications are more easily compared to
> >> what those were doing before I changed them...
> > I just took them as they were so you should be "happy" now :-)
> >
> > ...Even if I didn't like having all those as separate variables requiring 
> > if statements here and there, which could be avoided if core type would be 
> > an array index so one could simply do:
> >
> > 	...
> > 	case CPU_CORE_MAX:
> > 		cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
> > 		break;
> > 	...
> >
> > Doing that transformation incrementally looks simple enough it should be 
> > low risk after a careful review.
> >
> >
> Apparently one of the two new handhelds from asus reports
> weird numbers for core count so that area requires a bit of work
> anyway. I will soon move to investigate that hardware.
>
> >> Also if you have some more hints on how I could change that
> >> interface (while avoiding bad surprises due to index mismatch)
> >> I will try my best... without destroying any laptop...
> >> perhaps... Hopefully? Wish me luck.
> >>
> >>> I had to reorder a few includes to make the order alphabetical which 
> >>> luckily worked out without causing conflicts within the subsequent 
> >>> patches (and a need to respin the series). Please try to remember to
> >>> keep those in the alphabetical order.
> >> I have noticed a pair of warnings in this v17 I would like to solve:
> >> one line is too long, I should break it and one macro has an
> >> unused parameter.
> >>
> >> No semantic changes.
> >>
> >> I have seen one of those unordered includes in asus-armoury.h...
> >> That branch is public in your git tree: this means I can respin
> >> a v18 from a git format-path, correct?
> >
> > While I could replace the previous series with a new version, it would 
> > probably just be better to send incremental patches and I can see myself 
> > if I fold them into the existing patches or not.
>
> Ah forgive me, I am not used to the process and understood
> something totally different. All good, patches sent, thanks!
> 
> Would you also want to break the long assignment line?
> Is it better if it's just one long line for clarity?
> 
> ```
> const struct rog_tunables *const ac_rog_runables = ....
> ```

I'm not sure what that second const gains us here so I'd prefer removing 
it.

It's a local variable so it doesn't look like protecting the variable 
itself with const is that important (in contrast to things which are in 
global scope where const for the variable too is good).

Are you aware of scripts/checkpatch.pl? I think it would have caught this 
(if one remembers to run it before sending patches, which is the hardest 
part with that tool :-)).

-- 
 i.

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Mario Limonciello]

On 11/12/25 6:42 AM, Ilpo Järvinen wrote:
> On Tue, 11 Nov 2025, Denis Benato wrote:
>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>
>>>>>> 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
>>>>>> - v15
>>>>>>    - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>      - fix kernel doc
>>>>>>    - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>      - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>      - rework xg mobile activation logic
>>>>>>      - add helper for enum allowed attributes
>>>>>>      - improve mini_led_mode_current_value_store
>>>>>>      - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>      - unload attributes in reverse order of loading
>>>>>>    - platform/x86: asus-armoury: add apu-mem control support
>>>>>>      - fix return value in apu_mem_current_value_show
>>>>>>    - platform/x86: asus-armoury: add core count control
>>>>>>      - put more safeguards in place against possible bricking of laptops
>>>>>>      - improve loading logic
>>>>>>    - platform/x86: asus-wmi: deprecate bios features
>>>>>>      - modified deprecation message
>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>      - make _store(s) to interfaces unusable in DC to fail,
>>>>>>        instead of accepting 0 as a value (0 is also invalid)
>>>>>>      - make it easier to understand AC vs DC logic
>>>>>>      - improved init_rog_tunables() logic
>>>>>>      - commas after every field in the table for consistency
>>>>>>      - add support for RC73 handheld
>>>>>> -v16
>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>      - add support for GU605CX
>>>>>> -v17
>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>      - fix RC73 -> RC73AX as another RC73 exists
>>>>>>    - platform/x86: asus-armoury: add core count control
>>>>>>      - be more tolerant on out-or-range current CPU cores count
>>>>>>    - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>      - fix usage of undeclared static functions in macros
>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely
>>>>> happy with how the cpu cores change does store values without arrays but
>>>>> it's not an end of the world (and could be fixed in tree).
>>>> Hello and thanks.
>>>>
>>>> You would make me very happy applying things as Luke wrote them
>>>> so that successive modifications are more easily compared to
>>>> what those were doing before I changed them...
>>> I just took them as they were so you should be "happy" now :-)
>>>
>>> ...Even if I didn't like having all those as separate variables requiring
>>> if statements here and there, which could be avoided if core type would be
>>> an array index so one could simply do:
>>>
>>> 	...
>>> 	case CPU_CORE_MAX:
>>> 		cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>> 		break;
>>> 	...
>>>
>>> Doing that transformation incrementally looks simple enough it should be
>>> low risk after a careful review.
>>>
>>>
>> Apparently one of the two new handhelds from asus reports
>> weird numbers for core count so that area requires a bit of work
>> anyway. I will soon move to investigate that hardware.
>>
>>>> Also if you have some more hints on how I could change that
>>>> interface (while avoiding bad surprises due to index mismatch)
>>>> I will try my best... without destroying any laptop...
>>>> perhaps... Hopefully? Wish me luck.
>>>>
>>>>> I had to reorder a few includes to make the order alphabetical which
>>>>> luckily worked out without causing conflicts within the subsequent
>>>>> patches (and a need to respin the series). Please try to remember to
>>>>> keep those in the alphabetical order.
>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>> one line is too long, I should break it and one macro has an
>>>> unused parameter.
>>>>
>>>> No semantic changes.
>>>>
>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>> That branch is public in your git tree: this means I can respin
>>>> a v18 from a git format-path, correct?
>>>
>>> While I could replace the previous series with a new version, it would
>>> probably just be better to send incremental patches and I can see myself
>>> if I fold them into the existing patches or not.
>>
>> Ah forgive me, I am not used to the process and understood
>> something totally different. All good, patches sent, thanks!
>>
>> Would you also want to break the long assignment line?
>> Is it better if it's just one long line for clarity?
>>
>> ```
>> const struct rog_tunables *const ac_rog_runables = ....
>> ```
> 
> I'm not sure what that second const gains us here so I'd prefer removing
> it.
> 
> It's a local variable so it doesn't look like protecting the variable
> itself with const is that important (in contrast to things which are in
> global scope where const for the variable too is good).
> 
> Are you aware of scripts/checkpatch.pl? I think it would have caught this
> (if one remembers to run it before sending patches, which is the hardest
> part with that tool :-)).
> 
In case you aren't aware, two other quality of life improvements I want 
to share to look into:

1) There is a vscode extension for checkpatch

It can be configured to automatically run when you save the file and 
then will underline all the failures with blue squiggly lines.

https://marketplace.visualstudio.com/items?itemName=idanp.checkpatch

2) There is a pre-commit hook for checkpatch

This will help make sure that it's "automatically" run on every code 
commit you do at the right time you make the patch (ie on a per-patch 
basis).

https://github.com/dloidolt/pre-commit-checkpatch

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Andy Shevchenko]

On Sun, Nov 02, 2025 at 10:53:10PM +0100, 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.

This is more files starter with asus in PDx86.
Perhaps it's a time to have drivers/platform/x86/asus/ ?

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/12/25 13:42, Ilpo Järvinen wrote:
> On Tue, 11 Nov 2025, Denis Benato wrote:
>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>
>>>>>> 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
>>>>>> - v15
>>>>>>   - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>     - fix kernel doc
>>>>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>     - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>     - rework xg mobile activation logic
>>>>>>     - add helper for enum allowed attributes
>>>>>>     - improve mini_led_mode_current_value_store
>>>>>>     - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>     - unload attributes in reverse order of loading
>>>>>>   - platform/x86: asus-armoury: add apu-mem control support
>>>>>>     - fix return value in apu_mem_current_value_show
>>>>>>   - platform/x86: asus-armoury: add core count control
>>>>>>     - put more safeguards in place against possible bricking of laptops
>>>>>>     - improve loading logic
>>>>>>   - platform/x86: asus-wmi: deprecate bios features
>>>>>>     - modified deprecation message
>>>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>     - make _store(s) to interfaces unusable in DC to fail,
>>>>>>       instead of accepting 0 as a value (0 is also invalid)
>>>>>>     - make it easier to understand AC vs DC logic
>>>>>>     - improved init_rog_tunables() logic
>>>>>>     - commas after every field in the table for consistency
>>>>>>     - add support for RC73 handheld
>>>>>> -v16
>>>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>     - add support for GU605CX
>>>>>> -v17
>>>>>>   - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>     - fix RC73 -> RC73AX as another RC73 exists
>>>>>>   - platform/x86: asus-armoury: add core count control
>>>>>>     - be more tolerant on out-or-range current CPU cores count
>>>>>>   - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>     - fix usage of undeclared static functions in macros
>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely 
>>>>> happy with how the cpu cores change does store values without arrays but 
>>>>> it's not an end of the world (and could be fixed in tree).
>>>> Hello and thanks.
>>>>
>>>> You would make me very happy applying things as Luke wrote them
>>>> so that successive modifications are more easily compared to
>>>> what those were doing before I changed them...
>>> I just took them as they were so you should be "happy" now :-)
>>>
>>> ...Even if I didn't like having all those as separate variables requiring 
>>> if statements here and there, which could be avoided if core type would be 
>>> an array index so one could simply do:
>>>
>>> 	...
>>> 	case CPU_CORE_MAX:
>>> 		cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>> 		break;
>>> 	...
>>>
>>> Doing that transformation incrementally looks simple enough it should be 
>>> low risk after a careful review.
>>>
>>>
>> Apparently one of the two new handhelds from asus reports
>> weird numbers for core count so that area requires a bit of work
>> anyway. I will soon move to investigate that hardware.
>>
>>>> Also if you have some more hints on how I could change that
>>>> interface (while avoiding bad surprises due to index mismatch)
>>>> I will try my best... without destroying any laptop...
>>>> perhaps... Hopefully? Wish me luck.
>>>>
>>>>> I had to reorder a few includes to make the order alphabetical which 
>>>>> luckily worked out without causing conflicts within the subsequent 
>>>>> patches (and a need to respin the series). Please try to remember to
>>>>> keep those in the alphabetical order.
>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>> one line is too long, I should break it and one macro has an
>>>> unused parameter.
>>>>
>>>> No semantic changes.
>>>>
>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>> That branch is public in your git tree: this means I can respin
>>>> a v18 from a git format-path, correct?
>>> While I could replace the previous series with a new version, it would 
>>> probably just be better to send incremental patches and I can see myself 
>>> if I fold them into the existing patches or not.
>> Ah forgive me, I am not used to the process and understood
>> something totally different. All good, patches sent, thanks!
>>
>> Would you also want to break the long assignment line?
>> Is it better if it's just one long line for clarity?
>>
>> ```
>> const struct rog_tunables *const ac_rog_runables = ....
>> ```
> I'm not sure what that second const gains us here so I'd prefer removing 
> it.
>
> It's a local variable so it doesn't look like protecting the variable 
> itself with const is that important (in contrast to things which are in 
> global scope where const for the variable too is good).
Force of habit, that way if I ever find myself touching a pointer that
is not supposed to change I get an error.

I am fine removing that const, especially if blending in with the
existing code is deemed more important than the reason above.
> Are you aware of scripts/checkpatch.pl? I think it would have caught this 
> (if one remembers to run it before sending patches, which is the hardest 
> part with that tool :-)).
>
>
Yeah I always do that but the patch number 2 already had a warning due to
reasons tied to the MAINTAINER file, so I did not gave it much attentions. Sorry.

I ended up spotting it when I was going to prepare v18 adding that other laptop.

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/12/25 14:44, Mario Limonciello wrote:
>
>
> On 11/12/25 6:42 AM, Ilpo Järvinen wrote:
>> On Tue, 11 Nov 2025, Denis Benato wrote:
>>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>>
>>>>>>> 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
>>>>>>> - v15
>>>>>>>    - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>>      - fix kernel doc
>>>>>>>    - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>      - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>>      - rework xg mobile activation logic
>>>>>>>      - add helper for enum allowed attributes
>>>>>>>      - improve mini_led_mode_current_value_store
>>>>>>>      - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>>      - unload attributes in reverse order of loading
>>>>>>>    - platform/x86: asus-armoury: add apu-mem control support
>>>>>>>      - fix return value in apu_mem_current_value_show
>>>>>>>    - platform/x86: asus-armoury: add core count control
>>>>>>>      - put more safeguards in place against possible bricking of laptops
>>>>>>>      - improve loading logic
>>>>>>>    - platform/x86: asus-wmi: deprecate bios features
>>>>>>>      - modified deprecation message
>>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>      - make _store(s) to interfaces unusable in DC to fail,
>>>>>>>        instead of accepting 0 as a value (0 is also invalid)
>>>>>>>      - make it easier to understand AC vs DC logic
>>>>>>>      - improved init_rog_tunables() logic
>>>>>>>      - commas after every field in the table for consistency
>>>>>>>      - add support for RC73 handheld
>>>>>>> -v16
>>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>      - add support for GU605CX
>>>>>>> -v17
>>>>>>>    - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>      - fix RC73 -> RC73AX as another RC73 exists
>>>>>>>    - platform/x86: asus-armoury: add core count control
>>>>>>>      - be more tolerant on out-or-range current CPU cores count
>>>>>>>    - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>      - fix usage of undeclared static functions in macros
>>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely
>>>>>> happy with how the cpu cores change does store values without arrays but
>>>>>> it's not an end of the world (and could be fixed in tree).
>>>>> Hello and thanks.
>>>>>
>>>>> You would make me very happy applying things as Luke wrote them
>>>>> so that successive modifications are more easily compared to
>>>>> what those were doing before I changed them...
>>>> I just took them as they were so you should be "happy" now :-)
>>>>
>>>> ...Even if I didn't like having all those as separate variables requiring
>>>> if statements here and there, which could be avoided if core type would be
>>>> an array index so one could simply do:
>>>>
>>>>     ...
>>>>     case CPU_CORE_MAX:
>>>>         cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>>>         break;
>>>>     ...
>>>>
>>>> Doing that transformation incrementally looks simple enough it should be
>>>> low risk after a careful review.
>>>>
>>>>
>>> Apparently one of the two new handhelds from asus reports
>>> weird numbers for core count so that area requires a bit of work
>>> anyway. I will soon move to investigate that hardware.
>>>
>>>>> Also if you have some more hints on how I could change that
>>>>> interface (while avoiding bad surprises due to index mismatch)
>>>>> I will try my best... without destroying any laptop...
>>>>> perhaps... Hopefully? Wish me luck.
>>>>>
>>>>>> I had to reorder a few includes to make the order alphabetical which
>>>>>> luckily worked out without causing conflicts within the subsequent
>>>>>> patches (and a need to respin the series). Please try to remember to
>>>>>> keep those in the alphabetical order.
>>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>>> one line is too long, I should break it and one macro has an
>>>>> unused parameter.
>>>>>
>>>>> No semantic changes.
>>>>>
>>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>>> That branch is public in your git tree: this means I can respin
>>>>> a v18 from a git format-path, correct?
>>>>
>>>> While I could replace the previous series with a new version, it would
>>>> probably just be better to send incremental patches and I can see myself
>>>> if I fold them into the existing patches or not.
>>>
>>> Ah forgive me, I am not used to the process and understood
>>> something totally different. All good, patches sent, thanks!
>>>
>>> Would you also want to break the long assignment line?
>>> Is it better if it's just one long line for clarity?
>>>
>>> ```
>>> const struct rog_tunables *const ac_rog_runables = ....
>>> ```
>>
>> I'm not sure what that second const gains us here so I'd prefer removing
>> it.
>>
>> It's a local variable so it doesn't look like protecting the variable
>> itself with const is that important (in contrast to things which are in
>> global scope where const for the variable too is good).
>>
>> Are you aware of scripts/checkpatch.pl? I think it would have caught this
>> (if one remembers to run it before sending patches, which is the hardest
>> part with that tool :-)).
>>
> In case you aren't aware, two other quality of life improvements I want to share to look into:
>
> 1) There is a vscode extension for checkpatch
>
> It can be configured to automatically run when you save the file and then will underline all the failures with blue squiggly lines.
>
> https://marketplace.visualstudio.com/items?itemName=idanp.checkpatch 
>
It has been in place since the first time you recommended it to me,
but apparently it's only highlighting errors? In blue color?

Why isn't it telling me about warnings? :(
> 2) There is a pre-commit hook for checkpatch
>
> This will help make sure that it's "automatically" run on every code commit you do at the right time you make the patch (ie on a per-patch basis).
>
> https://github.com/dloidolt/pre-commit-checkpatch 
I am going to check this as well, thanks!

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Mario Limonciello]

On 11/12/25 1:23 PM, Denis Benato wrote:
> 
> On 11/12/25 14:44, Mario Limonciello wrote:
>>
>>
>> On 11/12/25 6:42 AM, Ilpo Järvinen wrote:
>>> On Tue, 11 Nov 2025, Denis Benato wrote:
>>>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>>>
>>>>>>>> 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
>>>>>>>> - v15
>>>>>>>>     - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>>>       - fix kernel doc
>>>>>>>>     - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>       - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>>>       - rework xg mobile activation logic
>>>>>>>>       - add helper for enum allowed attributes
>>>>>>>>       - improve mini_led_mode_current_value_store
>>>>>>>>       - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>>>       - unload attributes in reverse order of loading
>>>>>>>>     - platform/x86: asus-armoury: add apu-mem control support
>>>>>>>>       - fix return value in apu_mem_current_value_show
>>>>>>>>     - platform/x86: asus-armoury: add core count control
>>>>>>>>       - put more safeguards in place against possible bricking of laptops
>>>>>>>>       - improve loading logic
>>>>>>>>     - platform/x86: asus-wmi: deprecate bios features
>>>>>>>>       - modified deprecation message
>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>       - make _store(s) to interfaces unusable in DC to fail,
>>>>>>>>         instead of accepting 0 as a value (0 is also invalid)
>>>>>>>>       - make it easier to understand AC vs DC logic
>>>>>>>>       - improved init_rog_tunables() logic
>>>>>>>>       - commas after every field in the table for consistency
>>>>>>>>       - add support for RC73 handheld
>>>>>>>> -v16
>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>       - add support for GU605CX
>>>>>>>> -v17
>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>       - fix RC73 -> RC73AX as another RC73 exists
>>>>>>>>     - platform/x86: asus-armoury: add core count control
>>>>>>>>       - be more tolerant on out-or-range current CPU cores count
>>>>>>>>     - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>       - fix usage of undeclared static functions in macros
>>>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely
>>>>>>> happy with how the cpu cores change does store values without arrays but
>>>>>>> it's not an end of the world (and could be fixed in tree).
>>>>>> Hello and thanks.
>>>>>>
>>>>>> You would make me very happy applying things as Luke wrote them
>>>>>> so that successive modifications are more easily compared to
>>>>>> what those were doing before I changed them...
>>>>> I just took them as they were so you should be "happy" now :-)
>>>>>
>>>>> ...Even if I didn't like having all those as separate variables requiring
>>>>> if statements here and there, which could be avoided if core type would be
>>>>> an array index so one could simply do:
>>>>>
>>>>>      ...
>>>>>      case CPU_CORE_MAX:
>>>>>          cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>>>>          break;
>>>>>      ...
>>>>>
>>>>> Doing that transformation incrementally looks simple enough it should be
>>>>> low risk after a careful review.
>>>>>
>>>>>
>>>> Apparently one of the two new handhelds from asus reports
>>>> weird numbers for core count so that area requires a bit of work
>>>> anyway. I will soon move to investigate that hardware.
>>>>
>>>>>> Also if you have some more hints on how I could change that
>>>>>> interface (while avoiding bad surprises due to index mismatch)
>>>>>> I will try my best... without destroying any laptop...
>>>>>> perhaps... Hopefully? Wish me luck.
>>>>>>
>>>>>>> I had to reorder a few includes to make the order alphabetical which
>>>>>>> luckily worked out without causing conflicts within the subsequent
>>>>>>> patches (and a need to respin the series). Please try to remember to
>>>>>>> keep those in the alphabetical order.
>>>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>>>> one line is too long, I should break it and one macro has an
>>>>>> unused parameter.
>>>>>>
>>>>>> No semantic changes.
>>>>>>
>>>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>>>> That branch is public in your git tree: this means I can respin
>>>>>> a v18 from a git format-path, correct?
>>>>>
>>>>> While I could replace the previous series with a new version, it would
>>>>> probably just be better to send incremental patches and I can see myself
>>>>> if I fold them into the existing patches or not.
>>>>
>>>> Ah forgive me, I am not used to the process and understood
>>>> something totally different. All good, patches sent, thanks!
>>>>
>>>> Would you also want to break the long assignment line?
>>>> Is it better if it's just one long line for clarity?
>>>>
>>>> ```
>>>> const struct rog_tunables *const ac_rog_runables = ....
>>>> ```
>>>
>>> I'm not sure what that second const gains us here so I'd prefer removing
>>> it.
>>>
>>> It's a local variable so it doesn't look like protecting the variable
>>> itself with const is that important (in contrast to things which are in
>>> global scope where const for the variable too is good).
>>>
>>> Are you aware of scripts/checkpatch.pl? I think it would have caught this
>>> (if one remembers to run it before sending patches, which is the hardest
>>> part with that tool :-)).
>>>
>> In case you aren't aware, two other quality of life improvements I want to share to look into:
>>
>> 1) There is a vscode extension for checkpatch
>>
>> It can be configured to automatically run when you save the file and then will underline all the failures with blue squiggly lines.
>>
>> https://marketplace.visualstudio.com/items?itemName=idanp.checkpatch
>>
> It has been in place since the first time you recommended it to me,
> but apparently it's only highlighting errors? In blue color?
> 
> Why isn't it telling me about warnings? :(

Make sure that you set the path for checkpatch.pl properly in the 
extension settings and that you set it to run on every save.

>> 2) There is a pre-commit hook for checkpatch
>>
>> This will help make sure that it's "automatically" run on every code commit you do at the right time you make the patch (ie on a per-patch basis).
>>
>> https://github.com/dloidolt/pre-commit-checkpatch
> I am going to check this as well, thanks!

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/12/25 15:43, Andy Shevchenko wrote:
> On Sun, Nov 02, 2025 at 10:53:10PM +0100, 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.
> This is more files starter with asus in PDx86.
> Perhaps it's a time to have drivers/platform/x86/asus/ ?
>
I will leave the decision to you PDx86 maintainers: I'm fine either way.
Just drop me a note and I'll move asus drivers if you decide it's the best
course of action :)

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Denis Benato]

On 11/12/25 20:24, Mario Limonciello wrote:
> On 11/12/25 1:23 PM, Denis Benato wrote:
>>
>> On 11/12/25 14:44, Mario Limonciello wrote:
>>>
>>>
>>> On 11/12/25 6:42 AM, Ilpo Järvinen wrote:
>>>> On Tue, 11 Nov 2025, Denis Benato wrote:
>>>>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>>>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>>>>
>>>>>>>>> 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
>>>>>>>>> - v15
>>>>>>>>>     - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>>>>       - fix kernel doc
>>>>>>>>>     - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>>       - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>>>>       - rework xg mobile activation logic
>>>>>>>>>       - add helper for enum allowed attributes
>>>>>>>>>       - improve mini_led_mode_current_value_store
>>>>>>>>>       - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>>>>       - unload attributes in reverse order of loading
>>>>>>>>>     - platform/x86: asus-armoury: add apu-mem control support
>>>>>>>>>       - fix return value in apu_mem_current_value_show
>>>>>>>>>     - platform/x86: asus-armoury: add core count control
>>>>>>>>>       - put more safeguards in place against possible bricking of laptops
>>>>>>>>>       - improve loading logic
>>>>>>>>>     - platform/x86: asus-wmi: deprecate bios features
>>>>>>>>>       - modified deprecation message
>>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>       - make _store(s) to interfaces unusable in DC to fail,
>>>>>>>>>         instead of accepting 0 as a value (0 is also invalid)
>>>>>>>>>       - make it easier to understand AC vs DC logic
>>>>>>>>>       - improved init_rog_tunables() logic
>>>>>>>>>       - commas after every field in the table for consistency
>>>>>>>>>       - add support for RC73 handheld
>>>>>>>>> -v16
>>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>       - add support for GU605CX
>>>>>>>>> -v17
>>>>>>>>>     - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>       - fix RC73 -> RC73AX as another RC73 exists
>>>>>>>>>     - platform/x86: asus-armoury: add core count control
>>>>>>>>>       - be more tolerant on out-or-range current CPU cores count
>>>>>>>>>     - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>>       - fix usage of undeclared static functions in macros
>>>>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely
>>>>>>>> happy with how the cpu cores change does store values without arrays but
>>>>>>>> it's not an end of the world (and could be fixed in tree).
>>>>>>> Hello and thanks.
>>>>>>>
>>>>>>> You would make me very happy applying things as Luke wrote them
>>>>>>> so that successive modifications are more easily compared to
>>>>>>> what those were doing before I changed them...
>>>>>> I just took them as they were so you should be "happy" now :-)
>>>>>>
>>>>>> ...Even if I didn't like having all those as separate variables requiring
>>>>>> if statements here and there, which could be avoided if core type would be
>>>>>> an array index so one could simply do:
>>>>>>
>>>>>>      ...
>>>>>>      case CPU_CORE_MAX:
>>>>>>          cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>>>>>          break;
>>>>>>      ...
>>>>>>
>>>>>> Doing that transformation incrementally looks simple enough it should be
>>>>>> low risk after a careful review.
>>>>>>
>>>>>>
>>>>> Apparently one of the two new handhelds from asus reports
>>>>> weird numbers for core count so that area requires a bit of work
>>>>> anyway. I will soon move to investigate that hardware.
>>>>>
>>>>>>> Also if you have some more hints on how I could change that
>>>>>>> interface (while avoiding bad surprises due to index mismatch)
>>>>>>> I will try my best... without destroying any laptop...
>>>>>>> perhaps... Hopefully? Wish me luck.
>>>>>>>
>>>>>>>> I had to reorder a few includes to make the order alphabetical which
>>>>>>>> luckily worked out without causing conflicts within the subsequent
>>>>>>>> patches (and a need to respin the series). Please try to remember to
>>>>>>>> keep those in the alphabetical order.
>>>>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>>>>> one line is too long, I should break it and one macro has an
>>>>>>> unused parameter.
>>>>>>>
>>>>>>> No semantic changes.
>>>>>>>
>>>>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>>>>> That branch is public in your git tree: this means I can respin
>>>>>>> a v18 from a git format-path, correct?
>>>>>>
>>>>>> While I could replace the previous series with a new version, it would
>>>>>> probably just be better to send incremental patches and I can see myself
>>>>>> if I fold them into the existing patches or not.
>>>>>
>>>>> Ah forgive me, I am not used to the process and understood
>>>>> something totally different. All good, patches sent, thanks!
>>>>>
>>>>> Would you also want to break the long assignment line?
>>>>> Is it better if it's just one long line for clarity?
>>>>>
>>>>> ```
>>>>> const struct rog_tunables *const ac_rog_runables = ....
>>>>> ```
>>>>
>>>> I'm not sure what that second const gains us here so I'd prefer removing
>>>> it.
>>>>
>>>> It's a local variable so it doesn't look like protecting the variable
>>>> itself with const is that important (in contrast to things which are in
>>>> global scope where const for the variable too is good).
>>>>
>>>> Are you aware of scripts/checkpatch.pl? I think it would have caught this
>>>> (if one remembers to run it before sending patches, which is the hardest
>>>> part with that tool :-)).
>>>>
>>> In case you aren't aware, two other quality of life improvements I want to share to look into:
>>>
>>> 1) There is a vscode extension for checkpatch
>>>
>>> It can be configured to automatically run when you save the file and then will underline all the failures with blue squiggly lines.
>>>
>>> https://marketplace.visualstudio.com/items?itemName=idanp.checkpatch
>>>
>> It has been in place since the first time you recommended it to me,
>> but apparently it's only highlighting errors? In blue color?
>>
>> Why isn't it telling me about warnings? :(
>
> Make sure that you set the path for checkpatch.pl properly in the extension settings and that you set it to run on every save. 
>
I have these settings:

Checkpatch Path: checkpatch.pl (I have a link in /usr/bin)
Diagnostic level: Information (but I can only see errors in blue)
Run: onSave

Not sure If I am doing something wrong, but it is working for sure because
errors are reported.
>>> 2) There is a pre-commit hook for checkpatch
>>>
>>> This will help make sure that it's "automatically" run on every code commit you do at the right time you make the patch (ie on a per-patch basis).
>>>
>>> https://github.com/dloidolt/pre-commit-checkpatch
>> I am going to check this as well, thanks!
>

Re: [PATCH v17 0/9] platform/x86: Add asus-armoury driver

[Mario Limonciello]

On 11/12/25 1:30 PM, Denis Benato wrote:
> 
> On 11/12/25 20:24, Mario Limonciello wrote:
>> On 11/12/25 1:23 PM, Denis Benato wrote:
>>>
>>> On 11/12/25 14:44, Mario Limonciello wrote:
>>>>
>>>>
>>>> On 11/12/25 6:42 AM, Ilpo Järvinen wrote:
>>>>> On Tue, 11 Nov 2025, Denis Benato wrote:
>>>>>> On 11/11/25 11:38, Ilpo Järvinen wrote:
>>>>>>> On Mon, 10 Nov 2025, Denis Benato wrote:
>>>>>>>> On 11/10/25 16:17, Ilpo Järvinen wrote:
>>>>>>>>> On Sun, 2 Nov 2025, Denis Benato wrote:
>>>>>>>>>
>>>>>>>>>> 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
>>>>>>>>>> - v15
>>>>>>>>>>      - platform/x86: asus-wmi: export symbols used for read/write WMI
>>>>>>>>>>        - fix kernel doc
>>>>>>>>>>      - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>>>        - avoid direct calls to asus-wmi and provide helpers instead
>>>>>>>>>>        - rework xg mobile activation logic
>>>>>>>>>>        - add helper for enum allowed attributes
>>>>>>>>>>        - improve mini_led_mode_current_value_store
>>>>>>>>>>        - improved usage of kstrtouint, kstrtou32 and kstrtobool
>>>>>>>>>>        - unload attributes in reverse order of loading
>>>>>>>>>>      - platform/x86: asus-armoury: add apu-mem control support
>>>>>>>>>>        - fix return value in apu_mem_current_value_show
>>>>>>>>>>      - platform/x86: asus-armoury: add core count control
>>>>>>>>>>        - put more safeguards in place against possible bricking of laptops
>>>>>>>>>>        - improve loading logic
>>>>>>>>>>      - platform/x86: asus-wmi: deprecate bios features
>>>>>>>>>>        - modified deprecation message
>>>>>>>>>>      - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>>        - make _store(s) to interfaces unusable in DC to fail,
>>>>>>>>>>          instead of accepting 0 as a value (0 is also invalid)
>>>>>>>>>>        - make it easier to understand AC vs DC logic
>>>>>>>>>>        - improved init_rog_tunables() logic
>>>>>>>>>>        - commas after every field in the table for consistency
>>>>>>>>>>        - add support for RC73 handheld
>>>>>>>>>> -v16
>>>>>>>>>>      - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>>        - add support for GU605CX
>>>>>>>>>> -v17
>>>>>>>>>>      - platform/x86: asus-armoury: add ppt_* and nv_* tuning knobs
>>>>>>>>>>        - fix RC73 -> RC73AX as another RC73 exists
>>>>>>>>>>      - platform/x86: asus-armoury: add core count control
>>>>>>>>>>        - be more tolerant on out-or-range current CPU cores count
>>>>>>>>>>      - platform/x86: asus-armoury: move existing tunings to asus-armoury module
>>>>>>>>>>        - fix usage of undeclared static functions in macros
>>>>>>>>> I've applied this to the review-ilpo-next branch. I'm still not entirely
>>>>>>>>> happy with how the cpu cores change does store values without arrays but
>>>>>>>>> it's not an end of the world (and could be fixed in tree).
>>>>>>>> Hello and thanks.
>>>>>>>>
>>>>>>>> You would make me very happy applying things as Luke wrote them
>>>>>>>> so that successive modifications are more easily compared to
>>>>>>>> what those were doing before I changed them...
>>>>>>> I just took them as they were so you should be "happy" now :-)
>>>>>>>
>>>>>>> ...Even if I didn't like having all those as separate variables requiring
>>>>>>> if statements here and there, which could be avoided if core type would be
>>>>>>> an array index so one could simply do:
>>>>>>>
>>>>>>>       ...
>>>>>>>       case CPU_CORE_MAX:
>>>>>>>           cpu_core_value = asus_armoury.cpu_cores[core_type]->max;
>>>>>>>           break;
>>>>>>>       ...
>>>>>>>
>>>>>>> Doing that transformation incrementally looks simple enough it should be
>>>>>>> low risk after a careful review.
>>>>>>>
>>>>>>>
>>>>>> Apparently one of the two new handhelds from asus reports
>>>>>> weird numbers for core count so that area requires a bit of work
>>>>>> anyway. I will soon move to investigate that hardware.
>>>>>>
>>>>>>>> Also if you have some more hints on how I could change that
>>>>>>>> interface (while avoiding bad surprises due to index mismatch)
>>>>>>>> I will try my best... without destroying any laptop...
>>>>>>>> perhaps... Hopefully? Wish me luck.
>>>>>>>>
>>>>>>>>> I had to reorder a few includes to make the order alphabetical which
>>>>>>>>> luckily worked out without causing conflicts within the subsequent
>>>>>>>>> patches (and a need to respin the series). Please try to remember to
>>>>>>>>> keep those in the alphabetical order.
>>>>>>>> I have noticed a pair of warnings in this v17 I would like to solve:
>>>>>>>> one line is too long, I should break it and one macro has an
>>>>>>>> unused parameter.
>>>>>>>>
>>>>>>>> No semantic changes.
>>>>>>>>
>>>>>>>> I have seen one of those unordered includes in asus-armoury.h...
>>>>>>>> That branch is public in your git tree: this means I can respin
>>>>>>>> a v18 from a git format-path, correct?
>>>>>>>
>>>>>>> While I could replace the previous series with a new version, it would
>>>>>>> probably just be better to send incremental patches and I can see myself
>>>>>>> if I fold them into the existing patches or not.
>>>>>>
>>>>>> Ah forgive me, I am not used to the process and understood
>>>>>> something totally different. All good, patches sent, thanks!
>>>>>>
>>>>>> Would you also want to break the long assignment line?
>>>>>> Is it better if it's just one long line for clarity?
>>>>>>
>>>>>> ```
>>>>>> const struct rog_tunables *const ac_rog_runables = ....
>>>>>> ```
>>>>>
>>>>> I'm not sure what that second const gains us here so I'd prefer removing
>>>>> it.
>>>>>
>>>>> It's a local variable so it doesn't look like protecting the variable
>>>>> itself with const is that important (in contrast to things which are in
>>>>> global scope where const for the variable too is good).
>>>>>
>>>>> Are you aware of scripts/checkpatch.pl? I think it would have caught this
>>>>> (if one remembers to run it before sending patches, which is the hardest
>>>>> part with that tool :-)).
>>>>>
>>>> In case you aren't aware, two other quality of life improvements I want to share to look into:
>>>>
>>>> 1) There is a vscode extension for checkpatch
>>>>
>>>> It can be configured to automatically run when you save the file and then will underline all the failures with blue squiggly lines.
>>>>
>>>> https://marketplace.visualstudio.com/items?itemName=idanp.checkpatch
>>>>
>>> It has been in place since the first time you recommended it to me,
>>> but apparently it's only highlighting errors? In blue color?
>>>
>>> Why isn't it telling me about warnings? :(
>>
>> Make sure that you set the path for checkpatch.pl properly in the extension settings and that you set it to run on every save.
>>
> I have these settings:
> 
> Checkpatch Path: checkpatch.pl (I have a link in /usr/bin)
> Diagnostic level: Information (but I can only see errors in blue)
> Run: onSave

Yeah I have same settings.  If you want checkpatch to be "louder", 
change it from information to something louder.

> 
> Not sure If I am doing something wrong, but it is working for sure because
> errors are reported.
>>>> 2) There is a pre-commit hook for checkpatch
>>>>
>>>> This will help make sure that it's "automatically" run on every code commit you do at the right time you make the patch (ie on a per-patch basis).
>>>>
>>>> https://github.com/dloidolt/pre-commit-checkpatch
>>> I am going to check this as well, thanks!
>>