Unverified Commit d6999078 authored by Kurt Borja's avatar Kurt Borja Committed by Ilpo Järvinen
Browse files

platform/x86: alienware-wmi-wmax: Add HWMON support 



All models with the "AWCC" WMAX device support monitoring fan speed and
temperature sensors. Expose this feature through the HWMON interface.

Cc: Guenter Roeck <linux@roeck-us.net>
Cc: Jean Delvare <jdelvare@suse.com>
Cc: linux-hwmon@vger.kernel.org
Reviewed-by: default avatarArmin Wolf <W_Armin@gmx.de>
Signed-off-by: default avatarKurt Borja <kuurtb@gmail.com>
Link: https://lore.kernel.org/r/20250329-hwm-v7-7-a14ea39d8a94@gmail.com


Reviewed-by: default avatarIlpo Järvinen <ilpo.jarvinen@linux.intel.com>
Signed-off-by: default avatarIlpo Järvinen <ilpo.jarvinen@linux.intel.com>
parent 3dde0ae1

drivers/platform/x86/dell/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ config ALIENWARE_WMI 
	depends on DMI

	depends on LEDS_CLASS

	depends on NEW_LEDS

	depends on HWMON

	help

	 This is a driver for controlling Alienware WMI driven features.

drivers/platform/x86/dell/alienware-wmi-wmax.c

+396 −0
Original line number Diff line number Diff line
@@ -10,10 +10,13 @@ 


#include <linux/array_size.h>

#include <linux/bitfield.h>

#include <linux/bitmap.h>

#include <linux/bits.h>

#include <linux/dmi.h>

#include <linux/hwmon.h>

#include <linux/moduleparam.h>

#include <linux/platform_profile.h>

#include <linux/units.h>

#include <linux/wmi.h>

#include "alienware-wmi.h"
@@ -26,6 +29,7 @@ 
#define WMAX_METHOD_BRIGHTNESS			0x3

#define WMAX_METHOD_ZONE_CONTROL		0x4



#define AWCC_METHOD_GET_FAN_SENSORS		0x13

#define AWCC_METHOD_THERMAL_INFORMATION		0x14

#define AWCC_METHOD_THERMAL_CONTROL		0x15

#define AWCC_METHOD_GAME_SHIFT_STATUS		0x25
@@ -40,6 +44,12 @@ 


/* Arbitrary limit based on supported models */

#define AWCC_MAX_RES_COUNT			16

#define AWCC_ID_BITMAP_SIZE			(U8_MAX + 1)

#define AWCC_ID_BITMAP_LONGS			BITS_TO_LONGS(AWCC_ID_BITMAP_SIZE)



static bool force_hwmon;

module_param_unsafe(force_hwmon, bool, 0);

MODULE_PARM_DESC(force_hwmon, "Force probing for HWMON support without checking if the WMI backend is available");



static bool force_platform_profile;

module_param_unsafe(force_platform_profile, bool, 0);
@@ -50,16 +60,19 @@ module_param_unsafe(force_gmode, bool, 0); 
MODULE_PARM_DESC(force_gmode, "Forces G-Mode when performance profile is selected");



struct awcc_quirks {

	bool hwmon;

	bool pprof;

	bool gmode;

};



static struct awcc_quirks g_series_quirks = {

	.hwmon = true,

	.pprof = true,

	.gmode = true,

};



static struct awcc_quirks generic_quirks = {

	.hwmon = true,

	.pprof = true,

	.gmode = false,

};
@@ -157,9 +170,18 @@ static const struct dmi_system_id awcc_dmi_table[] __initconst = { 
	},

};



enum AWCC_GET_FAN_SENSORS_OPERATIONS {

	AWCC_OP_GET_TOTAL_FAN_TEMPS		= 0x01,

	AWCC_OP_GET_FAN_TEMP_ID			= 0x02,

};



enum AWCC_THERMAL_INFORMATION_OPERATIONS {

	AWCC_OP_GET_SYSTEM_DESCRIPTION		= 0x02,

	AWCC_OP_GET_RESOURCE_ID			= 0x03,

	AWCC_OP_GET_TEMPERATURE			= 0x04,

	AWCC_OP_GET_FAN_RPM			= 0x05,

	AWCC_OP_GET_FAN_MIN_RPM			= 0x08,

	AWCC_OP_GET_FAN_MAX_RPM			= 0x09,

