[mirror_ubuntu-jammy-kernel.git] / drivers / acpi / x86 / s2idle.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Architecture-specific ACPI-based support for suspend-to-idle.
 *
 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 * Author: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
 * Author: Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
 *
 * On platforms supporting the Low Power S0 Idle interface there is an ACPI
 * device object with the PNP0D80 compatible device ID (System Power Management
 * Controller) and a specific _DSM method under it.  That method, if present,
 * can be used to indicate to the platform that the OS is transitioning into a
 * low-power state in which certain types of activity are not desirable or that
 * it is leaving such a state, which allows the platform to adjust its operation
 * mode accordingly.
 */

#include <linux/acpi.h>
#include <linux/device.h>
#include <linux/suspend.h>

#include "../sleep.h"

#ifdef CONFIG_SUSPEND

static bool sleep_no_lps0 __read_mostly;
module_param(sleep_no_lps0, bool, 0644);
MODULE_PARM_DESC(sleep_no_lps0, "Do not use the special LPS0 device interface");

static const struct acpi_device_id lps0_device_ids[] = {
	{"PNP0D80", },
	{"", },
};

/* Microsoft platform agnostic UUID */
#define ACPI_LPS0_DSM_UUID_MICROSOFT      "11e00d56-ce64-47ce-837b-1f898f9aa461"

#define ACPI_LPS0_DSM_UUID	"c4eb40a0-6cd2-11e2-bcfd-0800200c9a66"

#define ACPI_LPS0_GET_DEVICE_CONSTRAINTS	1
#define ACPI_LPS0_SCREEN_OFF	3
#define ACPI_LPS0_SCREEN_ON	4
#define ACPI_LPS0_ENTRY		5
#define ACPI_LPS0_EXIT		6
#define ACPI_LPS0_MS_ENTRY      7
#define ACPI_LPS0_MS_EXIT       8

/* AMD */
#define ACPI_LPS0_DSM_UUID_AMD      "e3f32452-febc-43ce-9039-932122d37721"
#define ACPI_LPS0_ENTRY_AMD         2
#define ACPI_LPS0_EXIT_AMD          3
#define ACPI_LPS0_SCREEN_OFF_AMD    4
#define ACPI_LPS0_SCREEN_ON_AMD     5

static acpi_handle lps0_device_handle;
static guid_t lps0_dsm_guid;
static int lps0_dsm_func_mask;

static guid_t lps0_dsm_guid_microsoft;
static int lps0_dsm_func_mask_microsoft;

/* Device constraint entry structure */
struct lpi_device_info {
	char *name;
	int enabled;
	union acpi_object *package;
};

/* Constraint package structure */
struct lpi_device_constraint {
	int uid;
	int min_dstate;
	int function_states;
};

struct lpi_constraints {
	acpi_handle handle;
	int min_dstate;
};

/* AMD Constraint package structure */
struct lpi_device_constraint_amd {
	char *name;
	int enabled;
	int function_states;
	int min_dstate;
};

static struct lpi_constraints *lpi_constraints_table;
static int lpi_constraints_table_size;
static int rev_id;

static void lpi_device_get_constraints_amd(void)
{
	union acpi_object *out_obj;
	int i, j, k;

	out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
					  rev_id, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
					  NULL, ACPI_TYPE_PACKAGE);

	acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
			  out_obj ? "successful" : "failed");

	if (!out_obj)
		return;

	for (i = 0; i < out_obj->package.count; i++) {
		union acpi_object *package = &out_obj->package.elements[i];

		if (package->type == ACPI_TYPE_PACKAGE) {
			lpi_constraints_table = kcalloc(package->package.count,
							sizeof(*lpi_constraints_table),
							GFP_KERNEL);

			if (!lpi_constraints_table)
				goto free_acpi_buffer;

			acpi_handle_debug(lps0_device_handle,
					  "LPI: constraints list begin:\n");

			for (j = 0; j < package->package.count; ++j) {
				union acpi_object *info_obj = &package->package.elements[j];
				struct lpi_device_constraint_amd dev_info = {};
				struct lpi_constraints *list;
				acpi_status status;

				for (k = 0; k < info_obj->package.count; ++k) {
					union acpi_object *obj = &info_obj->package.elements[k];

					list = &lpi_constraints_table[lpi_constraints_table_size];
					list->min_dstate = -1;

					switch (k) {
					case 0:
						dev_info.enabled = obj->integer.value;
						break;
					case 1:
						dev_info.name = obj->string.pointer;
						break;
					case 2:
						dev_info.function_states = obj->integer.value;
						break;
					case 3:
						dev_info.min_dstate = obj->integer.value;
						break;
					}

					if (!dev_info.enabled || !dev_info.name ||
					    !dev_info.min_dstate)
						continue;

					status = acpi_get_handle(NULL, dev_info.name,
								 &list->handle);
					if (ACPI_FAILURE(status))
						continue;

					acpi_handle_debug(lps0_device_handle,
							  "Name:%s\n", dev_info.name);

					list->min_dstate = dev_info.min_dstate;

					if (list->min_dstate < 0) {
						acpi_handle_debug(lps0_device_handle,
								  "Incomplete constraint defined\n");
						continue;
					}
				}
				lpi_constraints_table_size++;
			}
		}
	}

	acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");

