Skip to contentSkip to conversation

platform/x86: introduce asus-armoury

PATCH Superseded Luke D. Jones 2 participants 19 messages Aug 6, 2024 – Sep 18, 2024

Subsystems (2)

v2 of 8 Superseded Latest is v8 →

lore
Share & tools
lore

Luke D. Jones

author maintainer
#0 lore raw

v2 cover platform/x86: introduce asus-armoury

This is the first major patch I've ever done with the intention of introducing a new module, so it's highly likely I've made some mistakes or misunderstood something.

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/[email protected]/

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.

The name asus-armoury was settled on after some debate with users of the module. This name is derived from the ASUS application named "Armoury Crate" as this is what many users look for in searches and articles when crossing over to Linux from Windows. The alternative was asus-fw-settings, which may still be up if there is any opposition to the new name.

I am unsure of how best to handle the deprecation of attributes.

There's also some attributes that are obviously boolean but are using 0/1. I'm unsure if I should change that.

And would it be best to move the asus stuff to a subdir now? Akin to the Dell platform stuff.

The two new files were formatted with clangd with line length 96

I get this with checkpatch:

```
ERROR: Macros with multiple statements should be enclosed in a do - while loop
#934: FILE: drivers/platform/x86/asus-armoury.h:116:
+#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
+	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                                \
+	__ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname)
```

I'm unsure what to do - adding the do/while breaks things.

All guidance deeply appreciated to get this over the line.

Regards,
Luke

Changelog:
- v1
- Initial submission
- v2
- Too many changes to list
- History: https://lore.kernel.org/platform-driver-x86/[email protected]/

Luke D. Jones (6):
platform/x86: asus-wmi: Add quirk for ROG Ally X platform/x86: asus-armoury: move existing tunings to asus-armoury
module
platform/x86: asus-armoury: add dgpu tgp control platform/x86: asus-armoury: add apu-mem control support platform/x86: asus-armoury: add core count control
asus-wmi: deprecate bios features

 .../ABI/testing/sysfs-platform-asus-wmi       |   17 +
 drivers/platform/x86/Kconfig                  |   22 +
 drivers/platform/x86/Makefile                 |    1 +
 drivers/platform/x86/asus-armoury.c           | 1047 +++++++++++++++++
 drivers/platform/x86/asus-armoury.h           |  241 ++++
 drivers/platform/x86/asus-wmi.c               |  187 ++-
 include/linux/platform_data/x86/asus-wmi.h    |   19 +
 7 files changed, 1506 insertions(+), 28 deletions(-)
 create mode 100644 drivers/platform/x86/asus-armoury.c
 create mode 100644 drivers/platform/x86/asus-armoury.h
Signature · 1 line
2.45.2
author maintainer
#1 lore raw

PATCH v2 1/6 platform/x86: asus-wmi: Add quirk for ROG Ally X

The new ROG Ally X functions the same as the previus model so we can use the same method to ensure the MCU USB devices wake and reconnect correctly.

Given that two devices marks the start of a trend, this patch also adds a quirk table to make future additions easier if the MCU is the same.

---
 drivers/platform/x86/asus-wmi.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)
drivers/platform/x86/asus-wmi.c +15 -1
index f15fcb45e1aa..0c80c6b0399b 100644
@@ -152,6 +152,20 @@ static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
 
 static int throttle_thermal_policy_write(struct asus_wmi *);
 
+static const struct dmi_system_id asus_ally_mcu_quirk[] = {
+	{
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
+		},
+	},
+	{
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "RC72L"),
+		},
+	},
+	{ },
+};
+
 static bool ashs_present(void)
 {
 	int i = 0;
@@ -4751,7 +4765,7 @@ static int asus_wmi_add(struct platform_device *pdev)
 	asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU);
 	asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE);
 	asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE)
-						&& dmi_match(DMI_BOARD_NAME, "RC71L");
+						&& dmi_check_system(asus_ally_mcu_quirk);
 
 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE))
 		asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
Signature · 1 line
2.45.2
maintainer Reviewed-by on v2 1/6
#2 lore raw

Re: [PATCH v2 1/6] platform/x86: asus-wmi: Add quirk for ROG Ally X

Quoted 1 line · Luke D. Jones

The new ROG Ally X functions the same as the previus model so we can use

previous

--
i.

Quoted 46 lines

the same method to ensure the MCU USB devices wake and reconnect correctly.

Given that two devices marks the start of a trend, this patch also adds a quirk table to make future additions easier if the MCU is the same.

---
 drivers/platform/x86/asus-wmi.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)
drivers/platform/x86/asus-wmi.c +15 -1
index f15fcb45e1aa..0c80c6b0399b 100644
@@ -152,6 +152,20 @@ static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
 
 static int throttle_thermal_policy_write(struct asus_wmi *);
 
+static const struct dmi_system_id asus_ally_mcu_quirk[] = {
+	{
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "RC71L"),
+		},
+	},
+	{
+		.matches = {
+			DMI_MATCH(DMI_BOARD_NAME, "RC72L"),
+		},
+	},
+	{ },
+};
+
 static bool ashs_present(void)
 {
 	int i = 0;
@@ -4751,7 +4765,7 @@ static int asus_wmi_add(struct platform_device *pdev)
 	asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU);
 	asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE);
 	asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE)
-						&& dmi_match(DMI_BOARD_NAME, "RC71L");
+						&& dmi_check_system(asus_ally_mcu_quirk);
 
 	if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE))
 		asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
Signature · 1 line
 i.
author maintainer
#3 lore raw

PATCH v2 2/6 platform/x86: asus-armoury: move existing tunings to asus-armoury module

In reply to Luke D. Jones

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.

---
 drivers/platform/x86/Kconfig               |  14 +
 drivers/platform/x86/Makefile              |   1 +
 drivers/platform/x86/asus-armoury.c        | 706 +++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        | 195 ++++++
 drivers/platform/x86/asus-wmi.c            |  48 +-
 include/linux/platform_data/x86/asus-wmi.h |  11 +
 6 files changed, 973 insertions(+), 2 deletions(-)
 create mode 100644 drivers/platform/x86/asus-armoury.c
 create mode 100644 drivers/platform/x86/asus-armoury.h
drivers/platform/x86/Kconfig +14 -0
index 665fa9524986..8ecc73ef2670 100644
@@ -265,6 +265,19 @@ 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 (firmware) Driver"
+	depends on ACPI_WMI
+	depends on ASUS_WMI
+	select FW_ATTR_CLASS
+	help
+	  Say Y here if you have a WMI aware Asus laptop 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
@@ -276,6 +289,7 @@ config ASUS_WMI
 	depends on HOTPLUG_PCI
 	depends on ACPI_VIDEO || ACPI_VIDEO = n
 	depends on SERIO_I8042 || SERIO_I8042 = n
+	select ASUS_ARMOURY
 	select INPUT_SPARSEKMAP
 	select LEDS_CLASS
 	select NEW_LEDS
drivers/platform/x86/Makefile +1 -0
index e1b142947067..fe3e7e7dede8 100644
@@ -32,6 +32,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
drivers/platform/x86/asus-armoury.c new file +706 -0

706 lines not on this page · raw message

drivers/platform/x86/asus-armoury.h new file +195 -0

195 lines not on this page · raw message

drivers/platform/x86/asus-wmi.c +46 -2

58 lines not on this page · raw message

include/linux/platform_data/x86/asus-wmi.h +11 -0
index b601b245a035..c164e656ae0b 100644
@@ -72,6 +72,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
@@ -157,8 +158,18 @@
 #define ASUS_WMI_DSTS_LIGHTBAR_MASK	0x0000000F
 
 #if IS_REACHABLE(CONFIG_ASUS_WMI)
+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
+static int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+	return -ENODEV;
+}
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
+{
+	return -ENODEV;
+}
 static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
 					   u32 *retval)
 {
Signature · 1 line
2.45.2
maintainer
#4 lore raw

Re: [PATCH v2 2/6] platform/x86: asus-armoury: move existing tunings to asus-armoury module

Quoted 168 lines · Luke D. Jones

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.

---
 drivers/platform/x86/Kconfig               |  14 +
 drivers/platform/x86/Makefile              |   1 +
 drivers/platform/x86/asus-armoury.c        | 706 +++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        | 195 ++++++
 drivers/platform/x86/asus-wmi.c            |  48 +-
 include/linux/platform_data/x86/asus-wmi.h |  11 +
 6 files changed, 973 insertions(+), 2 deletions(-)
 create mode 100644 drivers/platform/x86/asus-armoury.c
 create mode 100644 drivers/platform/x86/asus-armoury.h
drivers/platform/x86/Kconfig +14 -0
index 665fa9524986..8ecc73ef2670 100644
@@ -265,6 +265,19 @@ 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 (firmware) Driver"
+	depends on ACPI_WMI
+	depends on ASUS_WMI
+	select FW_ATTR_CLASS
+	help
+	  Say Y here if you have a WMI aware Asus laptop 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
@@ -276,6 +289,7 @@ config ASUS_WMI
 	depends on HOTPLUG_PCI
 	depends on ACPI_VIDEO || ACPI_VIDEO = n
 	depends on SERIO_I8042 || SERIO_I8042 = n
+	select ASUS_ARMOURY
 	select INPUT_SPARSEKMAP
 	select LEDS_CLASS
 	select NEW_LEDS
drivers/platform/x86/Makefile +1 -0
index e1b142947067..fe3e7e7dede8 100644
@@ -32,6 +32,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
drivers/platform/x86/asus-armoury.c new file +85 -0
new file mode 100644
index 000000000000..bb049ead00f9
@@ -0,0 +1,706 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Asus Armoury (WMI) attributes driver. This driver uses the fw_attributes
+ * class to expose the various WMI functions that many gaming and some
+ * non-gaming ASUS laptops have available.
+ * These typically don't fit anywhere else in the sysfs such as under LED class,
+ * hwmon or other, and are set in Windows using the ASUS Armoury Crate tool.
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2024-2024 Luke Jones <[email protected]>
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/types.h>
+#include <linux/dmi.h>
+#include <linux/device.h>
+#include <linux/kmod.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/kernel.h>
+#include "asus-armoury.h"
+#include "firmware_attributes_class.h"
+
+#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+#define ASUS_MINI_LED_MODE_MASK 0x03
+/* Standard modes for devices with only on/off */
+#define ASUS_MINI_LED_OFF 0x00
+#define ASUS_MINI_LED_ON 0x01
+/* New mode on some devices, define here to clarify remapping later */
+#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
+
+/* Default limits for tunables available on ASUS ROG laptops */
+#define PPT_CPU_LIMIT_MIN 5
+#define PPT_CPU_LIMIT_MAX 150
+#define PPT_CPU_LIMIT_DEFAULT 80
+#define PPT_PLATFORM_MIN 5
+#define PPT_PLATFORM_MAX 100
+#define PPT_PLATFORM_DEFAULT 80
+#define NVIDIA_BOOST_MIN 5
+#define NVIDIA_BOOST_MAX 25
+#define NVIDIA_TEMP_MIN 75
+#define NVIDIA_TEMP_MAX 87
+
+/* Tunables provided by ASUS for gaming laptops */
+struct rog_tunables {
+	u32 cpu_default;
+	u32 cpu_min;
+	u32 cpu_max;
+
+	u32 platform_default;
+	u32 platform_min;
+	u32 platform_max;
+
+	u32 ppt_pl1_spl; // cpu
+	u32 ppt_pl2_sppt; // cpu
+	u32 ppt_apu_sppt; // plat
+	u32 ppt_platform_sppt; // plat
+	u32 ppt_fppt; // cpu
+
+	u32 nv_boost_default;
+	u32 nv_boost_min;
+	u32 nv_boost_max;
+	u32 nv_dynamic_boost;
+
+	u32 nv_temp_default;
+	u32 nv_temp_min;
+	u32 nv_temp_max;
+	u32 nv_temp_target;
+};
+
+static const struct class *fw_attr_class;
+
+struct asus_armoury_priv {
+	struct device *fw_attr_dev;
+	struct kset *fw_attr_kset;

drivers/platform/x86/asus-armoury.c line 95

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+
+	struct rog_tunables *rog_tunables;
+	u32 mini_led_dev_id;
+	u32 gpu_mux_dev_id;
+
+	struct mutex mutex;
+};
+
+static struct asus_armoury_priv asus_armoury = { .mutex = __MUTEX_INITIALIZER(
+							 asus_armoury.mutex) };

Please put the mutex member on own line.

Quoted 105 lines
drivers/platform/x86/asus-armoury.c new file +105 -0
+
+struct fw_attrs_group {
+	u32 pending_reboot;
+};
+
+static struct fw_attrs_group fw_attrs = {
+	.pending_reboot = 0,
+};
+
+struct asus_attr_group {
+	const struct attribute_group *attr_group;
+	u32 wmi_devid;
+};
+
+/**
+ * asus_wmi_is_present() - determine if a WMI interface is available.
+ * @dev_id: The WMI function ID to use.
+ *
+ * Returns: Boolean state. Note that an error will also return false.
+ */
+static bool asus_wmi_is_present(u32 dev_id)
+{
+	u32 retval;
+	int status;
+
+	status = asus_wmi_get_devstate_dsts(dev_id, &retval);
+	pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
+
+	return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
+}
+
+static void asus_set_reboot_and_signal_event(void)
+{
+	fw_attrs.pending_reboot = 1;
+	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, "%u\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") ||
+	       !strcmp(attr->attr.name, "panel_hd_mode");
+}
+
+/**
+ * attr_int_store() - Generic store function for use with most WMI functions.
+ * @kobj: Pointer to the driver object.
+ * @kobj_attribute: Pointer the attribute calling this function.
+ * @buf: The buffer to read from, this is parsed to `int` type.
+ * @count:
+ * @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.
+ *
+ * The WMI functions available on most ASUS laptops return a 1 as "success", and
+ * a 0 as failed. However some functions can return n > 1 for additional errors.
+ * attr_int_store() currently treats all values which are not 1 as errors, ignoring
+ * the possible differences in WMI error returns.
+ *
+ * Returns: Either count, or an error.
+ */
+static ssize_t attr_int_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 result, value;
+	int err;
+
+	err = kstrtouint(buf, 10, &value);
+	if (err)
+		return err;
+
+	if (value < min || value > max)
+		return -EINVAL;
+
+	err = asus_wmi_set_devstate(wmi_dev, value, &result);
+	if (err) {
+		pr_err("Failed to set %s: %d\n", attr->attr.name, err);
+		return err;
+	}
+
+	if (result != 1) {
+		pr_err("Failed to set %s (result): 0x%x\n", attr->attr.name, result);
+		return -EIO;
+	}
+
+	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;
+}
+
+/* Mini-LED mode **************************************************************/
+static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,

drivers/platform/x86/asus-armoury.c line 210

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+						struct kobj_attribute *attr, char *buf)
+{
+	u32 value;
+	int err;
+
+	err = asus_wmi_get_devstate_dsts(asus_armoury.mini_led_dev_id, &value);
+	if (err)
+		return err;
+
+	value = value & ASUS_MINI_LED_MODE_MASK;

value &= ASUS_MINI_LED_MODE_MASK;

drivers/platform/x86/asus-armoury.c line 213

Quoted 3 lines
drivers/platform/x86/asus-armoury.c new file +3 -0
+
+	/*
+	 * Remap the mode values to match previous generation mini-led. The last gen

LED

drivers/platform/x86/asus-armoury.c line 214

Quoted 1 line
drivers/platform/x86/asus-armoury.c new file +1 -0
+	 * WMI 0 == off, while on this version WMI 2 ==off (flipped).

inconsistent spaces.

Quoted 116 lines
drivers/platform/x86/asus-armoury.c new file +116 -0
+	 */
+	if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+		switch (value) {
+		case ASUS_MINI_LED_2024_WEAK:
+			value = ASUS_MINI_LED_ON;
+			break;
+		case ASUS_MINI_LED_2024_STRONG:
+			value = ASUS_MINI_LED_STRONG_MODE;
+			break;
+		case ASUS_MINI_LED_2024_OFF:
+			value = ASUS_MINI_LED_OFF;
+			break;
+		}
+	}
+
+	return sysfs_emit(buf, "%u\n", value);
+}
+
+static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
+						 struct kobj_attribute *attr, const char *buf,
+						 size_t count)
+{
+	int result, err;
+	u32 mode;
+
+	err = kstrtou32(buf, 10, &mode);
+	if (err)
+		return err;
+
+	if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
+	    mode > ASUS_MINI_LED_ON)
+		return -EINVAL;
+	if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
+	    mode > ASUS_MINI_LED_STRONG_MODE)
+		return -EINVAL;
+
+	/*
+	 * Remap the mode values so expected behaviour is the same as the last
+	 * generation of mini-LED with 0 == off, 1 == on.
+	 */
+	if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+		switch (mode) {
+		case ASUS_MINI_LED_OFF:
+			mode = ASUS_MINI_LED_2024_OFF;
+			break;
+		case ASUS_MINI_LED_ON:
+			mode = ASUS_MINI_LED_2024_WEAK;
+			break;
+		case ASUS_MINI_LED_STRONG_MODE:
+			mode = ASUS_MINI_LED_2024_STRONG;
+			break;
+		}
+	}
+
+	err = asus_wmi_set_devstate(asus_armoury.mini_led_dev_id, mode, &result);
+	if (err) {
+		pr_warn("Failed to set mini-LED: %d\n", err);
+		return err;
+	}
+
+	if (result != 1) {
+		pr_warn("Failed to set mini-LED mode (result): 0x%x\n", result);
+		return -EIO;
+	}
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+
+static ssize_t mini_led_mode_possible_values_show(struct kobject *kobj,
+						  struct kobj_attribute *attr, char *buf)
+{
+	switch (asus_armoury.mini_led_dev_id) {
+	case ASUS_WMI_DEVID_MINI_LED_MODE:
+		return sysfs_emit(buf, "0;1\n");
+	case ASUS_WMI_DEVID_MINI_LED_MODE2:
+		return sysfs_emit(buf, "0;1;2\n");
+	}
+
+	return sysfs_emit(buf, "0\n");
+}
+
+ATTR_GROUP_ENUM_CUSTOM(mini_led_mode, "mini_led_mode", "Set the mini-LED backlight mode");
+
+static ssize_t gpu_mux_mode_current_value_store(struct kobject *kobj,
+						struct kobj_attribute *attr, const char *buf,
+						size_t count)
+{
+	int result, err;
+	u32 optimus;
+
+	err = kstrtou32(buf, 10, &optimus);
+	if (err)
+		return err;
+
+	if (optimus > 1)
+		return -EINVAL;
+
+	if (asus_wmi_is_present(ASUS_WMI_DEVID_DGPU)) {
+		err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_DGPU, &result);
+		if (err)
+			return err;
+		if (result && !optimus) {
+			err = -ENODEV;
+			pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n",
+				err);
+			return err;
+		}
+	}
+
+	if (asus_wmi_is_present(ASUS_WMI_DEVID_EGPU)) {
+		err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU, &result);
+		if (err)
+			return err;
+		if (result && !optimus) {

drivers/platform/x86/asus-armoury.c line 340

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+			err = -ENODEV;
+			pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n",
+				err);
+			return err;
+		}
+	}
+
+	err = asus_wmi_set_devstate(asus_armoury.gpu_mux_dev_id, optimus, &result);
+	if (err) {
+		pr_err("Failed to set GPU MUX mode: %d\nn", err);

Double n at the end of the string.

Quoted 7 lines
drivers/platform/x86/asus-armoury.c new file +7 -0
+		return err;
+	}
+	/* !1 is considered a fail by ASUS */
+	if (result != 1) {
+		pr_warn("Failed to set GPU MUX mode (result): 0x%x\n", result);
+		return -EIO;
+	}

