[deliverable/linux.git] / drivers / acpi / property.c

/*
 * ACPI device specific properties support.
 *
 * Copyright (C) 2014, Intel Corporation
 * All rights reserved.
 *
 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
 *          Darren Hart <dvhart@linux.intel.com>
 *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

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

#include "internal.h"

/* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
static const u8 prp_uuid[16] = {
	0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
	0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
};

static bool acpi_property_value_ok(const union acpi_object *value)
{
	int j;

	/*
	 * The value must be an integer, a string, a reference, or a package
	 * whose every element must be an integer, a string, or a reference.
	 */
	switch (value->type) {
	case ACPI_TYPE_INTEGER:
	case ACPI_TYPE_STRING:
	case ACPI_TYPE_LOCAL_REFERENCE:
		return true;

	case ACPI_TYPE_PACKAGE:
		for (j = 0; j < value->package.count; j++)
			switch (value->package.elements[j].type) {
			case ACPI_TYPE_INTEGER:
			case ACPI_TYPE_STRING:
			case ACPI_TYPE_LOCAL_REFERENCE:
				continue;

			default:
				return false;
			}

		return true;
	}
	return false;
}

static bool acpi_properties_format_valid(const union acpi_object *properties)
{
	int i;

	for (i = 0; i < properties->package.count; i++) {
		const union acpi_object *property;

		property = &properties->package.elements[i];
		/*
		 * Only two elements allowed, the first one must be a string and
		 * the second one has to satisfy certain conditions.
		 */
		if (property->package.count != 2
		    || property->package.elements[0].type != ACPI_TYPE_STRING
		    || !acpi_property_value_ok(&property->package.elements[1]))
			return false;
	}
	return true;
}

static void acpi_init_of_compatible(struct acpi_device *adev)
{
	const union acpi_object *of_compatible;
	int ret;

	ret = acpi_dev_get_property_array(adev, "compatible", ACPI_TYPE_STRING,
					  &of_compatible);
	if (ret) {
		ret = acpi_dev_get_property(adev, "compatible",
					    ACPI_TYPE_STRING, &of_compatible);
		if (ret) {
			if (adev->parent
			    && adev->parent->flags.of_compatible_ok)
				goto out;

			return;
		}
	}
	adev->data.of_compatible = of_compatible;

 out:
	adev->flags.of_compatible_ok = 1;
}

void acpi_init_properties(struct acpi_device *adev)
{
	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
	bool acpi_of = false;
	struct acpi_hardware_id *hwid;
	const union acpi_object *desc;
	acpi_status status;
	int i;

	/*
	 * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
	 * Device Tree compatible properties for this device.
	 */
	list_for_each_entry(hwid, &adev->pnp.ids, list) {
		if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
			acpi_of = true;
			break;
		}
	}

	status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
					    ACPI_TYPE_PACKAGE);
	if (ACPI_FAILURE(status))
		goto out;

	desc = buf.pointer;
	if (desc->package.count % 2)
		goto fail;

	/* Look for the device properties UUID. */
	for (i = 0; i < desc->package.count; i += 2) {
		const union acpi_object *uuid, *properties;

		uuid = &desc->package.elements[i];
		properties = &desc->package.elements[i + 1];

		/*
		 * The first element must be a UUID and the second one must be
		 * a package.
		 */
		if (uuid->type != ACPI_TYPE_BUFFER || uuid->buffer.length != 16
		    || properties->type != ACPI_TYPE_PACKAGE)
			break;

		if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
			continue;

		/*
		 * We found the matching UUID. Now validate the format of the
		 * package immediately following it.
		 */
		if (!acpi_properties_format_valid(properties))
			break;

		adev->data.pointer = buf.pointer;
		adev->data.properties = properties;

		if (acpi_of)
			acpi_init_of_compatible(adev);

		goto out;
	}

 fail:
	dev_dbg(&adev->dev, "Returned _DSD data is not valid, skipping\n");
	ACPI_FREE(buf.pointer);

 out:
	if (acpi_of && !adev->flags.of_compatible_ok)
		acpi_handle_info(adev->handle,
			 ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
}