free_acpi_buffer:
	ACPI_FREE(out_obj);
}

static void lpi_device_get_constraints(void)
{
	union acpi_object *out_obj;
	int i;

	out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
					  1, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
					  NULL, ACPI_TYPE_PACKAGE);

	acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
			  out_obj ? "successful" : "failed");

	if (!out_obj)
		return;

	lpi_constraints_table = kcalloc(out_obj->package.count,
					sizeof(*lpi_constraints_table),
					GFP_KERNEL);
	if (!lpi_constraints_table)
		goto free_acpi_buffer;

	acpi_handle_debug(lps0_device_handle, "LPI: constraints list begin:\n");

	for (i = 0; i < out_obj->package.count; i++) {
		struct lpi_constraints *constraint;
		acpi_status status;
		union acpi_object *package = &out_obj->package.elements[i];
		struct lpi_device_info info = { };
		int package_count = 0, j;

		if (!package)
			continue;

		for (j = 0; j < package->package.count; ++j) {
			union acpi_object *element =
					&(package->package.elements[j]);

			switch (element->type) {
			case ACPI_TYPE_INTEGER:
				info.enabled = element->integer.value;
				break;
			case ACPI_TYPE_STRING:
				info.name = element->string.pointer;
				break;
			case ACPI_TYPE_PACKAGE:
				package_count = element->package.count;
				info.package = element->package.elements;
				break;
			}
		}

		if (!info.enabled || !info.package || !info.name)
			continue;

		constraint = &lpi_constraints_table[lpi_constraints_table_size];

		status = acpi_get_handle(NULL, info.name, &constraint->handle);
		if (ACPI_FAILURE(status))
			continue;

		acpi_handle_debug(lps0_device_handle,
				  "index:%d Name:%s\n", i, info.name);

		constraint->min_dstate = -1;

		for (j = 0; j < package_count; ++j) {
			union acpi_object *info_obj = &info.package[j];
			union acpi_object *cnstr_pkg;
			union acpi_object *obj;
			struct lpi_device_constraint dev_info;

			switch (info_obj->type) {
			case ACPI_TYPE_INTEGER:
				/* version */
				break;
			case ACPI_TYPE_PACKAGE:
				if (info_obj->package.count < 2)
					break;

				cnstr_pkg = info_obj->package.elements;
				obj = &cnstr_pkg[0];
				dev_info.uid = obj->integer.value;
				obj = &cnstr_pkg[1];
				dev_info.min_dstate = obj->integer.value;

				acpi_handle_debug(lps0_device_handle,
					"uid:%d min_dstate:%s\n",
					dev_info.uid,
					acpi_power_state_string(dev_info.min_dstate));

				constraint->min_dstate = dev_info.min_dstate;
				break;
			}
		}

		if (constraint->min_dstate < 0) {
			acpi_handle_debug(lps0_device_handle,
					  "Incomplete constraint defined\n");
			continue;
		}

		lpi_constraints_table_size++;
	}

	acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");

free_acpi_buffer:
	ACPI_FREE(out_obj);
}

static void lpi_check_constraints(void)
{
	int i;

	for (i = 0; i < lpi_constraints_table_size; ++i) {
		acpi_handle handle = lpi_constraints_table[i].handle;
		struct acpi_device *adev;

		if (!handle || acpi_bus_get_device(handle, &adev))
			continue;

		acpi_handle_debug(handle,
			"LPI: required min power state:%s current power state:%s\n",
			acpi_power_state_string(lpi_constraints_table[i].min_dstate),
			acpi_power_state_string(adev->power.state));

		if (!adev->flags.power_manageable) {
			acpi_handle_info(handle, "LPI: Device not power manageable\n");
			lpi_constraints_table[i].handle = NULL;
			continue;
		}

		if (adev->power.state < lpi_constraints_table[i].min_dstate)
			acpi_handle_info(handle,
				"LPI: Constraint not met; min power state:%s current power state:%s\n",
				acpi_power_state_string(lpi_constraints_table[i].min_dstate),
				acpi_power_state_string(adev->power.state));
	}
}

static void acpi_sleep_run_lps0_dsm(unsigned int func, unsigned int func_mask, guid_t dsm_guid)
{
	union acpi_object *out_obj;

	if (!(func_mask & (1 << func)))
		return;

	out_obj = acpi_evaluate_dsm(lps0_device_handle, &dsm_guid,
					rev_id, func, NULL);
	ACPI_FREE(out_obj);

	acpi_handle_debug(lps0_device_handle, "_DSM function %u evaluation %s\n",
			  func, out_obj ? "successful" : "failed");
}