	AWCC_OP_GET_CURRENT_PROFILE		= 0x0B,

};
@@ -182,6 +204,11 @@ enum AWCC_SPECIAL_THERMAL_CODES { 
	AWCC_SPECIAL_PROFILE_GMODE		= 0xAB,

};



enum AWCC_TEMP_SENSOR_TYPES {

	AWCC_TEMP_SENSOR_CPU			= 0x01,

	AWCC_TEMP_SENSOR_GPU			= 0x06,

};



enum awcc_thermal_profile {

	AWCC_PROFILE_USTT_BALANCED,

	AWCC_PROFILE_USTT_BALANCED_PERFORMANCE,
@@ -218,6 +245,14 @@ struct wmax_u32_args { 
	u8 arg3;

};



struct awcc_fan_data {

	unsigned long auto_channels_temp;

	const char *label;

	u32 min_rpm;

	u32 max_rpm;

	u8 id;

};



struct awcc_priv {

	struct wmi_device *wdev;

	union {
@@ -233,6 +268,10 @@ struct awcc_priv { 


	struct device *ppdev;

	u8 supported_profiles[PLATFORM_PROFILE_LAST];



	struct device *hwdev;

	struct awcc_fan_data **fan_data;

	unsigned long temp_sensors[AWCC_ID_BITMAP_LONGS];

};



static const enum platform_profile_option awcc_mode_to_platform_profile[AWCC_PROFILE_LAST] = {
@@ -497,6 +536,19 @@ static int awcc_wmi_command(struct wmi_device *wdev, u32 method_id, 
	return 0;

}



static int awcc_get_fan_sensors(struct wmi_device *wdev, u8 operation,

				u8 fan_id, u8 index, u32 *out)

{

	struct wmax_u32_args args = {

		.operation = operation,

		.arg1 = fan_id,

		.arg2 = index,

		.arg3 = 0,

	};



	return awcc_wmi_command(wdev, AWCC_METHOD_GET_FAN_SENSORS, &args, out);

}



static int awcc_thermal_information(struct wmi_device *wdev, u8 operation, u8 arg,

				    u32 *out)

{
@@ -562,6 +614,30 @@ static int awcc_op_get_resource_id(struct wmi_device *wdev, u8 index, u8 *out) 
	return 0;

}



static int awcc_op_get_fan_rpm(struct wmi_device *wdev, u8 fan_id, u32 *out)

{

	struct wmax_u32_args args = {

		.operation = AWCC_OP_GET_FAN_RPM,

		.arg1 = fan_id,

		.arg2 = 0,

		.arg3 = 0,

	};



	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);

}



static int awcc_op_get_temperature(struct wmi_device *wdev, u8 temp_id, u32 *out)

{

	struct wmax_u32_args args = {

		.operation = AWCC_OP_GET_TEMPERATURE,

		.arg1 = temp_id,

		.arg2 = 0,

		.arg3 = 0,

	};



	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);

}



static int awcc_op_get_current_profile(struct wmi_device *wdev, u32 *out)

{

	struct wmax_u32_args args = {
@@ -587,6 +663,313 @@ static int awcc_op_activate_profile(struct wmi_device *wdev, u8 profile) 
	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_CONTROL, &args, &out);

}



/*

 * HWMON

 *  - Provides temperature and fan speed monitoring as well as manual fan

 *    control

 */

static umode_t awcc_hwmon_is_visible(const void *drvdata, enum hwmon_sensor_types type,

				     u32 attr, int channel)

{

	const struct awcc_priv *priv = drvdata;

	unsigned int temp_count;



	switch (type) {

	case hwmon_temp:

		temp_count = bitmap_weight(priv->temp_sensors, AWCC_ID_BITMAP_SIZE);



		return channel < temp_count ? 0444 : 0;

	case hwmon_fan:

		return channel < priv->fan_count ? 0444 : 0;

	case hwmon_pwm:

		return channel < priv->fan_count ? 0444 : 0;

	default:

		return 0;

	}

}



static int awcc_hwmon_read(struct device *dev, enum hwmon_sensor_types type,

			   u32 attr, int channel, long *val)

{

	struct awcc_priv *priv = dev_get_drvdata(dev);

	const struct awcc_fan_data *fan;

	u32 state;

	int ret;

	u8 temp;



	switch (type) {

	case hwmon_temp:

		temp = find_nth_bit(priv->temp_sensors, AWCC_ID_BITMAP_SIZE, channel);



		switch (attr) {

		case hwmon_temp_input:

			ret = awcc_op_get_temperature(priv->wdev, temp, &state);

			if (ret)

				return ret;



			*val = state * MILLIDEGREE_PER_DEGREE;

			break;

		default:

			return -EOPNOTSUPP;

		}



		break;

	case hwmon_fan:

		fan = priv->fan_data[channel];



		switch (attr) {

		case hwmon_fan_input:

			ret = awcc_op_get_fan_rpm(priv->wdev, fan->id, &state);

			if (ret)

				return ret;



			*val = state;

			break;

		case hwmon_fan_min:

			*val = fan->min_rpm;

			break;

		case hwmon_fan_max:

			*val = fan->max_rpm;

			break;

		default:

			return -EOPNOTSUPP;

		}



		break;

	case hwmon_pwm:

		fan = priv->fan_data[channel];



		switch (attr) {

		case hwmon_pwm_auto_channels_temp:

			*val = fan->auto_channels_temp;

			break;

		default:

			return -EOPNOTSUPP;

		}



		break;

	default:

		return -EOPNOTSUPP;

	}



	return 0;

}



static int awcc_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type,

