Merge branch 'acpi-dsm' (fbb9c10d) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/acpi/acpi_extlog.c

+12 −49

Original line number	Diff line number	Diff line
		@@ -19,11 +19,9 @@
		#define EXT_ELOG_ENTRY_MASK GENMASK_ULL(51, 0) /* elog entry address mask */

		#define EXTLOG_DSM_REV 0x0
		#define EXTLOG_FN_QUERY 0x0
		#define EXTLOG_FN_ADDR 0x1

		#define FLAG_OS_OPTIN BIT(0)
		#define EXTLOG_QUERY_L1_EXIST BIT(1)
		#define ELOG_ENTRY_VALID (1ULL<<63)
		#define ELOG_ENTRY_LEN 0x1000

		@@ -42,7 +40,7 @@ struct extlog_l1_head {
		u8 rev1[12];
		};

		static u8 extlog_dsm_uuid[] = "663E35AF-CC10-41A4-88EA-5470AF055295";
		static u8 extlog_dsm_uuid[] __initdata = "663E35AF-CC10-41A4-88EA-5470AF055295";

		/* L1 table related physical address */
		static u64 elog_base;
		@@ -152,62 +150,27 @@ static int extlog_print(struct notifier_block *nb, unsigned long val,
		return NOTIFY_DONE;
		}

		static int extlog_get_dsm(acpi_handle handle, int rev, int func, u64 *ret)
		static bool __init extlog_get_l1addr(void)
		{
		struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
		struct acpi_object_list input;
		union acpi_object params[4], *obj;
		u8 uuid[16];
		int i;
		acpi_handle handle;
		union acpi_object *obj;

		acpi_str_to_uuid(extlog_dsm_uuid, uuid);
		input.count = 4;
		input.pointer = params;
		params[0].type = ACPI_TYPE_BUFFER;
		params[0].buffer.length = 16;
		params[0].buffer.pointer = uuid;
		params[1].type = ACPI_TYPE_INTEGER;
		params[1].integer.value = rev;
		params[2].type = ACPI_TYPE_INTEGER;
		params[2].integer.value = func;
		params[3].type = ACPI_TYPE_PACKAGE;
		params[3].package.count = 0;
		params[3].package.elements = NULL;

		if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DSM", &input, &buf)))
		return -1;

		*ret = 0;
		obj = (union acpi_object *)buf.pointer;
		if (obj->type == ACPI_TYPE_INTEGER) {
		*ret = obj->integer.value;
		} else if (obj->type == ACPI_TYPE_BUFFER) {
		if (obj->buffer.length <= 8) {
		for (i = 0; i < obj->buffer.length; i++)
		ret \|= (obj->buffer.pointer[i] << (i 8));
		}
		}
		kfree(buf.pointer);

		return 0;
		}

		static bool extlog_get_l1addr(void)
		{
		acpi_handle handle;
		u64 ret;

		if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
		return false;

		if (extlog_get_dsm(handle, EXTLOG_DSM_REV, EXTLOG_FN_QUERY, &ret) \|\|
		!(ret & EXTLOG_QUERY_L1_EXIST))
		if (!acpi_check_dsm(handle, uuid, EXTLOG_DSM_REV, 1 << EXTLOG_FN_ADDR))
		return false;

		if (extlog_get_dsm(handle, EXTLOG_DSM_REV, EXTLOG_FN_ADDR, &ret))
		obj = acpi_evaluate_dsm_typed(handle, uuid, EXTLOG_DSM_REV,
		EXTLOG_FN_ADDR, NULL, ACPI_TYPE_INTEGER);
		if (!obj) {
		return false;
		} else {
		l1_dirbase = obj->integer.value;
		ACPI_FREE(obj);
		}

		l1_dirbase = ret;
		/* Spec says L1 directory must be 4K aligned, bail out if it isn't */
		if (l1_dirbase & ((1 << 12) - 1)) {
		pr_warn(FW_BUG "L1 Directory is invalid at physical %llx\n",

drivers/acpi/utils.c

+97 −0

Original line number	Diff line number	Diff line
		@@ -572,3 +572,100 @@ acpi_status acpi_evaluate_lck(acpi_handle handle, int lock)

		return status;
		}

		/**
		* acpi_evaluate_dsm - evaluate device's _DSM method
		* @handle: ACPI device handle
		* @uuid: UUID of requested functions, should be 16 bytes
		* @rev: revision number of requested function
		* @func: requested function number
		* @argv4: the function specific parameter
		*
		* Evaluate device's _DSM method with specified UUID, revision id and
		* function number. Caller needs to free the returned object.
		*
		* Though ACPI defines the fourth parameter for _DSM should be a package,
		* some old BIOSes do expect a buffer or an integer etc.
		*/
		union acpi_object *
		acpi_evaluate_dsm(acpi_handle handle, const u8 *uuid, int rev, int func,
		union acpi_object *argv4)
		{
		acpi_status ret;
		struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
		union acpi_object params[4];
		struct acpi_object_list input = {
		.count = 4,
		.pointer = params,
		};

		params[0].type = ACPI_TYPE_BUFFER;
		params[0].buffer.length = 16;
		params[0].buffer.pointer = (char *)uuid;
		params[1].type = ACPI_TYPE_INTEGER;
		params[1].integer.value = rev;
		params[2].type = ACPI_TYPE_INTEGER;
		params[2].integer.value = func;
		if (argv4) {
		params[3] = *argv4;
		} else {
		params[3].type = ACPI_TYPE_PACKAGE;
		params[3].package.count = 0;
		params[3].package.elements = NULL;
		}

		ret = acpi_evaluate_object(handle, "_DSM", &input, &buf);
		if (ACPI_SUCCESS(ret))
		return (union acpi_object *)buf.pointer;

		if (ret != AE_NOT_FOUND)
		acpi_handle_warn(handle,
		"failed to evaluate _DSM (0x%x)\n", ret);

		return NULL;
		}
		EXPORT_SYMBOL(acpi_evaluate_dsm);

		/**
		* acpi_check_dsm - check if _DSM method supports requested functions.
		* @handle: ACPI device handle
		* @uuid: UUID of requested functions, should be 16 bytes at least
		* @rev: revision number of requested functions
		* @funcs: bitmap of requested functions
		* @exclude: excluding special value, used to support i915 and nouveau
		*
		* Evaluate device's _DSM method to check whether it supports requested
		* functions. Currently only support 64 functions at maximum, should be
		* enough for now.
		*/
		bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, int rev, u64 funcs)
		{
		int i;
		u64 mask = 0;
		union acpi_object *obj;

		if (funcs == 0)
		return false;

		obj = acpi_evaluate_dsm(handle, uuid, rev, 0, NULL);
		if (!obj)
		return false;

		/* For compatibility, old BIOSes may return an integer */
		if (obj->type == ACPI_TYPE_INTEGER)
		mask = obj->integer.value;
		else if (obj->type == ACPI_TYPE_BUFFER)
		for (i = 0; i < obj->buffer.length && i < 8; i++)
		mask \|= (((u8)obj->buffer.pointer[i]) << (i * 8));
		ACPI_FREE(obj);

		/*
		* Bit 0 indicates whether there's support for any functions other than
		* function 0 for the specified UUID and revision.
		*/
		if ((mask & 0x1) && (mask & funcs) == funcs)
		return true;

		return false;
		}
		EXPORT_SYMBOL(acpi_check_dsm);

drivers/char/tpm/tpm_ppi.c

+142 −263

Original line number	Diff line number	Diff line
		#include <linux/acpi.h>
		#include "tpm.h"

		static const u8 tpm_ppi_uuid[] = {
		0xA6, 0xFA, 0xDD, 0x3D,
		0x1B, 0x36,
		0xB4, 0x4E,
		0xA4, 0x24,
		0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53
		};
		static char *tpm_device_name = "TPM";

		#define TPM_PPI_REVISION_ID 1
		#define TPM_PPI_FN_VERSION 1
		#define TPM_PPI_FN_SUBREQ 2
		@@ -23,250 +14,178 @@ static char *tpm_device_name = "TPM";
		#define PPI_VS_REQ_END 255
		#define PPI_VERSION_LEN 3

		static const u8 tpm_ppi_uuid[] = {
		0xA6, 0xFA, 0xDD, 0x3D,
		0x1B, 0x36,
		0xB4, 0x4E,
		0xA4, 0x24,
		0x8D, 0x10, 0x08, 0x9D, 0x16, 0x53
		};

		static char tpm_ppi_version[PPI_VERSION_LEN + 1];
		static acpi_handle tpm_ppi_handle;

		static acpi_status ppi_callback(acpi_handle handle, u32 level, void *context,
		void **return_value)
		{
		acpi_status status = AE_OK;
		struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object *obj;

		if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer))) {
		if (strstr(buffer.pointer, context) != NULL) {
		*return_value = handle;
		status = AE_CTRL_TERMINATE;
		}
		kfree(buffer.pointer);
		if (!acpi_check_dsm(handle, tpm_ppi_uuid, TPM_PPI_REVISION_ID,
		1 << TPM_PPI_FN_VERSION))
		return AE_OK;

		/* Cache version string */
		obj = acpi_evaluate_dsm_typed(handle, tpm_ppi_uuid,
		TPM_PPI_REVISION_ID, TPM_PPI_FN_VERSION,
		NULL, ACPI_TYPE_STRING);
		if (obj) {
		strlcpy(tpm_ppi_version, obj->string.pointer,
		PPI_VERSION_LEN + 1);
		ACPI_FREE(obj);
		}

		return status;
		*return_value = handle;

		return AE_CTRL_TERMINATE;
		}

		static inline void ppi_assign_params(union acpi_object params[4],
		u64 function_num)
		static inline union acpi_object *
		tpm_eval_dsm(int func, acpi_object_type type, union acpi_object *argv4)
		{
		params[0].type = ACPI_TYPE_BUFFER;
		params[0].buffer.length = sizeof(tpm_ppi_uuid);
		params[0].buffer.pointer = (char *)tpm_ppi_uuid;
		params[1].type = ACPI_TYPE_INTEGER;
		params[1].integer.value = TPM_PPI_REVISION_ID;
		params[2].type = ACPI_TYPE_INTEGER;
		params[2].integer.value = function_num;
		params[3].type = ACPI_TYPE_PACKAGE;
		params[3].package.count = 0;
		params[3].package.elements = NULL;
		BUG_ON(!tpm_ppi_handle);
		return acpi_evaluate_dsm_typed(tpm_ppi_handle, tpm_ppi_uuid,
		TPM_PPI_REVISION_ID, func, argv4, type);
		}

		static ssize_t tpm_show_ppi_version(struct device *dev,
		struct device_attribute attr, char buf)
		{
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		union acpi_object *obj;

		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_VERSION);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_STRING);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		obj = (union acpi_object *)output.pointer;
		status = scnprintf(buf, PAGE_SIZE, "%s\n", obj->string.pointer);
		kfree(output.pointer);
		return status;
		return scnprintf(buf, PAGE_SIZE, "%s\n", tpm_ppi_version);
		}

		static ssize_t tpm_show_ppi_request(struct device *dev,
		struct device_attribute attr, char buf)
		{
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		union acpi_object *ret_obj;

		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_GETREQ);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		ssize_t size = -EINVAL;
		union acpi_object *obj;

		obj = tpm_eval_dsm(TPM_PPI_FN_GETREQ, ACPI_TYPE_PACKAGE, NULL);
		if (!obj)
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_PACKAGE);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		/*
		* output.pointer should be of package type, including two integers.
		* The first is function return code, 0 means success and 1 means
		* error. The second is pending TPM operation requested by the OS, 0
		* means none and >0 means operation value.
		*/
		ret_obj = ((union acpi_object *)output.pointer)->package.elements;
		if (ret_obj->type == ACPI_TYPE_INTEGER) {
		if (ret_obj->integer.value) {
		status = -EFAULT;
		goto cleanup;
		}
		ret_obj++;
		if (ret_obj->type == ACPI_TYPE_INTEGER)
		status = scnprintf(buf, PAGE_SIZE, "%llu\n",
		ret_obj->integer.value);
		if (obj->package.count == 2 &&
		obj->package.elements[0].type == ACPI_TYPE_INTEGER &&
		obj->package.elements[1].type == ACPI_TYPE_INTEGER) {
		if (obj->package.elements[0].integer.value)
		size = -EFAULT;
		else
		status = -EINVAL;
		} else {
		status = -EINVAL;
		size = scnprintf(buf, PAGE_SIZE, "%llu\n",
		obj->package.elements[1].integer.value);
		}
		cleanup:
		kfree(output.pointer);
		return status;

		ACPI_FREE(obj);

		return size;
		}

		static ssize_t tpm_store_ppi_request(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
		{
		char version[PPI_VERSION_LEN + 1];
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		union acpi_object obj;
		u32 req;
		u64 ret;
		int func = TPM_PPI_FN_SUBREQ;
		union acpi_object *obj, tmp;
		union acpi_object argv4 = ACPI_INIT_DSM_ARGV4(1, &tmp);

		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_VERSION);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_STRING);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		strlcpy(version,
		((union acpi_object *)output.pointer)->string.pointer,
		PPI_VERSION_LEN + 1);
		kfree(output.pointer);
		output.length = ACPI_ALLOCATE_BUFFER;
		output.pointer = NULL;
		/*
		* the function to submit TPM operation request to pre-os environment
		* is updated with function index from SUBREQ to SUBREQ2 since PPI
		* version 1.1
		*/
		if (strcmp(version, "1.1") == -1)
		params[2].integer.value = TPM_PPI_FN_SUBREQ;
		else
		params[2].integer.value = TPM_PPI_FN_SUBREQ2;
		if (acpi_check_dsm(tpm_ppi_handle, tpm_ppi_uuid, TPM_PPI_REVISION_ID,
		1 << TPM_PPI_FN_SUBREQ2))
		func = TPM_PPI_FN_SUBREQ2;

		/*
		* PPI spec defines params[3].type as ACPI_TYPE_PACKAGE. Some BIOS
		* accept buffer/string/integer type, but some BIOS accept buffer/
		* string/package type. For PPI version 1.0 and 1.1, use buffer type
		* for compatibility, and use package type since 1.2 according to spec.
		*/
		if (strcmp(version, "1.2") == -1) {
		params[3].type = ACPI_TYPE_BUFFER;
		params[3].buffer.length = sizeof(req);
		sscanf(buf, "%d", &req);
		params[3].buffer.pointer = (char *)&req;
		if (strcmp(tpm_ppi_version, "1.2") < 0) {
		if (sscanf(buf, "%d", &req) != 1)
		return -EINVAL;
		argv4.type = ACPI_TYPE_BUFFER;
		argv4.buffer.length = sizeof(req);
		argv4.buffer.pointer = (u8 *)&req;
		} else {
		params[3].package.count = 1;
		obj.type = ACPI_TYPE_INTEGER;
		sscanf(buf, "%llu", &obj.integer.value);
		params[3].package.elements = &obj;
		tmp.type = ACPI_TYPE_INTEGER;
		if (sscanf(buf, "%llu", &tmp.integer.value) != 1)
		return -EINVAL;
		}

		obj = tpm_eval_dsm(func, ACPI_TYPE_INTEGER, &argv4);
		if (!obj) {
		return -ENXIO;
		} else {
		ret = obj->integer.value;
		ACPI_FREE(obj);
		}

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_INTEGER);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		ret = ((union acpi_object *)output.pointer)->integer.value;
		if (ret == 0)
		status = (acpi_status)count;
		else if (ret == 1)
		status = -EPERM;
		else
		status = -EFAULT;
		kfree(output.pointer);
		return status;
		return (acpi_status)count;

		return (ret == 1) ? -EPERM : -EFAULT;
		}

		static ssize_t tpm_show_ppi_transition_action(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		char version[PPI_VERSION_LEN + 1];
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		u32 ret;
		char *info[] = {
		acpi_status status;
		union acpi_object *obj = NULL;
		union acpi_object tmp = {
		.buffer.type = ACPI_TYPE_BUFFER,
		.buffer.length = 0,
		.buffer.pointer = NULL
		};

		static char *info[] = {
		"None",
		"Shutdown",
		"Reboot",
		"OS Vendor-specific",
		"Error",
		};
		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_VERSION);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_STRING);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		strlcpy(version,
		((union acpi_object *)output.pointer)->string.pointer,
		PPI_VERSION_LEN + 1);
		/*
		* PPI spec defines params[3].type as empty package, but some platforms
		* (e.g. Capella with PPI 1.0) need integer/string/buffer type, so for
		* compatibility, define params[3].type as buffer, if PPI version < 1.2
		*/
		if (strcmp(version, "1.2") == -1) {
		params[3].type = ACPI_TYPE_BUFFER;
		params[3].buffer.length = 0;
		params[3].buffer.pointer = NULL;
		if (strcmp(tpm_ppi_version, "1.2") < 0)
		obj = &tmp;
		obj = tpm_eval_dsm(TPM_PPI_FN_GETACT, ACPI_TYPE_INTEGER, obj);
		if (!obj) {
		return -ENXIO;
		} else {
		ret = obj->integer.value;
		ACPI_FREE(obj);
		}
		params[2].integer.value = TPM_PPI_FN_GETACT;
		kfree(output.pointer);
		output.length = ACPI_ALLOCATE_BUFFER;
		output.pointer = NULL;
		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_INTEGER);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		ret = ((union acpi_object *)output.pointer)->integer.value;

		if (ret < ARRAY_SIZE(info) - 1)
		status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret, info[ret]);
		else
		status = scnprintf(buf, PAGE_SIZE, "%d: %s\n", ret,
		info[ARRAY_SIZE(info)-1]);
		kfree(output.pointer);
		return status;
		}

		@@ -274,27 +193,14 @@ static ssize_t tpm_show_ppi_response(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		union acpi_object *ret_obj;
		u64 req;

		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_GETRSP);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		acpi_status status = -EINVAL;
		union acpi_object obj, ret_obj;
		u64 req, res;

		obj = tpm_eval_dsm(TPM_PPI_FN_GETRSP, ACPI_TYPE_PACKAGE, NULL);
		if (!obj)
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_PACKAGE);
		if (ACPI_FAILURE(status))
		return -ENOMEM;
		/*
		* parameter output.pointer should be of package type, including
		* 3 integers. The first means function return code, the second means
		@@ -302,115 +208,82 @@ static ssize_t tpm_show_ppi_response(struct device *dev,
		* the most recent TPM operation request. Only if the first is 0, and
		* the second integer is not 0, the response makes sense.
		*/
		ret_obj = ((union acpi_object *)output.pointer)->package.elements;
		if (ret_obj->type != ACPI_TYPE_INTEGER) {
		status = -EINVAL;
		ret_obj = obj->package.elements;
		if (obj->package.count < 3 \|\|
		ret_obj[0].type != ACPI_TYPE_INTEGER \|\|
		ret_obj[1].type != ACPI_TYPE_INTEGER \|\|
		ret_obj[2].type != ACPI_TYPE_INTEGER)
		goto cleanup;
		}
		if (ret_obj->integer.value) {

		if (ret_obj[0].integer.value) {
		status = -EFAULT;
		goto cleanup;
		}
		ret_obj++;
		if (ret_obj->type != ACPI_TYPE_INTEGER) {
		status = -EINVAL;
		goto cleanup;
		}
		if (ret_obj->integer.value) {
		req = ret_obj->integer.value;
		ret_obj++;
		if (ret_obj->type != ACPI_TYPE_INTEGER) {
		status = -EINVAL;
		goto cleanup;
		}
		if (ret_obj->integer.value == 0)

		req = ret_obj[1].integer.value;
		res = ret_obj[2].integer.value;
		if (req) {
		if (res == 0)
		status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
		"0: Success");
		else if (ret_obj->integer.value == 0xFFFFFFF0)
		else if (res == 0xFFFFFFF0)
		status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
		"0xFFFFFFF0: User Abort");
		else if (ret_obj->integer.value == 0xFFFFFFF1)
		else if (res == 0xFFFFFFF1)
		status = scnprintf(buf, PAGE_SIZE, "%llu %s\n", req,
		"0xFFFFFFF1: BIOS Failure");
		else if (ret_obj->integer.value >= 1 &&
		ret_obj->integer.value <= 0x00000FFF)
		else if (res >= 1 && res <= 0x00000FFF)
		status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
		req, ret_obj->integer.value,
		"Corresponding TPM error");
		req, res, "Corresponding TPM error");
		else
		status = scnprintf(buf, PAGE_SIZE, "%llu %llu: %s\n",
		req, ret_obj->integer.value,
		"Error");
		req, res, "Error");
		} else {
		status = scnprintf(buf, PAGE_SIZE, "%llu: %s\n",
		ret_obj->integer.value, "No Recent Request");
		req, "No Recent Request");
		}

		cleanup:
		kfree(output.pointer);
		ACPI_FREE(obj);
		return status;
		}

		static ssize_t show_ppi_operations(char *buf, u32 start, u32 end)
		{
		char *str = buf;
		char version[PPI_VERSION_LEN + 1];
		acpi_handle handle;
		acpi_status status;
		struct acpi_object_list input;
		struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object params[4];
		union acpi_object obj;
		int i;
		u32 ret;
		char *info[] = {
		char *str = buf;
		union acpi_object *obj, tmp;
		union acpi_object argv = ACPI_INIT_DSM_ARGV4(1, &tmp);

		static char *info[] = {
		"Not implemented",
		"BIOS only",
		"Blocked for OS by BIOS",
		"User required",
		"User not required",
		};
		input.count = 4;
		ppi_assign_params(params, TPM_PPI_FN_VERSION);
		input.pointer = params;
		status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
		ACPI_UINT32_MAX, ppi_callback, NULL,
		tpm_device_name, &handle);
		if (ACPI_FAILURE(status))
		return -ENXIO;

		status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output,
		ACPI_TYPE_STRING);
		if (ACPI_FAILURE(status))
		return -ENOMEM;

		strlcpy(version,
		((union acpi_object *)output.pointer)->string.pointer,
		PPI_VERSION_LEN + 1);
		kfree(output.pointer);
		output.length = ACPI_ALLOCATE_BUFFER;
		output.pointer = NULL;
		if (strcmp(version, "1.2") == -1)
		if (!acpi_check_dsm(tpm_ppi_handle, tpm_ppi_uuid, TPM_PPI_REVISION_ID,
		1 << TPM_PPI_FN_GETOPR))
		return -EPERM;

		params[2].integer.value = TPM_PPI_FN_GETOPR;
		params[3].package.count = 1;
		obj.type = ACPI_TYPE_INTEGER;
		params[3].package.elements = &obj;
		tmp.integer.type = ACPI_TYPE_INTEGER;
		for (i = start; i <= end; i++) {
		obj.integer.value = i;
		status = acpi_evaluate_object_typed(handle, "_DSM",
		&input, &output, ACPI_TYPE_INTEGER);
		if (ACPI_FAILURE(status))
		tmp.integer.value = i;
		obj = tpm_eval_dsm(TPM_PPI_FN_GETOPR, ACPI_TYPE_INTEGER, &argv);
		if (!obj) {
		return -ENOMEM;
		} else {
		ret = obj->integer.value;
		ACPI_FREE(obj);
		}

		ret = ((union acpi_object *)output.pointer)->integer.value;
		if (ret > 0 && ret < ARRAY_SIZE(info))
		str += scnprintf(str, PAGE_SIZE, "%d %d: %s\n",
		i, ret, info[ret]);
		kfree(output.pointer);
		output.length = ACPI_ALLOCATE_BUFFER;
		output.pointer = NULL;
		}

		return str - buf;
		}

		@@ -452,6 +325,12 @@ static struct attribute_group ppi_attr_grp = {

		int tpm_add_ppi(struct kobject *parent)
		{
		/* Cache TPM ACPI handle and version string */
		acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
		ppi_callback, NULL, NULL, &tpm_ppi_handle);
		if (tpm_ppi_handle == NULL)
		return -ENODEV;

		return sysfs_create_group(parent, &ppi_attr_grp);
		}