static bool acpi_s2idle_vendor_amd(void)
{
	return boot_cpu_data.x86_vendor == X86_VENDOR_AMD;
}

static int validate_dsm(acpi_handle handle, const char *uuid, int rev, guid_t *dsm_guid)
{
	union acpi_object *obj;
	int ret = -EINVAL;

	guid_parse(uuid, dsm_guid);
	obj = acpi_evaluate_dsm(handle, dsm_guid, rev, 0, NULL);

	/* Check if the _DSM is present and as expected. */
	if (!obj || obj->type != ACPI_TYPE_BUFFER || obj->buffer.length == 0 ||
	    obj->buffer.length > sizeof(u32)) {
		acpi_handle_debug(handle,
				"_DSM UUID %s rev %d function 0 evaluation failed\n", uuid, rev);
		goto out;
	}

	ret = *(int *)obj->buffer.pointer;
	acpi_handle_debug(handle, "_DSM UUID %s rev %d function mask: 0x%x\n", uuid, rev, ret);

out:
	ACPI_FREE(obj);
	return ret;
}

static int lps0_device_attach(struct acpi_device *adev,
			      const struct acpi_device_id *not_used)
{
	if (lps0_device_handle)
		return 0;

	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
		return 0;

	if (acpi_s2idle_vendor_amd()) {
		/* AMD0004, AMD0005, AMDI0005:
		 * - Should use rev_id 0x0
		 * - function mask > 0x3: Should use AMD method, but has off by one bug
		 * - function mask = 0x3: Should use Microsoft method
		 * AMDI0006:
		 * - should use rev_id 0x0
		 * - function mask = 0x3: Should use Microsoft method
		 * AMDI0007:
		 * - Should use rev_id 0x2
		 * - Should only use AMD method
		 */
		const char *hid = acpi_device_hid(adev);
		rev_id = strcmp(hid, "AMDI0007") ? 0 : 2;
		lps0_dsm_func_mask = validate_dsm(adev->handle,
					ACPI_LPS0_DSM_UUID_AMD, rev_id, &lps0_dsm_guid);
		lps0_dsm_func_mask_microsoft = validate_dsm(adev->handle,
					ACPI_LPS0_DSM_UUID_MICROSOFT, 0,
					&lps0_dsm_guid_microsoft);
		if (lps0_dsm_func_mask > 0x3 && (!strcmp(hid, "AMD0004") ||
						 !strcmp(hid, "AMD0005") ||
						 !strcmp(hid, "AMDI0005"))) {
			lps0_dsm_func_mask = (lps0_dsm_func_mask << 1) | 0x1;
			acpi_handle_debug(adev->handle, "_DSM UUID %s: Adjusted function mask: 0x%x\n",
					  ACPI_LPS0_DSM_UUID_AMD, lps0_dsm_func_mask);
		} else if (lps0_dsm_func_mask_microsoft > 0 && !strcmp(hid, "AMDI0007")) {
			lps0_dsm_func_mask_microsoft = -EINVAL;
			acpi_handle_debug(adev->handle, "_DSM Using AMD method\n");
		}
	} else {
		rev_id = 1;
		lps0_dsm_func_mask = validate_dsm(adev->handle,
					ACPI_LPS0_DSM_UUID, rev_id, &lps0_dsm_guid);
		lps0_dsm_func_mask_microsoft = -EINVAL;
	}

	if (lps0_dsm_func_mask < 0 && lps0_dsm_func_mask_microsoft < 0)
		return 0; //function evaluation failed

	lps0_device_handle = adev->handle;

	if (acpi_s2idle_vendor_amd())
		lpi_device_get_constraints_amd();
	else
		lpi_device_get_constraints();

	/*
	 * Use suspend-to-idle by default if the default suspend mode was not
	 * set from the command line.
	 */
	if (mem_sleep_default > PM_SUSPEND_MEM && !acpi_sleep_default_s3)
		mem_sleep_current = PM_SUSPEND_TO_IDLE;

	/*
	 * Some Intel based LPS0 systems, like ASUS Zenbook UX430UNR/i7-8550U don't
	 * use intel-hid or intel-vbtn but require the EC GPE to be enabled while
	 * suspended for certain wakeup devices to work, so mark it as wakeup-capable.
	 *
	 * Only enable on !AMD as enabling this universally causes problems for a number
	 * of AMD based systems.
	 */
	if (!acpi_s2idle_vendor_amd())
		acpi_ec_mark_gpe_for_wake();

	return 0;
}

static struct acpi_scan_handler lps0_handler = {
	.ids = lps0_device_ids,
	.attach = lps0_device_attach,
};