drivers/platform/x86/asus-armoury.c line 357

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+WMI_SHOW_INT(gpu_mux_mode_current_value, "%d\n", asus_armoury.gpu_mux_dev_id);
+ATTR_GROUP_BOOL_CUSTOM(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
+
+/*
+ * A user may be required to store the value twice, typcial store first, then

typical

Quoted 55 lines
drivers/platform/x86/asus-armoury.c new file +55 -0
+ * rescan PCI bus to activate power, then store a second time to save correctly.
+ * The reason for this is that an extra code path in the ACPI is enabled when
+ * the device and bus are powered.
+ */
+static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
+						struct kobj_attribute *attr, const char *buf,
+						size_t count)
+{
+	int result, err;
+	u32 disable;
+
+	err = kstrtou32(buf, 10, &disable);
+	if (err)
+		return err;
+
+	if (disable > 1)
+		return -EINVAL;
+
+	if (asus_armoury.gpu_mux_dev_id) {
+		err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+		if (err)
+			return err;
+		if (!result && disable) {
+			err = -ENODEV;
+			pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err);
+			return err;
+		}
+	}
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result);
+	if (err) {
+		pr_warn("Failed to set dgpu disable: %d\n", err);
+		return err;
+	}
+
+	if (result != 1) {
+		pr_warn("Failed to set dgpu disable (result): 0x%x\n", result);
+		return -EIO;
+	}
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
+ATTR_GROUP_BOOL_CUSTOM(dgpu_disable, "dgpu_disable", "Disable the dGPU");
+
+/* The ACPI call to enable the eGPU also disables the internal dGPU */
+static ssize_t egpu_enable_current_value_store(struct kobject *kobj,
+					       struct kobj_attribute *attr, const char *buf,
+					       size_t count)
+{
+	int result, err;
+	u32 enable;
+

drivers/platform/x86/asus-armoury.c line 422

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+	err = kstrtou32(buf, 10, &enable);
+	if (err)
+		return err;
+
+	if (enable > 1)
+		return -EINVAL;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU_CONNECTED, &result);
+	if (err) {
+		pr_warn("Failed to get egpu connection status: %d\n", err);

eGPU

drivers/platform/x86/asus-armoury.c line 429

Quoted 7 lines
drivers/platform/x86/asus-armoury.c new file +7 -0
+		return err;
+	}
+
+	if (asus_armoury.gpu_mux_dev_id) {
+		err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+		if (err) {
+			pr_warn("Failed to get gpu mux status: %d\n", result);

GPU MUX

drivers/platform/x86/asus-armoury.c line 441

Quoted 12 lines
drivers/platform/x86/asus-armoury.c new file +12 -0
+			return result;
+		}
+		if (!result && enable) {
+			err = -ENODEV;
+			pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err);
+			return err;
+		}
+	}
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result);
+	if (err) {
+		pr_warn("Failed to set egpu state: %d\n", err);

eGPU

drivers/platform/x86/asus-armoury.c line 446

Quoted 5 lines
drivers/platform/x86/asus-armoury.c new file +5 -0
+		return err;
+	}
+
+	if (result != 1) {
+		pr_warn("Failed to set egpu state (retval): 0x%x\n", result);

eGPU

Quoted 180 lines
drivers/platform/x86/asus-armoury.c new file +180 -0
+		return -EIO;
+	}
+
+	sysfs_notify(kobj, NULL, attr->attr.name);
+
+	return count;
+}
+WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
+ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
+
+/* Simple attribute creation */
+ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
+		       cpu_min, cpu_max, 1, "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_pl2_sppt, "ppt_pl2_sppt", ASUS_WMI_DEVID_PPT_PL2_SPPT, cpu_default,
+		       cpu_min, cpu_max, 1, "Set the CPU fast package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_apu_sppt, "ppt_apu_sppt", ASUS_WMI_DEVID_PPT_APU_SPPT,
+		       platform_default, platform_min, platform_max, 1,
+		       "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_platform_sppt, "ppt_platform_sppt", ASUS_WMI_DEVID_PPT_PLAT_SPPT,
+		       platform_default, platform_min, platform_max, 1,
+		       "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_fppt, "ppt_fppt", ASUS_WMI_DEVID_PPT_FPPT, cpu_default, cpu_min,
+		       cpu_max, 1, "Set the CPU slow package limit");
+
+ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, "nv_dynamic_boost", ASUS_WMI_DEVID_NV_DYN_BOOST,
+		       nv_boost_default, nv_boost_min, nv_boost_max, 1,
+		       "Set the Nvidia dynamic boost limit");
+ATTR_GROUP_ROG_TUNABLE(nv_temp_target, "nv_temp_target", ASUS_WMI_DEVID_NV_THERM_TARGET,
+		       nv_temp_default, nv_boost_min, nv_temp_max, 1,
+		       "Set the Nvidia max thermal limit");
+
+ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
+		       "Show the current mode of charging");
+ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
+		   "Set the boot POST sound");
+ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
+		   "Set MCU powersaving mode");
+ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
+		   "Set the panel refresh overdrive");
+ATTR_GROUP_BOOL_RW(panel_hd_mode, "panel_hd_mode", ASUS_WMI_DEVID_PANEL_HD,
+		   "Set the panel HD mode to UHD<0> or FHD<1>");
+ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
+		   "Show the eGPU connection status");
+
+/* 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 },
+
+	{ &ppt_pl1_spl_attr_group, ASUS_WMI_DEVID_PPT_PL1_SPL },
+	{ &ppt_pl2_sppt_attr_group, ASUS_WMI_DEVID_PPT_PL2_SPPT },
+	{ &ppt_apu_sppt_attr_group, ASUS_WMI_DEVID_PPT_APU_SPPT },
+	{ &ppt_platform_sppt_attr_group, ASUS_WMI_DEVID_PPT_PLAT_SPPT },
+	{ &ppt_fppt_attr_group, ASUS_WMI_DEVID_PPT_FPPT },
+	{ &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
+	{ &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
+
+	{ &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 },
+	{ &panel_hd_mode_attr_group, ASUS_WMI_DEVID_PANEL_HD },
+};
+
+static int asus_fw_attr_add(void)
+{
+	int err;
+
+	err = fw_attributes_class_get(&fw_attr_class);
+	if (err)
+		goto fail_class_created;
+
+	asus_armoury.fw_attr_dev =
+		device_create(fw_attr_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_created;
+	}
+
+	asus_armoury.fw_attr_kset =
+		kset_create_and_add("attributes", NULL, &asus_armoury.fw_attr_dev->kobj);
+	if (!asus_armoury.fw_attr_dev) {
+		err = -ENOMEM;
+		pr_debug("Failed to create and add attributes\n");
+		goto err_destroy_classdev;
+	}
+
+	err = sysfs_create_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+	if (err) {
+		pr_warn("Failed to create sysfs level attributes\n");
+		goto fail_class_created;
+	}
+
+	err = 0;
+	asus_armoury.mini_led_dev_id = 0;
+	if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE)) {
+		asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
+		err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+					 &mini_led_mode_attr_group);
+	} else if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE2)) {
+		asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
+		err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+					 &mini_led_mode_attr_group);
+	}
+	if (err)
+		pr_warn("Failed to create sysfs-group for mini_led\n");
+
+	err = 0;
+	asus_armoury.gpu_mux_dev_id = 0;
+	if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX)) {
+		asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
+		err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+					 &gpu_mux_mode_attr_group);
+	} else if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX_VIVO)) {
+		asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX_VIVO;
+		err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+					 &gpu_mux_mode_attr_group);
+	}
+	if (err)
+		pr_warn("Failed to create sysfs-group for gpu_mux\n");
+
+	for (int i = 0; i < ARRAY_SIZE(armoury_attr_groups); i++) {
+		if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
+			continue;
+
+		err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+					 armoury_attr_groups[i].attr_group);
+		if (err)
+			pr_warn("Failed to create sysfs-group for %s\n",
+				armoury_attr_groups[i].attr_group->name);
+		else
+			pr_debug("Created sysfs-group for %s\n",
+				 armoury_attr_groups[i].attr_group->name);
+	}
+
+	return 0;
+
+err_destroy_classdev:
+	device_destroy(fw_attr_class, MKDEV(0, 0));
+
+fail_class_created:
+	fw_attributes_class_put();
+	return err;
+}
+
+/* Init / exit ****************************************************************/
+
+/* Set up the min/max and defaults for ROG tunables */
+static void init_rog_tunables(struct rog_tunables *rog)
+{
+	const char *product;
+	u32 max_boost = NVIDIA_BOOST_MAX;
+	u32 cpu_default = PPT_CPU_LIMIT_DEFAULT;
+	u32 cpu_max = PPT_CPU_LIMIT_MAX;
+	u32 platform_default = PPT_PLATFORM_DEFAULT;
+	u32 platform_max = PPT_PLATFORM_MAX;
+
+	/*
+	 * ASUS product_name contains everything required, e.g,
+	 * "ROG Flow X16 GV601VV_GV601VV_00185149B"
+	 */
+	product = dmi_get_system_info(DMI_PRODUCT_NAME);
+
+	if (strstr(product, "GA402R")) {
+		cpu_default = 125;
+	} else if (strstr(product, "13QY")) {
+		cpu_max = 250;
+	} else if (strstr(product, "X13")) {
+		cpu_max = 75;
+		cpu_default = 50;
+	} else if (strstr(product, "RC71")) {
+		cpu_max = 50;
+		cpu_default = 30;
+	} else if (strstr(product, "G814") || strstr(product, "G614") ||
+		   strstr(product, "G834") || strstr(product, "G634")) {
+		cpu_max = 175;
+	} else if (strstr(product, "GA402X") || strstr(product, "GA403") ||
+		   strstr(product, "FA507N") || strstr(product, "FA507X") ||

drivers/platform/x86/asus-armoury.c line 636

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+		   strstr(product, "FA707N") || strstr(product, "FA707X")) {
+		cpu_max = 90;
+	}
+
+	if (strstr(product, "GZ301ZE"))
+		max_boost = 5;
+	else if (strstr(product, "FX507ZC4"))
+		max_boost = 15;
+	else if (strstr(product, "GU605"))
+		max_boost = 20;

It would be nice if driver_data could be used to store per model information rather than using if forests. It's a bit tricky to realize with dmi_check_system() though, only because you've rog available on global level, a callback could store info directly into rog fields but it doesn't not feel very clean solution having to have a global variable.

Quoted 28 lines
drivers/platform/x86/asus-armoury.c new file +28 -0
+	/* ensure defaults for tunables */
+	rog->cpu_default = cpu_default;
+	rog->cpu_min = PPT_CPU_LIMIT_MIN;
+	rog->cpu_max = cpu_max;
+
+	rog->platform_default = platform_default;
+	rog->platform_max = PPT_PLATFORM_MIN;
+	rog->platform_max = platform_max;
+
+	rog->ppt_pl1_spl = cpu_default;
+	rog->ppt_pl2_sppt = cpu_default;
+	rog->ppt_apu_sppt = cpu_default;
+
+	rog->ppt_platform_sppt = platform_default;
+	rog->ppt_fppt = platform_default;
+
+	rog->nv_boost_default = NVIDIA_BOOST_MAX;
+	rog->nv_boost_max = NVIDIA_BOOST_MIN;
+	rog->nv_boost_max = max_boost;
+	rog->nv_dynamic_boost = NVIDIA_BOOST_MIN;
+
+	rog->nv_temp_default = NVIDIA_TEMP_MAX;
+	rog->nv_temp_max = NVIDIA_TEMP_MIN;
+	rog->nv_temp_max = NVIDIA_TEMP_MAX;
+	rog->nv_temp_target = NVIDIA_TEMP_MIN;
+}
+
+static int __init asus_fw_init(void)