drivers/gpu/drm/i915/intel_acpi.c

+30 −114

File changed.

Preview size limit exceeded, changes collapsed.

drivers/gpu/drm/nouveau/core/subdev/mxm/base.c

+16 −32

Original line number	Diff line number	Diff line
		@@ -87,55 +87,39 @@ mxm_shadow_dsm(struct nouveau_mxm *mxm, u8 version)
		0xB8, 0x9C, 0x79, 0xB6, 0x2F, 0xD5, 0x56, 0x65
		};
		u32 mxms_args[] = { 0x00000000 };
		union acpi_object args[4] = {
		/* _DSM MUID */
		{ .buffer.type = 3,
		.buffer.length = sizeof(muid),
		.buffer.pointer = muid,
		},
		/* spec says this can be zero to mean "highest revision", but
		* of course there's at least one bios out there which fails
		* unless you pass in exactly the version it supports..
		*/
		{ .integer.type = ACPI_TYPE_INTEGER,
		.integer.value = (version & 0xf0) << 4 \| (version & 0x0f),
		},
		/* MXMS function */
		{ .integer.type = ACPI_TYPE_INTEGER,
		.integer.value = 0x00000010,
		},
		/* Pointer to MXMS arguments */
		{ .buffer.type = ACPI_TYPE_BUFFER,
		union acpi_object argv4 = {
		.buffer.type = ACPI_TYPE_BUFFER,
		.buffer.length = sizeof(mxms_args),
		.buffer.pointer = (char *)mxms_args,
		},
		};
		struct acpi_object_list list = { ARRAY_SIZE(args), args };
		struct acpi_buffer retn = { ACPI_ALLOCATE_BUFFER, NULL };
		union acpi_object *obj;
		acpi_handle handle;
		int ret;
		int rev;

		handle = ACPI_HANDLE(&device->pdev->dev);
		if (!handle)
		return false;

		ret = acpi_evaluate_object(handle, "_DSM", &list, &retn);
		if (ret) {
		nv_debug(mxm, "DSM MXMS failed: %d\n", ret);
		/*
		* spec says this can be zero to mean "highest revision", but
		* of course there's at least one bios out there which fails
		* unless you pass in exactly the version it supports..
		*/
		rev = (version & 0xf0) << 4 \| (version & 0x0f);
		obj = acpi_evaluate_dsm(handle, muid, rev, 0x00000010, &argv4);
		if (!obj) {
		nv_debug(mxm, "DSM MXMS failed\n");
		return false;
		}

		obj = retn.pointer;
		if (obj->type == ACPI_TYPE_BUFFER) {
		mxm->mxms = kmemdup(obj->buffer.pointer,
		obj->buffer.length, GFP_KERNEL);
		} else
		if (obj->type == ACPI_TYPE_INTEGER) {
		} else if (obj->type == ACPI_TYPE_INTEGER) {
		nv_debug(mxm, "DSM MXMS returned 0x%llx\n", obj->integer.value);
		}

		kfree(obj);
		ACPI_FREE(obj);
		return mxm->mxms != NULL;
		}
		#endif