void acpi_free_properties(struct acpi_device *adev)
{
	ACPI_FREE((void *)adev->data.pointer);
	adev->data.of_compatible = NULL;
	adev->data.pointer = NULL;
	adev->data.properties = NULL;
}

/**
 * acpi_dev_get_property - return an ACPI property with given name
 * @adev: ACPI device to get property
 * @name: Name of the property
 * @type: Expected property type
 * @obj: Location to store the property value (if not %NULL)
 *
 * Look up a property with @name and store a pointer to the resulting ACPI
 * object at the location pointed to by @obj if found.
 *
 * Callers must not attempt to free the returned objects.  These objects will be
 * freed by the ACPI core automatically during the removal of @adev.
 *
 * Return: %0 if property with @name has been found (success),
 *         %-EINVAL if the arguments are invalid,
 *         %-ENODATA if the property doesn't exist,
 *         %-EPROTO if the property value type doesn't match @type.
 */
int acpi_dev_get_property(struct acpi_device *adev, const char *name,
			  acpi_object_type type, const union acpi_object **obj)
{
	const union acpi_object *properties;
	int i;

	if (!adev || !name)
		return -EINVAL;

	if (!adev->data.pointer || !adev->data.properties)
		return -ENODATA;

	properties = adev->data.properties;
	for (i = 0; i < properties->package.count; i++) {
		const union acpi_object *propname, *propvalue;
		const union acpi_object *property;

		property = &properties->package.elements[i];

		propname = &property->package.elements[0];
		propvalue = &property->package.elements[1];

		if (!strcmp(name, propname->string.pointer)) {
			if (type != ACPI_TYPE_ANY && propvalue->type != type)
				return -EPROTO;
			else if (obj)
				*obj = propvalue;

			return 0;
		}
	}
	return -ENODATA;
}
EXPORT_SYMBOL_GPL(acpi_dev_get_property);

/**
 * acpi_dev_get_property_array - return an ACPI array property with given name
 * @adev: ACPI device to get property
 * @name: Name of the property
 * @type: Expected type of array elements
 * @obj: Location to store a pointer to the property value (if not NULL)
 *
 * Look up an array property with @name and store a pointer to the resulting
 * ACPI object at the location pointed to by @obj if found.
 *
 * Callers must not attempt to free the returned objects.  Those objects will be
 * freed by the ACPI core automatically during the removal of @adev.
 *
 * Return: %0 if array property (package) with @name has been found (success),
 *         %-EINVAL if the arguments are invalid,
 *         %-ENODATA if the property doesn't exist,
 *         %-EPROTO if the property is not a package or the type of its elements
 *           doesn't match @type.
 */
int acpi_dev_get_property_array(struct acpi_device *adev, const char *name,
				acpi_object_type type,
				const union acpi_object **obj)
{
	const union acpi_object *prop;
	int ret, i;

	ret = acpi_dev_get_property(adev, name, ACPI_TYPE_PACKAGE, &prop);
	if (ret)
		return ret;

	if (type != ACPI_TYPE_ANY) {
		/* Check that all elements are of correct type. */
		for (i = 0; i < prop->package.count; i++)
			if (prop->package.elements[i].type != type)
				return -EPROTO;
	}
	if (obj)
		*obj = prop;

	return 0;
}
EXPORT_SYMBOL_GPL(acpi_dev_get_property_array);

/**
 * acpi_dev_get_property_reference - returns handle to the referenced object
 * @adev: ACPI device to get property
 * @name: Name of the property
 * @index: Index of the reference to return
 * @args: Location to store the returned reference with optional arguments
 *
 * Find property with @name, verifify that it is a package containing at least
 * one object reference and if so, store the ACPI device object pointer to the
 * target object in @args->adev.  If the reference includes arguments, store
 * them in the @args->args[] array.
 *
 * If there's more than one reference in the property value package, @index is
 * used to select the one to return.
 *
 * Return: %0 on success, negative error code on failure.
 */
int acpi_dev_get_property_reference(struct acpi_device *adev,
				    const char *name, size_t index,
				    struct acpi_reference_args *args)
{
	const union acpi_object *element, *end;
	const union acpi_object *obj;
	struct acpi_device *device;
	int ret, idx = 0;