drivers/platform/x86/asus-armoury.c line 675

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+{
+	int err;
+
+	fw_attrs.pending_reboot = 0;
+
+	mutex_lock(&asus_armoury.mutex);
+
+	asus_armoury.rog_tunables = kzalloc(sizeof(struct rog_tunables), GFP_KERNEL);
+	if (!asus_armoury.rog_tunables) {
+		mutex_unlock(&asus_armoury.mutex);

Please use guard() to make this function much simpler. But why you need to take mutex here at all?

Quoted 38 lines
drivers/platform/x86/asus-armoury.c new file +31 -0
+		return -ENOMEM;
+	}
+	init_rog_tunables(asus_armoury.rog_tunables);
+
+	err = asus_fw_attr_add();
+	mutex_unlock(&asus_armoury.mutex);
+	if (err)
+		return err;
+
+	return 0;
+}
+
+static void __exit asus_fw_exit(void)
+{
+	mutex_lock(&asus_armoury.mutex);
+
+	sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+	kset_unregister(asus_armoury.fw_attr_kset);
+	device_destroy(fw_attr_class, MKDEV(0, 0));
+	fw_attributes_class_put();
+
+	mutex_unlock(&asus_armoury.mutex);
+}
+
+module_init(asus_fw_init);
+module_exit(asus_fw_exit);
+
+MODULE_AUTHOR("Luke Jones <[email protected]>");
+MODULE_DESCRIPTION("ASUS BIOS Configuration Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("wmi:" ASUS_NB_WMI_EVENT_GUID);
drivers/platform/x86/asus-armoury.h new file +1 -0
new file mode 100644
index 000000000000..146170f91e69
@@ -0,0 +1,195 @@
+/* SPDX-License-Identifier: GPL-2.0

drivers/platform/x86/asus-armoury.h line 11

Quoted 10 lines
drivers/platform/x86/asus-armoury.h new file +10 -0
+ *
+ * Definitions for kernel modules using asus-armoury driver
+ *
+ *  Copyright (c) 2024 Luke Jones <[email protected]>
+ */
+
+#ifndef _ASUS_BIOSCFG_H_
+#define _ASUS_BIOSCFG_H_
+
+#include <linux/types.h>

This is missing some includes for structs and functions you use below.

drivers/platform/x86/asus-armoury.h line 19

Quoted 8 lines
drivers/platform/x86/asus-armoury.h new file +8 -0
+
+#define DRIVER_NAME "asus-armoury"
+
+static ssize_t attr_int_store(struct kobject *kobj, struct kobj_attribute *attr,
+			      const char *buf, size_t count, u32 min, u32 max, u32 *store_value,
+			      u32 wmi_dev);
+
+static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

drivers/platform/x86/asus-armoury.h line 21

Quoted 2 lines
drivers/platform/x86/asus-armoury.h new file +2 -0
+{
+	return sysfs_emit(buf, "integer\n");

Lukas Wunner might have done something to make emitting constant strings easier, please check out if that's already in mainline.

drivers/platform/x86/asus-armoury.h line 24

Quoted 3 lines
drivers/platform/x86/asus-armoury.h new file +3 -0
+}
+
+static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

Quoted 195 lines
drivers/platform/x86/asus-armoury.h new file +171 -0
+{
+	return sysfs_emit(buf, "enumeration\n");
+}
+
+#define __ASUS_ATTR_RO(_func, _name)                                  \
+	{                                                             \
+		.attr = { .name = __stringify(_name), .mode = 0444 }, \
+		.show = _func##_##_name##_show,                       \
+	}
+
+#define __ASUS_ATTR_RO_AS(_name, _show)                               \
+	{                                                             \
+		.attr = { .name = __stringify(_name), .mode = 0444 }, \
+		.show = _show,                                        \
+	}
+
+#define __ASUS_ATTR_RW(_func, _name) \
+	__ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store)
+
+#define __WMI_STORE_INT(_attr, _min, _max, _wmi)                                        \
+	static ssize_t _attr##_store(struct kobject *kobj, struct kobj_attribute *attr, \
+				     const char *buf, size_t count)                     \
+	{                                                                               \
+		return attr_int_store(kobj, attr, buf, count, _min, _max, NULL, _wmi);  \
+	}
+
+#define WMI_SHOW_INT(_attr, _fmt, _wmi)                                                \
+	static ssize_t _attr##_show(struct kobject *kobj, struct kobj_attribute *attr, \
+				    char *buf)                                         \
+	{                                                                              \
+		u32 result;                                                            \
+		int err;                                                               \
+		err = asus_wmi_get_devstate_dsts(_wmi, &result);                       \
+		if (err)                                                               \
+			return err;                                                    \
+		return sysfs_emit(buf, _fmt, result & ~ASUS_WMI_DSTS_PRESENCE_BIT);    \
+	}
+
+/* Create functions and attributes for use in other macros or on their own */
+
+#define __ATTR_CURRENT_INT_RO(_attr, _wmi)                          \
+	WMI_SHOW_INT(_attr##_current_value, "%d\n", _wmi);          \
+	static struct kobj_attribute attr_##_attr##_current_value = \
+		__ASUS_ATTR_RO(_attr, current_value)
+
+#define __ATTR_CURRENT_INT_RW(_attr, _minv, _maxv, _wmi)            \
+	__WMI_STORE_INT(_attr##_current_value, _minv, _maxv, _wmi); \
+	WMI_SHOW_INT(_attr##_current_value, "%d\n", _wmi);          \
+	static struct kobj_attribute attr_##_attr##_current_value = \
+		__ASUS_ATTR_RW(_attr, current_value)
+
+/* 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)
+
+/* Boolean style enumeration, base macro. Requires adding show/store */
+#define __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname)                            \
+	__ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);                           \
+	__ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible);                        \
+	static struct kobj_attribute attr_##_attrname##_type =                                 \
+		__ASUS_ATTR_RO_AS(type, enum_type_show);                                       \
+	static struct attribute *_attrname##_attrs[] = {                                       \
+		&attr_##_attrname##_current_value.attr, &attr_##_attrname##_display_name.attr, \
+		&attr_##_attrname##_possible_values.attr, &attr_##_attrname##_type.attr, NULL  \
+	};                                                                                     \
+	static const struct attribute_group _attrname##_attr_group = {                         \
+		.name = _fsname, .attrs = _attrname##_attrs                                    \
+	}
+
+#define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
+	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                 \
+	__ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+#define ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname) \
+	__ATTR_CURRENT_INT_RW(_attrname, 0, 1, _wmi);           \
+	__ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ */
+#define ATTR_GROUP_BOOL_CUSTOM(_attrname, _fsname, _dispname)           \
+	static struct kobj_attribute attr_##_attrname##_current_value = \
+		__ASUS_ATTR_RW(_attrname, current_value);               \
+	__ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
+	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                                \
+	__ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ * and <name>_possible_values_show()
+ */
+#define ATTR_GROUP_ENUM_CUSTOM(_attrname, _fsname, _dispname)                                  \
+	__ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);                           \
+	static struct kobj_attribute attr_##_attrname##_current_value =                        \
+		__ASUS_ATTR_RW(_attrname, current_value);                                      \
+	static struct kobj_attribute attr_##_attrname##_possible_values =                      \
+		__ASUS_ATTR_RO(_attrname, possible_values);                                    \
+	static struct kobj_attribute attr_##_attrname##_type =                                 \
+		__ASUS_ATTR_RO_AS(type, enum_type_show);                                       \
+	static struct attribute *_attrname##_attrs[] = {                                       \
+		&attr_##_attrname##_current_value.attr, &attr_##_attrname##_display_name.attr, \
+		&attr_##_attrname##_possible_values.attr, &attr_##_attrname##_type.attr, NULL  \
+	};                                                                                     \
+	static const struct attribute_group _attrname##_attr_group = {                         \
+		.name = _fsname, .attrs = _attrname##_attrs                                    \
+	}
+
+/*
+ * ROG PPT attributes need a little different in setup as they
+ * require rog_tunables members.
+ */
+
+#define __ROG_TUNABLE_RW(_attr, _min, _max, _wmi)                                              \
+	static ssize_t _attr##_current_value_store(struct kobject *kobj,                       \
+						   struct kobj_attribute *attr,                \
+						   const char *buf, size_t count)              \
+	{                                                                                      \
+		return attr_int_store(kobj, attr, buf, count, asus_armoury.rog_tunables->_min, \
+				      asus_armoury.rog_tunables->_max,                         \
+				      &asus_armoury.rog_tunables->_attr, _wmi);                \
+	}                                                                                      \
+	static ssize_t _attr##_current_value_show(struct kobject *kobj,                        \
+						  struct kobj_attribute *attr, char *buf)      \
+	{                                                                                      \
+		return sysfs_emit(buf, "%u\n", asus_armoury.rog_tunables->_attr);              \
+	}                                                                                      \
+	static struct kobj_attribute attr_##_attr##_current_value =                            \
+		__ASUS_ATTR_RW(_attr, current_value)
+
+#define __ROG_TUNABLE_SHOW(_prop, _attrname, _val)                                        \
+	static ssize_t _attrname##_##_prop##_show(struct kobject *kobj,                   \
+						  struct kobj_attribute *attr, char *buf) \
+	{                                                                                 \
+		return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->_val);          \
+	}                                                                                 \
+	static struct kobj_attribute attr_##_attrname##_##_prop =                         \
+		__ASUS_ATTR_RO(_attrname, _prop)
+
+#define ATTR_GROUP_ROG_TUNABLE(_attrname, _fsname, _wmi, _default, _min, _max, _incstep, \
+			       _dispname)                                                \
+	__ROG_TUNABLE_SHOW(default_value, _attrname, _default);                          \
+	__ROG_TUNABLE_RW(_attrname, _min, _max, _wmi);                                   \
+	__ROG_TUNABLE_SHOW(min_value, _attrname, _min);                                  \
+	__ROG_TUNABLE_SHOW(max_value, _attrname, _max);                                  \
+	__ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", _incstep);                  \
+	__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                              \
+	}
+
+#endif /* _ASUS_BIOSCFG_H_ */
drivers/platform/x86/asus-wmi.c +14 -2
index 0c80c6b0399b..165e7932c371 100644
@@ -550,12 +550,56 @@ static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 	return 0;
 }
 
-static 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 function to call.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state can also be used to determine if the WMI
+ * function is supported by checking if the asus_wmi_get_devstate_dsts()
+ * returns an error.
+ *
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed, or if it returns "unsupported" which is typically a 0
+ * (no return, and no 'supported' bit set), or a 0xFFFFFFFE (~1) which if not
+ * caught here can result in unexpected behaviour later.

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 576

Quoted 10 lines
drivers/platform/x86/asus-wmi.c +10 -0
+ */
+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;
+	/* Be explicit about retval */
+	if (*retval == 0xFFFFFFFE || *retval == 0)

Please name the literals with defines.

Quoted 16 lines
drivers/platform/x86/asus-wmi.c +16 -0
+		return -ENODEV;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_get_devstate_dsts);
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ * @dev_id: The WMI function to call.
+ * @ctrl_param: The argument to be used for this WMI function.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state if not checked here for error as
+ * asus_wmi_set_devstate() is not called unless first paired with a call to
+ * asus_wmi_get_devstate_dsts() to check that the WMI function is supported.
+ *

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 602

Quoted 10 lines
drivers/platform/x86/asus-wmi.c +6 -0
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed.
+ */
+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_GPL(asus_wmi_set_devstate);

Namespace exports.

Signature · 1 line
 i.
Quoted 34 lines
drivers/platform/x86/asus-wmi.c +0 -0
 /* Helper for special devices with magic return codes */
 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
include/linux/platform_data/x86/asus-wmi.h +11 -0
index b601b245a035..c164e656ae0b 100644
@@ -72,6 +72,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
@@ -157,8 +158,18 @@
 #define ASUS_WMI_DSTS_LIGHTBAR_MASK	0x0000000F
 
 #if IS_REACHABLE(CONFIG_ASUS_WMI)
+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
+static int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+	return -ENODEV;
+}
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
+{
+	return -ENODEV;
+}
 static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
 					   u32 *retval)
 {
author maintainer
#5 lore raw

Re: [PATCH v2 2/6] platform/x86: asus-armoury: move existing tunings to asus-armoury module

Quoted 743 lines · Ilpo Järvinen
Quoted 168 lines · Luke D. Jones

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.

---
 drivers/platform/x86/Kconfig               |  14 +
 drivers/platform/x86/Makefile              |   1 +
 drivers/platform/x86/asus-armoury.c        | 706 +++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        | 195 ++++++
 drivers/platform/x86/asus-wmi.c            |  48 +-
 include/linux/platform_data/x86/asus-wmi.h |  11 +
 6 files changed, 973 insertions(+), 2 deletions(-)
 create mode 100644 drivers/platform/x86/asus-armoury.c
 create mode 100644 drivers/platform/x86/asus-armoury.h
drivers/platform/x86/Kconfig +14 -0
index 665fa9524986..8ecc73ef2670 100644
@@ -265,6 +265,19 @@ 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 (firmware) Driver"
+ depends on ACPI_WMI
+ depends on ASUS_WMI
+ select FW_ATTR_CLASS
+ help
+   Say Y here if you have a WMI aware Asus laptop 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
@@ -276,6 +289,7 @@ config ASUS_WMI
 depends on HOTPLUG_PCI
 depends on ACPI_VIDEO || ACPI_VIDEO = n
 depends on SERIO_I8042 || SERIO_I8042 = n
+ select ASUS_ARMOURY
 select INPUT_SPARSEKMAP
 select LEDS_CLASS
 select NEW_LEDS
drivers/platform/x86/Makefile +1 -0
index e1b142947067..fe3e7e7dede8 100644
@@ -32,6 +32,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
drivers/platform/x86/asus-armoury.c new file +85 -0
new file mode 100644
index 000000000000..bb049ead00f9
@@ -0,0 +1,706 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Asus Armoury (WMI) attributes driver. This driver uses the fw_attributes
+ * class to expose the various WMI functions that many gaming and some
+ * non-gaming ASUS laptops have available.
+ * These typically don't fit anywhere else in the sysfs such as under LED class,
+ * hwmon or other, and are set in Windows using the ASUS Armoury Crate tool.
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2024-2024 Luke Jones <[email protected]>
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/platform_data/x86/asus-wmi.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/types.h>
+#include <linux/dmi.h>
+#include <linux/device.h>
+#include <linux/kmod.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/kernel.h>
+#include "asus-armoury.h"
+#include "firmware_attributes_class.h"
+
+#define ASUS_NB_WMI_EVENT_GUID "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+#define ASUS_MINI_LED_MODE_MASK 0x03
+/* Standard modes for devices with only on/off */
+#define ASUS_MINI_LED_OFF 0x00
+#define ASUS_MINI_LED_ON 0x01
+/* New mode on some devices, define here to clarify remapping later */
+#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
+
+/* Default limits for tunables available on ASUS ROG laptops */
+#define PPT_CPU_LIMIT_MIN 5
+#define PPT_CPU_LIMIT_MAX 150
+#define PPT_CPU_LIMIT_DEFAULT 80
+#define PPT_PLATFORM_MIN 5
+#define PPT_PLATFORM_MAX 100
+#define PPT_PLATFORM_DEFAULT 80
+#define NVIDIA_BOOST_MIN 5
+#define NVIDIA_BOOST_MAX 25
+#define NVIDIA_TEMP_MIN 75
+#define NVIDIA_TEMP_MAX 87
+
+/* Tunables provided by ASUS for gaming laptops */
+struct rog_tunables {
+ u32 cpu_default;
+ u32 cpu_min;
+ u32 cpu_max;
+
+ u32 platform_default;
+ u32 platform_min;
+ u32 platform_max;
+
+ u32 ppt_pl1_spl; // cpu
+ u32 ppt_pl2_sppt; // cpu
+ u32 ppt_apu_sppt; // plat
+ u32 ppt_platform_sppt; // plat
+ u32 ppt_fppt; // cpu
+
+ u32 nv_boost_default;
+ u32 nv_boost_min;
+ u32 nv_boost_max;
+ u32 nv_dynamic_boost;
+
+ u32 nv_temp_default;
+ u32 nv_temp_min;
+ u32 nv_temp_max;
+ u32 nv_temp_target;
+};
+
+static const struct class *fw_attr_class;
+
+struct asus_armoury_priv {
+ struct device *fw_attr_dev;
+ struct kset *fw_attr_kset;

drivers/platform/x86/asus-armoury.c line 95

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+
+ struct rog_tunables *rog_tunables;
+ u32 mini_led_dev_id;
+ u32 gpu_mux_dev_id;
+
+ struct mutex mutex;
+};
+
+static struct asus_armoury_priv asus_armoury = { .mutex = __MUTEX_INITIALIZER(
+ asus_armoury.mutex) };

Please put the mutex member on own line.

Quoted 105 lines
drivers/platform/x86/asus-armoury.c new file +105 -0
+
+struct fw_attrs_group {
+ u32 pending_reboot;
+};
+
+static struct fw_attrs_group fw_attrs = {
+ .pending_reboot = 0,
+};
+
+struct asus_attr_group {
+ const struct attribute_group *attr_group;
+ u32 wmi_devid;
+};
+
+/**
+ * asus_wmi_is_present() - determine if a WMI interface is available.
+ * @dev_id: The WMI function ID to use.
+ *
+ * Returns: Boolean state. Note that an error will also return false.
+ */
+static bool asus_wmi_is_present(u32 dev_id)
+{
+ u32 retval;
+ int status;
+
+ status = asus_wmi_get_devstate_dsts(dev_id, &retval);
+ pr_debug("%s called (0x%08x), retval: 0x%08x\n", __func__, dev_id, retval);
+
+ return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
+}
+
+static void asus_set_reboot_and_signal_event(void)
+{
+ fw_attrs.pending_reboot = 1;
+ 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, "%u\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") ||
+        !strcmp(attr->attr.name, "panel_hd_mode");
+}
+
+/**
+ * attr_int_store() - Generic store function for use with most WMI functions.
+ * @kobj: Pointer to the driver object.
+ * @kobj_attribute: Pointer the attribute calling this function.
+ * @buf: The buffer to read from, this is parsed to `int` type.
+ * @count:
+ * @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.
+ *
+ * The WMI functions available on most ASUS laptops return a 1 as "success", and
+ * a 0 as failed. However some functions can return n > 1 for additional errors.
+ * attr_int_store() currently treats all values which are not 1 as errors, ignoring
+ * the possible differences in WMI error returns.
+ *
+ * Returns: Either count, or an error.
+ */
+static ssize_t attr_int_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 result, value;
+ int err;
+
+ err = kstrtouint(buf, 10, &value);
+ if (err)
+ return err;
+
+ if (value < min || value > max)
+ return -EINVAL;
+
+ err = asus_wmi_set_devstate(wmi_dev, value, &result);
+ if (err) {
+ pr_err("Failed to set %s: %d\n", attr->attr.name, err);
+ return err;
+ }
+
+ if (result != 1) {
+ pr_err("Failed to set %s (result): 0x%x\n", attr->attr.name, result);
+ return -EIO;
+ }
+
+ 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;
+}
+
+/* Mini-LED mode **************************************************************/
+static ssize_t mini_led_mode_current_value_show(struct kobject *kobj,

drivers/platform/x86/asus-armoury.c line 210

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+ struct kobj_attribute *attr, char *buf)
+{
+ u32 value;
+ int err;
+
+ err = asus_wmi_get_devstate_dsts(asus_armoury.mini_led_dev_id, &value);
+ if (err)
+ return err;
+
+ value = value & ASUS_MINI_LED_MODE_MASK;

value &= ASUS_MINI_LED_MODE_MASK;

drivers/platform/x86/asus-armoury.c line 213

Quoted 3 lines
drivers/platform/x86/asus-armoury.c new file +3 -0
+
+ /*
+ * Remap the mode values to match previous generation mini-led. The last gen

LED

drivers/platform/x86/asus-armoury.c line 214

Quoted 1 line
drivers/platform/x86/asus-armoury.c new file +1 -0
+ * WMI 0 == off, while on this version WMI 2 ==off (flipped).

inconsistent spaces.

Quoted 116 lines
drivers/platform/x86/asus-armoury.c new file +116 -0
+ */
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+ switch (value) {
+ case ASUS_MINI_LED_2024_WEAK:
+ value = ASUS_MINI_LED_ON;
+ break;
+ case ASUS_MINI_LED_2024_STRONG:
+ value = ASUS_MINI_LED_STRONG_MODE;
+ break;
+ case ASUS_MINI_LED_2024_OFF:
+ value = ASUS_MINI_LED_OFF;
+ break;
+ }
+ }
+
+ return sysfs_emit(buf, "%u\n", value);
+}
+
+static ssize_t mini_led_mode_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int result, err;
+ u32 mode;
+
+ err = kstrtou32(buf, 10, &mode);
+ if (err)
+ return err;
+
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE &&
+     mode > ASUS_MINI_LED_ON)
+ return -EINVAL;
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 &&
+     mode > ASUS_MINI_LED_STRONG_MODE)
+ return -EINVAL;
+
+ /*
+ * Remap the mode values so expected behaviour is the same as the last
+ * generation of mini-LED with 0 == off, 1 == on.
+ */
+ if (asus_armoury.mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) {
+ switch (mode) {
+ case ASUS_MINI_LED_OFF:
+ mode = ASUS_MINI_LED_2024_OFF;
+ break;
+ case ASUS_MINI_LED_ON:
+ mode = ASUS_MINI_LED_2024_WEAK;
+ break;
+ case ASUS_MINI_LED_STRONG_MODE:
+ mode = ASUS_MINI_LED_2024_STRONG;
+ break;
+ }
+ }
+
+ err = asus_wmi_set_devstate(asus_armoury.mini_led_dev_id, mode, &result);
+ if (err) {
+ pr_warn("Failed to set mini-LED: %d\n", err);
+ return err;
+ }
+
+ if (result != 1) {
+ pr_warn("Failed to set mini-LED mode (result): 0x%x\n", result);
+ return -EIO;
+ }
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+
+static ssize_t mini_led_mode_possible_values_show(struct kobject *kobj,
+   struct kobj_attribute *attr, char *buf)
+{
+ switch (asus_armoury.mini_led_dev_id) {
+ case ASUS_WMI_DEVID_MINI_LED_MODE:
+ return sysfs_emit(buf, "0;1\n");
+ case ASUS_WMI_DEVID_MINI_LED_MODE2:
+ return sysfs_emit(buf, "0;1;2\n");
+ }
+
+ return sysfs_emit(buf, "0\n");
+}
+
+ATTR_GROUP_ENUM_CUSTOM(mini_led_mode, "mini_led_mode", "Set the mini-LED backlight mode");
+
+static ssize_t gpu_mux_mode_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int result, err;
+ u32 optimus;
+
+ err = kstrtou32(buf, 10, &optimus);
+ if (err)
+ return err;
+
+ if (optimus > 1)
+ return -EINVAL;
+
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_DGPU)) {
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_DGPU, &result);
+ if (err)
+ return err;
+ if (result && !optimus) {
+ err = -ENODEV;
+ pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n",
+ err);
+ return err;
+ }
+ }
+
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_EGPU)) {
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU, &result);
+ if (err)
+ return err;
+ if (result && !optimus) {

drivers/platform/x86/asus-armoury.c line 340

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+ err = -ENODEV;
+ pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n",
+ err);
+ return err;
+ }
+ }
+
+ err = asus_wmi_set_devstate(asus_armoury.gpu_mux_dev_id, optimus, &result);
+ if (err) {
+ pr_err("Failed to set GPU MUX mode: %d\nn", err);

Double n at the end of the string.

Quoted 7 lines
drivers/platform/x86/asus-armoury.c new file +7 -0
+ return err;
+ }
+ /* !1 is considered a fail by ASUS */
+ if (result != 1) {
+ pr_warn("Failed to set GPU MUX mode (result): 0x%x\n", result);
+ return -EIO;
+ }