int acpi_s2idle_prepare_late(void)
{
	if (!lps0_device_handle || sleep_no_lps0)
		return 0;

	if (pm_debug_messages_on)
		lpi_check_constraints();

	/* Screen off */
	if (lps0_dsm_func_mask > 0)
		acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
					ACPI_LPS0_SCREEN_OFF_AMD :
					ACPI_LPS0_SCREEN_OFF,
					lps0_dsm_func_mask, lps0_dsm_guid);

	if (lps0_dsm_func_mask_microsoft > 0)
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_OFF,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);

	/* LPS0 entry */
	if (lps0_dsm_func_mask > 0)
		acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
					ACPI_LPS0_ENTRY_AMD :
					ACPI_LPS0_ENTRY,
					lps0_dsm_func_mask, lps0_dsm_guid);
	if (lps0_dsm_func_mask_microsoft > 0) {
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_ENTRY,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
		/* modern standby entry */
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_ENTRY,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
	}
	return 0;
}

void acpi_s2idle_restore_early(void)
{
	if (!lps0_device_handle || sleep_no_lps0)
		return;

	/* Modern standby exit */
	if (lps0_dsm_func_mask_microsoft > 0)
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_EXIT,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);

	/* LPS0 exit */
	if (lps0_dsm_func_mask > 0)
		acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
					ACPI_LPS0_EXIT_AMD :
					ACPI_LPS0_EXIT,
					lps0_dsm_func_mask, lps0_dsm_guid);
	if (lps0_dsm_func_mask_microsoft > 0)
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_EXIT,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);

	/* Screen on */
	if (lps0_dsm_func_mask_microsoft > 0)
		acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_ON,
				lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
	if (lps0_dsm_func_mask > 0)
		acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
					ACPI_LPS0_SCREEN_ON_AMD :
					ACPI_LPS0_SCREEN_ON,
					lps0_dsm_func_mask, lps0_dsm_guid);
}

static const struct platform_s2idle_ops acpi_s2idle_ops_lps0 = {
	.begin = acpi_s2idle_begin,
	.prepare = acpi_s2idle_prepare,
	.prepare_late = acpi_s2idle_prepare_late,
	.wake = acpi_s2idle_wake,
	.restore_early = acpi_s2idle_restore_early,
	.restore = acpi_s2idle_restore,
	.end = acpi_s2idle_end,
};

void acpi_s2idle_setup(void)
{
	acpi_scan_add_handler(&lps0_handler);
	s2idle_set_ops(&acpi_s2idle_ops_lps0);
}

#endif /* CONFIG_SUSPEND */
Commit	Line	Data
fef98671 RW	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Architecture-specific ACPI-based support for suspend-to-idle.
	4	*
	5	* Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
	6	* Author: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
	7	* Author: Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
	8	*
	9	* On platforms supporting the Low Power S0 Idle interface there is an ACPI
	10	* device object with the PNP0D80 compatible device ID (System Power Management
	11	* Controller) and a specific _DSM method under it. That method, if present,
	12	* can be used to indicate to the platform that the OS is transitioning into a
	13	* low-power state in which certain types of activity are not desirable or that
	14	* it is leaving such a state, which allows the platform to adjust its operation
	15	* mode accordingly.
	16	*/
	17
	18	#include <linux/acpi.h>
	19	#include <linux/device.h>
	20	#include <linux/suspend.h>
	21
	22	#include "../sleep.h"
	23
	24	#ifdef CONFIG_SUSPEND
	25
	26	static bool sleep_no_lps0 __read_mostly;
	27	module_param(sleep_no_lps0, bool, 0644);
	28	MODULE_PARM_DESC(sleep_no_lps0, "Do not use the special LPS0 device interface");
	29
	30	static const struct acpi_device_id lps0_device_ids[] = {
	31	{"PNP0D80", },
	32	{"", },
	33	};
	34
5dbf5099 PV	35	/* Microsoft platform agnostic UUID */
	36	#define ACPI_LPS0_DSM_UUID_MICROSOFT "11e00d56-ce64-47ce-837b-1f898f9aa461"
	37
fef98671 RW	38	#define ACPI_LPS0_DSM_UUID "c4eb40a0-6cd2-11e2-bcfd-0800200c9a66"
	39
	40	#define ACPI_LPS0_GET_DEVICE_CONSTRAINTS 1
	41	#define ACPI_LPS0_SCREEN_OFF 3
	42	#define ACPI_LPS0_SCREEN_ON 4
	43	#define ACPI_LPS0_ENTRY 5
	44	#define ACPI_LPS0_EXIT 6
5dbf5099 PV	45	#define ACPI_LPS0_MS_ENTRY 7
5dbf5099 PV	46	#define ACPI_LPS0_MS_EXIT 8
fef98671 RW	47
	48	/* AMD */
	49	#define ACPI_LPS0_DSM_UUID_AMD "e3f32452-febc-43ce-9039-932122d37721"