	ret = acpi_dev_get_property(adev, name, ACPI_TYPE_ANY, &obj);
	if (ret)
		return ret;

	/*
	 * The simplest case is when the value is a single reference.  Just
	 * return that reference then.
	 */
	if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
		if (index)
			return -EINVAL;

		ret = acpi_bus_get_device(obj->reference.handle, &device);
		if (ret)
			return ret;

		args->adev = device;
		args->nargs = 0;
		return 0;
	}

	/*
	 * If it is not a single reference, then it is a package of
	 * references followed by number of ints as follows:
	 *
	 *  Package () { REF, INT, REF, INT, INT }
	 *
	 * The index argument is then used to determine which reference
	 * the caller wants (along with the arguments).
	 */
	if (obj->type != ACPI_TYPE_PACKAGE || index >= obj->package.count)
		return -EPROTO;

	element = obj->package.elements;
	end = element + obj->package.count;

	while (element < end) {
		u32 nargs, i;

		if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
			return -EPROTO;

		ret = acpi_bus_get_device(element->reference.handle, &device);
		if (ret)
			return -ENODEV;

		element++;
		nargs = 0;

		/* assume following integer elements are all args */
		for (i = 0; element + i < end; i++) {
			int type = element[i].type;

			if (type == ACPI_TYPE_INTEGER)
				nargs++;
			else if (type == ACPI_TYPE_LOCAL_REFERENCE)
				break;
			else
				return -EPROTO;
		}

		if (idx++ == index) {
			args->adev = device;
			args->nargs = nargs;
			for (i = 0; i < nargs; i++)
				args->args[i] = element[i].integer.value;

			return 0;
		}

		element += nargs;
	}

	return -EPROTO;
}
EXPORT_SYMBOL_GPL(acpi_dev_get_property_reference);

int acpi_dev_prop_get(struct acpi_device *adev, const char *propname,
		      void **valptr)
{
	return acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
				     (const union acpi_object **)valptr);
}

int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
			      enum dev_prop_type proptype, void *val)
{
	const union acpi_object *obj;
	int ret;

	if (!val)
		return -EINVAL;

	if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
		ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_INTEGER, &obj);
		if (ret)
			return ret;

		switch (proptype) {
		case DEV_PROP_U8:
			if (obj->integer.value > U8_MAX)
				return -EOVERFLOW;
			*(u8 *)val = obj->integer.value;
			break;
		case DEV_PROP_U16:
			if (obj->integer.value > U16_MAX)
				return -EOVERFLOW;
			*(u16 *)val = obj->integer.value;
			break;
		case DEV_PROP_U32:
			if (obj->integer.value > U32_MAX)
				return -EOVERFLOW;
			*(u32 *)val = obj->integer.value;
			break;
		default:
			*(u64 *)val = obj->integer.value;
			break;
		}
	} else if (proptype == DEV_PROP_STRING) {
		ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_STRING, &obj);
		if (ret)
			return ret;

		*(char **)val = obj->string.pointer;
	} else {
		ret = -EINVAL;
	}
	return ret;
}

static int acpi_copy_property_array_u8(const union acpi_object *items, u8 *val,
				       size_t nval)
{
	int i;

	for (i = 0; i < nval; i++) {
		if (items[i].type != ACPI_TYPE_INTEGER)
			return -EPROTO;
		if (items[i].integer.value > U8_MAX)
			return -EOVERFLOW;

		val[i] = items[i].integer.value;
	}
	return 0;
}

static int acpi_copy_property_array_u16(const union acpi_object *items,
					u16 *val, size_t nval)
{
	int i;

	for (i = 0; i < nval; i++) {
		if (items[i].type != ACPI_TYPE_INTEGER)
			return -EPROTO;
		if (items[i].integer.value > U16_MAX)
			return -EOVERFLOW;

		val[i] = items[i].integer.value;
	}
	return 0;
}

