alienware-wmi-wmax.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Alienware WMAX WMI device driver
   4 *
   5 * Copyright (C) 2014 Dell Inc <Dell.Client.Kernel@dell.com>
   6 * Copyright (C) 2025 Kurt Borja <kuurtb@gmail.com>
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11#include <linux/array_size.h>
  12#include <linux/bitfield.h>
  13#include <linux/bitmap.h>
  14#include <linux/bits.h>
  15#include <linux/debugfs.h>
  16#include <linux/dmi.h>
  17#include <linux/hwmon.h>
  18#include <linux/hwmon-sysfs.h>
  19#include <linux/kstrtox.h>
  20#include <linux/minmax.h>
  21#include <linux/moduleparam.h>
  22#include <linux/platform_profile.h>
  23#include <linux/pm.h>
  24#include <linux/seq_file.h>
  25#include <linux/units.h>
  26#include <linux/wmi.h>
  27#include "alienware-wmi.h"
  28
  29#define WMAX_METHOD_HDMI_SOURCE			0x1
  30#define WMAX_METHOD_HDMI_STATUS			0x2
  31#define WMAX_METHOD_HDMI_CABLE			0x5
  32#define WMAX_METHOD_AMPLIFIER_CABLE		0x6
  33#define WMAX_METHOD_DEEP_SLEEP_CONTROL		0x0B
  34#define WMAX_METHOD_DEEP_SLEEP_STATUS		0x0C
  35#define WMAX_METHOD_BRIGHTNESS			0x3
  36#define WMAX_METHOD_ZONE_CONTROL		0x4
  37
  38#define AWCC_METHOD_GET_FAN_SENSORS		0x13
  39#define AWCC_METHOD_THERMAL_INFORMATION		0x14
  40#define AWCC_METHOD_THERMAL_CONTROL		0x15
  41#define AWCC_METHOD_FWUP_GPIO_CONTROL		0x20
  42#define AWCC_METHOD_READ_TOTAL_GPIOS		0x21
  43#define AWCC_METHOD_READ_GPIO_STATUS		0x22
  44#define AWCC_METHOD_GAME_SHIFT_STATUS		0x25
  45
  46#define AWCC_FAILURE_CODE			0xFFFFFFFF
  47#define AWCC_FAILURE_CODE_2			0xFFFFFFFE
  48
  49#define AWCC_SENSOR_ID_FLAG			BIT(8)
  50#define AWCC_THERMAL_MODE_MASK			GENMASK(3, 0)
  51#define AWCC_THERMAL_TABLE_MASK			GENMASK(7, 4)
  52#define AWCC_RESOURCE_ID_MASK			GENMASK(7, 0)
  53
  54/* Arbitrary limit based on supported models */
  55#define AWCC_MAX_RES_COUNT			16
  56#define AWCC_ID_BITMAP_SIZE			(U8_MAX + 1)
  57#define AWCC_ID_BITMAP_LONGS			BITS_TO_LONGS(AWCC_ID_BITMAP_SIZE)
  58
  59static bool force_hwmon;
  60module_param_unsafe(force_hwmon, bool, 0);
  61MODULE_PARM_DESC(force_hwmon, "Force probing for HWMON support without checking if the WMI backend is available");
  62
  63static bool force_platform_profile;
  64module_param_unsafe(force_platform_profile, bool, 0);
  65MODULE_PARM_DESC(force_platform_profile, "Forces auto-detecting thermal profiles without checking if WMI thermal backend is available");
  66
  67static bool force_gmode;
  68module_param_unsafe(force_gmode, bool, 0);
  69MODULE_PARM_DESC(force_gmode, "Forces G-Mode when performance profile is selected");
  70
  71struct awcc_quirks {
  72	bool hwmon;
  73	bool pprof;
  74	bool gmode;
  75};
  76
  77static struct awcc_quirks g_series_quirks = {
  78	.hwmon = true,
  79	.pprof = true,
  80	.gmode = true,
  81};
  82
  83static struct awcc_quirks generic_quirks = {
  84	.hwmon = true,
  85	.pprof = true,
  86	.gmode = false,
  87};
  88
  89static struct awcc_quirks empty_quirks;
  90
  91static const struct dmi_system_id awcc_dmi_table[] __initconst = {
  92	{
  93		.ident = "Alienware 16 Area-51",
  94		.matches = {
  95			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
  96			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware 16 Area-51"),
  97		},
  98		.driver_data = &g_series_quirks,
  99	},
 100	{
 101		.ident = "Alienware 16X Aurora",
 102		.matches = {
 103			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 104			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware 16X Aurora"),
 105		},
 106		.driver_data = &g_series_quirks,
 107	},
 108	{
 109		.ident = "Alienware 18 Area-51",
 110		.matches = {
 111			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 112			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware 18 Area-51"),
 113		},
 114		.driver_data = &g_series_quirks,
 115	},
 116	{
 117		.ident = "Alienware 16 Aurora",
 118		.matches = {
 119			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 120			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware 16 Aurora"),
 121		},
 122		.driver_data = &g_series_quirks,
 123	},
 124	{
 125		.ident = "Alienware Area-51m",
 126		.matches = {
 127			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 128			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware Area-51m"),
 129		},
 130		.driver_data = &generic_quirks,
 131	},
 132	{
 133		.ident = "Alienware m15",
 134		.matches = {
 135			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 136			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m15"),
 137		},
 138		.driver_data = &generic_quirks,
 139	},
 140	{
 141		.ident = "Alienware m16 R1 AMD",
 142		.matches = {
 143			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 144			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m16 R1 AMD"),
 145		},
 146		.driver_data = &generic_quirks,
 147	},
 148	{
 149		.ident = "Alienware m16 R1",
 150		.matches = {
 151			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 152			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m16 R1"),
 153		},
 154		.driver_data = &g_series_quirks,
 155	},
 156	{
 157		.ident = "Alienware m16 R2",
 158		.matches = {
 159			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 160			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m16 R2"),
 161		},
 162		.driver_data = &generic_quirks,
 163	},
 164	{
 165		.ident = "Alienware m17",
 166		.matches = {
 167			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 168			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m17"),
 169		},
 170		.driver_data = &generic_quirks,
 171	},
 172	{
 173		.ident = "Alienware m18",
 174		.matches = {
 175			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 176			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware m18"),
 177		},
 178		.driver_data = &g_series_quirks,
 179	},
 180	{
 181		.ident = "Alienware x15",
 182		.matches = {
 183			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 184			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware x15"),
 185		},
 186		.driver_data = &generic_quirks,
 187	},
 188	{
 189		.ident = "Alienware x16",
 190		.matches = {
 191			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 192			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware x16"),
 193		},
 194		.driver_data = &g_series_quirks,
 195	},
 196	{
 197		.ident = "Alienware x17",
 198		.matches = {
 199			DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
 200			DMI_MATCH(DMI_PRODUCT_NAME, "Alienware x17"),
 201		},
 202		.driver_data = &generic_quirks,
 203	},
 204	{
 205		.ident = "Dell Inc. G15",
 206		.matches = {
 207			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 208			DMI_MATCH(DMI_PRODUCT_NAME, "Dell G15"),
 209		},
 210		.driver_data = &g_series_quirks,
 211	},
 212	{
 213		.ident = "Dell Inc. G16",
 214		.matches = {
 215			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 216			DMI_MATCH(DMI_PRODUCT_NAME, "Dell G16"),
 217		},
 218		.driver_data = &g_series_quirks,
 219	},
 220	{
 221		.ident = "Dell Inc. G3",
 222		.matches = {
 223			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 224			DMI_MATCH(DMI_PRODUCT_NAME, "G3"),
 225		},
 226		.driver_data = &g_series_quirks,
 227	},
 228	{
 229		.ident = "Dell Inc. G5",
 230		.matches = {
 231			DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 232			DMI_MATCH(DMI_PRODUCT_NAME, "G5"),
 233		},
 234		.driver_data = &g_series_quirks,
 235	},
 236	{}
 237};
 238
 239enum AWCC_GET_FAN_SENSORS_OPERATIONS {
 240	AWCC_OP_GET_TOTAL_FAN_TEMPS		= 0x01,
 241	AWCC_OP_GET_FAN_TEMP_ID			= 0x02,
 242};
 243
 244enum AWCC_THERMAL_INFORMATION_OPERATIONS {
 245	AWCC_OP_GET_SYSTEM_DESCRIPTION		= 0x02,
 246	AWCC_OP_GET_RESOURCE_ID			= 0x03,
 247	AWCC_OP_GET_TEMPERATURE			= 0x04,
 248	AWCC_OP_GET_FAN_RPM			= 0x05,
 249	AWCC_OP_GET_FAN_MIN_RPM			= 0x08,
 250	AWCC_OP_GET_FAN_MAX_RPM			= 0x09,
 251	AWCC_OP_GET_CURRENT_PROFILE		= 0x0B,
 252	AWCC_OP_GET_FAN_BOOST			= 0x0C,
 253};
 254
 255enum AWCC_THERMAL_CONTROL_OPERATIONS {
 256	AWCC_OP_ACTIVATE_PROFILE		= 0x01,
 257	AWCC_OP_SET_FAN_BOOST			= 0x02,
 258};
 259
 260enum AWCC_GAME_SHIFT_STATUS_OPERATIONS {
 261	AWCC_OP_TOGGLE_GAME_SHIFT		= 0x01,
 262	AWCC_OP_GET_GAME_SHIFT_STATUS		= 0x02,
 263};
 264
 265enum AWCC_THERMAL_TABLES {
 266	AWCC_THERMAL_TABLE_LEGACY		= 0x9,
 267	AWCC_THERMAL_TABLE_USTT			= 0xA,
 268};
 269
 270enum AWCC_TEMP_SENSOR_TYPES {
 271	AWCC_TEMP_SENSOR_CPU			= 0x01,
 272	AWCC_TEMP_SENSOR_FRONT			= 0x03,
 273	AWCC_TEMP_SENSOR_GPU			= 0x06,
 274};
 275
 276enum AWCC_FAN_TYPES {
 277	AWCC_FAN_CPU_1				= 0x32,
 278	AWCC_FAN_GPU_1				= 0x33,
 279	AWCC_FAN_PCI				= 0x34,
 280	AWCC_FAN_MID				= 0x35,
 281	AWCC_FAN_TOP_1				= 0x36,
 282	AWCC_FAN_SIDE				= 0x37,
 283	AWCC_FAN_U2_1				= 0x38,
 284	AWCC_FAN_U2_2				= 0x39,
 285	AWCC_FAN_FRONT_1			= 0x3A,
 286	AWCC_FAN_CPU_2				= 0x3B,
 287	AWCC_FAN_GPU_2				= 0x3C,
 288	AWCC_FAN_TOP_2				= 0x3D,
 289	AWCC_FAN_TOP_3				= 0x3E,
 290	AWCC_FAN_FRONT_2			= 0x3F,
 291	AWCC_FAN_BOTTOM_1			= 0x40,
 292	AWCC_FAN_BOTTOM_2			= 0x41,
 293};
 294
 295enum awcc_thermal_profile {
 296	AWCC_PROFILE_SPECIAL_CUSTOM			= 0x00,
 297	AWCC_PROFILE_LEGACY_QUIET			= 0x96,
 298	AWCC_PROFILE_LEGACY_BALANCED			= 0x97,
 299	AWCC_PROFILE_LEGACY_BALANCED_PERFORMANCE	= 0x98,
 300	AWCC_PROFILE_LEGACY_PERFORMANCE			= 0x99,
 301	AWCC_PROFILE_USTT_BALANCED			= 0xA0,
 302	AWCC_PROFILE_USTT_BALANCED_PERFORMANCE		= 0xA1,
 303	AWCC_PROFILE_USTT_COOL				= 0xA2,
 304	AWCC_PROFILE_USTT_QUIET				= 0xA3,
 305	AWCC_PROFILE_USTT_PERFORMANCE			= 0xA4,
 306	AWCC_PROFILE_USTT_LOW_POWER			= 0xA5,
 307	AWCC_PROFILE_SPECIAL_GMODE			= 0xAB,
 308};
 309
 310struct wmax_led_args {
 311	u32 led_mask;
 312	struct color_platform colors;
 313	u8 state;
 314} __packed;
 315
 316struct wmax_brightness_args {
 317	u32 led_mask;
 318	u32 percentage;
 319};
 320
 321struct wmax_basic_args {
 322	u8 arg;
 323};
 324
 325struct wmax_u32_args {
 326	u8 operation;
 327	u8 arg1;
 328	u8 arg2;
 329	u8 arg3;
 330};
 331
 332struct awcc_fan_data {
 333	unsigned long auto_channels_temp;
 334	u32 min_rpm;
 335	u32 max_rpm;
 336	u8 suspend_cache;
 337	u8 id;
 338};
 339
 340struct awcc_priv {
 341	struct wmi_device *wdev;
 342	union {
 343		u32 system_description;
 344		struct {
 345			u8 fan_count;
 346			u8 temp_count;
 347			u8 unknown_count;
 348			u8 profile_count;
 349		};
 350		u8 res_count[4];
 351	};
 352
 353	struct device *ppdev;
 354	u8 supported_profiles[PLATFORM_PROFILE_LAST];
 355
 356	struct device *hwdev;
 357	struct awcc_fan_data **fan_data;
 358	unsigned long temp_sensors[AWCC_ID_BITMAP_LONGS];
 359
 360	u32 gpio_count;
 361};
 362
 363static struct awcc_quirks *awcc;
 364
 365/*
 366 *	The HDMI mux sysfs node indicates the status of the HDMI input mux.
 367 *	It can toggle between standard system GPU output and HDMI input.
 368 */
 369static ssize_t cable_show(struct device *dev, struct device_attribute *attr,
 370			  char *buf)
 371{
 372	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 373	struct wmax_basic_args in_args = {
 374		.arg = 0,
 375	};
 376	u32 out_data;
 377	int ret;
 378
 379	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_HDMI_CABLE,
 380				    &in_args, sizeof(in_args), &out_data);
 381	if (!ret) {
 382		if (out_data == 0)
 383			return sysfs_emit(buf, "[unconnected] connected unknown\n");
 384		else if (out_data == 1)
 385			return sysfs_emit(buf, "unconnected [connected] unknown\n");
 386	}
 387
 388	pr_err("alienware-wmi: unknown HDMI cable status: %d\n", ret);
 389	return sysfs_emit(buf, "unconnected connected [unknown]\n");
 390}
 391
 392static ssize_t source_show(struct device *dev, struct device_attribute *attr,
 393			   char *buf)
 394{
 395	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 396	struct wmax_basic_args in_args = {
 397		.arg = 0,
 398	};
 399	u32 out_data;
 400	int ret;
 401
 402	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_HDMI_STATUS,
 403				    &in_args, sizeof(in_args), &out_data);
 404	if (!ret) {
 405		if (out_data == 1)
 406			return sysfs_emit(buf, "[input] gpu unknown\n");
 407		else if (out_data == 2)
 408			return sysfs_emit(buf, "input [gpu] unknown\n");
 409	}
 410
 411	pr_err("alienware-wmi: unknown HDMI source status: %u\n", ret);
 412	return sysfs_emit(buf, "input gpu [unknown]\n");
 413}
 414
 415static ssize_t source_store(struct device *dev, struct device_attribute *attr,
 416			    const char *buf, size_t count)
 417{
 418	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 419	struct wmax_basic_args args;
 420	int ret;
 421
 422	if (strcmp(buf, "gpu\n") == 0)
 423		args.arg = 1;
 424	else if (strcmp(buf, "input\n") == 0)
 425		args.arg = 2;
 426	else
 427		args.arg = 3;
 428	pr_debug("alienware-wmi: setting hdmi to %d : %s", args.arg, buf);
 429
 430	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_HDMI_SOURCE, &args,
 431				    sizeof(args), NULL);
 432	if (ret < 0)
 433		pr_err("alienware-wmi: HDMI toggle failed: results: %u\n", ret);
 434
 435	return count;
 436}
 437
 438static DEVICE_ATTR_RO(cable);
 439static DEVICE_ATTR_RW(source);
 440
 441static bool hdmi_group_visible(struct kobject *kobj)
 442{
 443	return alienware_interface == WMAX && alienfx->hdmi_mux;
 444}
 445DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(hdmi);
 446
 447static struct attribute *hdmi_attrs[] = {
 448	&dev_attr_cable.attr,
 449	&dev_attr_source.attr,
 450	NULL,
 451};
 452
 453const struct attribute_group wmax_hdmi_attribute_group = {
 454	.name = "hdmi",
 455	.is_visible = SYSFS_GROUP_VISIBLE(hdmi),
 456	.attrs = hdmi_attrs,
 457};
 458
 459/*
 460 * Alienware GFX amplifier support
 461 * - Currently supports reading cable status
 462 * - Leaving expansion room to possibly support dock/undock events later
 463 */
 464static ssize_t status_show(struct device *dev, struct device_attribute *attr,
 465			   char *buf)
 466{
 467	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 468	struct wmax_basic_args in_args = {
 469		.arg = 0,
 470	};
 471	u32 out_data;
 472	int ret;
 473
 474	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_AMPLIFIER_CABLE,
 475				    &in_args, sizeof(in_args), &out_data);
 476	if (!ret) {
 477		if (out_data == 0)
 478			return sysfs_emit(buf, "[unconnected] connected unknown\n");
 479		else if (out_data == 1)
 480			return sysfs_emit(buf, "unconnected [connected] unknown\n");
 481	}
 482
 483	pr_err("alienware-wmi: unknown amplifier cable status: %d\n", ret);
 484	return sysfs_emit(buf, "unconnected connected [unknown]\n");
 485}
 486
 487static DEVICE_ATTR_RO(status);
 488
 489static bool amplifier_group_visible(struct kobject *kobj)
 490{
 491	return alienware_interface == WMAX && alienfx->amplifier;
 492}
 493DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(amplifier);
 494
 495static struct attribute *amplifier_attrs[] = {
 496	&dev_attr_status.attr,
 497	NULL,
 498};
 499
 500const struct attribute_group wmax_amplifier_attribute_group = {
 501	.name = "amplifier",
 502	.is_visible = SYSFS_GROUP_VISIBLE(amplifier),
 503	.attrs = amplifier_attrs,
 504};
 505
 506/*
 507 * Deep Sleep Control support
 508 * - Modifies BIOS setting for deep sleep control allowing extra wakeup events
 509 */
 510static ssize_t deepsleep_show(struct device *dev, struct device_attribute *attr,
 511			      char *buf)
 512{
 513	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 514	struct wmax_basic_args in_args = {
 515		.arg = 0,
 516	};
 517	u32 out_data;
 518	int ret;
 519
 520	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_DEEP_SLEEP_STATUS,
 521				    &in_args, sizeof(in_args), &out_data);
 522	if (!ret) {
 523		if (out_data == 0)
 524			return sysfs_emit(buf, "[disabled] s5 s5_s4\n");
 525		else if (out_data == 1)
 526			return sysfs_emit(buf, "disabled [s5] s5_s4\n");
 527		else if (out_data == 2)
 528			return sysfs_emit(buf, "disabled s5 [s5_s4]\n");
 529	}
 530
 531	pr_err("alienware-wmi: unknown deep sleep status: %d\n", ret);
 532	return sysfs_emit(buf, "disabled s5 s5_s4 [unknown]\n");
 533}
 534
 535static ssize_t deepsleep_store(struct device *dev, struct device_attribute *attr,
 536			       const char *buf, size_t count)
 537{
 538	struct alienfx_platdata *pdata = dev_get_platdata(dev);
 539	struct wmax_basic_args args;
 540	int ret;
 541
 542	if (strcmp(buf, "disabled\n") == 0)
 543		args.arg = 0;
 544	else if (strcmp(buf, "s5\n") == 0)
 545		args.arg = 1;
 546	else
 547		args.arg = 2;
 548	pr_debug("alienware-wmi: setting deep sleep to %d : %s", args.arg, buf);
 549
 550	ret = alienware_wmi_command(pdata->wdev, WMAX_METHOD_DEEP_SLEEP_CONTROL,
 551				    &args, sizeof(args), NULL);
 552	if (!ret)
 553		pr_err("alienware-wmi: deep sleep control failed: results: %u\n", ret);
 554
 555	return count;
 556}
 557
 558static DEVICE_ATTR_RW(deepsleep);
 559
 560static bool deepsleep_group_visible(struct kobject *kobj)
 561{
 562	return alienware_interface == WMAX && alienfx->deepslp;
 563}
 564DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(deepsleep);
 565
 566static struct attribute *deepsleep_attrs[] = {
 567	&dev_attr_deepsleep.attr,
 568	NULL,
 569};
 570
 571const struct attribute_group wmax_deepsleep_attribute_group = {
 572	.name = "deepsleep",
 573	.is_visible = SYSFS_GROUP_VISIBLE(deepsleep),
 574	.attrs = deepsleep_attrs,
 575};
 576
 577/*
 578 * AWCC Helpers
 579 */
 580static int awcc_profile_to_pprof(enum awcc_thermal_profile profile,
 581				 enum platform_profile_option *pprof)
 582{
 583	switch (profile) {
 584	case AWCC_PROFILE_SPECIAL_CUSTOM:
 585		*pprof = PLATFORM_PROFILE_CUSTOM;
 586		break;
 587	case AWCC_PROFILE_LEGACY_QUIET:
 588	case AWCC_PROFILE_USTT_QUIET:
 589		*pprof = PLATFORM_PROFILE_QUIET;
 590		break;
 591	case AWCC_PROFILE_LEGACY_BALANCED:
 592	case AWCC_PROFILE_USTT_BALANCED:
 593		*pprof = PLATFORM_PROFILE_BALANCED;
 594		break;
 595	case AWCC_PROFILE_LEGACY_BALANCED_PERFORMANCE:
 596	case AWCC_PROFILE_USTT_BALANCED_PERFORMANCE:
 597		*pprof = PLATFORM_PROFILE_BALANCED_PERFORMANCE;
 598		break;
 599	case AWCC_PROFILE_LEGACY_PERFORMANCE:
 600	case AWCC_PROFILE_USTT_PERFORMANCE:
 601	case AWCC_PROFILE_SPECIAL_GMODE:
 602		*pprof = PLATFORM_PROFILE_PERFORMANCE;
 603		break;
 604	case AWCC_PROFILE_USTT_COOL:
 605		*pprof = PLATFORM_PROFILE_COOL;
 606		break;
 607	case AWCC_PROFILE_USTT_LOW_POWER:
 608		*pprof = PLATFORM_PROFILE_LOW_POWER;
 609		break;
 610	default:
 611		return -EINVAL;
 612	}
 613
 614	return 0;
 615}
 616
 617static int awcc_wmi_command(struct wmi_device *wdev, u32 method_id,
 618			    struct wmax_u32_args *args, u32 *out)
 619{
 620	int ret;
 621
 622	ret = alienware_wmi_command(wdev, method_id, args, sizeof(*args), out);
 623	if (ret)
 624		return ret;
 625
 626	if (*out == AWCC_FAILURE_CODE || *out == AWCC_FAILURE_CODE_2)
 627		return -EBADRQC;
 628
 629	return 0;
 630}
 631
 632static int awcc_get_fan_sensors(struct wmi_device *wdev, u8 operation,
 633				u8 fan_id, u8 index, u32 *out)
 634{
 635	struct wmax_u32_args args = {
 636		.operation = operation,
 637		.arg1 = fan_id,
 638		.arg2 = index,
 639		.arg3 = 0,
 640	};
 641
 642	return awcc_wmi_command(wdev, AWCC_METHOD_GET_FAN_SENSORS, &args, out);
 643}
 644
 645static int awcc_thermal_information(struct wmi_device *wdev, u8 operation, u8 arg,
 646				    u32 *out)
 647{
 648	struct wmax_u32_args args = {
 649		.operation = operation,
 650		.arg1 = arg,
 651		.arg2 = 0,
 652		.arg3 = 0,
 653	};
 654
 655	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);
 656}
 657
 658static int awcc_fwup_gpio_control(struct wmi_device *wdev, u8 pin, u8 status)
 659{
 660	struct wmax_u32_args args = {
 661		.operation = pin,
 662		.arg1 = status,
 663		.arg2 = 0,
 664		.arg3 = 0,
 665	};
 666	u32 out;
 667
 668	return awcc_wmi_command(wdev, AWCC_METHOD_FWUP_GPIO_CONTROL, &args, &out);
 669}
 670
 671static int awcc_read_total_gpios(struct wmi_device *wdev, u32 *count)
 672{
 673	struct wmax_u32_args args = {};
 674
 675	return awcc_wmi_command(wdev, AWCC_METHOD_READ_TOTAL_GPIOS, &args, count);
 676}
 677
 678static int awcc_read_gpio_status(struct wmi_device *wdev, u8 pin, u32 *status)
 679{
 680	struct wmax_u32_args args = {
 681		.operation = pin,
 682		.arg1 = 0,
 683		.arg2 = 0,
 684		.arg3 = 0,
 685	};
 686
 687	return awcc_wmi_command(wdev, AWCC_METHOD_READ_GPIO_STATUS, &args, status);
 688}
 689
 690static int awcc_game_shift_status(struct wmi_device *wdev, u8 operation,
 691				  u32 *out)
 692{
 693	struct wmax_u32_args args = {
 694		.operation = operation,
 695		.arg1 = 0,
 696		.arg2 = 0,
 697		.arg3 = 0,
 698	};
 699
 700	return awcc_wmi_command(wdev, AWCC_METHOD_GAME_SHIFT_STATUS, &args, out);
 701}
 702
 703/**
 704 * awcc_op_get_resource_id - Get the resource ID at a given index
 705 * @wdev: AWCC WMI device
 706 * @index: Index
 707 * @out: Value returned by the WMI call
 708 *
 709 * Get the resource ID at a given @index. Resource IDs are listed in the
 710 * following order:
 711 *
 712 *	- Fan IDs
 713 *	- Sensor IDs
 714 *	- Unknown IDs
 715 *	- Thermal Profile IDs
 716 *
 717 * The total number of IDs of a given type can be obtained with
 718 * AWCC_OP_GET_SYSTEM_DESCRIPTION.
 719 *
 720 * Return: 0 on success, -errno on failure
 721 */
 722static int awcc_op_get_resource_id(struct wmi_device *wdev, u8 index, u8 *out)
 723{
 724	struct wmax_u32_args args = {
 725		.operation = AWCC_OP_GET_RESOURCE_ID,
 726		.arg1 = index,
 727		.arg2 = 0,
 728		.arg3 = 0,
 729	};
 730	u32 out_data;
 731	int ret;
 732
 733	ret = awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, &out_data);
 734	if (ret)
 735		return ret;
 736
 737	*out = FIELD_GET(AWCC_RESOURCE_ID_MASK, out_data);
 738
 739	return 0;
 740}
 741
 742static int awcc_op_get_fan_rpm(struct wmi_device *wdev, u8 fan_id, u32 *out)
 743{
 744	struct wmax_u32_args args = {
 745		.operation = AWCC_OP_GET_FAN_RPM,
 746		.arg1 = fan_id,
 747		.arg2 = 0,
 748		.arg3 = 0,
 749	};
 750
 751	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);
 752}
 753
 754static int awcc_op_get_temperature(struct wmi_device *wdev, u8 temp_id, u32 *out)
 755{
 756	struct wmax_u32_args args = {
 757		.operation = AWCC_OP_GET_TEMPERATURE,
 758		.arg1 = temp_id,
 759		.arg2 = 0,
 760		.arg3 = 0,
 761	};
 762
 763	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);
 764}
 765
 766static int awcc_op_get_fan_boost(struct wmi_device *wdev, u8 fan_id, u32 *out)
 767{
 768	struct wmax_u32_args args = {
 769		.operation = AWCC_OP_GET_FAN_BOOST,
 770		.arg1 = fan_id,
 771		.arg2 = 0,
 772		.arg3 = 0,
 773	};
 774
 775	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);
 776}
 777
 778static int awcc_op_get_current_profile(struct wmi_device *wdev, u32 *out)
 779{
 780	struct wmax_u32_args args = {
 781		.operation = AWCC_OP_GET_CURRENT_PROFILE,
 782		.arg1 = 0,
 783		.arg2 = 0,
 784		.arg3 = 0,
 785	};
 786
 787	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_INFORMATION, &args, out);
 788}
 789
 790static int awcc_op_activate_profile(struct wmi_device *wdev, u8 profile)
 791{
 792	struct wmax_u32_args args = {
 793		.operation = AWCC_OP_ACTIVATE_PROFILE,
 794		.arg1 = profile,
 795		.arg2 = 0,
 796		.arg3 = 0,
 797	};
 798	u32 out;
 799
 800	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_CONTROL, &args, &out);
 801}
 802
 803static int awcc_op_set_fan_boost(struct wmi_device *wdev, u8 fan_id, u8 boost)
 804{
 805	struct wmax_u32_args args = {
 806		.operation = AWCC_OP_SET_FAN_BOOST,
 807		.arg1 = fan_id,
 808		.arg2 = boost,
 809		.arg3 = 0,
 810	};
 811	u32 out;
 812
 813	return awcc_wmi_command(wdev, AWCC_METHOD_THERMAL_CONTROL, &args, &out);
 814}
 815
 816/*
 817 * HWMON
 818 *  - Provides temperature and fan speed monitoring as well as manual fan
 819 *    control
 820 */
 821static umode_t awcc_hwmon_is_visible(const void *drvdata, enum hwmon_sensor_types type,
 822				     u32 attr, int channel)
 823{
 824	const struct awcc_priv *priv = drvdata;
 825	unsigned int temp_count;
 826
 827	switch (type) {
 828	case hwmon_temp:
 829		temp_count = bitmap_weight(priv->temp_sensors, AWCC_ID_BITMAP_SIZE);
 830
 831		return channel < temp_count ? 0444 : 0;
 832	case hwmon_fan:
 833		return channel < priv->fan_count ? 0444 : 0;
 834	case hwmon_pwm:
 835		return channel < priv->fan_count ? 0444 : 0;
 836	default:
 837		return 0;
 838	}
 839}
 840
 841static int awcc_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
 842			   u32 attr, int channel, long *val)
 843{
 844	struct awcc_priv *priv = dev_get_drvdata(dev);
 845	const struct awcc_fan_data *fan;
 846	u32 state;
 847	int ret;
 848	u8 temp;
 849
 850	switch (type) {
 851	case hwmon_temp:
 852		temp = find_nth_bit(priv->temp_sensors, AWCC_ID_BITMAP_SIZE, channel);
 853
 854		switch (attr) {
 855		case hwmon_temp_input:
 856			ret = awcc_op_get_temperature(priv->wdev, temp, &state);
 857			if (ret)
 858				return ret;
 859
 860			*val = state * MILLIDEGREE_PER_DEGREE;
 861			break;
 862		default:
 863			return -EOPNOTSUPP;
 864		}
 865
 866		break;
 867	case hwmon_fan:
 868		fan = priv->fan_data[channel];
 869
 870		switch (attr) {
 871		case hwmon_fan_input:
 872			ret = awcc_op_get_fan_rpm(priv->wdev, fan->id, &state);
 873			if (ret)
 874				return ret;
 875
 876			*val = state;
 877			break;
 878		case hwmon_fan_min:
 879			*val = fan->min_rpm;
 880			break;
 881		case hwmon_fan_max:
 882			*val = fan->max_rpm;
 883			break;
 884		default:
 885			return -EOPNOTSUPP;
 886		}
 887
 888		break;
 889	case hwmon_pwm:
 890		fan = priv->fan_data[channel];
 891
 892		switch (attr) {
 893		case hwmon_pwm_auto_channels_temp:
 894			*val = fan->auto_channels_temp;
 895			break;
 896		default:
 897			return -EOPNOTSUPP;
 898		}
 899
 900		break;
 901	default:
 902		return -EOPNOTSUPP;
 903	}
 904
 905	return 0;
 906}
 907
 908static int awcc_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type,
 909				  u32 attr, int channel, const char **str)
 910{
 911	struct awcc_priv *priv = dev_get_drvdata(dev);
 912	u8 temp;
 913
 914	switch (type) {
 915	case hwmon_temp:
 916		temp = find_nth_bit(priv->temp_sensors, AWCC_ID_BITMAP_SIZE, channel);
 917
 918		switch (temp) {
 919		case AWCC_TEMP_SENSOR_CPU:
 920			*str = "CPU";
 921			break;
 922		case AWCC_TEMP_SENSOR_FRONT:
 923			*str = "Front";
 924			break;
 925		case AWCC_TEMP_SENSOR_GPU:
 926			*str = "GPU";
 927			break;
 928		default:
 929			*str = "Unknown";
 930			break;
 931		}
 932
 933		break;
 934	case hwmon_fan:
 935		switch (priv->fan_data[channel]->id) {
 936		case AWCC_FAN_CPU_1:
 937		case AWCC_FAN_CPU_2:
 938			*str = "CPU Fan";
 939			break;
 940		case AWCC_FAN_GPU_1:
 941		case AWCC_FAN_GPU_2:
 942			*str = "GPU Fan";
 943			break;
 944		case AWCC_FAN_PCI:
 945			*str = "PCI Fan";
 946			break;
 947		case AWCC_FAN_MID:
 948			*str = "Mid Fan";
 949			break;
 950		case AWCC_FAN_TOP_1:
 951		case AWCC_FAN_TOP_2:
 952		case AWCC_FAN_TOP_3:
 953			*str = "Top Fan";
 954			break;
 955		case AWCC_FAN_SIDE:
 956			*str = "Side Fan";
 957			break;
 958		case AWCC_FAN_U2_1:
 959		case AWCC_FAN_U2_2:
 960			*str = "U.2 Fan";
 961			break;
 962		case AWCC_FAN_FRONT_1:
 963		case AWCC_FAN_FRONT_2:
 964			*str = "Front Fan";
 965			break;
 966		case AWCC_FAN_BOTTOM_1:
 967		case AWCC_FAN_BOTTOM_2:
 968			*str = "Bottom Fan";
 969			break;
 970		default:
 971			*str = "Unknown Fan";
 972			break;
 973		}
 974
 975		break;
 976	default:
 977		return -EOPNOTSUPP;
 978	}
 979
 980	return 0;
 981}
 982
 983static const struct hwmon_ops awcc_hwmon_ops = {
 984	.is_visible = awcc_hwmon_is_visible,
 985	.read = awcc_hwmon_read,
 986	.read_string = awcc_hwmon_read_string,
 987};
 988
 989static const struct hwmon_channel_info * const awcc_hwmon_info[] = {
 990	HWMON_CHANNEL_INFO(temp,
 991			   HWMON_T_LABEL | HWMON_T_INPUT,
 992			   HWMON_T_LABEL | HWMON_T_INPUT,
 993			   HWMON_T_LABEL | HWMON_T_INPUT,
 994			   HWMON_T_LABEL | HWMON_T_INPUT,
 995			   HWMON_T_LABEL | HWMON_T_INPUT,
 996			   HWMON_T_LABEL | HWMON_T_INPUT
 997			   ),
 998	HWMON_CHANNEL_INFO(fan,
 999			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,
1000			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,
1001			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,
1002			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,
1003			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX,
1004			   HWMON_F_LABEL | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX
1005			   ),
1006	HWMON_CHANNEL_INFO(pwm,
1007			   HWMON_PWM_AUTO_CHANNELS_TEMP,
1008			   HWMON_PWM_AUTO_CHANNELS_TEMP,
1009			   HWMON_PWM_AUTO_CHANNELS_TEMP,
1010			   HWMON_PWM_AUTO_CHANNELS_TEMP,
1011			   HWMON_PWM_AUTO_CHANNELS_TEMP,
1012			   HWMON_PWM_AUTO_CHANNELS_TEMP
1013			   ),
1014	NULL
1015};
1016
1017static const struct hwmon_chip_info awcc_hwmon_chip_info = {
1018	.ops = &awcc_hwmon_ops,
1019	.info = awcc_hwmon_info,
1020};
1021
1022static ssize_t fan_boost_show(struct device *dev, struct device_attribute *attr,
1023			      char *buf)
1024{
1025	struct awcc_priv *priv = dev_get_drvdata(dev);
1026	int index = to_sensor_dev_attr(attr)->index;
1027	struct awcc_fan_data *fan = priv->fan_data[index];
1028	u32 boost;
1029	int ret;
1030
1031	ret = awcc_op_get_fan_boost(priv->wdev, fan->id, &boost);
1032	if (ret)
1033		return ret;
1034
1035	return sysfs_emit(buf, "%u\n", boost);
1036}
1037
1038static ssize_t fan_boost_store(struct device *dev, struct device_attribute *attr,
1039			       const char *buf, size_t count)
1040{
1041	struct awcc_priv *priv = dev_get_drvdata(dev);
1042	int index = to_sensor_dev_attr(attr)->index;
1043	struct awcc_fan_data *fan = priv->fan_data[index];
1044	unsigned long val;
1045	int ret;
1046
1047	ret = kstrtoul(buf, 0, &val);
1048	if (ret)
1049		return ret;
1050
1051	ret = awcc_op_set_fan_boost(priv->wdev, fan->id, clamp_val(val, 0, 255));
1052
1053	return ret ? ret : count;
1054}
1055
1056static SENSOR_DEVICE_ATTR_RW(fan1_boost, fan_boost, 0);
1057static SENSOR_DEVICE_ATTR_RW(fan2_boost, fan_boost, 1);
1058static SENSOR_DEVICE_ATTR_RW(fan3_boost, fan_boost, 2);
1059static SENSOR_DEVICE_ATTR_RW(fan4_boost, fan_boost, 3);
1060static SENSOR_DEVICE_ATTR_RW(fan5_boost, fan_boost, 4);
1061static SENSOR_DEVICE_ATTR_RW(fan6_boost, fan_boost, 5);
1062
1063static umode_t fan_boost_attr_visible(struct kobject *kobj, struct attribute *attr, int n)
1064{
1065	struct awcc_priv *priv = dev_get_drvdata(kobj_to_dev(kobj));
1066
1067	return n < priv->fan_count ? attr->mode : 0;
1068}
1069
1070static bool fan_boost_group_visible(struct kobject *kobj)
1071{
1072	return true;
1073}
1074
1075DEFINE_SYSFS_GROUP_VISIBLE(fan_boost);
1076
1077static struct attribute *fan_boost_attrs[] = {
1078	&sensor_dev_attr_fan1_boost.dev_attr.attr,
1079	&sensor_dev_attr_fan2_boost.dev_attr.attr,
1080	&sensor_dev_attr_fan3_boost.dev_attr.attr,
1081	&sensor_dev_attr_fan4_boost.dev_attr.attr,
1082	&sensor_dev_attr_fan5_boost.dev_attr.attr,
1083	&sensor_dev_attr_fan6_boost.dev_attr.attr,
1084	NULL
1085};
1086
1087static const struct attribute_group fan_boost_group = {
1088	.attrs = fan_boost_attrs,
1089	.is_visible = SYSFS_GROUP_VISIBLE(fan_boost),
1090};
1091
1092static const struct attribute_group *awcc_hwmon_groups[] = {
1093	&fan_boost_group,
1094	NULL
1095};
1096
1097static int awcc_hwmon_temps_init(struct wmi_device *wdev)
1098{
1099	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);
1100	unsigned int i;
1101	int ret;
1102	u8 id;
1103
1104	for (i = 0; i < priv->temp_count; i++) {
1105		/*
1106		 * Temperature sensors IDs are listed after the fan IDs at
1107		 * offset `fan_count`
1108		 */
1109		ret = awcc_op_get_resource_id(wdev, i + priv->fan_count, &id);
1110		if (ret)
1111			return ret;
1112
1113		__set_bit(id, priv->temp_sensors);
1114	}
1115
1116	return 0;
1117}
1118
1119static int awcc_hwmon_fans_init(struct wmi_device *wdev)
1120{
1121	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);
1122	unsigned long fan_temps[AWCC_ID_BITMAP_LONGS];
1123	unsigned long gather[AWCC_ID_BITMAP_LONGS];
1124	u32 min_rpm, max_rpm, temp_count, temp_id;
1125	struct awcc_fan_data *fan_data;
1126	unsigned int i, j;
1127	int ret;
1128	u8 id;
1129
1130	for (i = 0; i < priv->fan_count; i++) {
1131		fan_data = devm_kzalloc(&wdev->dev, sizeof(*fan_data), GFP_KERNEL);
1132		if (!fan_data)
1133			return -ENOMEM;
1134
1135		/*
1136		 * Fan IDs are listed first at offset 0
1137		 */
1138		ret = awcc_op_get_resource_id(wdev, i, &id);
1139		if (ret)
1140			return ret;
1141
1142		ret = awcc_thermal_information(wdev, AWCC_OP_GET_FAN_MIN_RPM, id,
1143					       &min_rpm);
1144		if (ret)
1145			return ret;
1146
1147		ret = awcc_thermal_information(wdev, AWCC_OP_GET_FAN_MAX_RPM, id,
1148					       &max_rpm);
1149		if (ret)
1150			return ret;
1151
1152		ret = awcc_get_fan_sensors(wdev, AWCC_OP_GET_TOTAL_FAN_TEMPS, id,
1153					   0, &temp_count);
1154		if (ret)
1155			return ret;
1156
1157		bitmap_zero(fan_temps, AWCC_ID_BITMAP_SIZE);
1158
1159		for (j = 0; j < temp_count; j++) {
1160			ret = awcc_get_fan_sensors(wdev, AWCC_OP_GET_FAN_TEMP_ID,
1161						   id, j, &temp_id);
1162			if (ret)
1163				break;
1164
1165			temp_id = FIELD_GET(AWCC_RESOURCE_ID_MASK, temp_id);
1166			__set_bit(temp_id, fan_temps);
1167		}
1168
1169		fan_data->id = id;
1170		fan_data->min_rpm = min_rpm;
1171		fan_data->max_rpm = max_rpm;
1172		bitmap_gather(gather, fan_temps, priv->temp_sensors, AWCC_ID_BITMAP_SIZE);
1173		bitmap_copy(&fan_data->auto_channels_temp, gather, BITS_PER_LONG);
1174		priv->fan_data[i] = fan_data;
1175	}
1176
1177	return 0;
1178}
1179
1180static int awcc_hwmon_init(struct wmi_device *wdev)
1181{
1182	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);
1183	int ret;
1184
1185	priv->fan_data = devm_kcalloc(&wdev->dev, priv->fan_count,
1186				      sizeof(*priv->fan_data), GFP_KERNEL);
1187	if (!priv->fan_data)
1188		return -ENOMEM;
1189
1190	ret = awcc_hwmon_temps_init(wdev);
1191	if (ret)
1192		return ret;
1193
1194	ret = awcc_hwmon_fans_init(wdev);
1195	if (ret)
1196		return ret;
1197
1198	priv->hwdev = devm_hwmon_device_register_with_info(&wdev->dev, "alienware_wmi",
1199							   priv, &awcc_hwmon_chip_info,
1200							   awcc_hwmon_groups);
1201
1202	return PTR_ERR_OR_ZERO(priv->hwdev);
1203}
1204
1205static void awcc_hwmon_suspend(struct device *dev)
1206{
1207	struct awcc_priv *priv = dev_get_drvdata(dev);
1208	struct awcc_fan_data *fan;
1209	unsigned int i;
1210	u32 boost;
1211	int ret;
1212
1213	for (i = 0; i < priv->fan_count; i++) {
1214		fan = priv->fan_data[i];
1215
1216		ret = awcc_thermal_information(priv->wdev, AWCC_OP_GET_FAN_BOOST,
1217					       fan->id, &boost);
1218		if (ret)
1219			dev_err(dev, "Failed to store Fan %u boost while suspending\n", i);
1220
1221		fan->suspend_cache = ret ? 0 : clamp_val(boost, 0, 255);
1222
1223		awcc_op_set_fan_boost(priv->wdev, fan->id, 0);
1224		if (ret)
1225			dev_err(dev, "Failed to set Fan %u boost to 0 while suspending\n", i);
1226	}
1227}
1228
1229static void awcc_hwmon_resume(struct device *dev)
1230{
1231	struct awcc_priv *priv = dev_get_drvdata(dev);
1232	struct awcc_fan_data *fan;
1233	unsigned int i;
1234	int ret;
1235
1236	for (i = 0; i < priv->fan_count; i++) {
1237		fan = priv->fan_data[i];
1238
1239		if (!fan->suspend_cache)
1240			continue;
1241
1242		ret = awcc_op_set_fan_boost(priv->wdev, fan->id, fan->suspend_cache);
1243		if (ret)
1244			dev_err(dev, "Failed to restore Fan %u boost while resuming\n", i);
1245	}
1246}
1247
1248/*
1249 * Thermal Profile control
1250 *  - Provides thermal profile control through the Platform Profile API
1251 */
1252static int awcc_platform_profile_get(struct device *dev,
1253				     enum platform_profile_option *profile)
1254{
1255	struct awcc_priv *priv = dev_get_drvdata(dev);
1256	u32 out_data;
1257	int ret;
1258
1259	ret = awcc_op_get_current_profile(priv->wdev, &out_data);
1260	if (ret)
1261		return ret;
1262
1263	return awcc_profile_to_pprof(out_data, profile);
1264}
1265
1266static int awcc_platform_profile_set(struct device *dev,
1267				     enum platform_profile_option profile)
1268{
1269	struct awcc_priv *priv = dev_get_drvdata(dev);
1270
1271	if (awcc->gmode) {
1272		u32 gmode_status;
1273		int ret;
1274
1275		ret = awcc_game_shift_status(priv->wdev,
1276					     AWCC_OP_GET_GAME_SHIFT_STATUS,
1277					     &gmode_status);
1278
1279		if (ret < 0)
1280			return ret;
1281
1282		if ((profile == PLATFORM_PROFILE_PERFORMANCE && !gmode_status) ||
1283		    (profile != PLATFORM_PROFILE_PERFORMANCE && gmode_status)) {
1284			ret = awcc_game_shift_status(priv->wdev,
1285						     AWCC_OP_TOGGLE_GAME_SHIFT,
1286						     &gmode_status);
1287
1288			if (ret < 0)
1289				return ret;
1290		}
1291	}
1292
1293	return awcc_op_activate_profile(priv->wdev, priv->supported_profiles[profile]);
1294}
1295
1296static int awcc_platform_profile_probe(void *drvdata, unsigned long *choices)
1297{
1298	enum platform_profile_option profile;
1299	struct awcc_priv *priv = drvdata;
1300	u8 id, offset = 0;
1301	int ret;
1302
1303	/*
1304	 * Thermal profile IDs are listed last at offset
1305	 *	fan_count + temp_count + unknown_count
1306	 */
1307	for (unsigned int i = 0; i < ARRAY_SIZE(priv->res_count) - 1; i++)
1308		offset += priv->res_count[i];
1309
1310	for (unsigned int i = 0; i < priv->profile_count; i++) {
1311		ret = awcc_op_get_resource_id(priv->wdev, i + offset, &id);
1312		/*
1313		 * Some devices report an incorrect number of thermal profiles
1314		 * so the resource ID list may end prematurely
1315		 */
1316		if (ret == -EBADRQC)
1317			break;
1318		if (ret)
1319			return ret;
1320
1321		/*
1322		 * G-Mode profile ID is not listed consistently across modeles
1323		 * that support it, therefore we handle it through quirks.
1324		 */
1325		if (id == AWCC_PROFILE_SPECIAL_GMODE)
1326			continue;
1327
1328		ret = awcc_profile_to_pprof(id, &profile);
1329		if (ret) {
1330			dev_dbg(&priv->wdev->dev, "Unmapped thermal profile ID 0x%02x\n", id);
1331			continue;
1332		}
1333
1334		priv->supported_profiles[profile] = id;
1335		__set_bit(profile, choices);
1336	}
1337
1338	if (bitmap_empty(choices, PLATFORM_PROFILE_LAST))
1339		return -ENODEV;
1340
1341	if (awcc->gmode) {
1342		priv->supported_profiles[PLATFORM_PROFILE_PERFORMANCE] =
1343			AWCC_PROFILE_SPECIAL_GMODE;
1344
1345		__set_bit(PLATFORM_PROFILE_PERFORMANCE, choices);
1346	}
1347
1348	/* Every model supports the "custom" profile */
1349	priv->supported_profiles[PLATFORM_PROFILE_CUSTOM] =
1350		AWCC_PROFILE_SPECIAL_CUSTOM;
1351
1352	__set_bit(PLATFORM_PROFILE_CUSTOM, choices);
1353
1354	return 0;
1355}
1356
1357static const struct platform_profile_ops awcc_platform_profile_ops = {
1358	.probe = awcc_platform_profile_probe,
1359	.profile_get = awcc_platform_profile_get,
1360	.profile_set = awcc_platform_profile_set,
1361};
1362
1363static int awcc_platform_profile_init(struct wmi_device *wdev)
1364{
1365	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);
1366
1367	priv->ppdev = devm_platform_profile_register(&wdev->dev, "alienware-wmi",
1368						     priv, &awcc_platform_profile_ops);
1369
1370	return PTR_ERR_OR_ZERO(priv->ppdev);
1371}
1372
1373/*
1374 * DebugFS
1375 */
1376static int awcc_debugfs_system_description_read(struct seq_file *seq, void *data)
1377{
1378	struct device *dev = seq->private;
1379	struct awcc_priv *priv = dev_get_drvdata(dev);
1380
1381	seq_printf(seq, "0x%08x\n", priv->system_description);
1382
1383	return 0;
1384}
1385
1386static int awcc_debugfs_hwmon_data_read(struct seq_file *seq, void *data)
1387{
1388	struct device *dev = seq->private;
1389	struct awcc_priv *priv = dev_get_drvdata(dev);
1390	const struct awcc_fan_data *fan;
1391	unsigned int bit;
1392
1393	seq_printf(seq, "Number of fans: %u\n", priv->fan_count);
1394	seq_printf(seq, "Number of temperature sensors: %u\n\n", priv->temp_count);
1395
1396	for (u32 i = 0; i < priv->fan_count; i++) {
1397		fan = priv->fan_data[i];
1398
1399		seq_printf(seq, "Fan %u:\n", i);
1400		seq_printf(seq, "  ID: 0x%02x\n", fan->id);
1401		seq_printf(seq, "  Related temperature sensors bitmap: %lu\n",
1402			   fan->auto_channels_temp);
1403	}
1404
1405	seq_puts(seq, "\nTemperature sensor IDs:\n");
1406	for_each_set_bit(bit, priv->temp_sensors, AWCC_ID_BITMAP_SIZE)
1407		seq_printf(seq, "  0x%02x\n", bit);
1408
1409	return 0;
1410}
1411
1412static int awcc_debugfs_pprof_data_read(struct seq_file *seq, void *data)
1413{
1414	struct device *dev = seq->private;
1415	struct awcc_priv *priv = dev_get_drvdata(dev);
1416
1417	seq_printf(seq, "Number of thermal profiles: %u\n\n", priv->profile_count);
1418
1419	for (u32 i = 0; i < PLATFORM_PROFILE_LAST; i++) {
1420		if (!priv->supported_profiles[i])
1421			continue;
1422
1423		seq_printf(seq, "Platform profile %u:\n", i);
1424		seq_printf(seq, "  ID: 0x%02x\n", priv->supported_profiles[i]);
1425	}
1426
1427	return 0;
1428}
1429
1430static int awcc_gpio_pin_show(struct seq_file *seq, void *data)
1431{
1432	unsigned long pin = debugfs_get_aux_num(seq->file);
1433	struct wmi_device *wdev = seq->private;
1434	u32 status;
1435	int ret;
1436
1437	ret = awcc_read_gpio_status(wdev, pin, &status);
1438	if (ret)
1439		return ret;
1440
1441	seq_printf(seq, "%u\n", status);
1442
1443	return 0;
1444}
1445
1446static ssize_t awcc_gpio_pin_write(struct file *file, const char __user *buf,
1447				   size_t count, loff_t *ppos)
1448{
1449	unsigned long pin = debugfs_get_aux_num(file);
1450	struct seq_file *seq = file->private_data;
1451	struct wmi_device *wdev = seq->private;
1452	bool status;
1453	int ret;
1454
1455	if (!ppos || *ppos)
1456		return -EINVAL;
1457
1458	ret = kstrtobool_from_user(buf, count, &status);
1459	if (ret)
1460		return ret;
1461
1462	ret = awcc_fwup_gpio_control(wdev, pin, status);
1463	if (ret)
1464		return ret;
1465
1466	return count;
1467}
1468
1469DEFINE_SHOW_STORE_ATTRIBUTE(awcc_gpio_pin);
1470
1471static void awcc_debugfs_remove(void *data)
1472{
1473	struct dentry *root = data;
1474
1475	debugfs_remove(root);
1476}
1477
1478static void awcc_debugfs_init(struct wmi_device *wdev)
1479{
1480	struct awcc_priv *priv = dev_get_drvdata(&wdev->dev);
1481	struct dentry *root, *gpio_ctl;
1482	u32 gpio_count;
1483	char name[64];
1484	int ret;
1485
1486	scnprintf(name, sizeof(name), "%s-%s", "alienware-wmi", dev_name(&wdev->dev));
1487	root = debugfs_create_dir(name, NULL);
1488
1489	debugfs_create_devm_seqfile(&wdev->dev, "system_description", root,
1490				    awcc_debugfs_system_description_read);
1491
1492	if (awcc->hwmon)
1493		debugfs_create_devm_seqfile(&wdev->dev, "hwmon_data", root,
1494					    awcc_debugfs_hwmon_data_read);
1495
1496	if (awcc->pprof)
1497		debugfs_create_devm_seqfile(&wdev->dev, "pprof_data", root,
1498					    awcc_debugfs_pprof_data_read);
1499
1500	ret = awcc_read_total_gpios(wdev, &gpio_count);
1501	if (ret) {
1502		dev_dbg(&wdev->dev, "Failed to get total GPIO Pin count\n");
1503		goto out_add_action;
1504	} else if (gpio_count > AWCC_MAX_RES_COUNT) {
1505		dev_dbg(&wdev->dev, "Reported GPIO Pin count may be incorrect: %u\n", gpio_count);
1506		goto out_add_action;
1507	}
1508
1509	gpio_ctl = debugfs_create_dir("gpio_ctl", root);
1510
1511	priv->gpio_count = gpio_count;
1512	debugfs_create_u32("total_gpios", 0444, gpio_ctl, &priv->gpio_count);
1513
1514	for (unsigned int i = 0; i < gpio_count; i++) {
1515		scnprintf(name, sizeof(name), "pin%u", i);
1516		debugfs_create_file_aux_num(name, 0644, gpio_ctl, wdev, i,
1517					    &awcc_gpio_pin_fops);
1518	}
1519
1520out_add_action:
1521	devm_add_action_or_reset(&wdev->dev, awcc_debugfs_remove, root);
1522}
1523
1524static int alienware_awcc_setup(struct wmi_device *wdev)
1525{
1526	struct awcc_priv *priv;
1527	int ret;
1528
1529	priv = devm_kzalloc(&wdev->dev, sizeof(*priv), GFP_KERNEL);
1530	if (!priv)
1531		return -ENOMEM;
1532
1533	ret = awcc_thermal_information(wdev, AWCC_OP_GET_SYSTEM_DESCRIPTION,
1534				       0, &priv->system_description);
1535	if (ret < 0)
1536		return ret;
1537
1538	/* Sanity check */
1539	for (unsigned int i = 0; i < ARRAY_SIZE(priv->res_count); i++) {
1540		if (priv->res_count[i] > AWCC_MAX_RES_COUNT) {
1541			dev_err(&wdev->dev, "Malformed system description: 0x%08x\n",
1542				priv->system_description);
1543			return -ENXIO;
1544		}
1545	}
1546
1547	priv->wdev = wdev;
1548	dev_set_drvdata(&wdev->dev, priv);
1549
1550	if (awcc->hwmon) {
1551		ret = awcc_hwmon_init(wdev);
1552		if (ret)
1553			return ret;
1554	}
1555
1556	if (awcc->pprof) {
1557		ret = awcc_platform_profile_init(wdev);
1558		if (ret)
1559			return ret;
1560	}
1561
1562	awcc_debugfs_init(wdev);
1563
1564	return 0;
1565}
1566
1567/*
1568 * WMAX WMI driver
1569 */
1570static int wmax_wmi_update_led(struct alienfx_priv *priv,
1571			       struct wmi_device *wdev, u8 location)
1572{
1573	struct wmax_led_args in_args = {
1574		.led_mask = 1 << location,
1575		.colors = priv->colors[location],
1576		.state = priv->lighting_control_state,
1577	};
1578
1579	return alienware_wmi_command(wdev, WMAX_METHOD_ZONE_CONTROL, &in_args,
1580				     sizeof(in_args), NULL);
1581}
1582
1583static int wmax_wmi_update_brightness(struct alienfx_priv *priv,
1584				      struct wmi_device *wdev, u8 brightness)
1585{
1586	struct wmax_brightness_args in_args = {
1587		.led_mask = 0xFF,
1588		.percentage = brightness,
1589	};
1590
1591	return alienware_wmi_command(wdev, WMAX_METHOD_BRIGHTNESS, &in_args,
1592				     sizeof(in_args), NULL);
1593}
1594
1595static int wmax_wmi_probe(struct wmi_device *wdev, const void *context)
1596{
1597	struct alienfx_platdata pdata = {
1598		.wdev = wdev,
1599		.ops = {
1600			.upd_led = wmax_wmi_update_led,
1601			.upd_brightness = wmax_wmi_update_brightness,
1602		},
1603	};
1604	int ret;
1605
1606	if (awcc)
1607		ret = alienware_awcc_setup(wdev);
1608	else
1609		ret = alienware_alienfx_setup(&pdata);
1610
1611	return ret;
1612}
1613
1614static int wmax_wmi_suspend(struct device *dev)
1615{
1616	if (awcc && awcc->hwmon)
1617		awcc_hwmon_suspend(dev);
1618
1619	return 0;
1620}
1621
1622static int wmax_wmi_resume(struct device *dev)
1623{
1624	if (awcc && awcc->hwmon)
1625		awcc_hwmon_resume(dev);
1626
1627	return 0;
1628}
1629
1630static DEFINE_SIMPLE_DEV_PM_OPS(wmax_wmi_pm_ops, wmax_wmi_suspend, wmax_wmi_resume);
1631
1632static const struct wmi_device_id alienware_wmax_device_id_table[] = {
1633	{ WMAX_CONTROL_GUID, NULL },
1634	{ },
1635};
1636MODULE_DEVICE_TABLE(wmi, alienware_wmax_device_id_table);
1637
1638static struct wmi_driver alienware_wmax_wmi_driver = {
1639	.driver = {
1640		.name = "alienware-wmi-wmax",
1641		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
1642		.pm = pm_sleep_ptr(&wmax_wmi_pm_ops),
1643	},
1644	.id_table = alienware_wmax_device_id_table,
1645	.probe = wmax_wmi_probe,
1646	.no_singleton = true,
1647};
1648
1649int __init alienware_wmax_wmi_init(void)
1650{
1651	const struct dmi_system_id *id;
1652
1653	id = dmi_first_match(awcc_dmi_table);
1654	if (id)
1655		awcc = id->driver_data;
1656
1657	if (force_hwmon) {
1658		if (!awcc)
1659			awcc = &empty_quirks;
1660
1661		awcc->hwmon = true;
1662	}
1663
1664	if (force_platform_profile) {
1665		if (!awcc)
1666			awcc = &empty_quirks;
1667
1668		awcc->pprof = true;
1669	}
1670
1671	if (force_gmode) {
1672		if (awcc)
1673			awcc->gmode = true;
1674		else
1675			pr_warn("force_gmode requires platform profile support\n");
1676	}
1677
1678	return wmi_driver_register(&alienware_wmax_wmi_driver);
1679}
1680
1681void __exit alienware_wmax_wmi_exit(void)
1682{
1683	wmi_driver_unregister(&alienware_wmax_wmi_driver);
1684}