drivers/platform/x86/asus-armoury.c line 357

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+WMI_SHOW_INT(gpu_mux_mode_current_value, "%d\n", asus_armoury.gpu_mux_dev_id);
+ATTR_GROUP_BOOL_CUSTOM(gpu_mux_mode, "gpu_mux_mode", "Set the GPU display MUX mode");
+
+/*
+ * A user may be required to store the value twice, typcial store first, then

typical

Quoted 55 lines
drivers/platform/x86/asus-armoury.c new file +55 -0
+ * rescan PCI bus to activate power, then store a second time to save correctly.
+ * The reason for this is that an extra code path in the ACPI is enabled when
+ * the device and bus are powered.
+ */
+static ssize_t dgpu_disable_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ size_t count)
+{
+ int result, err;
+ u32 disable;
+
+ err = kstrtou32(buf, 10, &disable);
+ if (err)
+ return err;
+
+ if (disable > 1)
+ return -EINVAL;
+
+ if (asus_armoury.gpu_mux_dev_id) {
+ err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+ if (err)
+ return err;
+ if (!result && disable) {
+ err = -ENODEV;
+ pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err);
+ return err;
+ }
+ }
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result);
+ if (err) {
+ pr_warn("Failed to set dgpu disable: %d\n", err);
+ return err;
+ }
+
+ if (result != 1) {
+ pr_warn("Failed to set dgpu disable (result): 0x%x\n", result);
+ return -EIO;
+ }
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+WMI_SHOW_INT(dgpu_disable_current_value, "%d\n", ASUS_WMI_DEVID_DGPU);
+ATTR_GROUP_BOOL_CUSTOM(dgpu_disable, "dgpu_disable", "Disable the dGPU");
+
+/* The ACPI call to enable the eGPU also disables the internal dGPU */
+static ssize_t egpu_enable_current_value_store(struct kobject *kobj,
+        struct kobj_attribute *attr, const char *buf,
+        size_t count)
+{
+ int result, err;
+ u32 enable;
+

drivers/platform/x86/asus-armoury.c line 422

Quoted 10 lines
drivers/platform/x86/asus-armoury.c new file +10 -0
+ err = kstrtou32(buf, 10, &enable);
+ if (err)
+ return err;
+
+ if (enable > 1)
+ return -EINVAL;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_EGPU_CONNECTED, &result);
+ if (err) {
+ pr_warn("Failed to get egpu connection status: %d\n", err);

eGPU

drivers/platform/x86/asus-armoury.c line 429

Quoted 7 lines
drivers/platform/x86/asus-armoury.c new file +7 -0
+ return err;
+ }
+
+ if (asus_armoury.gpu_mux_dev_id) {
+ err = asus_wmi_get_devstate_dsts(asus_armoury.gpu_mux_dev_id, &result);
+ if (err) {
+ pr_warn("Failed to get gpu mux status: %d\n", result);

GPU MUX

drivers/platform/x86/asus-armoury.c line 441

Quoted 12 lines
drivers/platform/x86/asus-armoury.c new file +12 -0
+ return result;
+ }
+ if (!result && enable) {
+ err = -ENODEV;
+ pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err);
+ return err;
+ }
+ }
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result);
+ if (err) {
+ pr_warn("Failed to set egpu state: %d\n", err);

eGPU

drivers/platform/x86/asus-armoury.c line 446

Quoted 5 lines
drivers/platform/x86/asus-armoury.c new file +5 -0
+ return err;
+ }
+
+ if (result != 1) {
+ pr_warn("Failed to set egpu state (retval): 0x%x\n", result);

eGPU

Quoted 182 lines
drivers/platform/x86/asus-armoury.c new file +182 -0
+ return -EIO;
+ }
+
+ sysfs_notify(kobj, NULL, attr->attr.name);
+
+ return count;
+}
+WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
+ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
+
+/* Simple attribute creation */
+ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
+        cpu_min, cpu_max, 1, "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_pl2_sppt, "ppt_pl2_sppt", ASUS_WMI_DEVID_PPT_PL2_SPPT, cpu_default,
+        cpu_min, cpu_max, 1, "Set the CPU fast package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_apu_sppt, "ppt_apu_sppt", ASUS_WMI_DEVID_PPT_APU_SPPT,
+        platform_default, platform_min, platform_max, 1,
+        "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_platform_sppt, "ppt_platform_sppt", ASUS_WMI_DEVID_PPT_PLAT_SPPT,
+        platform_default, platform_min, platform_max, 1,
+        "Set the CPU slow package limit");
+ATTR_GROUP_ROG_TUNABLE(ppt_fppt, "ppt_fppt", ASUS_WMI_DEVID_PPT_FPPT, cpu_default, cpu_min,
+        cpu_max, 1, "Set the CPU slow package limit");
+
+ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, "nv_dynamic_boost", ASUS_WMI_DEVID_NV_DYN_BOOST,
+        nv_boost_default, nv_boost_min, nv_boost_max, 1,
+        "Set the Nvidia dynamic boost limit");
+ATTR_GROUP_ROG_TUNABLE(nv_temp_target, "nv_temp_target", ASUS_WMI_DEVID_NV_THERM_TARGET,
+        nv_temp_default, nv_boost_min, nv_temp_max, 1,
+        "Set the Nvidia max thermal limit");
+
+ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
+        "Show the current mode of charging");
+ATTR_GROUP_BOOL_RW(boot_sound, "boot_sound", ASUS_WMI_DEVID_BOOT_SOUND,
+    "Set the boot POST sound");
+ATTR_GROUP_BOOL_RW(mcu_powersave, "mcu_powersave", ASUS_WMI_DEVID_MCU_POWERSAVE,
+    "Set MCU powersaving mode");
+ATTR_GROUP_BOOL_RW(panel_od, "panel_overdrive", ASUS_WMI_DEVID_PANEL_OD,
+    "Set the panel refresh overdrive");
+ATTR_GROUP_BOOL_RW(panel_hd_mode, "panel_hd_mode", ASUS_WMI_DEVID_PANEL_HD,
+    "Set the panel HD mode to UHD<0> or FHD<1>");
+ATTR_GROUP_BOOL_RO(egpu_connected, "egpu_connected", ASUS_WMI_DEVID_EGPU_CONNECTED,
+    "Show the eGPU connection status");
+
+/* 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 },
+
+ { &ppt_pl1_spl_attr_group, ASUS_WMI_DEVID_PPT_PL1_SPL },
+ { &ppt_pl2_sppt_attr_group, ASUS_WMI_DEVID_PPT_PL2_SPPT },
+ { &ppt_apu_sppt_attr_group, ASUS_WMI_DEVID_PPT_APU_SPPT },
+ { &ppt_platform_sppt_attr_group, ASUS_WMI_DEVID_PPT_PLAT_SPPT },
+ { &ppt_fppt_attr_group, ASUS_WMI_DEVID_PPT_FPPT },
+ { &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
+ { &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
+
+ { &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 },
+ { &panel_hd_mode_attr_group, ASUS_WMI_DEVID_PANEL_HD },
+};
+
+static int asus_fw_attr_add(void)
+{
+ int err;
+
+ err = fw_attributes_class_get(&fw_attr_class);
+ if (err)
+ goto fail_class_created;
+
+ asus_armoury.fw_attr_dev =
+ device_create(fw_attr_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_created;
+ }
+
+ asus_armoury.fw_attr_kset =
+ kset_create_and_add("attributes", NULL, &asus_armoury.fw_attr_dev->kobj);
+ if (!asus_armoury.fw_attr_dev) {
+ err = -ENOMEM;
+ pr_debug("Failed to create and add attributes\n");
+ goto err_destroy_classdev;
+ }
+
+ err = sysfs_create_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+ if (err) {
+ pr_warn("Failed to create sysfs level attributes\n");
+ goto fail_class_created;
+ }
+
+ err = 0;
+ asus_armoury.mini_led_dev_id = 0;
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE)) {
+ asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE;
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &mini_led_mode_attr_group);
+ } else if (asus_wmi_is_present(ASUS_WMI_DEVID_MINI_LED_MODE2)) {
+ asus_armoury.mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2;
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &mini_led_mode_attr_group);
+ }
+ if (err)
+ pr_warn("Failed to create sysfs-group for mini_led\n");
+
+ err = 0;
+ asus_armoury.gpu_mux_dev_id = 0;
+ if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX)) {
+ asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX;
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &gpu_mux_mode_attr_group);
+ } else if (asus_wmi_is_present(ASUS_WMI_DEVID_GPU_MUX_VIVO)) {
+ asus_armoury.gpu_mux_dev_id = ASUS_WMI_DEVID_GPU_MUX_VIVO;
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ &gpu_mux_mode_attr_group);
+ }
+ if (err)
+ pr_warn("Failed to create sysfs-group for gpu_mux\n");
+
+ for (int i = 0; i < ARRAY_SIZE(armoury_attr_groups); i++) {
+ if (!asus_wmi_is_present(armoury_attr_groups[i].wmi_devid))
+ continue;
+
+ err = sysfs_create_group(&asus_armoury.fw_attr_kset->kobj,
+ armoury_attr_groups[i].attr_group);
+ if (err)
+ pr_warn("Failed to create sysfs-group for %s\n",
+ armoury_attr_groups[i].attr_group->name);
+ else
+ pr_debug("Created sysfs-group for %s\n",
+ armoury_attr_groups[i].attr_group->name);
+ }
+
+ return 0;
+
+err_destroy_classdev:
+ device_destroy(fw_attr_class, MKDEV(0, 0));
+
+fail_class_created:
+ fw_attributes_class_put();
+ return err;
+}
+
+/* Init / exit ****************************************************************/
+
+/* Set up the min/max and defaults for ROG tunables */
+static void init_rog_tunables(struct rog_tunables *rog)
+{
+ const char *product;
+ u32 max_boost = NVIDIA_BOOST_MAX;
+ u32 cpu_default = PPT_CPU_LIMIT_DEFAULT;
+ u32 cpu_max = PPT_CPU_LIMIT_MAX;
+ u32 platform_default = PPT_PLATFORM_DEFAULT;
+ u32 platform_max = PPT_PLATFORM_MAX;
+
+ /*
+ * ASUS product_name contains everything required, e.g,
+ * "ROG Flow X16 GV601VV_GV601VV_00185149B"
+ */
+ product = dmi_get_system_info(DMI_PRODUCT_NAME);
+
+ if (strstr(product, "GA402R")) {
+ cpu_default = 125;
+ } else if (strstr(product, "13QY")) {
+ cpu_max = 250;
+ } else if (strstr(product, "X13")) {
+ cpu_max = 75;
+ cpu_default = 50;
+ } else if (strstr(product, "RC71")) {
+ cpu_max = 50;
+ cpu_default = 30;
+ } else if (strstr(product, "G814") || strstr(product, "G614") ||
+    strstr(product, "G834") || strstr(product, "G634")) {
+ cpu_max = 175;
+ } else if (strstr(product, "GA402X") || strstr(product, "GA403") ||
+    strstr(product, "FA507N") || strstr(product, "FA507X") ||
+    strstr(product, "FA707N") || strstr(product, "FA707X")) {
+ cpu_max = 90;
Quoted 8 lines

drivers/platform/x86/asus-armoury.c line 636

Quoted 8 lines
drivers/platform/x86/asus-armoury.c new file +8 -0
+ }
+
+ if (strstr(product, "GZ301ZE"))
+ max_boost = 5;
+ else if (strstr(product, "FX507ZC4"))
+ max_boost = 15;
+ else if (strstr(product, "GU605"))
+ max_boost = 20;

Ack everything up to here - search and replace many things.

Quoted 5 lines

It would be nice if driver_data could be used to store per model information rather than using if forests. It's a bit tricky to realize with dmi_check_system() though, only because you've rog available on global level, a callback could store info directly into rog fields but it doesn't not feel very clean solution having to have a global variable.

I agree. I had been trying to think of a better way to do this, and woul dlike to revisit later, after having the patch accepted.

Quoted 33 lines
Quoted 33 lines
drivers/platform/x86/asus-armoury.c new file +33 -0
+ /* ensure defaults for tunables */
+ rog->cpu_default = cpu_default;
+ rog->cpu_min = PPT_CPU_LIMIT_MIN;
+ rog->cpu_max = cpu_max;
+
+ rog->platform_default = platform_default;
+ rog->platform_max = PPT_PLATFORM_MIN;
+ rog->platform_max = platform_max;
+
+ rog->ppt_pl1_spl = cpu_default;
+ rog->ppt_pl2_sppt = cpu_default;
+ rog->ppt_apu_sppt = cpu_default;
+
+ rog->ppt_platform_sppt = platform_default;
+ rog->ppt_fppt = platform_default;
+
+ rog->nv_boost_default = NVIDIA_BOOST_MAX;
+ rog->nv_boost_max = NVIDIA_BOOST_MIN;
+ rog->nv_boost_max = max_boost;
+ rog->nv_dynamic_boost = NVIDIA_BOOST_MIN;
+
+ rog->nv_temp_default = NVIDIA_TEMP_MAX;
+ rog->nv_temp_max = NVIDIA_TEMP_MIN;
+ rog->nv_temp_max = NVIDIA_TEMP_MAX;
+ rog->nv_temp_target = NVIDIA_TEMP_MIN;
+}
+
+static int __init asus_fw_init(void)
+{
+ int err;
+
+ fw_attrs.pending_reboot = 0;
+
Quoted 8 lines

drivers/platform/x86/asus-armoury.c line 675

Quoted 5 lines
drivers/platform/x86/asus-armoury.c new file +5 -0
+ mutex_lock(&asus_armoury.mutex);
+
+ asus_armoury.rog_tunables = kzalloc(sizeof(struct rog_tunables), GFP_KERNEL);
+ if (!asus_armoury.rog_tunables) {
+ mutex_unlock(&asus_armoury.mutex);

Please use guard() to make this function much simpler. But why you need to take mutex here at all?

I don't :) TBH I don't know if a mutex is required in any of this driver at all and I'll review the use of it. As it is it was used in just these two places.

Quoted 63 lines
Quoted 39 lines
drivers/platform/x86/asus-armoury.c new file +31 -0
+ return -ENOMEM;
+ }
+ init_rog_tunables(asus_armoury.rog_tunables);
+
+ err = asus_fw_attr_add();
+ mutex_unlock(&asus_armoury.mutex);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static void __exit asus_fw_exit(void)
+{
+ mutex_lock(&asus_armoury.mutex);
+
+ sysfs_remove_file(&asus_armoury.fw_attr_kset->kobj, &pending_reboot.attr);
+ kset_unregister(asus_armoury.fw_attr_kset);
+ device_destroy(fw_attr_class, MKDEV(0, 0));
+ fw_attributes_class_put();
+
+ mutex_unlock(&asus_armoury.mutex);
+}
+
+module_init(asus_fw_init);
+module_exit(asus_fw_exit);
+
+MODULE_AUTHOR("Luke Jones <[email protected]>");
+MODULE_DESCRIPTION("ASUS BIOS Configuration Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("wmi:" ASUS_NB_WMI_EVENT_GUID);
drivers/platform/x86/asus-armoury.h new file +1 -0
new file mode 100644
index 000000000000..146170f91e69
@@ -0,0 +1,195 @@
+/* SPDX-License-Identifier: GPL-2.0

drivers/platform/x86/asus-armoury.h line 11

Quoted 10 lines
drivers/platform/x86/asus-armoury.h new file +10 -0
+ *
+ * Definitions for kernel modules using asus-armoury driver
+ *
+ *  Copyright (c) 2024 Luke Jones <[email protected]>
+ */
+
+#ifndef _ASUS_BIOSCFG_H_
+#define _ASUS_BIOSCFG_H_
+
+#include <linux/types.h>

This is missing some includes for structs and functions you use below.

drivers/platform/x86/asus-armoury.h line 19

Quoted 8 lines
drivers/platform/x86/asus-armoury.h new file +8 -0
+
+#define DRIVER_NAME "asus-armoury"
+
+static ssize_t attr_int_store(struct kobject *kobj, struct kobj_attribute *attr,
+       const char *buf, size_t count, u32 min, u32 max, u32 *store_value,
+       u32 wmi_dev);
+
+static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

Quoted 5 lines

drivers/platform/x86/asus-armoury.h line 21

Quoted 2 lines
drivers/platform/x86/asus-armoury.h new file +2 -0
+{
+ return sysfs_emit(buf, "integer\n");

Lukas Wunner might have done something to make emitting constant strings easier, please check out if that's already in mainline.

I'm not sure what I'm looking for here. Searching my current pdx86 pull isn't returning anything likely and I can't find anything on lore.

Quoted 206 lines

drivers/platform/x86/asus-armoury.h line 24

Quoted 4 lines
drivers/platform/x86/asus-armoury.h new file +3 -0
+}
+
+static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

Quoted 199 lines
drivers/platform/x86/asus-armoury.h new file +171 -0
+{
+ return sysfs_emit(buf, "enumeration\n");
+}
+
+#define __ASUS_ATTR_RO(_func, _name)                                  \
+ {                                                             \
+ .attr = { .name = __stringify(_name), .mode = 0444 }, \
+ .show = _func##_##_name##_show,                       \
+ }
+
+#define __ASUS_ATTR_RO_AS(_name, _show)                               \
+ {                                                             \
+ .attr = { .name = __stringify(_name), .mode = 0444 }, \
+ .show = _show,                                        \
+ }
+
+#define __ASUS_ATTR_RW(_func, _name) \
+ __ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store)
+
+#define __WMI_STORE_INT(_attr, _min, _max, _wmi)                                        \
+ static ssize_t _attr##_store(struct kobject *kobj, struct kobj_attribute *attr, \
+      const char *buf, size_t count)                     \
+ {                                                                               \
+ return attr_int_store(kobj, attr, buf, count, _min, _max, NULL, _wmi);  \
+ }
+
+#define WMI_SHOW_INT(_attr, _fmt, _wmi)                                                \
+ static ssize_t _attr##_show(struct kobject *kobj, struct kobj_attribute *attr, \
+     char *buf)                                         \
+ {                                                                              \
+ u32 result;                                                            \
+ int err;                                                               \
+ err = asus_wmi_get_devstate_dsts(_wmi, &result);                       \
+ if (err)                                                               \
+ return err;                                                    \
+ return sysfs_emit(buf, _fmt, result & ~ASUS_WMI_DSTS_PRESENCE_BIT);    \
+ }
+
+/* Create functions and attributes for use in other macros or on their own */
+
+#define __ATTR_CURRENT_INT_RO(_attr, _wmi)                          \
+ WMI_SHOW_INT(_attr##_current_value, "%d\n", _wmi);          \
+ static struct kobj_attribute attr_##_attr##_current_value = \
+ __ASUS_ATTR_RO(_attr, current_value)
+
+#define __ATTR_CURRENT_INT_RW(_attr, _minv, _maxv, _wmi)            \
+ __WMI_STORE_INT(_attr##_current_value, _minv, _maxv, _wmi); \
+ WMI_SHOW_INT(_attr##_current_value, "%d\n", _wmi);          \
+ static struct kobj_attribute attr_##_attr##_current_value = \
+ __ASUS_ATTR_RW(_attr, current_value)
+
+/* 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)
+
+/* Boolean style enumeration, base macro. Requires adding show/store */
+#define __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname)                            \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);                           \
+ __ATTR_SHOW_FMT(possible_values, _attrname, "%s\n", _possible);                        \
+ static struct kobj_attribute attr_##_attrname##_type =                                 \
+ __ASUS_ATTR_RO_AS(type, enum_type_show);                                       \
+ static struct attribute *_attrname##_attrs[] = {                                       \
+ &attr_##_attrname##_current_value.attr, &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, &attr_##_attrname##_type.attr, NULL  \
+ };                                                                                     \
+ static const struct attribute_group _attrname##_attr_group = {                         \
+ .name = _fsname, .attrs = _attrname##_attrs                                    \
+ }
+
+#define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
+ __ATTR_CURRENT_INT_RO(_attrname, _wmi);                 \
+ __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+#define ATTR_GROUP_BOOL_RW(_attrname, _fsname, _wmi, _dispname) \
+ __ATTR_CURRENT_INT_RW(_attrname, 0, 1, _wmi);           \
+ __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ */
+#define ATTR_GROUP_BOOL_CUSTOM(_attrname, _fsname, _dispname)           \
+ static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value);               \
+ __ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
+
+#define ATTR_GROUP_ENUM_INT_RO(_attrname, _fsname, _wmi, _possible, _dispname) \
+ __ATTR_CURRENT_INT_RO(_attrname, _wmi);                                \
+ __ATTR_GROUP_ENUM(_attrname, _fsname, _possible, _dispname)
+
+/*
+ * Requires <name>_current_value_show(), <name>_current_value_show()
+ * and <name>_possible_values_show()
+ */
+#define ATTR_GROUP_ENUM_CUSTOM(_attrname, _fsname, _dispname)                                  \
+ __ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);                           \
+ static struct kobj_attribute attr_##_attrname##_current_value =                        \
+ __ASUS_ATTR_RW(_attrname, current_value);                                      \
+ static struct kobj_attribute attr_##_attrname##_possible_values =                      \
+ __ASUS_ATTR_RO(_attrname, possible_values);                                    \
+ static struct kobj_attribute attr_##_attrname##_type =                                 \
+ __ASUS_ATTR_RO_AS(type, enum_type_show);                                       \
+ static struct attribute *_attrname##_attrs[] = {                                       \
+ &attr_##_attrname##_current_value.attr, &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_possible_values.attr, &attr_##_attrname##_type.attr, NULL  \
+ };                                                                                     \
+ static const struct attribute_group _attrname##_attr_group = {                         \
+ .name = _fsname, .attrs = _attrname##_attrs                                    \
+ }
+
+/*
+ * ROG PPT attributes need a little different in setup as they
+ * require rog_tunables members.
+ */
+
+#define __ROG_TUNABLE_RW(_attr, _min, _max, _wmi)                                              \
+ static ssize_t _attr##_current_value_store(struct kobject *kobj,                       \
+    struct kobj_attribute *attr,                \
+    const char *buf, size_t count)              \
+ {                                                                                      \
+ return attr_int_store(kobj, attr, buf, count, asus_armoury.rog_tunables->_min, \
+       asus_armoury.rog_tunables->_max,                         \
+       &asus_armoury.rog_tunables->_attr, _wmi);                \
+ }                                                                                      \
+ static ssize_t _attr##_current_value_show(struct kobject *kobj,                        \
+   struct kobj_attribute *attr, char *buf)      \
+ {                                                                                      \
+ return sysfs_emit(buf, "%u\n", asus_armoury.rog_tunables->_attr);              \
+ }                                                                                      \
+ static struct kobj_attribute attr_##_attr##_current_value =                            \
+ __ASUS_ATTR_RW(_attr, current_value)
+
+#define __ROG_TUNABLE_SHOW(_prop, _attrname, _val)                                        \
+ static ssize_t _attrname##_##_prop##_show(struct kobject *kobj,                   \
+   struct kobj_attribute *attr, char *buf) \
+ {                                                                                 \
+ return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->_val);          \
+ }                                                                                 \
+ static struct kobj_attribute attr_##_attrname##_##_prop =                         \
+ __ASUS_ATTR_RO(_attrname, _prop)
+
+#define ATTR_GROUP_ROG_TUNABLE(_attrname, _fsname, _wmi, _default, _min, _max, _incstep, \
+        _dispname)                                                \
+ __ROG_TUNABLE_SHOW(default_value, _attrname, _default);                          \
+ __ROG_TUNABLE_RW(_attrname, _min, _max, _wmi);                                   \
+ __ROG_TUNABLE_SHOW(min_value, _attrname, _min);                                  \
+ __ROG_TUNABLE_SHOW(max_value, _attrname, _max);                                  \
+ __ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", _incstep);                  \
+ __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                              \
+ }
+
+#endif /* _ASUS_BIOSCFG_H_ */
drivers/platform/x86/asus-wmi.c +18 -2
index 0c80c6b0399b..165e7932c371 100644
@@ -550,12 +550,56 @@ static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 return 0;
 }
 