static int acpi_copy_property_array_u32(const union acpi_object *items,
					u32 *val, size_t nval)
{
	int i;

	for (i = 0; i < nval; i++) {
		if (items[i].type != ACPI_TYPE_INTEGER)
			return -EPROTO;
		if (items[i].integer.value > U32_MAX)
			return -EOVERFLOW;

		val[i] = items[i].integer.value;
	}
	return 0;
}

static int acpi_copy_property_array_u64(const union acpi_object *items,
					u64 *val, size_t nval)
{
	int i;

	for (i = 0; i < nval; i++) {
		if (items[i].type != ACPI_TYPE_INTEGER)
			return -EPROTO;

		val[i] = items[i].integer.value;
	}
	return 0;
}

static int acpi_copy_property_array_string(const union acpi_object *items,
					   char **val, size_t nval)
{
	int i;

	for (i = 0; i < nval; i++) {
		if (items[i].type != ACPI_TYPE_STRING)
			return -EPROTO;

		val[i] = items[i].string.pointer;
	}
	return 0;
}

int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
		       enum dev_prop_type proptype, void *val, size_t nval)
{
	const union acpi_object *obj;
	const union acpi_object *items;
	int ret;

	if (val && nval == 1) {
		ret = acpi_dev_prop_read_single(adev, propname, proptype, val);
		if (!ret)
			return ret;
	}

	ret = acpi_dev_get_property_array(adev, propname, ACPI_TYPE_ANY, &obj);
	if (ret)
		return ret;

	if (!val)
		return obj->package.count;
	else if (nval <= 0)
		return -EINVAL;

	if (nval > obj->package.count)
		return -EOVERFLOW;

	items = obj->package.elements;
	switch (proptype) {
	case DEV_PROP_U8:
		ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
		break;
	case DEV_PROP_U16:
		ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
		break;
	case DEV_PROP_U32:
		ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
		break;
	case DEV_PROP_U64:
		ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
		break;
	case DEV_PROP_STRING:
		ret = acpi_copy_property_array_string(items, (char **)val, nval);
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}
Commit	Line	Data
ffdcd955 MW	1	/*
	2	* ACPI device specific properties support.
	3	*
	4	* Copyright (C) 2014, Intel Corporation
	5	* All rights reserved.
	6	*
	7	* Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
	8	* Darren Hart <dvhart@linux.intel.com>
	9	* Rafael J. Wysocki <rafael.j.wysocki@intel.com>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15
	16	#include <linux/acpi.h>
	17	#include <linux/device.h>
	18	#include <linux/export.h>
	19
	20	#include "internal.h"
	21
	22	/* ACPI _DSD device properties UUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
	23	static const u8 prp_uuid[16] = {
	24	0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
	25	0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
	26	};
	27
	28	static bool acpi_property_value_ok(const union acpi_object *value)
	29	{
	30	int j;
	31
	32	/*
	33	* The value must be an integer, a string, a reference, or a package
	34	* whose every element must be an integer, a string, or a reference.
	35	*/
	36	switch (value->type) {
	37	case ACPI_TYPE_INTEGER:
	38	case ACPI_TYPE_STRING:
	39	case ACPI_TYPE_LOCAL_REFERENCE:
	40	return true;
	41
	42	case ACPI_TYPE_PACKAGE:
	43	for (j = 0; j < value->package.count; j++)
	44	switch (value->package.elements[j].type) {
	45	case ACPI_TYPE_INTEGER:
	46	case ACPI_TYPE_STRING:
	47	case ACPI_TYPE_LOCAL_REFERENCE:
	48	continue;
	49
	50	default:
	51	return false;
	52	}
	53
	54	return true;
	55	}
	56	return false;
	57	}
	58
	59	static bool acpi_properties_format_valid(const union acpi_object *properties)
	60	{
	61	int i;
	62
	63	for (i = 0; i < properties->package.count; i++) {
	64	const union acpi_object *property;
65
66	property = &properties->package.elements[i];
67	/*
68	* Only two elements allowed, the first one must be a string and
69	* the second one has to satisfy certain conditions.
70	*/
71	if (property->package.count != 2
72	\|\| property->package.elements[0].type != ACPI_TYPE_STRING
73	\|\| !acpi_property_value_ok(&property->package.elements[1]))
74	return false;
75	}
76	return true;
77	}
78
733e6251 MW	79	static void acpi_init_of_compatible(struct acpi_device *adev)
	80	{
	81	const union acpi_object *of_compatible;
733e6251 MW	82	int ret;
733e6251 MW	83
733e6251 MW	84	ret = acpi_dev_get_property_array(adev, "compatible", ACPI_TYPE_STRING,
	85	&of_compatible);
	86	if (ret) {
	87	ret = acpi_dev_get_property(adev, "compatible",
	88	ACPI_TYPE_STRING, &of_compatible);
	89	if (ret) {
5c53b262 RW	90	if (adev->parent
	91	&& adev->parent->flags.of_compatible_ok)
	92	goto out;
	93
733e6251 MW	94	return;
	95	}
	96	}
	97	adev->data.of_compatible = of_compatible;
5c53b262 RW	98
	99	out:
	100	adev->flags.of_compatible_ok = 1;
733e6251 MW	101	}
733e6251 MW	102
ffdcd955 MW	103	void acpi_init_properties(struct acpi_device *adev)
	104	{
	105	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
5c53b262 RW	106	bool acpi_of = false;
5c53b262 RW	107	struct acpi_hardware_id *hwid;
ffdcd955 MW	108	const union acpi_object *desc;
	109	acpi_status status;
	110	int i;
	111
5c53b262	112	/*
ee892094 RW	113	* Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
ee892094 RW	114	* Device Tree compatible properties for this device.
5c53b262 RW	115	*/
5c53b262 RW	116	list_for_each_entry(hwid, &adev->pnp.ids, list) {
ee892094	117	if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
5c53b262 RW	118	acpi_of = true;
	119	break;
	120	}
	121	}
	122