				  u32 attr, int channel, const char **str)

{

	struct awcc_priv *priv = dev_get_drvdata(dev);

	u8 temp;



	switch (type) {

	case hwmon_temp:

		temp = find_nth_bit(priv->temp_sensors, AWCC_ID_BITMAP_SIZE, channel);



		switch (temp) {

		case AWCC_TEMP_SENSOR_CPU:

			*str = "CPU";

			break;

		case AWCC_TEMP_SENSOR_GPU:

			*str = "GPU";

			break;

		default:

			*str = "Unknown";

			break;

		}



		break;

	case hwmon_fan:

		*str = priv->fan_data[channel]->label;

		break;

	default:

		return -EOPNOTSUPP;

	}



	return 0;

}



static const struct hwmon_ops awcc_hwmon_ops = {

	.is_visible = awcc_hwmon_is_visible,

	.read = awcc_hwmon_read,

	.read_string = awcc_hwmon_read_string,

};



static const struct hwmon_channel_info * const awcc_hwmon_info[] = {

	HWMON_CHANNEL_INFO(temp,

			   HWMON_T_LABEL | HWMON_T_INPUT,

			   HWMON_T_LABEL | HWMON_T_INPUT,

			   HWMON_T_LABEL | HWMON_T_INPUT,

			   HWMON_T_LABEL | HWMON_T_INPUT,

			   HWMON_T_LABEL | HWMON_T_INPUT,

			   HWMON_T_LABEL | HWMON_T_INPUT

			   ),

	HWMON_CHANNEL_INFO(fan,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,

			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX

			   ),

	HWMON_CHANNEL_INFO(pwm,

			   HWMON_PWM_AUTO_CHANNELS_TEMP,

			   HWMON_PWM_AUTO_CHANNELS_TEMP,

			   HWMON_PWM_AUTO_CHANNELS_TEMP,

			   HWMON_PWM_AUTO_CHANNELS_TEMP,

			   HWMON_PWM_AUTO_CHANNELS_TEMP,

			   HWMON_PWM_AUTO_CHANNELS_TEMP

			   ),

	NULL

};



static const struct hwmon_chip_info awcc_hwmon_chip_info = {

	.ops = &awcc_hwmon_ops,

	.info = awcc_hwmon_info,

};



static int awcc_hwmon_temps_init(struct wmi_device *wdev)

{

	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);

	unsigned int i;

	int ret;

	u8 id;



	for (i = 0; i < priv->temp_count; i++) {

		/*

		 * Temperature sensors IDs are listed after the fan IDs at

		 * offset `fan_count`

		 */

		ret = awcc_op_get_resource_id(wdev, i + priv->fan_count, &id);

		if (ret)

			return ret;



		__set_bit(id, priv->temp_sensors);

	}



	return 0;

}



static char *awcc_get_fan_label(struct device *dev, u32 temp_count, u8 temp_id)