-static 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 function to call.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state can also be used to determine if the WMI
+ * function is supported by checking if the asus_wmi_get_devstate_dsts()
+ * returns an error.
+ *
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed, or if it returns "unsupported" which is typically a 0
+ * (no return, and no 'supported' bit set), or a 0xFFFFFFFE (~1) which if not
+ * caught here can result in unexpected behaviour later.
+ */
+int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+ int err;
Quoted 8 lines

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 576

Quoted 6 lines
drivers/platform/x86/asus-wmi.c +6 -0
+
+ err = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, retval);
+ if (err)
+ return err;
+ /* Be explicit about retval */
+ if (*retval == 0xFFFFFFFE || *retval == 0)

Please name the literals with defines.

Should have been ASUS_WMI_UNSUPPORTED_METHOD :)

Quoted 21 lines
Quoted 21 lines
drivers/platform/x86/asus-wmi.c +20 -0
+ return -ENODEV;
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_get_devstate_dsts);
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ * @dev_id: The WMI function to call.
+ * @ctrl_param: The argument to be used for this WMI function.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state if not checked here for error as
+ * asus_wmi_set_devstate() is not called unless first paired with a call to
+ * asus_wmi_get_devstate_dsts() to check that the WMI function is supported.
+ *
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed.
+ */
Quoted 8 lines

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 602

Quoted 6 lines
drivers/platform/x86/asus-wmi.c +2 -0
+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_GPL(asus_wmi_set_devstate);

Namespace exports.

I'm sorry, I don't understand.

Thanks,
Luke.

Quoted 39 lines
Signature · 2 lines
-- 
i.
Quoted 34 lines
drivers/platform/x86/asus-wmi.c +0 -0
 /* Helper for special devices with magic return codes */
 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
include/linux/platform_data/x86/asus-wmi.h +11 -0
index b601b245a035..c164e656ae0b 100644
@@ -72,6 +72,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
@@ -157,8 +158,18 @@
 #define ASUS_WMI_DSTS_LIGHTBAR_MASK 0x0000000F
 
 #if IS_REACHABLE(CONFIG_ASUS_WMI)
+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
+static int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+ return -ENODEV;
+}
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, u32 *retval)
+{
+ return -ENODEV;
+}
 static inline int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
    u32 *retval)
 {
maintainer
#6 lore raw

Re: [PATCH v2 2/6] platform/x86: asus-armoury: move existing tunings to asus-armoury module

Quoted 34 lines · Luke Jones
Quoted 33 lines · Ilpo Järvinen
Quoted 23 lines · Luke D. Jones

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.

drivers/platform/x86/asus-armoury.h line 19

Quoted 5 lines
drivers/platform/x86/asus-armoury.h new file +5 -0
+static ssize_t attr_int_store(struct kobject *kobj, struct kobj_attribute *attr,
+       const char *buf, size_t count, u32 min, u32 max, u32 *store_value,
+       u32 wmi_dev);
+
+static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

Quoted 8 lines
Quoted 5 lines
Quoted 2 lines

+{
+ return sysfs_emit(buf, "integer\n");

Lukas Wunner might have done something to make emitting constant strings easier, please check out if that's already in mainline.

I'm not sure what I'm looking for here. Searching my current pdx86 pull isn't returning anything likely and I can't find anything on lore.

I think that was done mostly outside of pdx86, here it is:

https://lore.kernel.org/all/[email protected]/

So DEVICE_STRING_ATTR_RO() seems the way to go, I think.

Quoted 18 lines
Quoted 9 lines
Quoted 9 lines

+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed, or if it returns "unsupported" which is typically a 0
+ * (no return, and no 'supported' bit set), or a 0xFFFFFFFE (~1) which if not
+ * caught here can result in unexpected behaviour later.
+ */

drivers/platform/x86/asus-wmi.c +3 -0
+int asus_wmi_get_devstate_dsts(u32 dev_id, u32 *retval)
+{
+ int err;
Quoted 8 lines
Quoted 6 lines

+
+ err = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, dev_id, 0, retval);
+ if (err)
+ return err;
+ /* Be explicit about retval */
+ if (*retval == 0xFFFFFFFE || *retval == 0)

Please name the literals with defines.

Quoted 1 line

Should have been ASUS_WMI_UNSUPPORTED_METHOD :)

Is one define enough if you have two ways to indicate "unsupported"?

Quoted 29 lines
Quoted 20 lines
Quoted 20 lines

+ return -ENODEV;

drivers/platform/x86/asus-wmi.c +19 -0
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_get_devstate_dsts);
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ * @dev_id: The WMI function to call.
+ * @ctrl_param: The argument to be used for this WMI function.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state if not checked here for error as
+ * asus_wmi_set_devstate() is not called unless first paired with a call to
+ * asus_wmi_get_devstate_dsts() to check that the WMI function is supported.
+ *
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed.
+ */
Quoted 8 lines

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 602

Quoted 6 lines
drivers/platform/x86/asus-wmi.c +2 -0
+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_GPL(asus_wmi_set_devstate);

Namespace exports.

Quoted 1 line

I'm sorry, I don't understand.

Use EXPORT_SYMBOL_NS_GPL(). The driver using the functions, will then do MODULE_IMPORT_NS() to pair with the namespace defined by the EXPORT_SYMBOL_NS_GPL().

Signature · 1 line
 i.
author maintainer
#7 lore raw

Re: [PATCH v2 2/6] platform/x86: asus-armoury: move existing tunings to asus-armoury module

Quoted 42 lines · Ilpo Järvinen
Quoted 40 lines · Luke Jones
Quoted 38 lines · Ilpo Järvinen
Quoted 23 lines · Luke D. Jones

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.

drivers/platform/x86/asus-armoury.h line 19

Quoted 5 lines
drivers/platform/x86/asus-armoury.h new file +5 -0
+static ssize_t attr_int_store(struct kobject *kobj, struct kobj_attribute *attr,
+       const char *buf, size_t count, u32 min, u32 max, u32 *store_value,
+       u32 wmi_dev);
+
+static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)

inline missing

Quoted 2 lines

+{
+ return sysfs_emit(buf, "integer\n");

Lukas Wunner might have done something to make emitting constant strings easier, please check out if that's already in mainline.

Quoted 8 lines
Quoted 2 lines

I'm not sure what I'm looking for here. Searching my current pdx86 pull isn't returning anything likely and I can't find anything on lore.

I think that was done mostly outside of pdx86, here it is:

https://lore.kernel.org/all/[email protected]/

So DEVICE_STRING_ATTR_RO() seems the way to go, I think.

Thanks. I did try this but the signature is different to the bulk of what I;ve done already. I don't have the time for it yet and will revisit it later.

Quoted 19 lines
Quoted 19 lines
Quoted 18 lines
Quoted 7 lines

+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed, or if it returns "unsupported" which is typically a 0
+ * (no return, and no 'supported' bit set), or a 0xFFFFFFFE (~1) which if not
+ * caught here can result in unexpected behaviour later.
+ */

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 576

Quoted 9 lines
drivers/platform/x86/asus-wmi.c +9 -0
+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;
+ /* Be explicit about retval */
+ if (*retval == 0xFFFFFFFE || *retval == 0)

Please name the literals with defines.

Quoted 3 lines
Quoted 1 line

Should have been ASUS_WMI_UNSUPPORTED_METHOD :)

Is one define enough if you have two ways to indicate "unsupported"?

This function body wasn't correct. It now is and that retval == 0 is removed.

Quoted 30 lines
Quoted 30 lines
Quoted 29 lines
Quoted 17 lines

+ return -ENODEV;

drivers/platform/x86/asus-wmi.c +15 -0
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_get_devstate_dsts);
+
+/**
+ * asus_wmi_set_devstate() - Set the WMI function state.
+ * @dev_id: The WMI function to call.
+ * @ctrl_param: The argument to be used for this WMI function.
+ * @retval: A pointer to where to store the value returned from WMI.
+ *
+ * The returned WMI function state if not checked here for error as
+ * asus_wmi_set_devstate() is not called unless first paired with a call to
+ * asus_wmi_get_devstate_dsts() to check that the WMI function is supported.
+ *

drivers/platform/x86/asus-wmi.c static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) · line 602

Quoted 10 lines
drivers/platform/x86/asus-wmi.c +6 -0
+ * On success the return value is 0, and the retval is a valid value returned
+ * by the successful WMI function call. An error value is returned only if the
+ * WMI function failed.
+ */
+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_GPL(asus_wmi_set_devstate);

Namespace exports.

Quoted 5 lines
Quoted 1 line

I'm sorry, I don't understand.

Use EXPORT_SYMBOL_NS_GPL(). The driver using the functions, will then do MODULE_IMPORT_NS() to pair with the namespace defined by the EXPORT_SYMBOL_NS_GPL().

Got it. I did wonder about this while reading a few kernel books (rather old now).

Quoted 4 lines
Signature · 2 lines
-- 
i.
author maintainer
#8 lore raw

Re: [PATCH v2 2/6] platform/x86: asus-armoury: move existing tunings to asus-armoury module

In reply to Ilpo Järvinen
Quoted 5 lines
Quoted 2 lines