ffdcd955 MW	123	status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
	124	ACPI_TYPE_PACKAGE);
	125	if (ACPI_FAILURE(status))
5c53b262	126	goto out;
ffdcd955 MW	127
	128	desc = buf.pointer;
	129	if (desc->package.count % 2)
	130	goto fail;
	131
	132	/* Look for the device properties UUID. */
	133	for (i = 0; i < desc->package.count; i += 2) {
	134	const union acpi_object uuid, properties;
	135
	136	uuid = &desc->package.elements[i];
	137	properties = &desc->package.elements[i + 1];
	138
	139	/*
	140	* The first element must be a UUID and the second one must be
	141	* a package.
	142	*/
	143	if (uuid->type != ACPI_TYPE_BUFFER \|\| uuid->buffer.length != 16
	144	\|\| properties->type != ACPI_TYPE_PACKAGE)
	145	break;
	146
	147	if (memcmp(uuid->buffer.pointer, prp_uuid, sizeof(prp_uuid)))
	148	continue;
	149
	150	/*
	151	* We found the matching UUID. Now validate the format of the
	152	* package immediately following it.
	153	*/
	154	if (!acpi_properties_format_valid(properties))
	155	break;
	156
	157	adev->data.pointer = buf.pointer;
	158	adev->data.properties = properties;
733e6251	159
5c53b262 RW	160	if (acpi_of)
	161	acpi_init_of_compatible(adev);
	162
	163	goto out;
ffdcd955 MW	164	}
	165
	166	fail:
