Messages in this thread Patches in this message | | | Date | Tue, 31 Aug 2021 21:56:09 +1200 | From | Luke Jones <> | Subject | Re: [PATCH v7] asus-wmi: Add support for custom fan curves |
| |
Additionally to the above I've taken in to account feedback for v7 patch, and cleaned up plus tidied a few things.
I'll again attach for quick look over before I submit next patch as full review. I am thinking that this version (v9 here) is the proper and expected outcome.
Cheers, Luke
On Tue, Aug 31 2021 at 20:58:49 +1200, Luke Jones <luke@ljones.dev> wrote: > Hi Barnabás, > > I did another refactor using hwmon_device_register_with_info() and > HWMON_CHANNEL_INFO(). I'm unsure if this is what you were looking for > so I'm going to attach the patch instead of submitting as a V8 for > now. > > My main concern as that the use of the above removes the > pwm1_auto_point1_pwm + pwm1_auto_point1_temp format and gives two > hwmon<num>, one per cpu/gpu fan with: > > device power > fan1_input subsystem > fan2_input temp1_input > fan3_input temp2_input > fan4_input temp3_input > fan5_input temp4_input > fan6_input temp5_input > fan7_input temp6_input > fan8_input temp7_input > in0_enable temp8_input > name uevent > > cat -p /sys/devices/platform/asus-nb-wmi/hwmon/hwmon7/name > asus_cpu_fan_custom_curve > > I've named the root name of each as descriptive as possible to convey > exactly what each is > > Oh and `sensors` now shows: > > asus_cpu_fan_curve-isa-0000 > Adapter: ISA adapter > fan1: 8 RPM > fan2: 10 RPM > fan3: 18 RPM > fan4: 20 RPM > fan5: 28 RPM > fan6: 34 RPM > fan7: 44 RPM > fan8: 56 RPM > temp1: +0.0°C > temp2: +0.1°C > temp3: +0.1°C > temp4: +0.1°C > temp5: +0.1°C > temp6: +0.1°C > temp7: +0.1°C > temp8: +0.1°C > > > > FYI, the pwmX_enable attributes can be created by the hwmon > > subsystem itself if you use [devm_]hwmon_device_register_with_info() > > with appropriately populated `struct hwmon_chip_info`. > > So when you say this, did you mean *just* for the pwmX_enable > attributes? > > > On Mon, Aug 30 2021 at 21:28:18 +0000, Barnabás Pőcze > <pobrn@protonmail.com> wrote: >> Hi >> >> >> 2021. augusztus 30., hétfő 13:31 keltezéssel, Luke D. Jones írta: >>> Add support for custom fan curves found on some ASUS ROG laptops. >>> >>> These laptops have the ability to set a custom curve for the CPU >>> and GPU fans via an ACPI method call. This patch enables this, >>> additionally enabling custom fan curves per-profile, where profile >>> here means each of the 3 levels of "throttle_thermal_policy". >>> >>> This patch adds two blocks of attributes to the hwmon sysfs, >>> 1 block each for CPU and GPU fans. >>> >>> When the user switches profiles the associated curve data for that >>> profile is then show/store enabled to allow users to rotate through >>> the profiles and set a fan curve for each profile which then >>> activates on profile switch if enabled. >>> >>> Signed-off-by: Luke D. Jones <luke@ljones.dev> >>> --- >>> drivers/platform/x86/asus-wmi.c | 568 >>> ++++++++++++++++++++- >>> include/linux/platform_data/x86/asus-wmi.h | 2 + >>> 2 files changed, 566 insertions(+), 4 deletions(-) >>> >>> diff --git a/drivers/platform/x86/asus-wmi.c >>> b/drivers/platform/x86/asus-wmi.c >>> index cc5811844012..b594c2475034 100644 >>> --- a/drivers/platform/x86/asus-wmi.c >>> +++ b/drivers/platform/x86/asus-wmi.c >>> [...] >>> +/* >>> + * Returns as an error if the method output is not a buffer. >>> Typically this >> >> It seems to me it will simply leave the output buffer uninitialized >> if something >> other than ACPI_TYPE_BUFFER and ACPI_TYPE_INTEGER is encountered and >> return 0. >> >> >>> + * means that the method called is unsupported. >>> + */ >>> +static int asus_wmi_evaluate_method_buf(u32 method_id, >>> + u32 arg0, u32 arg1, u8 *ret_buffer) >>> +{ >>> + struct bios_args args = { >>> + .arg0 = arg0, >>> + .arg1 = arg1, >>> + .arg2 = 0, >>> + }; >>> + struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; >>> + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; >>> + acpi_status status; >>> + union acpi_object *obj; >>> + u32 int_tmp = 0; >>> + >>> + status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id, >>> + &input, &output); >>> + >>> + if (ACPI_FAILURE(status)) >>> + return -EIO; >>> + >>> + obj = (union acpi_object *)output.pointer; >>> + >>> + if (obj && obj->type == ACPI_TYPE_INTEGER) { >>> + int_tmp = (u32) obj->integer.value; >>> + if (int_tmp == ASUS_WMI_UNSUPPORTED_METHOD) >>> + return -ENODEV; >>> + return int_tmp; >> >> Is anything known about the possible values? You are later >> using it as if it was an errno (e.g. in >> `custom_fan_check_present()`). >> >> And `obj` is leaked in both of the previous two returns. >> >> >>> + } >>> + >>> + if (obj && obj->type == ACPI_TYPE_BUFFER) >>> + memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length); >> >> I would suggest you add a "size_t size" argument to this function, >> and >> return -ENOSPC/-ENODATA depending on whether the returned buffer is >> too >> big/small. Maybe return -ENODATA if `obj` is NULL, too. >> >> >>> + >>> + kfree(obj); >>> + >>> + return 0; >>> +} >>> [...] >>> +static ssize_t fan_curve_show(struct device *dev, >>> + struct device_attribute *attr, char *buf) >>> +{ >>> + struct fan_curve_data *data = fan_curve_attr_data_select(dev, >>> attr); >>> + int value; >>> + >>> + int index = to_sensor_dev_attr_2(attr)->index; >>> + int nr = to_sensor_dev_attr_2(attr)->nr; >>> + int pwm = nr & FAN_CURVE_PWM_MASK; >>> + >>> + if (pwm) >>> + value = 255 * data->percents[index] / 100; >>> + else >>> + value = data->temps[index]; >>> + >>> + return scnprintf(buf, PAGE_SIZE, "%d\n", value); >> >> sysfs_emit() >> >> >>> +} >>> + >>> +/* >>> + * "dev" is the related WMI method such as >>> ASUS_WMI_DEVID_CPU_FAN_CURVE. >>> + */ >>> +static int fan_curve_write(struct asus_wmi *asus, u32 dev, >>> + struct fan_curve_data *data) >>> +{ >>> + int ret, i, shift = 0; >>> + u32 arg1, arg2, arg3, arg4; >>> + >>> + arg1 = arg2 = arg3 = arg4 = 0; >>> + >>> + for (i = 0; i < FAN_CURVE_POINTS / 2; i++) { >>> + arg1 += data->temps[i] << shift; >>> + arg2 += data->temps[i + 4] << shift; >>> + arg3 += data->percents[0] << shift; >>> + arg4 += data->percents[i + 4] << shift; >>> + shift += 8; >>> + } >>> + >>> + return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS, dev, >>> + arg1, arg2, arg3, arg4, &ret); >>> +} >>> + >>> +/* >>> + * Called only by throttle_thermal_policy_write() >>> + */ >> >> Am I correct in thinking that the firmware does not actually >> support specifying fan curves for each mode, only a single one, >> and the fan curve switching is done by this driver when >> the performance mode is changed? >> >> >>> +static int fan_curve_write_data(struct asus_wmi *asus) >>> +{ >>> + struct fan_curve_data *cpu; >>> + struct fan_curve_data *gpu; >>> + int err, mode; >>> + >>> + mode = asus->throttle_thermal_policy_mode; >>> + cpu = &asus->throttle_fan_curves[mode][FAN_CURVE_DEV_CPU]; >>> + gpu = &asus->throttle_fan_curves[mode][FAN_CURVE_DEV_GPU]; >>> + >>> + if (cpu->enabled) { >>> + err = fan_curve_write(asus, ASUS_WMI_DEVID_CPU_FAN_CURVE, cpu); >>> + if (err) >>> + return err; >>> + } >>> + >>> + if (gpu->enabled) { >>> + err = fan_curve_write(asus, ASUS_WMI_DEVID_GPU_FAN_CURVE, gpu); >>> + if (err) >>> + return err; >>> + } >>> + >>> + return 0; >>> +} >>> [...] >>> +static ssize_t fan_curve_store(struct device *dev, >>> + struct device_attribute *attr, >>> + const char *buf, size_t count) >>> +{ >>> + struct fan_curve_data *data = fan_curve_attr_data_select(dev, >>> attr); >>> + u8 value, old_value; >>> + int err; >>> + >>> + int index = to_sensor_dev_attr_2(attr)->index; >>> + int nr = to_sensor_dev_attr_2(attr)->nr; >>> + int pwm = nr & FAN_CURVE_PWM_MASK; >>> + >>> + err = kstrtou8(buf, 10, &value); >>> + if (err < 0) >>> + return err; >>> + >>> + if (pwm) { >>> + old_value = data->percents[index]; >>> + data->percents[index] = 100 * value / 255; >>> + } else { >>> + old_value = data->temps[index]; >>> + data->temps[index] = value; >>> + } >>> + /* >>> + * The check here forces writing a curve graph in reverse, >>> + * from highest to lowest. >>> + */ >>> + err = fan_curve_verify(data); >>> + if (err) { >>> + if (pwm) { >>> + dev_err(dev, "a fan curve percentage was higher than the next >>> in sequence\n"); >>> + data->percents[index] = old_value; >>> + } else { >>> + dev_err(dev, "a fan curve temperature was higher than the next >>> in sequence\n"); >>> + data->temps[index] = old_value; >>> + } >>> + return err; >>> + } >> >> Are such sequences rejected by the firmware itself? >> Or is this just an extra layer of protection? >> >> >>> + >>> + return count; >>> +} >>> + >>> +static ssize_t fan_curve_enable_show(struct device *dev, >>> + struct device_attribute *attr, char *buf) >>> +{ >>> + struct fan_curve_data *data = fan_curve_attr_data_select(dev, >>> attr); >>> + >>> + return scnprintf(buf, PAGE_SIZE, "%d\n", data->enabled); >> >> sysfs_emit() >> >> >>> +} >>> + >>> +static ssize_t fan_curve_enable_store(struct device *dev, >>> + struct device_attribute *attr, >>> + const char *buf, size_t count) >>> +{ >>> + struct fan_curve_data *data = fan_curve_attr_data_select(dev, >>> attr); >>> + struct asus_wmi *asus = dev_get_drvdata(dev); >>> + bool value; >>> + int err; >>> + >>> + err = kstrtobool(buf, &value); >>> + if (err < 0) >>> + return err; >>> + >>> + data->enabled = value; >>> + throttle_thermal_policy_write(asus); >>> + >>> + return count; >>> +} >>> + >>> +/* CPU */ >>> +// TODO: enable >>> +static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, >>> + FAN_CURVE_DEV_CPU); >> >> FYI, the pwmX_enable attributes can be created by the hwmon >> subsystem itself if you use [devm_]hwmon_device_register_with_info() >> with appropriately populated `struct hwmon_chip_info`. >> >> >>> [...] >>> +static const struct attribute_group fan_curve_attribute_group = { >>> + .is_visible = fan_curve_sysfs_is_visible, >>> + .attrs = fan_curve_attributes >> >> Small thing, but it is customary to put commas after non-terminating >> entries in initializers / enum definitions. >> >> >>> +}; >>> +__ATTRIBUTE_GROUPS(fan_curve_attribute); >>> + >>> +static int asus_wmi_fan_curve_init(struct asus_wmi *asus) >>> +{ >>> + struct device *dev = &asus->platform_device->dev; >>> + struct device *hwmon; >>> + >>> + hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus, >>> + fan_curve_attribute_groups); >>> + >>> + if (IS_ERR(hwmon)) { >>> + pr_err("Could not register asus fan_curve device\n"); >> >> I think `dev_err()` would be better. >> >> >>> + return PTR_ERR(hwmon); >>> + } >>> + >>> + return 0; >>> +} >>> [...] >>> diff --git a/include/linux/platform_data/x86/asus-wmi.h >>> b/include/linux/platform_data/x86/asus-wmi.h >>> index 17dc5cb6f3f2..a571b47ff362 100644 >>> --- a/include/linux/platform_data/x86/asus-wmi.h >>> +++ b/include/linux/platform_data/x86/asus-wmi.h >>> @@ -77,6 +77,8 @@ >>> #define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011 >>> #define ASUS_WMI_DEVID_FAN_CTRL 0x00110012 /* deprecated */ >>> #define ASUS_WMI_DEVID_CPU_FAN_CTRL 0x00110013 >>> +#define ASUS_WMI_DEVID_CPU_FAN_CURVE 0x00110024 >>> +#define ASUS_WMI_DEVID_GPU_FAN_CURVE 0x00110025 >>> >>> /* Power */ >>> #define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012 >>> -- >>> 2.31.1 >> >> >> Best regards, >> Barnabás Pőcze >
From 05f7f9c4990e097b8a71a2a39a36aa1d5d39742a Mon Sep 17 00:00:00 2001 From: "Luke D. Jones" <luke@ljones.dev> Date: Sun, 29 Aug 2021 13:21:23 +1200 Subject: [PATCH v9] asus-wmi: Add support for custom fan curves
Add support for custom fan curves found on some ASUS ROG laptops.
These laptops have the ability to set a custom curve for the CPU and GPU fans via an ACPI method call. This patch enables this, additionally enabling custom fan curves per-profile, where profile here means each of the 3 levels of "throttle_thermal_policy".
This patch adds two blocks of attributes to the hwmon sysfs, 1 block each for CPU and GPU fans.
When the user switches profiles the associated curve data for that profile is then show/store enabled to allow users to rotate through the profiles and set a fan curve for each profile which then activates on profile switch if enabled.
Signed-off-by: Luke D. Jones <luke@ljones.dev> --- drivers/platform/x86/asus-wmi.c | 568 ++++++++++++++++++++- include/linux/platform_data/x86/asus-wmi.h | 2 + 2 files changed, 566 insertions(+), 4 deletions(-)
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c index cc5811844012..b594c2475034 100644 --- a/drivers/platform/x86/asus-wmi.c +++ b/drivers/platform/x86/asus-wmi.c @@ -106,8 +106,18 @@ module_param(fnlock_default, bool, 0444); #define WMI_EVENT_MASK 0xFFFF +/* The number of ASUS_THROTTLE_THERMAL_POLICY_* available */ +#define FAN_CURVE_PROFILE_NUM (ASUS_THROTTLE_THERMAL_POLICY_SILENT + 1) +#define FAN_CURVE_POINTS 8 +#define FAN_CURVE_DEV_CPU 0x00 +#define FAN_CURVE_DEV_GPU 0x01 +/* Mask to determine if setting temperature or percentage */ +#define FAN_CURVE_PWM_MASK 0x04 + static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL }; +static int throttle_thermal_policy_write(struct asus_wmi *); + static bool ashs_present(void) { int i = 0; @@ -122,7 +132,8 @@ struct bios_args { u32 arg0; u32 arg1; u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */ - u32 arg4; + u32 arg3; + u32 arg4; /* Some ROG laptops require a full 5 input args */ u32 arg5; } __packed; @@ -173,6 +184,17 @@ enum fan_type { FAN_TYPE_SPEC83, /* starting in Spec 8.3, use CPU_FAN_CTRL */ }; +/* + * The related ACPI method for testing availability also returns the factory + * default fan curves. We save them here so that a user can reset custom + * settings if required. + */ +struct fan_curve_data { + bool enabled; + u8 temps[FAN_CURVE_POINTS]; + u8 percents[FAN_CURVE_POINTS]; +}; + struct asus_wmi { int dsts_id; int spec; @@ -220,6 +242,11 @@ struct asus_wmi { bool throttle_thermal_policy_available; u8 throttle_thermal_policy_mode; + bool cpu_fan_curve_available; + bool gpu_fan_curve_available; + /* [throttle modes][fan count] */ + struct fan_curve_data throttle_fan_curves[FAN_CURVE_PROFILE_NUM][2]; + struct platform_profile_handler platform_profile_handler; bool platform_profile_support; @@ -285,6 +312,84 @@ int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval) } EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method); +static int asus_wmi_evaluate_method5(u32 method_id, + u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval) +{ + struct bios_args args = { + .arg0 = arg0, + .arg1 = arg1, + .arg2 = arg2, + .arg3 = arg3, + .arg4 = arg4, + }; + struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; + acpi_status status; + union acpi_object *obj; + u32 tmp = 0; + + status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id, + &input, &output); + + if (ACPI_FAILURE(status)) + return -EIO; + + obj = (union acpi_object *)output.pointer; + if (obj && obj->type == ACPI_TYPE_INTEGER) + tmp = (u32) obj->integer.value; + + if (retval) + *retval = tmp; + + kfree(obj); + + if (tmp == ASUS_WMI_UNSUPPORTED_METHOD) + return -ENODEV; + + return 0; +} + +/* + * Returns as an error if the method output is not a buffer. Typically this + * means that the method called is unsupported. + */ +static int asus_wmi_evaluate_method_buf(u32 method_id, + u32 arg0, u32 arg1, u8 *ret_buffer) +{ + struct bios_args args = { + .arg0 = arg0, + .arg1 = arg1, + .arg2 = 0, + }; + struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; + acpi_status status; + union acpi_object *obj; + u32 int_tmp = 0; + + status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id, + &input, &output); + + if (ACPI_FAILURE(status)) + return -EIO; + + obj = (union acpi_object *)output.pointer; + + if (obj && obj->type == ACPI_TYPE_INTEGER) { + int_tmp = (u32) obj->integer.value; + if (int_tmp == ASUS_WMI_UNSUPPORTED_METHOD) + return -ENODEV; + return int_tmp; + } + + if (obj && obj->type == ACPI_TYPE_BUFFER) + memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length); + + kfree(obj); + + return 0; +} + static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args) { struct acpi_buffer input; @@ -2043,6 +2148,440 @@ static ssize_t fan_boost_mode_store(struct device *dev, // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent static DEVICE_ATTR_RW(fan_boost_mode); +/* Custom fan curves per-profile **********************************************/ + +static void init_fan_curve(struct fan_curve_data *data, u8 *buf) +{ + int i; + + for (i = 0; i < FAN_CURVE_POINTS; i++) + data->temps[i] = buf[i]; + + for (i = 0; i < FAN_CURVE_POINTS; i++) + data->percents[i] = buf[i + 8]; +} + +/* + * Check if the ability to set fan curves on either fan exists, and populate + * with system defaults to provide users with a starting point. + * + * "dev" is either CPU_FAN_CURVE or GPU_FAN_CURVE. + */ +static int custom_fan_check_present(struct asus_wmi *asus, + bool *available, u32 dev) +{ + struct fan_curve_data *curves; + u8 buf[FAN_CURVE_POINTS * 2]; + int fan_idx = 0; + int err; + + *available = false; + if (dev == ASUS_WMI_DEVID_GPU_FAN_CURVE) + fan_idx = 1; + + /* Balanced default */ + curves = &asus->throttle_fan_curves + [ASUS_THROTTLE_THERMAL_POLICY_DEFAULT][fan_idx]; + err = asus_wmi_evaluate_method_buf(asus->dsts_id, dev, 0, buf); + if (err) { + if (err == -ENODEV) + return 0; + return err; + } + init_fan_curve(curves, buf); + + /* + * Quiet default. The index num for ACPI method does not match the + * throttle_thermal number, same for Performance. + */ + curves = &asus->throttle_fan_curves + [ASUS_THROTTLE_THERMAL_POLICY_SILENT][fan_idx]; + err = asus_wmi_evaluate_method_buf(asus->dsts_id, dev, 1, buf); + if (err) { + if (err == -ENODEV) + return 0; + return err; + } + init_fan_curve(curves, buf); + + /* Performance default */ + curves = &asus->throttle_fan_curves + [ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST][fan_idx]; + err = asus_wmi_evaluate_method_buf(asus->dsts_id, dev, 2, buf); + if (err) { + if (err == -ENODEV) + return 0; + return err; + } + init_fan_curve(curves, buf); + + *available = true; + return 0; +} + +static struct fan_curve_data *fan_curve_attr_data_select(struct device *dev, + struct device_attribute *attr) +{ + struct asus_wmi *asus = dev_get_drvdata(dev); + u8 mode = asus->throttle_thermal_policy_mode; + + int nr = to_sensor_dev_attr_2(attr)->nr; + int fan = nr & FAN_CURVE_DEV_GPU; + + return &asus->throttle_fan_curves[mode][fan]; +} + +static ssize_t fan_curve_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fan_curve_data *data = fan_curve_attr_data_select(dev, attr); + int value; + + int index = to_sensor_dev_attr_2(attr)->index; + int nr = to_sensor_dev_attr_2(attr)->nr; + int pwm = nr & FAN_CURVE_PWM_MASK; + + if (pwm) + value = 255 * data->percents[index] / 100; + else + value = data->temps[index]; + + return scnprintf(buf, PAGE_SIZE, "%d\n", value); +} + +/* + * "dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE. + */ +static int fan_curve_write(struct asus_wmi *asus, u32 dev, + struct fan_curve_data *data) +{ + int ret, i, shift = 0; + u32 arg1, arg2, arg3, arg4; + + arg1 = arg2 = arg3 = arg4 = 0; + + for (i = 0; i < FAN_CURVE_POINTS / 2; i++) { + arg1 += data->temps[i] << shift; + arg2 += data->temps[i + 4] << shift; + arg3 += data->percents[0] << shift; + arg4 += data->percents[i + 4] << shift; + shift += 8; + } + + return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS, dev, + arg1, arg2, arg3, arg4, &ret); +} + +/* + * Called only by throttle_thermal_policy_write() + */ +static int fan_curve_write_data(struct asus_wmi *asus) +{ + struct fan_curve_data *cpu; + struct fan_curve_data *gpu; + int err, mode; + + mode = asus->throttle_thermal_policy_mode; + cpu = &asus->throttle_fan_curves[mode][FAN_CURVE_DEV_CPU]; + gpu = &asus->throttle_fan_curves[mode][FAN_CURVE_DEV_GPU]; + + if (cpu->enabled) { + err = fan_curve_write(asus, ASUS_WMI_DEVID_CPU_FAN_CURVE, cpu); + if (err) + return err; + } + + if (gpu->enabled) { + err = fan_curve_write(asus, ASUS_WMI_DEVID_GPU_FAN_CURVE, gpu); + if (err) + return err; + } + + return 0; +} + +static int fan_curve_verify(struct fan_curve_data *data) +{ + int i = 0; + u8 tmp = 0; + u8 prev_tmp = 0; + + + for (i = 0; i < FAN_CURVE_POINTS; i++) { + tmp = data->temps[i]; + if (tmp < prev_tmp) + return -EINVAL; + prev_tmp = tmp; + } + + tmp = 0; + prev_tmp = 0; + for (i = 0; i < FAN_CURVE_POINTS; i++) { + tmp = data->percents[i]; + if (tmp < prev_tmp) + return -EINVAL; + prev_tmp = tmp; + } + + return 0; +} + +static ssize_t fan_curve_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fan_curve_data *data = fan_curve_attr_data_select(dev, attr); + u8 value, old_value; + int err; + + int index = to_sensor_dev_attr_2(attr)->index; + int nr = to_sensor_dev_attr_2(attr)->nr; + int pwm = nr & FAN_CURVE_PWM_MASK; + + err = kstrtou8(buf, 10, &value); + if (err < 0) + return err; + + if (pwm) { + old_value = data->percents[index]; + data->percents[index] = 100 * value / 255; + } else { + old_value = data->temps[index]; + data->temps[index] = value; + } + /* + * The check here forces writing a curve graph in reverse, + * from highest to lowest. + */ + err = fan_curve_verify(data); + if (err) { + if (pwm) { + dev_err(dev, "a fan curve percentage was higher than the next in sequence\n"); + data->percents[index] = old_value; + } else { + dev_err(dev, "a fan curve temperature was higher than the next in sequence\n"); + data->temps[index] = old_value; + } + return err; + } + + return count; +} + +static ssize_t fan_curve_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fan_curve_data *data = fan_curve_attr_data_select(dev, attr); + + return scnprintf(buf, PAGE_SIZE, "%d\n", data->enabled); +} + +static ssize_t fan_curve_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fan_curve_data *data = fan_curve_attr_data_select(dev, attr); + struct asus_wmi *asus = dev_get_drvdata(dev); + bool value; + int err; + + err = kstrtobool(buf, &value); + if (err < 0) + return err; + + data->enabled = value; + throttle_thermal_policy_write(asus); + + return count; +} + +/* CPU */ +// TODO: enable +static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, + FAN_CURVE_DEV_CPU); +// (name, function, fan, point) TODO: need to mask if temp or percent +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve, + FAN_CURVE_DEV_CPU, 0); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve, + FAN_CURVE_DEV_CPU, 1); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve, + FAN_CURVE_DEV_CPU, 2); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve, + FAN_CURVE_DEV_CPU, 3); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve, + FAN_CURVE_DEV_CPU, 4); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve, + FAN_CURVE_DEV_CPU, 5); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve, + FAN_CURVE_DEV_CPU, 6); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve, + FAN_CURVE_DEV_CPU, 7); + +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6); +static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve, + FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7); + +/* GPU */ +static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, + FAN_CURVE_DEV_GPU); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve, + FAN_CURVE_DEV_GPU, 0); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve, + FAN_CURVE_DEV_GPU, 1); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve, + FAN_CURVE_DEV_GPU, 2); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve, + FAN_CURVE_DEV_GPU, 3); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve, + FAN_CURVE_DEV_GPU, 4); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve, + FAN_CURVE_DEV_GPU, 5); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve, + FAN_CURVE_DEV_GPU, 6); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve, + FAN_CURVE_DEV_GPU, 7); + +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6); +static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve, + FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7); + +static struct attribute *fan_curve_attributes[] = { + /* CPU */ + &sensor_dev_attr_pwm1_enable.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr, + &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr, + /* GPU */ + &sensor_dev_attr_pwm2_enable.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr, + &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr, + NULL +}; + +static umode_t fan_curve_sysfs_is_visible(struct kobject *kobj, + struct attribute *attr, int idx) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct asus_wmi *asus = dev_get_drvdata(dev->parent); + + if (attr == &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr) { + if (!asus->cpu_fan_curve_available) + return 0; + } + + if (attr == &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr + || attr == &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr) { + if (!asus->gpu_fan_curve_available) + return 0; + } + + return attr->mode; +} + +static const struct attribute_group fan_curve_attribute_group = { + .is_visible = fan_curve_sysfs_is_visible, + .attrs = fan_curve_attributes +}; +__ATTRIBUTE_GROUPS(fan_curve_attribute); + +static int asus_wmi_fan_curve_init(struct asus_wmi *asus) +{ + struct device *dev = &asus->platform_device->dev; + struct device *hwmon; + + hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus, + fan_curve_attribute_groups); + + if (IS_ERR(hwmon)) { + pr_err("Could not register asus fan_curve device\n"); + return PTR_ERR(hwmon); + } + + return 0; +} + /* Throttle thermal policy ****************************************************/ static int throttle_thermal_policy_check_present(struct asus_wmi *asus) @@ -2053,8 +2592,8 @@ static int throttle_thermal_policy_check_present(struct asus_wmi *asus) asus->throttle_thermal_policy_available = false; err = asus_wmi_get_devstate(asus, - ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, - &result); + ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, + &result); if (err) { if (err == -ENODEV) return 0; @@ -2092,6 +2631,12 @@ static int throttle_thermal_policy_write(struct asus_wmi *asus) return -EIO; } + if (asus->cpu_fan_curve_available || asus->gpu_fan_curve_available) { + err = fan_curve_write_data(asus); + if (err) + return err; + } + return 0; } @@ -2904,7 +3449,7 @@ static int show_call(struct seq_file *m, void *data) if (ACPI_FAILURE(status)) return -EIO; - obj = (union acpi_object *)output.pointer; + obj = output.pointer; if (obj && obj->type == ACPI_TYPE_INTEGER) seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id, asus->debug.dev_id, asus->debug.ctrl_param, @@ -3016,6 +3561,16 @@ static int asus_wmi_add(struct platform_device *pdev) else throttle_thermal_policy_set_default(asus); + err = custom_fan_check_present(asus, &asus->cpu_fan_curve_available, + ASUS_WMI_DEVID_CPU_FAN_CURVE); + if (err) + goto fail_custom_fan_curve; + + err = custom_fan_check_present(asus, &asus->gpu_fan_curve_available, + ASUS_WMI_DEVID_GPU_FAN_CURVE); + if (err) + goto fail_custom_fan_curve; + err = platform_profile_setup(asus); if (err) goto fail_platform_profile_setup; @@ -3038,6 +3593,10 @@ static int asus_wmi_add(struct platform_device *pdev) if (err) goto fail_hwmon; + err = asus_wmi_fan_curve_init(asus); + if (err) + goto fail_custom_fan_curve; + err = asus_wmi_led_init(asus); if (err) goto fail_leds; @@ -3109,6 +3668,7 @@ static int asus_wmi_add(struct platform_device *pdev) asus_wmi_sysfs_exit(asus->platform_device); fail_sysfs: fail_throttle_thermal_policy: +fail_custom_fan_curve: fail_platform_profile_setup: if (asus->platform_profile_support) platform_profile_remove(); diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h index 17dc5cb6f3f2..a571b47ff362 100644 --- a/include/linux/platform_data/x86/asus-wmi.h +++ b/include/linux/platform_data/x86/asus-wmi.h @@ -77,6 +77,8 @@ #define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011 #define ASUS_WMI_DEVID_FAN_CTRL 0x00110012 /* deprecated */ #define ASUS_WMI_DEVID_CPU_FAN_CTRL 0x00110013 +#define ASUS_WMI_DEVID_CPU_FAN_CURVE 0x00110024 +#define ASUS_WMI_DEVID_GPU_FAN_CURVE 0x00110025 /* Power */ #define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012 -- 2.31.1
| |