f59a905b AD	50	#define ACPI_LPS0_ENTRY_AMD 2
f59a905b AD	51	#define ACPI_LPS0_EXIT_AMD 3
fef98671 RW	52	#define ACPI_LPS0_SCREEN_OFF_AMD 4
	53	#define ACPI_LPS0_SCREEN_ON_AMD 5
	54
	55	static acpi_handle lps0_device_handle;
	56	static guid_t lps0_dsm_guid;
4a012dc8	57	static int lps0_dsm_func_mask;
fef98671	58
5dbf5099 PV	59	static guid_t lps0_dsm_guid_microsoft;
	60	static int lps0_dsm_func_mask_microsoft;
	61
fef98671 RW	62	/* Device constraint entry structure */
	63	struct lpi_device_info {
	64	char *name;
	65	int enabled;
	66	union acpi_object *package;
	67	};
	68
	69	/* Constraint package structure */
	70	struct lpi_device_constraint {
	71	int uid;
	72	int min_dstate;
	73	int function_states;
	74	};
	75
	76	struct lpi_constraints {
	77	acpi_handle handle;
	78	int min_dstate;
	79	};
	80
4a012dc8	81	/* AMD Constraint package structure */
fef98671 RW	82	struct lpi_device_constraint_amd {
	83	char *name;
	84	int enabled;
	85	int function_states;
	86	int min_dstate;
	87	};
	88
	89	static struct lpi_constraints *lpi_constraints_table;
	90	static int lpi_constraints_table_size;
	91	static int rev_id;
	92
	93	static void lpi_device_get_constraints_amd(void)
	94	{
	95	union acpi_object *out_obj;
	96	int i, j, k;
	97
	98	out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
904d4a6c	99	rev_id, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
fef98671 RW	100	NULL, ACPI_TYPE_PACKAGE);
fef98671 RW	101
fef98671 RW	102	acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
	103	out_obj ? "successful" : "failed");
	104
4a012dc8 PV	105	if (!out_obj)
	106	return;
	107
fef98671 RW	108	for (i = 0; i < out_obj->package.count; i++) {
fef98671 RW	109	union acpi_object *package = &out_obj->package.elements[i];
aa7a1bb0 RW	110
aa7a1bb0 RW	111	if (package->type == ACPI_TYPE_PACKAGE) {
fef98671 RW	112	lpi_constraints_table = kcalloc(package->package.count,
	113	sizeof(*lpi_constraints_table),
	114	GFP_KERNEL);
	115
	116	if (!lpi_constraints_table)
	117	goto free_acpi_buffer;
	118
	119	acpi_handle_debug(lps0_device_handle,
	120	"LPI: constraints list begin:\n");
	121
	122	for (j = 0; j < package->package.count; ++j) {
	123	union acpi_object *info_obj = &package->package.elements[j];
	124	struct lpi_device_constraint_amd dev_info = {};
	125	struct lpi_constraints *list;
	126	acpi_status status;
	127
	128	for (k = 0; k < info_obj->package.count; ++k) {
	129	union acpi_object *obj = &info_obj->package.elements[k];
fef98671 RW	130
	131	list = &lpi_constraints_table[lpi_constraints_table_size];
	132	list->min_dstate = -1;
	133
fef98671 RW	134	switch (k) {
	135	case 0:
	136	dev_info.enabled = obj->integer.value;
	137	break;
	138	case 1:
	139	dev_info.name = obj->string.pointer;
	140	break;
	141	case 2:
	142	dev_info.function_states = obj->integer.value;
	143	break;
	144	case 3:
	145	dev_info.min_dstate = obj->integer.value;
	146	break;
	147	}
	148
	149	if (!dev_info.enabled \|\| !dev_info.name \|\|
	150	!dev_info.min_dstate)
	151	continue;
	152
	153	status = acpi_get_handle(NULL, dev_info.name,
	154	&list->handle);
	155	if (ACPI_FAILURE(status))
	156	continue;
	157
	158	acpi_handle_debug(lps0_device_handle,
	159	"Name:%s\n", dev_info.name);
	160
	161	list->min_dstate = dev_info.min_dstate;
	162
	163	if (list->min_dstate < 0) {
	164	acpi_handle_debug(lps0_device_handle,
	165	"Incomplete constraint defined\n");
	166	continue;
	167	}
	168	}
	169	lpi_constraints_table_size++;
	170	}
	171	}
	172	}
	173
	174	acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");
	175
	176	free_acpi_buffer:
	177	ACPI_FREE(out_obj);
	178	}
	179
	180	static void lpi_device_get_constraints(void)
	181	{
	182	union acpi_object *out_obj;
	183	int i;
	184
	185	out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
	186	1, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
	187	NULL, ACPI_TYPE_PACKAGE);
	188
	189	acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
	190	out_obj ? "successful" : "failed");
	191
	192	if (!out_obj)
	193	return;
	194
	195	lpi_constraints_table = kcalloc(out_obj->package.count,
	196	sizeof(*lpi_constraints_table),
	197	GFP_KERNEL);