5c53b262	167	dev_dbg(&adev->dev, "Returned _DSD data is not valid, skipping\n");
ffdcd955	168	ACPI_FREE(buf.pointer);
5c53b262 RW	169
	170	out:
	171	if (acpi_of && !adev->flags.of_compatible_ok)
	172	acpi_handle_info(adev->handle,
ee892094	173	ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
ffdcd955 MW	174	}
	175
	176	void acpi_free_properties(struct acpi_device *adev)
	177	{
	178	ACPI_FREE((void *)adev->data.pointer);
733e6251	179	adev->data.of_compatible = NULL;
ffdcd955 MW	180	adev->data.pointer = NULL;
	181	adev->data.properties = NULL;
	182	}
	183
	184	/**
	185	* acpi_dev_get_property - return an ACPI property with given name
	186	* @adev: ACPI device to get property
	187	* @name: Name of the property
	188	* @type: Expected property type
	189	* @obj: Location to store the property value (if not %NULL)
	190	*
	191	* Look up a property with @name and store a pointer to the resulting ACPI
	192	* object at the location pointed to by @obj if found.
	193	*
	194	* Callers must not attempt to free the returned objects. These objects will be
	195	* freed by the ACPI core automatically during the removal of @adev.
	196	*
	197	* Return: %0 if property with @name has been found (success),
	198	* %-EINVAL if the arguments are invalid,
	199	* %-ENODATA if the property doesn't exist,
	200	* %-EPROTO if the property value type doesn't match @type.
	201	*/
	202	int acpi_dev_get_property(struct acpi_device adev, const char name,
	203	acpi_object_type type, const union acpi_object **obj)
	204	{
	205	const union acpi_object *properties;
	206	int i;
	207
	208	if (!adev \|\| !name)
	209	return -EINVAL;
	210
	211	if (!adev->data.pointer \|\| !adev->data.properties)
	212	return -ENODATA;
	213
	214	properties = adev->data.properties;
	215	for (i = 0; i < properties->package.count; i++) {
	216	const union acpi_object propname, propvalue;
	217	const union acpi_object *property;
	218
	219	property = &properties->package.elements[i];
	220
	221	propname = &property->package.elements[0];
	222	propvalue = &property->package.elements[1];
	223
	224	if (!strcmp(name, propname->string.pointer)) {
	225	if (type != ACPI_TYPE_ANY && propvalue->type != type)
	226	return -EPROTO;
	227	else if (obj)
	228	*obj = propvalue;
	229
	230	return 0;
	231	}
	232	}
	233	return -ENODATA;
	234	}
	235	EXPORT_SYMBOL_GPL(acpi_dev_get_property);
	236
	237	/**
	238	* acpi_dev_get_property_array - return an ACPI array property with given name
	239	* @adev: ACPI device to get property
	240	* @name: Name of the property
	241	* @type: Expected type of array elements
	242	* @obj: Location to store a pointer to the property value (if not NULL)
	243	*
244	* Look up an array property with @name and store a pointer to the resulting
245	* ACPI object at the location pointed to by @obj if found.
246	*
247	* Callers must not attempt to free the returned objects. Those objects will be
248	* freed by the ACPI core automatically during the removal of @adev.
249	*
250	* Return: %0 if array property (package) with @name has been found (success),
251	* %-EINVAL if the arguments are invalid,
252	* %-ENODATA if the property doesn't exist,
253	* %-EPROTO if the property is not a package or the type of its elements
254	* doesn't match @type.
255	*/
256	int acpi_dev_get_property_array(struct acpi_device adev, const char name,
257	acpi_object_type type,
258	const union acpi_object **obj)
259	{
260	const union acpi_object *prop;
261	int ret, i;
262
263	ret = acpi_dev_get_property(adev, name, ACPI_TYPE_PACKAGE, &prop);
264	if (ret)
265	return ret;
266
267	if (type != ACPI_TYPE_ANY) {
268	/* Check that all elements are of correct type. */
269	for (i = 0; i < prop->package.count; i++)
270	if (prop->package.elements[i].type != type)
271	return -EPROTO;
272	}
273	if (obj)
274	*obj = prop;
275
276	return 0;
277	}
278	EXPORT_SYMBOL_GPL(acpi_dev_get_property_array);
279
280	/**
281	* acpi_dev_get_property_reference - returns handle to the referenced object
282	* @adev: ACPI device to get property
283	* @name: Name of the property
ffdcd955 MW	284	* @index: Index of the reference to return
	285	* @args: Location to store the returned reference with optional arguments
	286	*
	287	* Find property with @name, verifify that it is a package containing at least
	288	* one object reference and if so, store the ACPI device object pointer to the
60ba032e RW	289	* target object in @args->adev. If the reference includes arguments, store
60ba032e RW	290	* them in the @args->args[] array.
ffdcd955	291	*
60ba032e RW	292	* If there's more than one reference in the property value package, @index is
60ba032e RW	293	* used to select the one to return.
ffdcd955 MW	294	*
	295	* Return: %0 on success, negative error code on failure.
	296	*/