+{
+ return sysfs_emit(buf, "integer\n");

Lukas Wunner might have done something to make emitting constant strings easier, please check out if that's already in mainline.

Found it, DEVICE_STRING_ATTR_RO is what you mean?

author maintainer
#9 lore raw

PATCH v2 3/6 platform/x86: asus-armoury: add dgpu tgp control

In reply to Luke D. Jones

Implement the dgpu TGP control under the asus-armoury module using the fw_attributes class.

---
 drivers/platform/x86/asus-armoury.c        | 20 ++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        | 17 +++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |  3 +++
 3 files changed, 40 insertions(+)
drivers/platform/x86/asus-armoury.c +20 -0
index bb049ead00f9..31dbdacd8978 100644
@@ -50,6 +50,9 @@
 #define NVIDIA_BOOST_MAX 25
 #define NVIDIA_TEMP_MIN 75
 #define NVIDIA_TEMP_MAX 87
+#define NVIDIA_POWER_MIN 0
+#define NVIDIA_POWER_MAX 70
+#define NVIDIA_POWER_DEFAULT 70
 
 /* Tunables provided by ASUS for gaming laptops */
 struct rog_tunables {
@@ -76,6 +79,11 @@ struct rog_tunables {
 	u32 nv_temp_min;
 	u32 nv_temp_max;
 	u32 nv_temp_target;
+
+	u32 dgpu_tgp_default;
+	u32 dgpu_tgp_min;
+	u32 dgpu_tgp_max;
+	u32 dgpu_tgp;
 };
 
 static const struct class *fw_attr_class;
@@ -474,6 +482,11 @@ ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, "nv_dynamic_boost", ASUS_WMI_DEVID_NV_D
 ATTR_GROUP_ROG_TUNABLE(nv_temp_target, "nv_temp_target", ASUS_WMI_DEVID_NV_THERM_TARGET,
 		       nv_temp_default, nv_boost_min, nv_temp_max, 1,
 		       "Set the Nvidia max thermal limit");
+ATTR_GROUP_INT_VALUE_ONLY_RO(dgpu_base_tgp, "dgpu_base_tgp", ASUS_WMI_DEVID_DGPU_BASE_TGP,
+			     "Read the base TGP value");
+ATTR_GROUP_ROG_TUNABLE(dgpu_tgp, "dgpu_tgp", ASUS_WMI_DEVID_DGPU_SET_TGP, dgpu_tgp_default,
+		       dgpu_tgp_min, dgpu_tgp_max, 1,
+		       "Set the additional TGP on top of the base TGP");
 
 ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
 		       "Show the current mode of charging");
@@ -501,6 +514,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &ppt_fppt_attr_group, ASUS_WMI_DEVID_PPT_FPPT },
 	{ &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
 	{ &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
+	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
+	{ &dgpu_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 },
@@ -660,6 +675,11 @@ static void init_rog_tunables(struct rog_tunables *rog)
 	rog->nv_temp_max = NVIDIA_TEMP_MIN;
 	rog->nv_temp_max = NVIDIA_TEMP_MAX;
 	rog->nv_temp_target = NVIDIA_TEMP_MIN;
+
+	rog->dgpu_tgp_default = NVIDIA_POWER_DEFAULT;
+	rog->dgpu_tgp_min = NVIDIA_POWER_MIN;
+	rog->dgpu_tgp_max = NVIDIA_POWER_MAX;
+	rog->dgpu_tgp = NVIDIA_POWER_MAX;
 }
 
 static int __init asus_fw_init(void)
drivers/platform/x86/asus-armoury.h +17 -0
index 146170f91e69..96d991383b8a 100644
@@ -83,6 +83,19 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 	static struct kobj_attribute attr_##_attrname##_##_prop =                         \
 		__ASUS_ATTR_RO(_attrname, _prop)
 
+/* Requires current_value show&|store */
+#define __ATTR_GROUP_INT_VALUE_ONLY(_attrname, _fsname, _dispname)                             \
+	__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                                    \
+	}
+
 /* 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);                           \
@@ -97,6 +110,10 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 		.name = _fsname, .attrs = _attrname##_attrs                                    \
 	}
 
+#define ATTR_GROUP_INT_VALUE_ONLY_RO(_attrname, _fsname, _wmi, _dispname) \
+	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                           \
+	__ATTR_GROUP_INT_VALUE_ONLY(_attrname, _fsname, _dispname)
+
 #define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
 	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                 \
 	__ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
include/linux/platform_data/x86/asus-wmi.h +3 -0
index c164e656ae0b..3ce0c63be4c1 100644
@@ -133,6 +133,9 @@
 /* dgpu on/off */
 #define ASUS_WMI_DEVID_DGPU		0x00090020
 
+#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
Signature · 1 line
2.45.2
maintainer
#10 lore raw

Re: [PATCH v2 3/6] platform/x86: asus-armoury: add dgpu tgp control

Quoted 74 lines · Luke D. Jones

Implement the dgpu TGP control under the asus-armoury module using the fw_attributes class.

---
 drivers/platform/x86/asus-armoury.c        | 20 ++++++++++++++++++++
 drivers/platform/x86/asus-armoury.h        | 17 +++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |  3 +++
 3 files changed, 40 insertions(+)
drivers/platform/x86/asus-armoury.c +20 -0
index bb049ead00f9..31dbdacd8978 100644
@@ -50,6 +50,9 @@
 #define NVIDIA_BOOST_MAX 25
 #define NVIDIA_TEMP_MIN 75
 #define NVIDIA_TEMP_MAX 87
+#define NVIDIA_POWER_MIN 0
+#define NVIDIA_POWER_MAX 70
+#define NVIDIA_POWER_DEFAULT 70
 
 /* Tunables provided by ASUS for gaming laptops */
 struct rog_tunables {
@@ -76,6 +79,11 @@ struct rog_tunables {
 	u32 nv_temp_min;
 	u32 nv_temp_max;
 	u32 nv_temp_target;
+
+	u32 dgpu_tgp_default;
+	u32 dgpu_tgp_min;
+	u32 dgpu_tgp_max;
+	u32 dgpu_tgp;
 };
 
 static const struct class *fw_attr_class;
@@ -474,6 +482,11 @@ ATTR_GROUP_ROG_TUNABLE(nv_dynamic_boost, "nv_dynamic_boost", ASUS_WMI_DEVID_NV_D
 ATTR_GROUP_ROG_TUNABLE(nv_temp_target, "nv_temp_target", ASUS_WMI_DEVID_NV_THERM_TARGET,
 		       nv_temp_default, nv_boost_min, nv_temp_max, 1,
 		       "Set the Nvidia max thermal limit");
+ATTR_GROUP_INT_VALUE_ONLY_RO(dgpu_base_tgp, "dgpu_base_tgp", ASUS_WMI_DEVID_DGPU_BASE_TGP,
+			     "Read the base TGP value");
+ATTR_GROUP_ROG_TUNABLE(dgpu_tgp, "dgpu_tgp", ASUS_WMI_DEVID_DGPU_SET_TGP, dgpu_tgp_default,
+		       dgpu_tgp_min, dgpu_tgp_max, 1,
+		       "Set the additional TGP on top of the base TGP");
 
 ATTR_GROUP_ENUM_INT_RO(charge_mode, "charge_mode", ASUS_WMI_DEVID_CHARGE_MODE, "0;1;2",
 		       "Show the current mode of charging");
@@ -501,6 +514,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &ppt_fppt_attr_group, ASUS_WMI_DEVID_PPT_FPPT },
 	{ &nv_dynamic_boost_attr_group, ASUS_WMI_DEVID_NV_DYN_BOOST },
 	{ &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
+	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
+	{ &dgpu_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 },
@@ -660,6 +675,11 @@ static void init_rog_tunables(struct rog_tunables *rog)
 	rog->nv_temp_max = NVIDIA_TEMP_MIN;
 	rog->nv_temp_max = NVIDIA_TEMP_MAX;
 	rog->nv_temp_target = NVIDIA_TEMP_MIN;
+
+	rog->dgpu_tgp_default = NVIDIA_POWER_DEFAULT;
+	rog->dgpu_tgp_min = NVIDIA_POWER_MIN;
+	rog->dgpu_tgp_max = NVIDIA_POWER_MAX;
+	rog->dgpu_tgp = NVIDIA_POWER_MAX;
 }
 
 static int __init asus_fw_init(void)
drivers/platform/x86/asus-armoury.h +0 -0
index 146170f91e69..96d991383b8a 100644

drivers/platform/x86/asus-armoury.h static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr, · line 86

Quoted 4 lines
drivers/platform/x86/asus-armoury.h +1 -0
@@ -83,6 +83,19 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 	static struct kobj_attribute attr_##_attrname##_##_prop =                         \
 		__ASUS_ATTR_RO(_attrname, _prop)
 
+/* Requires current_value show&|store */

"&|" ??

Signature · 1 line
 i.
Quoted 41 lines
drivers/platform/x86/asus-armoury.h +16 -0
+#define __ATTR_GROUP_INT_VALUE_ONLY(_attrname, _fsname, _dispname)                             \
+	__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                                    \
+	}
+
 /* 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);                           \
@@ -97,6 +110,10 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 		.name = _fsname, .attrs = _attrname##_attrs                                    \
 	}
 
+#define ATTR_GROUP_INT_VALUE_ONLY_RO(_attrname, _fsname, _wmi, _dispname) \
+	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                           \
+	__ATTR_GROUP_INT_VALUE_ONLY(_attrname, _fsname, _dispname)
+
 #define ATTR_GROUP_BOOL_RO(_attrname, _fsname, _wmi, _dispname) \
 	__ATTR_CURRENT_INT_RO(_attrname, _wmi);                 \
 	__ATTR_GROUP_ENUM(_attrname, _fsname, "0;1", _dispname)
include/linux/platform_data/x86/asus-wmi.h +3 -0
index c164e656ae0b..3ce0c63be4c1 100644
@@ -133,6 +133,9 @@
 /* dgpu on/off */
 #define ASUS_WMI_DEVID_DGPU		0x00090020
 
+#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
author maintainer
#11 lore raw

PATCH v2 4/6 platform/x86: asus-armoury: add apu-mem control support

In reply to Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 115 +++++++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |   1 +
 2 files changed, 116 insertions(+)
drivers/platform/x86/asus-armoury.c +115 -0
index 31dbdacd8978..412e75c652a4 100644
@@ -462,6 +462,120 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj,
 WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
 ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
 
+/* Device memory available to APU */
+
+static ssize_t apu_mem_current_value_show(struct kobject *kobj,
+				struct kobj_attribute *attr, char *buf)
+{
+	int err;
+	u32 mem;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
+	if (err)
+		return err;
+
+	switch (mem) {
+	case 256:
+		mem = 0;
+		break;
+	case 258:
+		mem = 1;
+		break;
+	case 259:
+		mem = 2;
+		break;
+	case 260:
+		mem = 3;
+		break;
+	case 261:
+		mem = 4;
+		break;
+	case 262:
+		/* This is out of order and looks wrong but is correct */
+		mem = 8;
+		break;
+	case 263:
+		mem = 5;
+		break;
+	case 264:
+		mem = 6;
+		break;
+	case 265:
+		mem = 7;
+		break;
+	default:
+		mem = 4;
+		break;
+	}
+
+	return sysfs_emit(buf, "%d\n", mem);
+}
+
+static ssize_t apu_mem_current_value_store(struct kobject *kobj,
+				struct kobj_attribute *attr,
+				const char *buf, size_t count)
+{
+	int result, err;
+	u32 requested, mem;
+
+	result = kstrtou32(buf, 10, &requested);
+	if (result)
+		return result;
+
+	switch (requested) {
+	case 0:
+		mem = 0;
+		break;
+	case 1:
+		mem = 258;
+		break;
+	case 2:
+		mem = 259;
+		break;
+	case 3:
+		mem = 260;
+		break;
+	case 4:
+		mem = 261;
+		break;
+	case 5:
+		mem = 263;
+		break;
+	case 6:
+		mem = 264;
+		break;
+	case 7:
+		mem = 265;
+		break;
+	case 8:
+		/* This is outof order and looks wrong but is correct */
+		mem = 262;
+		break;
+	default:
+		return -EIO;
+	}
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
+	if (err) {
+		pr_warn("Failed to set apu_mem: %d\n", err);
+		return err;
+	}
+
+	pr_info("APU memory changed to %dGB, reboot required\n", requested);
+	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 sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");
+}
+ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
 		       cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -516,6 +630,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
 	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 	{ &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
+	{ &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 },
include/linux/platform_data/x86/asus-wmi.h +1 -0
index 3ce0c63be4c1..287206a03763 100644
@@ -135,6 +135,7 @@
 
 #define ASUS_WMI_DEVID_DGPU_BASE_TGP	0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP	0x00120098
+#define ASUS_WMI_DEVID_APU_MEM		0x000600C1
 
 /* gpu mux switch, 0 = dGPU, 1 = Optimus */
 #define ASUS_WMI_DEVID_GPU_MUX		0x00090016
Signature · 1 line
2.45.2
maintainer
#12 lore raw

Re: [PATCH v2 4/6] platform/x86: asus-armoury: add apu-mem control support

Quoted 57 lines · Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 115 +++++++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |   1 +
 2 files changed, 116 insertions(+)
drivers/platform/x86/asus-armoury.c +37 -0
index 31dbdacd8978..412e75c652a4 100644
@@ -462,6 +462,120 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj,
 WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
 ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
 
+/* Device memory available to APU */
+
+static ssize_t apu_mem_current_value_show(struct kobject *kobj,
+				struct kobj_attribute *attr, char *buf)
+{
+	int err;
+	u32 mem;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
+	if (err)
+		return err;
+
+	switch (mem) {
+	case 256:
+		mem = 0;
+		break;
+	case 258:
+		mem = 1;
+		break;
+	case 259:
+		mem = 2;
+		break;
+	case 260:
+		mem = 3;
+		break;
+	case 261:
+		mem = 4;
+		break;
+	case 262:
+		/* This is out of order and looks wrong but is correct */
+		mem = 8;
+		break;
+	case 263:
+		mem = 5;
+		break;
+	case 264:
+		mem = 6;

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 511

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+		break;
+	case 265:
+		mem = 7;
+		break;
+	default:
+		mem = 4;
+		break;
+	}
+
+	return sysfs_emit(buf, "%d\n", mem);

%u

Quoted 30 lines
drivers/platform/x86/asus-armoury.c +30 -0
+}
+
+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;
+
+	switch (requested) {
+	case 0:
+		mem = 0;
+		break;
+	case 1:
+		mem = 258;
+		break;
+	case 2:
+		mem = 259;
+		break;
+	case 3:
+		mem = 260;
+		break;
+	case 4:
+		mem = 261;
+		break;
+	case 5:

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 551

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+		mem = 263;
+		break;
+	case 6:
+		mem = 264;
+		break;
+	case 7:
+		mem = 265;
+		break;
+	case 8:
+		/* This is outof order and looks wrong but is correct */

outof -> out of

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 564

Quoted 13 lines
drivers/platform/x86/asus-armoury.c +13 -0
+		mem = 262;
+		break;
+	default:
+		return -EIO;
+	}
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
+	if (err) {
+		pr_warn("Failed to set apu_mem: %d\n", err);
+		return err;
+	}
+
+	pr_info("APU memory changed to %dGB, reboot required\n", requested);

%u

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 575

Quoted 11 lines
drivers/platform/x86/asus-armoury.c +11 -0
+	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 sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");

IIRC, space or newline is the usual separator for possible values sysfs files. I don't think I've ever seen ; used.

Signature · 1 line
 i.
Quoted 27 lines
drivers/platform/x86/asus-armoury.c +4 -0
+}
+ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
 		       cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -516,6 +630,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
 	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 	{ &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
+	{ &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 },
include/linux/platform_data/x86/asus-wmi.h +1 -0
index 3ce0c63be4c1..287206a03763 100644
@@ -135,6 +135,7 @@
 
 #define ASUS_WMI_DEVID_DGPU_BASE_TGP	0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP	0x00120098
+#define ASUS_WMI_DEVID_APU_MEM		0x000600C1
 
 /* gpu mux switch, 0 = dGPU, 1 = Optimus */
 #define ASUS_WMI_DEVID_GPU_MUX		0x00090016
author maintainer
#13 lore raw

Re: [PATCH v2 4/6] platform/x86: asus-armoury: add apu-mem control support

Quoted 131 lines · Ilpo Järvinen
Quoted 57 lines · Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 115 +++++++++++++++++++++
 include/linux/platform_data/x86/asus-wmi.h |   1 +
 2 files changed, 116 insertions(+)
drivers/platform/x86/asus-armoury.c +37 -0
index 31dbdacd8978..412e75c652a4 100644
@@ -462,6 +462,120 @@ static ssize_t egpu_enable_current_value_store(struct kobject *kobj,
 WMI_SHOW_INT(egpu_enable_current_value, "%d\n", ASUS_WMI_DEVID_EGPU);
 ATTR_GROUP_BOOL_CUSTOM(egpu_enable, "egpu_enable", "Enable the eGPU (also disables dGPU)");
 
+/* Device memory available to APU */
+
+static ssize_t apu_mem_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ int err;
+ u32 mem;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_APU_MEM, &mem);
+ if (err)
+ return err;
+
+ switch (mem) {
+ case 256:
+ mem = 0;
+ break;
+ case 258:
+ mem = 1;
+ break;
+ case 259:
+ mem = 2;
+ break;
+ case 260:
+ mem = 3;
+ break;
+ case 261:
+ mem = 4;
+ break;
+ case 262:
+ /* This is out of order and looks wrong but is correct */
+ mem = 8;
+ break;
+ case 263:
+ mem = 5;
+ break;
+ case 264:
+ mem = 6;

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 511

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+ break;
+ case 265:
+ mem = 7;
+ break;
+ default:
+ mem = 4;
+ break;
+ }
+
+ return sysfs_emit(buf, "%d\n", mem);

%u

Quoted 30 lines
drivers/platform/x86/asus-armoury.c +30 -0
+}
+
+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;
+
+ switch (requested) {
+ case 0:
+ mem = 0;
+ break;
+ case 1:
+ mem = 258;
+ break;
+ case 2:
+ mem = 259;
+ break;
+ case 3:
+ mem = 260;
+ break;
+ case 4:
+ mem = 261;
+ break;
+ case 5:

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 551

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+ mem = 263;
+ break;
+ case 6:
+ mem = 264;
+ break;
+ case 7:
+ mem = 265;
+ break;
+ case 8:
+ /* This is outof order and looks wrong but is correct */

outof -> out of

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 564

Quoted 13 lines
drivers/platform/x86/asus-armoury.c +13 -0
+ mem = 262;
+ break;
+ default:
+ return -EIO;
+ }
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_APU_MEM, mem, &result);
+ if (err) {
+ pr_warn("Failed to set apu_mem: %d\n", err);
+ return err;
+ }
+
+ pr_info("APU memory changed to %dGB, reboot required\n", requested);