198	if (!lpi_constraints_table)
199	goto free_acpi_buffer;
200
201	acpi_handle_debug(lps0_device_handle, "LPI: constraints list begin:\n");
202
203	for (i = 0; i < out_obj->package.count; i++) {
204	struct lpi_constraints *constraint;
205	acpi_status status;
206	union acpi_object *package = &out_obj->package.elements[i];
207	struct lpi_device_info info = { };
208	int package_count = 0, j;
209
210	if (!package)
211	continue;
212
213	for (j = 0; j < package->package.count; ++j) {
214	union acpi_object *element =
215	&(package->package.elements[j]);
216
217	switch (element->type) {
218	case ACPI_TYPE_INTEGER:
219	info.enabled = element->integer.value;
220	break;
221	case ACPI_TYPE_STRING:
222	info.name = element->string.pointer;
223	break;
224	case ACPI_TYPE_PACKAGE:
225	package_count = element->package.count;
226	info.package = element->package.elements;
227	break;
228	}
229	}
230
231	if (!info.enabled \|\| !info.package \|\| !info.name)
232	continue;
233
234	constraint = &lpi_constraints_table[lpi_constraints_table_size];
235
236	status = acpi_get_handle(NULL, info.name, &constraint->handle);
237	if (ACPI_FAILURE(status))
238	continue;
239
240	acpi_handle_debug(lps0_device_handle,
241	"index:%d Name:%s\n", i, info.name);
242
243	constraint->min_dstate = -1;
244
245	for (j = 0; j < package_count; ++j) {
246	union acpi_object *info_obj = &info.package[j];
247	union acpi_object *cnstr_pkg;
248	union acpi_object *obj;
249	struct lpi_device_constraint dev_info;
250
251	switch (info_obj->type) {
252	case ACPI_TYPE_INTEGER:
253	/* version */
254	break;
255	case ACPI_TYPE_PACKAGE:
256	if (info_obj->package.count < 2)
257	break;
258
259	cnstr_pkg = info_obj->package.elements;
260	obj = &cnstr_pkg[0];
261	dev_info.uid = obj->integer.value;
262	obj = &cnstr_pkg[1];
263	dev_info.min_dstate = obj->integer.value;
264
265	acpi_handle_debug(lps0_device_handle,
266	"uid:%d min_dstate:%s\n",
267	dev_info.uid,
268	acpi_power_state_string(dev_info.min_dstate));
269
270	constraint->min_dstate = dev_info.min_dstate;
271	break;
272	}
273	}
274
275	if (constraint->min_dstate < 0) {
276	acpi_handle_debug(lps0_device_handle,
277	"Incomplete constraint defined\n");
278	continue;
279	}
280
281	lpi_constraints_table_size++;
282	}
283
284	acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");
285
286	free_acpi_buffer:
287	ACPI_FREE(out_obj);
288	}
289
290	static void lpi_check_constraints(void)
291	{
292	int i;
293
294	for (i = 0; i < lpi_constraints_table_size; ++i) {
295	acpi_handle handle = lpi_constraints_table[i].handle;
296	struct acpi_device *adev;
297
298	if (!handle \|\| acpi_bus_get_device(handle, &adev))
299	continue;
300
301	acpi_handle_debug(handle,
302	"LPI: required min power state:%s current power state:%s\n",
303	acpi_power_state_string(lpi_constraints_table[i].min_dstate),
304	acpi_power_state_string(adev->power.state));
305
306	if (!adev->flags.power_manageable) {
307	acpi_handle_info(handle, "LPI: Device not power manageable\n");
308	lpi_constraints_table[i].handle = NULL;
309	continue;
310	}
311
312	if (adev->power.state < lpi_constraints_table[i].min_dstate)
313	acpi_handle_info(handle,
314	"LPI: Constraint not met; min power state:%s current power state:%s\n",
315	acpi_power_state_string(lpi_constraints_table[i].min_dstate),
316	acpi_power_state_string(adev->power.state));
317	}
318	}
319
3f4b116c	320	static void acpi_sleep_run_lps0_dsm(unsigned int func, unsigned int func_mask, guid_t dsm_guid)
fef98671 RW	321	{
	322	union acpi_object *out_obj;
	323
3f4b116c	324	if (!(func_mask & (1 << func)))
fef98671 RW	325	return;
fef98671 RW	326
3f4b116c PV	327	out_obj = acpi_evaluate_dsm(lps0_device_handle, &dsm_guid,
3f4b116c PV	328	rev_id, func, NULL);
fef98671 RW	329	ACPI_FREE(out_obj);
	330
	331	acpi_handle_debug(lps0_device_handle, "_DSM function %u evaluation %s\n",
	332	func, out_obj ? "successful" : "failed");
	333	}
	334
	335	static bool acpi_s2idle_vendor_amd(void)
	336	{
	337	return boot_cpu_data.x86_vendor == X86_VENDOR_AMD;
	338	}
	339