60ba032e RW	297	int acpi_dev_get_property_reference(struct acpi_device *adev,
60ba032e RW	298	const char *name, size_t index,
ffdcd955 MW	299	struct acpi_reference_args *args)
	300	{
	301	const union acpi_object element, end;
	302	const union acpi_object *obj;
	303	struct acpi_device *device;
	304	int ret, idx = 0;
	305
	306	ret = acpi_dev_get_property(adev, name, ACPI_TYPE_ANY, &obj);
	307	if (ret)
	308	return ret;
	309
	310	/*
	311	* The simplest case is when the value is a single reference. Just
	312	* return that reference then.
	313	*/
	314	if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) {
60ba032e	315	if (index)
ffdcd955 MW	316	return -EINVAL;
	317
	318	ret = acpi_bus_get_device(obj->reference.handle, &device);
	319	if (ret)
	320	return ret;
	321
	322	args->adev = device;
	323	args->nargs = 0;
	324	return 0;
	325	}
	326
	327	/*
	328	* If it is not a single reference, then it is a package of
	329	* references followed by number of ints as follows:
	330	*
	331	* Package () { REF, INT, REF, INT, INT }
	332	*
	333	* The index argument is then used to determine which reference
	334	* the caller wants (along with the arguments).
	335	*/
	336	if (obj->type != ACPI_TYPE_PACKAGE \|\| index >= obj->package.count)
	337	return -EPROTO;
	338
	339	element = obj->package.elements;
	340	end = element + obj->package.count;
	341
	342	while (element < end) {
	343	u32 nargs, i;
	344
	345	if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
	346	return -EPROTO;
	347
	348	ret = acpi_bus_get_device(element->reference.handle, &device);
	349	if (ret)
	350	return -ENODEV;
	351
	352	element++;
	353	nargs = 0;
	354
60ba032e RW	355	/* assume following integer elements are all args */
	356	for (i = 0; element + i < end; i++) {
	357	int type = element[i].type;
ffdcd955	358
60ba032e RW	359	if (type == ACPI_TYPE_INTEGER)
	360	nargs++;
	361	else if (type == ACPI_TYPE_LOCAL_REFERENCE)
	362	break;
	363	else
	364	return -EPROTO;
ffdcd955 MW	365	}
	366
	367	if (idx++ == index) {
	368	args->adev = device;
	369	args->nargs = nargs;
	370	for (i = 0; i < nargs; i++)
	371	args->args[i] = element[i].integer.value;
	372
	373	return 0;
	374	}
	375
	376	element += nargs;
	377	}
	378
	379	return -EPROTO;
	380	}
	381	EXPORT_SYMBOL_GPL(acpi_dev_get_property_reference);