%u

Quoted 11 lines

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 575

Quoted 11 lines
drivers/platform/x86/asus-armoury.c +11 -0
+ 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 sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");

Ack all

Quoted 2 lines

IIRC, space or newline is the usual separator for possible values sysfs files. I don't think I've ever seen ; used.

The docs specify this format. https://github.com/torvalds/linux/blob/5189dafa4cf950e675f02ee04b577dfbbad0d9b1/Documentation/ABI/testing/sysfs-class-firmware-attributes#L56

Thanks,
Luke.

Quoted 31 lines
Signature · 1 line
i.
Quoted 27 lines
drivers/platform/x86/asus-armoury.c +4 -0
+}
+ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
        cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -516,6 +630,7 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 { &nv_temp_target_attr_group, ASUS_WMI_DEVID_NV_THERM_TARGET },
 { &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 { &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
+ { &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 },
include/linux/platform_data/x86/asus-wmi.h +1 -0
index 3ce0c63be4c1..287206a03763 100644
@@ -135,6 +135,7 @@
 
 #define ASUS_WMI_DEVID_DGPU_BASE_TGP 0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP 0x00120098
+#define ASUS_WMI_DEVID_APU_MEM 0x000600C1
 
 /* gpu mux switch, 0 = dGPU, 1 = Optimus */
 #define ASUS_WMI_DEVID_GPU_MUX 0x00090016
maintainer
#14 lore raw

Re: [PATCH v2 4/6] platform/x86: asus-armoury: add apu-mem control support

Quoted 26 lines · Luke Jones
Quoted 11 lines · Ilpo Järvinen
Quoted 8 lines · Luke D. Jones

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.

---

Quoted 11 lines

drivers/platform/x86/asus-armoury.c static ssize_t egpu_enable_current_value_store(struct kobject *kobj, · line 575

Quoted 11 lines

+ sysfs_notify(kobj, NULL, attr->attr.name);

drivers/platform/x86/asus-armoury.c +10 -0
+
+ 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 sysfs_emit(buf, "0;1;2;3;4;5;6;7;8\n");

Ack all

Quoted 4 lines
Quoted 2 lines

IIRC, space or newline is the usual separator for possible values sysfs files. I don't think I've ever seen ; used.

The docs specify this format. https://github.com/torvalds/linux/blob/5189dafa4cf950e675f02ee04b577dfbbad0d9b1/Documentation/ABI/testing/sysfs-class-firmware-attributes#L56

Okay, I didn't know. Please use what's documented then.

Signature · 1 line
 i.
author maintainer
#15 lore raw

PATCH v2 5/6 platform/x86: asus-armoury: add core count control

In reply to Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 208 ++++++++++++++++++++-
 drivers/platform/x86/asus-armoury.h        |  29 +++
 include/linux/platform_data/x86/asus-wmi.h |   4 +
 3 files changed, 240 insertions(+), 1 deletion(-)
drivers/platform/x86/asus-armoury.c +207 -1
index 412e75c652a4..592ebea35ad5 100644
@@ -39,6 +39,18 @@
 #define ASUS_MINI_LED_2024_STRONG 0x01
 #define ASUS_MINI_LED_2024_OFF 0x02
 
+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,
+};
+
 /* Default limits for tunables available on ASUS ROG laptops */
 #define PPT_CPU_LIMIT_MIN 5
 #define PPT_CPU_LIMIT_MAX 150
@@ -84,6 +96,10 @@ struct rog_tunables {
 	u32 dgpu_tgp_min;
 	u32 dgpu_tgp_max;
 	u32 dgpu_tgp;
+
+	u32 min_perf_cores;
+	u32 max_perf_cores;
+	u32 max_power_cores;
 };
 
 static const struct class *fw_attr_class;
@@ -148,7 +164,9 @@ 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, "panel_hd_mode");
+		!strcmp(attr->attr.name, "cores_performance") ||
+		!strcmp(attr->attr.name, "cores_efficiency") ||
+		!strcmp(attr->attr.name, "panel_hd_mode");
 }
 
 /**
@@ -576,6 +594,191 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj,
 }
 ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
 
+static int init_max_cpu_cores(void)
+{
+	u32 cores;
+	int err;
+
+	asus_armoury.rog_tunables->min_perf_cores = 4;
+	asus_armoury.rog_tunables->max_perf_cores = 4;
+	asus_armoury.rog_tunables->max_power_cores = 8;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
+	if (err)
+		return err;
+
+	cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+	asus_armoury.rog_tunables->max_power_cores = (cores & 0xff00) >> 8;
+	asus_armoury.rog_tunables->max_perf_cores = cores & 0xff;
+
+	return 0;
+}
+
+static ssize_t cores_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf,
+					enum cpu_core_type core_type,
+					enum cpu_core_value core_value)
+{
+	u32 cores;
+	int err;
+
+	switch (core_value) {
+	case CPU_CORE_DEFAULT:
+	case CPU_CORE_MAX:
+		if (core_type == CPU_CORE_PERF)
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_perf_cores);
+		else
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_power_cores);
+	case CPU_CORE_MIN:
+		if (core_type == CPU_CORE_PERF)
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->min_perf_cores);
+		else
+			return sysfs_emit(buf, "%d\n", 0);
+	default:
+	break;
+	}
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
+	if (err)
+		return err;
+
+	cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+	if (core_type == CPU_CORE_PERF)
+		cores &= 0xff;
+	else
+		cores = (cores & 0xff00) >> 8;
+	return sysfs_emit(buf, "%d\n", cores);
+}
+
+static ssize_t cores_current_value_store(struct kobject *kobj,
+				struct kobj_attribute *attr, const char *buf,
+				enum cpu_core_type core_type)
+{
+	int result, err;
+	u32 cores, currentv, min, max;
+
+	result = kstrtou32(buf, 10, &cores);
+	if (result)
+		return result;
+
+	if (core_type == CPU_CORE_PERF) {
+		min = asus_armoury.rog_tunables->min_perf_cores;
+		max = asus_armoury.rog_tunables->max_perf_cores;
+	} else {
+		min = 0;
+		max = asus_armoury.rog_tunables->max_power_cores;
+	}
+	if (cores < min || cores > max)
+		return -EINVAL;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &currentv);
+	if (err)
+		return err;
+
+	if (core_type == CPU_CORE_PERF)
+		cores |= (currentv & 0xff00);
+	else
+		cores |= currentv & 0xff;
+
+	if (cores == currentv)
+		return 0;
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, cores, &result);
+	if (err) {
+		pr_warn("Failed to set CPU core count: %d\n", err);
+		return err;
+	}
+
+	if (result > 1) {
+		pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
+		return -EIO;
+	}
+
+	pr_info("CPU core count changed, reboot required\n");
+	sysfs_notify(kobj, NULL, attr->attr.name);
+	asus_set_reboot_and_signal_event();
+
+	return 0;
+}
+
+static ssize_t cores_performance_min_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
+}
+
+static ssize_t cores_performance_max_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
+}
+
+static ssize_t cores_performance_default_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_performance_current_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_performance_current_value_store(struct kobject *kobj,
+					struct kobj_attribute *attr,
+					const char *buf, size_t count)
+{
+	int err;
+
+	err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
+	if (err)
+		return err;
+
+	return count;
+}
+ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
+		"Set the max available performance cores");
+
+static ssize_t cores_efficiency_min_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
+}
+
+static ssize_t cores_efficiency_max_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
+}
+
+static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
+					struct kobj_attribute *attr,
+					const char *buf, size_t count)
+{
+	int err;
+
+	err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
+	if (err)
+		return err;
+
+	return count;
+}
+ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
+		"Set the max available efficiency cores");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
 		       cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -631,6 +834,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 	{ &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
 	{ &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 },
@@ -811,6 +1016,7 @@ static int __init asus_fw_init(void)
 		return -ENOMEM;
 	}
 	init_rog_tunables(asus_armoury.rog_tunables);
+	init_max_cpu_cores();
 
 	err = asus_fw_attr_add();
 	mutex_unlock(&asus_armoury.mutex);
drivers/platform/x86/asus-armoury.h +29 -0
index 96d991383b8a..da585a180125 100644
@@ -154,6 +154,35 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 		.name = _fsname, .attrs = _attrname##_attrs                                    \
 	}
 
+/* CPU core attributes need a little different in setup */
+#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname)	\
+__ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1);	\
+__ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);	\
+static struct kobj_attribute attr_##_attrname##_current_value = \
+	__ASUS_ATTR_RW(_attrname, current_value);		\
+static struct kobj_attribute attr_##_attrname##_default_value = \
+	__ASUS_ATTR_RO(_attrname, default_value);		\
+static struct kobj_attribute attr_##_attrname##_min_value =	\
+	__ASUS_ATTR_RO(_attrname, min_value);			\
+static struct kobj_attribute attr_##_attrname##_max_value =	\
+	__ASUS_ATTR_RO(_attrname, max_value);			\
+static struct kobj_attribute attr_##_attrname##_type =		\
+	__ASUS_ATTR_RO_AS(type, int_type_show);			\
+static struct attribute *_attrname##_attrs[] = {		\
+		&attr_##_attrname##_current_value.attr,		\
+		&attr_##_attrname##_default_value.attr,		\
+		&attr_##_attrname##_min_value.attr,		\
+		&attr_##_attrname##_max_value.attr,		\
+		&attr_##_attrname##_scalar_increment.attr,	\
+		&attr_##_attrname##_display_name.attr,		\
+		&attr_##_attrname##_type.attr,			\
+		NULL						\
+};								\
+static const struct attribute_group _attrname##_attr_group = {	\
+		.name = _fsname,				\
+		.attrs = _attrname##_attrs			\
+}
+
 /*
  * ROG PPT attributes need a little different in setup as they
  * require rog_tunables members.
include/linux/platform_data/x86/asus-wmi.h +4 -0
index 287206a03763..2e7509ab5be0 100644
@@ -133,6 +133,10 @@
 /* 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_DGPU_BASE_TGP	0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP	0x00120098
 #define ASUS_WMI_DEVID_APU_MEM		0x000600C1
Signature · 1 line
2.45.2
maintainer
#16 lore raw

Re: [PATCH v2 5/6] platform/x86: asus-armoury: add core count control

Quoted 68 lines · Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 208 ++++++++++++++++++++-
 drivers/platform/x86/asus-armoury.h        |  29 +++
 include/linux/platform_data/x86/asus-wmi.h |   4 +
 3 files changed, 240 insertions(+), 1 deletion(-)
drivers/platform/x86/asus-armoury.c +25 -1
index 412e75c652a4..592ebea35ad5 100644
@@ -39,6 +39,18 @@
 #define ASUS_MINI_LED_2024_STRONG 0x01
 #define ASUS_MINI_LED_2024_OFF 0x02
 
+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,
+};
+
 /* Default limits for tunables available on ASUS ROG laptops */
 #define PPT_CPU_LIMIT_MIN 5
 #define PPT_CPU_LIMIT_MAX 150
@@ -84,6 +96,10 @@ struct rog_tunables {
 	u32 dgpu_tgp_min;
 	u32 dgpu_tgp_max;
 	u32 dgpu_tgp;
+
+	u32 min_perf_cores;
+	u32 max_perf_cores;
+	u32 max_power_cores;
 };
 
 static const struct class *fw_attr_class;
@@ -148,7 +164,9 @@ 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, "panel_hd_mode");
+		!strcmp(attr->attr.name, "cores_performance") ||
+		!strcmp(attr->attr.name, "cores_efficiency") ||
+		!strcmp(attr->attr.name, "panel_hd_mode");
 }
 
 /**
@@ -576,6 +594,191 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj,
 }
 ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
 
+static int init_max_cpu_cores(void)
+{
+	u32 cores;
+	int err;
+
+	asus_armoury.rog_tunables->min_perf_cores = 4;

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 612

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+	asus_armoury.rog_tunables->max_perf_cores = 4;
+	asus_armoury.rog_tunables->max_power_cores = 8;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
+	if (err)
+		return err;
+
+	cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+	asus_armoury.rog_tunables->max_power_cores = (cores & 0xff00) >> 8;
+	asus_armoury.rog_tunables->max_perf_cores = cores & 0xff;

Define names for the fields returned in 'cores' using GENMASK() and use FIELD_GET() here to extract them.

Quoted 7 lines
drivers/platform/x86/asus-armoury.c +7 -0
+
+	return 0;
+}
+
+static ssize_t cores_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf,
+					enum cpu_core_type core_type,

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 629

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+					enum cpu_core_value core_value)
+{
+	u32 cores;
+	int err;
+
+	switch (core_value) {
+	case CPU_CORE_DEFAULT:
+	case CPU_CORE_MAX:
+		if (core_type == CPU_CORE_PERF)
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_perf_cores);

%u for u32, please check all %d, I won't mark the rest.

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 638

Quoted 9 lines
drivers/platform/x86/asus-armoury.c +9 -0
+		else
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_power_cores);
+	case CPU_CORE_MIN:
+		if (core_type == CPU_CORE_PERF)
+			return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->min_perf_cores);
+		else
+			return sysfs_emit(buf, "%d\n", 0);
+	default:
+	break;

Misindented.

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 649

Quoted 11 lines
drivers/platform/x86/asus-armoury.c +11 -0
+	}
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
+	if (err)
+		return err;
+
+	cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+	if (core_type == CPU_CORE_PERF)
+		cores &= 0xff;
+	else
+		cores = (cores & 0xff00) >> 8;

Perhaps create a helper which takes two pointers for core types as this code is similar to the one in init_max_cpu_cores().

Quoted 22 lines
drivers/platform/x86/asus-armoury.c +22 -0
+	return sysfs_emit(buf, "%d\n", cores);
+}
+
+static ssize_t cores_current_value_store(struct kobject *kobj,
+				struct kobj_attribute *attr, const char *buf,
+				enum cpu_core_type core_type)
+{
+	int result, err;
+	u32 cores, currentv, min, max;
+
+	result = kstrtou32(buf, 10, &cores);
+	if (result)
+		return result;
+
+	if (core_type == CPU_CORE_PERF) {
+		min = asus_armoury.rog_tunables->min_perf_cores;
+		max = asus_armoury.rog_tunables->max_perf_cores;
+	} else {
+		min = 0;
+		max = asus_armoury.rog_tunables->max_power_cores;
+	}
+	if (cores < min || cores > max)

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 681

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+		return -EINVAL;
+
+	err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &currentv);
+	if (err)
+		return err;
+
+	if (core_type == CPU_CORE_PERF)
+		cores |= (currentv & 0xff00);
+	else
+		cores |= currentv & 0xff;

Use normal pattern to alter a field:

	xx &= ~YY;
	xx |= FIELD_PREP(YY, cores);

Alternatively you could just recalculate it fully since you've cached the values?

Quoted 8 lines
drivers/platform/x86/asus-armoury.c +8 -0
+
+	if (cores == currentv)
+		return 0;
+
+	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, cores, &result);
+	if (err) {
+		pr_warn("Failed to set CPU core count: %d\n", err);
+		return err;

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 699

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+	}
+
+	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();

What prevents two change requests racing with each other?

Signature · 1 line
 i.
Quoted 157 lines
drivers/platform/x86/asus-armoury.c +84 -0
+	return 0;
+}
+
+static ssize_t cores_performance_min_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
+}
+
+static ssize_t cores_performance_max_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
+}
+
+static ssize_t cores_performance_default_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_performance_current_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_performance_current_value_store(struct kobject *kobj,
+					struct kobj_attribute *attr,
+					const char *buf, size_t count)
+{
+	int err;
+
+	err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
+	if (err)
+		return err;
+
+	return count;
+}
+ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
+		"Set the max available performance cores");
+
+static ssize_t cores_efficiency_min_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
+}
+
+static ssize_t cores_efficiency_max_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
+}
+
+static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
+					struct kobj_attribute *attr,
+					const char *buf, size_t count)
+{
+	int err;
+
+	err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
+	if (err)
+		return err;
+
+	return count;
+}
+ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
+		"Set the max available efficiency cores");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
 		       cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -631,6 +834,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 	{ &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 	{ &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
 	{ &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 },
@@ -811,6 +1016,7 @@ static int __init asus_fw_init(void)
 		return -ENOMEM;
 	}
 	init_rog_tunables(asus_armoury.rog_tunables);
+	init_max_cpu_cores();
 
 	err = asus_fw_attr_add();
 	mutex_unlock(&asus_armoury.mutex);
drivers/platform/x86/asus-armoury.h +29 -0
index 96d991383b8a..da585a180125 100644
@@ -154,6 +154,35 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 		.name = _fsname, .attrs = _attrname##_attrs                                    \
 	}
 
+/* CPU core attributes need a little different in setup */
+#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname)	\
+__ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1);	\
+__ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname);	\
+static struct kobj_attribute attr_##_attrname##_current_value = \
+	__ASUS_ATTR_RW(_attrname, current_value);		\
+static struct kobj_attribute attr_##_attrname##_default_value = \
+	__ASUS_ATTR_RO(_attrname, default_value);		\
+static struct kobj_attribute attr_##_attrname##_min_value =	\
+	__ASUS_ATTR_RO(_attrname, min_value);			\
+static struct kobj_attribute attr_##_attrname##_max_value =	\
+	__ASUS_ATTR_RO(_attrname, max_value);			\
+static struct kobj_attribute attr_##_attrname##_type =		\
+	__ASUS_ATTR_RO_AS(type, int_type_show);			\
+static struct attribute *_attrname##_attrs[] = {		\
+		&attr_##_attrname##_current_value.attr,		\
+		&attr_##_attrname##_default_value.attr,		\
+		&attr_##_attrname##_min_value.attr,		\
+		&attr_##_attrname##_max_value.attr,		\
+		&attr_##_attrname##_scalar_increment.attr,	\
+		&attr_##_attrname##_display_name.attr,		\
+		&attr_##_attrname##_type.attr,			\
+		NULL						\
+};								\
+static const struct attribute_group _attrname##_attr_group = {	\
+		.name = _fsname,				\
+		.attrs = _attrname##_attrs			\
+}
+
 /*
  * ROG PPT attributes need a little different in setup as they
  * require rog_tunables members.
include/linux/platform_data/x86/asus-wmi.h +4 -0
index 287206a03763..2e7509ab5be0 100644
@@ -133,6 +133,10 @@
 /* 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_DGPU_BASE_TGP	0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP	0x00120098
 #define ASUS_WMI_DEVID_APU_MEM		0x000600C1
author maintainer
#17 lore raw

Re: [PATCH v2 5/6] platform/x86: asus-armoury: add core count control

Quoted 75 lines · Ilpo Järvinen
Quoted 73 lines · Luke D. Jones

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.

---
 drivers/platform/x86/asus-armoury.c        | 208 ++++++++++++++++++++-
 drivers/platform/x86/asus-armoury.h        |  29 +++
 include/linux/platform_data/x86/asus-wmi.h |   4 +
 3 files changed, 240 insertions(+), 1 deletion(-)
drivers/platform/x86/asus-armoury.c +30 -1
index 412e75c652a4..592ebea35ad5 100644
@@ -39,6 +39,18 @@
 #define ASUS_MINI_LED_2024_STRONG 0x01
 #define ASUS_MINI_LED_2024_OFF 0x02
 
+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,
+};
+
 /* Default limits for tunables available on ASUS ROG laptops */
 #define PPT_CPU_LIMIT_MIN 5
 #define PPT_CPU_LIMIT_MAX 150