4a012dc8 PV	340	static int validate_dsm(acpi_handle handle, const char uuid, int rev, guid_t dsm_guid)
	341	{
	342	union acpi_object *obj;
	343	int ret = -EINVAL;
	344
	345	guid_parse(uuid, dsm_guid);
	346	obj = acpi_evaluate_dsm(handle, dsm_guid, rev, 0, NULL);
	347
	348	/* Check if the _DSM is present and as expected. */
	349	if (!obj \|\| obj->type != ACPI_TYPE_BUFFER \|\| obj->buffer.length == 0 \|\|
	350	obj->buffer.length > sizeof(u32)) {
	351	acpi_handle_debug(handle,
	352	"_DSM UUID %s rev %d function 0 evaluation failed\n", uuid, rev);
	353	goto out;
	354	}
	355
	356	ret = (int )obj->buffer.pointer;
	357	acpi_handle_debug(handle, "_DSM UUID %s rev %d function mask: 0x%x\n", uuid, rev, ret);
	358
	359	out:
	360	ACPI_FREE(obj);
	361	return ret;
	362	}
	363
fef98671 RW	364	static int lps0_device_attach(struct acpi_device *adev,
	365	const struct acpi_device_id *not_used)
	366	{
fef98671 RW	367	if (lps0_device_handle)
	368	return 0;
	369
	370	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
	371	return 0;
	372
	373	if (acpi_s2idle_vendor_amd()) {
1ea1dbf1	374	/* AMD0004, AMD0005, AMDI0005:
8fbd6c15 ML	375	* - Should use rev_id 0x0
	376	* - function mask > 0x3: Should use AMD method, but has off by one bug
	377	* - function mask = 0x3: Should use Microsoft method
	378	* AMDI0006:
	379	* - should use rev_id 0x0
	380	* - function mask = 0x3: Should use Microsoft method
f0c62255 ML	381	* AMDI0007:
	382	* - Should use rev_id 0x2
	383	* - Should only use AMD method
8fbd6c15 ML	384	*/
8fbd6c15 ML	385	const char *hid = acpi_device_hid(adev);
f0c62255	386	rev_id = strcmp(hid, "AMDI0007") ? 0 : 2;
4a012dc8 PV	387	lps0_dsm_func_mask = validate_dsm(adev->handle,
4a012dc8 PV	388	ACPI_LPS0_DSM_UUID_AMD, rev_id, &lps0_dsm_guid);
5dbf5099	389	lps0_dsm_func_mask_microsoft = validate_dsm(adev->handle,
f0c62255	390	ACPI_LPS0_DSM_UUID_MICROSOFT, 0,
5dbf5099	391	&lps0_dsm_guid_microsoft);
8fbd6c15	392	if (lps0_dsm_func_mask > 0x3 && (!strcmp(hid, "AMD0004") \|\|
1ea1dbf1	393	!strcmp(hid, "AMD0005") \|\|
8fbd6c15 ML	394	!strcmp(hid, "AMDI0005"))) {
	395	lps0_dsm_func_mask = (lps0_dsm_func_mask << 1) \| 0x1;
	396	acpi_handle_debug(adev->handle, "_DSM UUID %s: Adjusted function mask: 0x%x\n",
	397	ACPI_LPS0_DSM_UUID_AMD, lps0_dsm_func_mask);
f0c62255 ML	398	} else if (lps0_dsm_func_mask_microsoft > 0 && !strcmp(hid, "AMDI0007")) {
	399	lps0_dsm_func_mask_microsoft = -EINVAL;
	400	acpi_handle_debug(adev->handle, "_DSM Using AMD method\n");
8fbd6c15	401	}
fef98671	402	} else {
fef98671	403	rev_id = 1;
4a012dc8 PV	404	lps0_dsm_func_mask = validate_dsm(adev->handle,
4a012dc8 PV	405	ACPI_LPS0_DSM_UUID, rev_id, &lps0_dsm_guid);
5dbf5099	406	lps0_dsm_func_mask_microsoft = -EINVAL;
fef98671 RW	407	}
fef98671 RW	408
5dbf5099 PV	409	if (lps0_dsm_func_mask < 0 && lps0_dsm_func_mask_microsoft < 0)
5dbf5099 PV	410	return 0; //function evaluation failed
fef98671 RW	411
	412	lps0_device_handle = adev->handle;
	413
	414	if (acpi_s2idle_vendor_amd())
	415	lpi_device_get_constraints_amd();
	416	else
	417	lpi_device_get_constraints();
	418
	419	/*
	420	* Use suspend-to-idle by default if the default suspend mode was not
	421	* set from the command line.
	422	*/
	423	if (mem_sleep_default > PM_SUSPEND_MEM && !acpi_sleep_default_s3)
	424	mem_sleep_current = PM_SUSPEND_TO_IDLE;
	425
	426	/*
7b167c4c ML	427	* Some Intel based LPS0 systems, like ASUS Zenbook UX430UNR/i7-8550U don't
	428	* use intel-hid or intel-vbtn but require the EC GPE to be enabled while
	429	* suspended for certain wakeup devices to work, so mark it as wakeup-capable.
	430	*
	431	* Only enable on !AMD as enabling this universally causes problems for a number
	432	* of AMD based systems.
fef98671	433	*/
7b167c4c ML	434	if (!acpi_s2idle_vendor_amd())
7b167c4c ML	435	acpi_ec_mark_gpe_for_wake();
fef98671 RW	436
	437	return 0;
	438	}
	439
	440	static struct acpi_scan_handler lps0_handler = {
	441	.ids = lps0_device_ids,
	442	.attach = lps0_device_attach,
	443	};
	444
	445	int acpi_s2idle_prepare_late(void)
	446	{
	447	if (!lps0_device_handle \|\| sleep_no_lps0)
	448	return 0;
	449
	450	if (pm_debug_messages_on)
	451	lpi_check_constraints();
	452
fa209644 ML	453	/* Screen off */
	454	if (lps0_dsm_func_mask > 0)
	455	acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
	456	ACPI_LPS0_SCREEN_OFF_AMD :
	457	ACPI_LPS0_SCREEN_OFF,
	458	lps0_dsm_func_mask, lps0_dsm_guid);
	459
	460	if (lps0_dsm_func_mask_microsoft > 0)