{

	char *label;



	switch (temp_count) {

	case 0:

		label = "Independent Fan";

		break;

	case 1:

		switch (temp_id) {

		case AWCC_TEMP_SENSOR_CPU:

			label = "Processor Fan";

			break;

		case AWCC_TEMP_SENSOR_GPU:

			label = "Video Fan";

			break;

		default:

			label = "Unknown Fan";

			break;

		}



		break;

	default:

		label = "Shared Fan";

		break;

	}



	return label;

}



static int awcc_hwmon_fans_init(struct wmi_device *wdev)

{

	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);

	unsigned long fan_temps[AWCC_ID_BITMAP_LONGS];

	unsigned long gather[AWCC_ID_BITMAP_LONGS];

	u32 min_rpm, max_rpm, temp_count, temp_id;

	struct awcc_fan_data *fan_data;

	unsigned int i, j;

	char *label;

	int ret;

	u8 id;



	for (i = 0; i < priv->fan_count; i++) {

		fan_data = devm_kzalloc(&wdev->dev, sizeof(*fan_data), GFP_KERNEL);

		if (!fan_data)

			return -ENOMEM;



		/*

		 * Fan IDs are listed first at offset 0

		 */

		ret = awcc_op_get_resource_id(wdev, i, &id);

		if (ret)

			return ret;



		ret = awcc_thermal_information(wdev, AWCC_OP_GET_FAN_MIN_RPM, id,

					       &min_rpm);

		if (ret)

			return ret;



		ret = awcc_thermal_information(wdev, AWCC_OP_GET_FAN_MAX_RPM, id,

					       &max_rpm);

		if (ret)

			return ret;



		ret = awcc_get_fan_sensors(wdev, AWCC_OP_GET_TOTAL_FAN_TEMPS, id,

					   0, &temp_count);

		if (ret)

			return ret;



		for (j = 0; j < temp_count; j++) {

			ret = awcc_get_fan_sensors(wdev, AWCC_OP_GET_FAN_TEMP_ID,

						   id, j, &temp_id);

			if (ret)

				break;



			temp_id = FIELD_GET(AWCC_RESOURCE_ID_MASK, temp_id);

			__set_bit(temp_id, fan_temps);

		}



		label = awcc_get_fan_label(&wdev->dev, temp_count, temp_id);

		if (!label)

			return -ENOMEM;



		fan_data->id = id;

		fan_data->min_rpm = min_rpm;

		fan_data->max_rpm = max_rpm;

		fan_data->label = label;

		bitmap_gather(gather, fan_temps, priv->temp_sensors, AWCC_ID_BITMAP_SIZE);

		bitmap_copy(&fan_data->auto_channels_temp, gather, BITS_PER_LONG);

		priv->fan_data[i] = fan_data;



		bitmap_zero(fan_temps, AWCC_ID_BITMAP_SIZE);

	}



	return 0;

}



static int awcc_hwmon_init(struct wmi_device *wdev)

{

	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);

	int ret;



	priv->fan_data = devm_kcalloc(&wdev->dev, priv->fan_count,

				      sizeof(*priv->fan_data), GFP_KERNEL);

	if (!priv->fan_data)

		return -ENOMEM;



	ret = awcc_hwmon_temps_init(wdev);

	if (ret)

		return ret;



	ret = awcc_hwmon_fans_init(wdev);

	if (ret)

		return ret;



	priv->hwdev = devm_hwmon_device_register_with_info(&wdev->dev, "alienware_wmi", priv,

							   &awcc_hwmon_chip_info, NULL);



	return PTR_ERR_OR_ZERO(priv->hwdev);

}



/*

 * Thermal Profile control

 *  - Provides thermal profile control through the Platform Profile API
@@ -751,6 +1134,12 @@ static int alienware_awcc_setup(struct wmi_device *wdev) 
	priv->wdev = wdev;

	dev_set_drvdata(&wdev->dev, priv);



	if (awcc->hwmon) {

		ret = awcc_hwmon_init(wdev);

		if (ret)

			return ret;

	}



	if (awcc->pprof) {

		ret = awcc_platform_profile_init(wdev);

		if (ret)
@@ -831,6 +1220,13 @@ int __init alienware_wmax_wmi_init(void) 
	if (id)

		awcc = id->driver_data;



	if (force_hwmon) {

		if (!awcc)

			awcc = &empty_quirks;



		awcc->hwmon = true;

	}



	if (force_platform_profile) {

		if (!awcc)

			awcc = &empty_quirks;