b31384fa RW	382
	383	int acpi_dev_prop_get(struct acpi_device adev, const char propname,
	384	void **valptr)
	385	{
	386	return acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
	387	(const union acpi_object **)valptr);
	388	}
	389
	390	int acpi_dev_prop_read_single(struct acpi_device adev, const char propname,
	391	enum dev_prop_type proptype, void *val)
	392	{
	393	const union acpi_object *obj;
	394	int ret;
	395
	396	if (!val)
	397	return -EINVAL;
	398
	399	if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
	400	ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_INTEGER, &obj);
	401	if (ret)
	402	return ret;
	403
	404	switch (proptype) {
	405	case DEV_PROP_U8:
	406	if (obj->integer.value > U8_MAX)
	407	return -EOVERFLOW;
	408	(u8 )val = obj->integer.value;
	409	break;
	410	case DEV_PROP_U16:
	411	if (obj->integer.value > U16_MAX)
	412	return -EOVERFLOW;
	413	(u16 )val = obj->integer.value;
	414	break;
	415	case DEV_PROP_U32:
	416	if (obj->integer.value > U32_MAX)
	417	return -EOVERFLOW;
	418	(u32 )val = obj->integer.value;
	419	break;
	420	default:
	421	(u64 )val = obj->integer.value;
	422	break;
	423	}
	424	} else if (proptype == DEV_PROP_STRING) {
	425	ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_STRING, &obj);
	426	if (ret)
	427	return ret;
	428
	429	(char *)val = obj->string.pointer;
	430	} else {
	431	ret = -EINVAL;
	432	}
	433	return ret;
	434	}
	435
	436	static int acpi_copy_property_array_u8(const union acpi_object items, u8 val,
	437	size_t nval)
	438	{
	439	int i;
	440
	441	for (i = 0; i < nval; i++) {
	442	if (items[i].type != ACPI_TYPE_INTEGER)
	443	return -EPROTO;
	444	if (items[i].integer.value > U8_MAX)
	445	return -EOVERFLOW;
446
447	val[i] = items[i].integer.value;
448	}
449	return 0;
450	}
451
452	static int acpi_copy_property_array_u16(const union acpi_object *items,
453	u16 *val, size_t nval)
454	{
455	int i;
456
457	for (i = 0; i < nval; i++) {
458	if (items[i].type != ACPI_TYPE_INTEGER)
459	return -EPROTO;
460	if (items[i].integer.value > U16_MAX)
461	return -EOVERFLOW;
462
463	val[i] = items[i].integer.value;
464	}
465	return 0;
466	}
467
468	static int acpi_copy_property_array_u32(const union acpi_object *items,
469	u32 *val, size_t nval)
470	{
471	int i;
472
473	for (i = 0; i < nval; i++) {
474	if (items[i].type != ACPI_TYPE_INTEGER)
475	return -EPROTO;
476	if (items[i].integer.value > U32_MAX)
477	return -EOVERFLOW;
478
479	val[i] = items[i].integer.value;
480	}
481	return 0;
482	}
483
484	static int acpi_copy_property_array_u64(const union acpi_object *items,
485	u64 *val, size_t nval)
486	{
487	int i;
488
489	for (i = 0; i < nval; i++) {
490	if (items[i].type != ACPI_TYPE_INTEGER)
491	return -EPROTO;
492
493	val[i] = items[i].integer.value;
494	}
495	return 0;
496	}
497
498	static int acpi_copy_property_array_string(const union acpi_object *items,
499	char **val, size_t nval)
500	{
501	int i;
502
503	for (i = 0; i < nval; i++) {
504	if (items[i].type != ACPI_TYPE_STRING)
505	return -EPROTO;
506
507	val[i] = items[i].string.pointer;
508	}
509	return 0;
510	}
511
512	int acpi_dev_prop_read(struct acpi_device adev, const char propname,
513	enum dev_prop_type proptype, void *val, size_t nval)
514	{
515	const union acpi_object *obj;
516	const union acpi_object *items;
517	int ret;
518
519	if (val && nval == 1) {
520	ret = acpi_dev_prop_read_single(adev, propname, proptype, val);
521	if (!ret)
522	return ret;
523	}
524
525	ret = acpi_dev_get_property_array(adev, propname, ACPI_TYPE_ANY, &obj);
526	if (ret)
527	return ret;
528
529	if (!val)
530	return obj->package.count;
531	else if (nval <= 0)
532	return -EINVAL;
533
534	if (nval > obj->package.count)
535	return -EOVERFLOW;
536
537	items = obj->package.elements;
538	switch (proptype) {
539	case DEV_PROP_U8:
540	ret = acpi_copy_property_array_u8(items, (u8 *)val, nval);
541	break;
542	case DEV_PROP_U16:
543	ret = acpi_copy_property_array_u16(items, (u16 *)val, nval);
544	break;
545	case DEV_PROP_U32:
546	ret = acpi_copy_property_array_u32(items, (u32 *)val, nval);
547	break;
548	case DEV_PROP_U64:
549	ret = acpi_copy_property_array_u64(items, (u64 *)val, nval);
550	break;
551	case DEV_PROP_STRING:
552	ret = acpi_copy_property_array_string(items, (char **)val, nval);
553	break;
554	default:
555	ret = -EINVAL;
556	break;
557	}
558	return ret;
559	}