5dbf5099 PV	461	acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_OFF,
5dbf5099 PV	462	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
fa209644 ML	463
	464	/* LPS0 entry */
	465	if (lps0_dsm_func_mask > 0)
	466	acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
	467	ACPI_LPS0_ENTRY_AMD :
	468	ACPI_LPS0_ENTRY,
	469	lps0_dsm_func_mask, lps0_dsm_guid);
	470	if (lps0_dsm_func_mask_microsoft > 0) {
5dbf5099 PV	471	acpi_sleep_run_lps0_dsm(ACPI_LPS0_ENTRY,
5dbf5099 PV	472	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
fa209644 ML	473	/* modern standby entry */
	474	acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_ENTRY,
	475	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
fef98671	476	}
fef98671 RW	477	return 0;
	478	}
	479
	480	void acpi_s2idle_restore_early(void)
	481	{
	482	if (!lps0_device_handle \|\| sleep_no_lps0)
	483	return;
	484
fa209644 ML	485	/* Modern standby exit */
fa209644 ML	486	if (lps0_dsm_func_mask_microsoft > 0)
4753b46e	487	acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_EXIT,
5dbf5099	488	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
fa209644 ML	489
	490	/* LPS0 exit */
	491	if (lps0_dsm_func_mask > 0)
	492	acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
	493	ACPI_LPS0_EXIT_AMD :
	494	ACPI_LPS0_EXIT,
	495	lps0_dsm_func_mask, lps0_dsm_guid);
	496	if (lps0_dsm_func_mask_microsoft > 0)
3f4b116c	497	acpi_sleep_run_lps0_dsm(ACPI_LPS0_EXIT,
fa209644 ML	498	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
	499
	500	/* Screen on */
	501	if (lps0_dsm_func_mask_microsoft > 0)
3f4b116c	502	acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_ON,
fa209644 ML	503	lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft);
	504	if (lps0_dsm_func_mask > 0)
	505	acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ?
	506	ACPI_LPS0_SCREEN_ON_AMD :
	507	ACPI_LPS0_SCREEN_ON,
	508	lps0_dsm_func_mask, lps0_dsm_guid);
fef98671 RW	509	}
	510
	511	static const struct platform_s2idle_ops acpi_s2idle_ops_lps0 = {
	512	.begin = acpi_s2idle_begin,
	513	.prepare = acpi_s2idle_prepare,
	514	.prepare_late = acpi_s2idle_prepare_late,
	515	.wake = acpi_s2idle_wake,
	516	.restore_early = acpi_s2idle_restore_early,
	517	.restore = acpi_s2idle_restore,
	518	.end = acpi_s2idle_end,
	519	};
	520
	521	void acpi_s2idle_setup(void)
	522	{
	523	acpi_scan_add_handler(&lps0_handler);
	524	s2idle_set_ops(&acpi_s2idle_ops_lps0);
	525	}
	526
	527	#endif /* CONFIG_SUSPEND */