@@ -84,6 +96,10 @@ struct rog_tunables {
 u32 dgpu_tgp_min;
 u32 dgpu_tgp_max;
 u32 dgpu_tgp;
+
+ u32 min_perf_cores;
+ u32 max_perf_cores;
+ u32 max_power_cores;
 };
 
 static const struct class *fw_attr_class;
@@ -148,7 +164,9 @@ 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, "panel_hd_mode");
+ !strcmp(attr->attr.name, "cores_performance") ||
+ !strcmp(attr->attr.name, "cores_efficiency") ||
+ !strcmp(attr->attr.name, "panel_hd_mode");
 }
 
 /**
@@ -576,6 +594,191 @@ static ssize_t apu_mem_possible_values_show(struct kobject *kobj,
 }
 ATTR_GROUP_ENUM_CUSTOM(apu_mem, "apu_mem", "Set the available system memory for the APU to use");
 
+static int init_max_cpu_cores(void)
+{
+ u32 cores;
+ int err;
+
+ asus_armoury.rog_tunables->min_perf_cores = 4;
+ asus_armoury.rog_tunables->max_perf_cores = 4;
+ asus_armoury.rog_tunables->max_power_cores = 8;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES_MAX, &cores);
+ if (err)
Quoted 8 lines

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 612

Quoted 5 lines
drivers/platform/x86/asus-armoury.c +5 -0
+ return err;
+
+ cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+ asus_armoury.rog_tunables->max_power_cores = (cores & 0xff00) >> 8;
+ asus_armoury.rog_tunables->max_perf_cores = cores & 0xff;

Define names for the fields returned in 'cores' using GENMASK() and use FIELD_GET() here to extract them.

Wasn't aware of this. Also had to look at this https://mazdermind.de/genmask/ as the documentation for these things is... lacking.

Quoted 11 lines
Quoted 11 lines
drivers/platform/x86/asus-armoury.c +11 -0
+
+ return 0;
+}
+
+static ssize_t cores_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf,
+ enum cpu_core_type core_type,
+ enum cpu_core_value core_value)
+{
+ u32 cores;
+ int err;
Quoted 8 lines

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 629

Quoted 6 lines
drivers/platform/x86/asus-armoury.c +6 -0
+
+ switch (core_value) {
+ case CPU_CORE_DEFAULT:
+ case CPU_CORE_MAX:
+ if (core_type == CPU_CORE_PERF)
+ return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_perf_cores);

%u for u32, please check all %d, I won't mark the rest.

Got it. Sorry.

Quoted 11 lines

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 638

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +9 -0
+ else
+ return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->max_power_cores);
+ case CPU_CORE_MIN:
+ if (core_type == CPU_CORE_PERF)
+ return sysfs_emit(buf, "%d\n", asus_armoury.rog_tunables->min_perf_cores);
+ else
+ return sysfs_emit(buf, "%d\n", 0);
+ default:
+ break;
Quoted 1 line

Misindented.

Ack

Quoted 15 lines

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 649

Quoted 12 lines
drivers/platform/x86/asus-armoury.c +11 -0
+ }
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &cores);
+ if (err)
+ return err;
+
+ cores &= ~ASUS_WMI_DSTS_PRESENCE_BIT;
+ if (core_type == CPU_CORE_PERF)
+ cores &= 0xff;
+ else
+ cores = (cores & 0xff00) >> 8;

Perhaps create a helper which takes two pointers for core types as this code is similar to the one in init_max_cpu_cores().

Maybe. I'll try work something out.

Quoted 52 lines
Quoted 22 lines
drivers/platform/x86/asus-armoury.c +22 -0
+ return sysfs_emit(buf, "%d\n", cores);
+}
+
+static ssize_t cores_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr, const char *buf,
+ enum cpu_core_type core_type)
+{
+ int result, err;
+ u32 cores, currentv, min, max;
+
+ result = kstrtou32(buf, 10, &cores);
+ if (result)
+ return result;
+
+ if (core_type == CPU_CORE_PERF) {
+ min = asus_armoury.rog_tunables->min_perf_cores;
+ max = asus_armoury.rog_tunables->max_perf_cores;
+ } else {
+ min = 0;
+ max = asus_armoury.rog_tunables->max_power_cores;
+ }
+ if (cores < min || cores > max)

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 681

Quoted 10 lines
drivers/platform/x86/asus-armoury.c +10 -0
+ return -EINVAL;
+
+ err = asus_wmi_get_devstate_dsts(ASUS_WMI_DEVID_CORES, &currentv);
+ if (err)
+ return err;
+
+ if (core_type == CPU_CORE_PERF)
+ cores |= (currentv & 0xff00);
+ else
+ cores |= currentv & 0xff;

Use normal pattern to alter a field:
xx &= ~YY;
xx |= FIELD_PREP(YY, cores);

Alternatively you could just recalculate it fully since you've cached the values?

Quoted 12 lines
drivers/platform/x86/asus-armoury.c +12 -0
+
+ if (cores == currentv)
+ return 0;
+
+ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_CORES, cores, &result);
+ if (err) {
+ pr_warn("Failed to set CPU core count: %d\n", err);
+ return err;
+ }
+
+ if (result > 1) {
+ pr_warn("Failed to set CPU core count (result): 0x%x\n", result);
Quoted 8 lines

drivers/platform/x86/asus-armoury.c static ssize_t apu_mem_possible_values_show(struct kobject *kobj, · line 699

Quoted 6 lines
drivers/platform/x86/asus-armoury.c +6 -0
+ return -EIO;
+ }
+
+ pr_info("CPU core count changed, reboot required\n");
+ sysfs_notify(kobj, NULL, attr->attr.name);
+ asus_set_reboot_and_signal_event();

What prevents two change requests racing with each other?

Ah.. That's why I added a mutex I never used.

Thnak you for your patience and reviews.

Cheers,
Luke.

Quoted 162 lines
Signature · 2 lines
-- 
i.
Quoted 157 lines
drivers/platform/x86/asus-armoury.c +84 -0
+ return 0;
+}
+
+static ssize_t cores_performance_min_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MIN);
+}
+
+static ssize_t cores_performance_max_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_MAX);
+}
+
+static ssize_t cores_performance_default_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_performance_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_PERF, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_performance_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ int err;
+
+ err = cores_current_value_store(kobj, attr, buf, CPU_CORE_PERF);
+ if (err)
+ return err;
+
+ return count;
+}
+ATTR_GROUP_CORES_RW(cores_performance, "cores_performance",
+ "Set the max available performance cores");
+
+static ssize_t cores_efficiency_min_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MIN);
+}
+
+static ssize_t cores_efficiency_max_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_MAX);
+}
+
+static ssize_t cores_efficiency_default_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_DEFAULT);
+}
+
+static ssize_t cores_efficiency_current_value_show(struct kobject *kobj,
+ struct kobj_attribute *attr, char *buf)
+{
+ return cores_value_show(kobj, attr, buf, CPU_CORE_POWER, CPU_CORE_CURRENT);
+}
+
+static ssize_t cores_efficiency_current_value_store(struct kobject *kobj,
+ struct kobj_attribute *attr,
+ const char *buf, size_t count)
+{
+ int err;
+
+ err = cores_current_value_store(kobj, attr, buf, CPU_CORE_POWER);
+ if (err)
+ return err;
+
+ return count;
+}
+ATTR_GROUP_CORES_RW(cores_efficiency, "cores_efficiency",
+ "Set the max available efficiency cores");
+
 /* Simple attribute creation */
 ATTR_GROUP_ROG_TUNABLE(ppt_pl1_spl, "ppt_pl1_spl", ASUS_WMI_DEVID_PPT_PL1_SPL, cpu_default,
        cpu_min, cpu_max, 1, "Set the CPU slow package limit");
@@ -631,6 +834,8 @@ static const struct asus_attr_group armoury_attr_groups[] = {
 { &dgpu_base_tgp_attr_group, ASUS_WMI_DEVID_DGPU_BASE_TGP },
 { &dgpu_tgp_attr_group, ASUS_WMI_DEVID_DGPU_SET_TGP },
 { &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 },
@@ -811,6 +1016,7 @@ static int __init asus_fw_init(void)
 return -ENOMEM;
 }
 init_rog_tunables(asus_armoury.rog_tunables);
+ init_max_cpu_cores();
 
 err = asus_fw_attr_add();
 mutex_unlock(&asus_armoury.mutex);
drivers/platform/x86/asus-armoury.h +29 -0
index 96d991383b8a..da585a180125 100644
@@ -154,6 +154,35 @@ static ssize_t enum_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 .name = _fsname, .attrs = _attrname##_attrs                                    \
 }
 
+/* CPU core attributes need a little different in setup */
+#define ATTR_GROUP_CORES_RW(_attrname, _fsname, _dispname) \
+__ATTR_SHOW_FMT(scalar_increment, _attrname, "%d\n", 1); \
+__ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \
+static struct kobj_attribute attr_##_attrname##_current_value = \
+ __ASUS_ATTR_RW(_attrname, current_value); \
+static struct kobj_attribute attr_##_attrname##_default_value = \
+ __ASUS_ATTR_RO(_attrname, default_value); \
+static struct kobj_attribute attr_##_attrname##_min_value = \
+ __ASUS_ATTR_RO(_attrname, min_value); \
+static struct kobj_attribute attr_##_attrname##_max_value = \
+ __ASUS_ATTR_RO(_attrname, max_value); \
+static struct kobj_attribute attr_##_attrname##_type = \
+ __ASUS_ATTR_RO_AS(type, int_type_show); \
+static struct attribute *_attrname##_attrs[] = { \
+ &attr_##_attrname##_current_value.attr, \
+ &attr_##_attrname##_default_value.attr, \
+ &attr_##_attrname##_min_value.attr, \
+ &attr_##_attrname##_max_value.attr, \
+ &attr_##_attrname##_scalar_increment.attr, \
+ &attr_##_attrname##_display_name.attr, \
+ &attr_##_attrname##_type.attr, \
+ NULL \
+}; \
+static const struct attribute_group _attrname##_attr_group = { \
+ .name = _fsname, \
+ .attrs = _attrname##_attrs \
+}
+
 /*
  * ROG PPT attributes need a little different in setup as they
  * require rog_tunables members.
include/linux/platform_data/x86/asus-wmi.h +4 -0
index 287206a03763..2e7509ab5be0 100644
@@ -133,6 +133,10 @@
 /* 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_DGPU_BASE_TGP 0x00120099
 #define ASUS_WMI_DEVID_DGPU_SET_TGP 0x00120098
 #define ASUS_WMI_DEVID_APU_MEM 0x000600C1
author maintainer
#18 lore raw

PATCH v2 6/6 asus-wmi: deprecate bios features

In reply to Luke D. Jones

With the existence of the asus-bioscfg 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.

---
 .../ABI/testing/sysfs-platform-asus-wmi       |  17 +++
 drivers/platform/x86/Kconfig                  |   8 ++
 drivers/platform/x86/asus-wmi.c               | 125 ++++++++++++++----
 3 files changed, 124 insertions(+), 26 deletions(-)
Documentation/ABI/testing/sysfs-platform-asus-wmi +17 -0
index 28144371a0f1..765d50b0d9df 100644
@@ -63,6 +63,7 @@ Date:		Aug 2022
 KernelVersion:	6.1
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Switch the GPU hardware MUX mode. Laptops with this feature can
 		can be toggled to boot with only the dGPU (discrete mode) or in
 		standard Optimus/Hybrid mode. On switch a reboot is required:
@@ -75,6 +76,7 @@ Date:		Aug 2022
 KernelVersion:	5.17
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Disable discrete GPU:
 			* 0 - Enable dGPU,
 			* 1 - Disable dGPU
@@ -84,6 +86,7 @@ Date:		Aug 2022
 KernelVersion:	5.17
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Enable the external GPU paired with ROG X-Flow laptops.
 		Toggling this setting will also trigger ACPI to disable the dGPU:
 
@@ -95,6 +98,7 @@ Date:		Aug 2022
 KernelVersion:	5.17
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Enable an LCD response-time boost to reduce or remove ghosting:
 			* 0 - Disable,
 			* 1 - Enable
@@ -104,6 +108,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Get the current charging mode being used:
 			* 1 - Barrel connected charger,
 			* 2 - USB-C charging
@@ -114,6 +119,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Show if the egpu (XG Mobile) is correctly connected:
 			* 0 - False,
 			* 1 - True
@@ -123,6 +129,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Change the mini-LED mode:
 			* 0 - Single-zone,
 			* 1 - Multi-zone
@@ -133,6 +140,7 @@ Date:		Apr 2024
 KernelVersion:	6.10
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		List the available mini-led modes.
 
 What:		/sys/devices/platform/<platform>/ppt_pl1_spl
@@ -140,6 +148,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the Package Power Target total of CPU: PL1 on Intel, SPL on AMD.
 		Shown on Intel+Nvidia or AMD+Nvidia based systems:
 
@@ -150,6 +159,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the Slow Package Power Tracking Limit of CPU: PL2 on Intel, SPPT,
 		on AMD. Shown on Intel+Nvidia or AMD+Nvidia based systems:
 
@@ -160,6 +170,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the Fast Package Power Tracking Limit of CPU. AMD+Nvidia only:
 			* min=5, max=250
 
@@ -168,6 +179,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the APU SPPT limit. Shown on full AMD systems only:
 			* min=5, max=130
 
@@ -176,6 +188,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the platform SPPT limit. Shown on full AMD systems only:
 			* min=5, max=130
 
@@ -184,6 +197,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the dynamic boost limit of the Nvidia dGPU:
 			* min=5, max=25
 
@@ -192,6 +206,7 @@ Date:		Jun 2023
 KernelVersion:	6.5
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set the target temperature limit of the Nvidia dGPU:
 			* min=75, max=87
 
@@ -200,6 +215,7 @@ Date:		Apr 2024
 KernelVersion:	6.10
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set if the BIOS POST sound is played on boot.
 			* 0 - False,
 			* 1 - True
@@ -209,6 +225,7 @@ Date:		Apr 2024
 KernelVersion:	6.10
 Contact:	"Luke Jones" <[email protected]>
 Description:
+        DEPRECATED, WILL BE REMOVED SOON
 		Set if the MCU can go in to low-power mode on system sleep
 			* 0 - False,
 			* 1 - True
drivers/platform/x86/Kconfig +8 -0
index 8ecc73ef2670..bafe5883805b 100644
@@ -301,6 +301,14 @@ config ASUS_WMI
 	  To compile this driver as a module, choose M here: the module will
 	  be called asus-wmi.
 
+config ASUS_WMI_BIOS
+	bool "BIOS option support in WMI platform (DEPRECATED)"
+	depends on ASUS_WMI
+	help
+	  Say Y to expose the configurable BIOS options through the asus-wmi
+	  driver. This can be used with or without the new asus-bios driver as
+	  the options are the same but the asus-bios driver has more features.
+
 config ASUS_NB_WMI
 	tristate "Asus Notebook WMI Driver"
 	depends on ASUS_WMI
drivers/platform/x86/asus-wmi.c +99 -26

377 lines not on this page · raw message

Signature · 1 line
2.45.2