1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * ACPI device specific properties support.
   4 *
   5 * Copyright (C) 2014 - 2023, Intel Corporation
   6 * All rights reserved.
   7 *
   8 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
   9 *          Darren Hart <dvhart@linux.intel.com>
  10 *          Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  11 *          Sakari Ailus <sakari.ailus@linux.intel.com>
 
 
 
  12 */
  13
  14#define pr_fmt(fmt) "ACPI: " fmt
  15
  16#include <linux/acpi.h>
  17#include <linux/device.h>
  18#include <linux/export.h>
  19
  20#include "internal.h"
  21
  22static int acpi_data_get_property_array(const struct acpi_device_data *data,
  23					const char *name,
  24					acpi_object_type type,
  25					const union acpi_object **obj);
  26
  27/*
  28 * The GUIDs here are made equivalent to each other in order to avoid extra
  29 * complexity in the properties handling code, with the caveat that the
  30 * kernel will accept certain combinations of GUID and properties that are
  31 * not defined without a warning. For instance if any of the properties
  32 * from different GUID appear in a property list of another, it will be
  33 * accepted by the kernel. Firmware validation tools should catch these.
  34 *
  35 * References:
  36 *
  37 * [1] UEFI DSD Guide.
  38 *     https://github.com/UEFI/DSD-Guide/blob/main/src/dsd-guide.adoc
  39 */
  40static const guid_t prp_guids[] = {
  41	/* ACPI _DSD device properties GUID [1]: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */
  42	GUID_INIT(0xdaffd814, 0x6eba, 0x4d8c,
  43		  0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01),
  44	/* Hotplug in D3 GUID: 6211e2c0-58a3-4af3-90e1-927a4e0c55a4 */
  45	GUID_INIT(0x6211e2c0, 0x58a3, 0x4af3,
  46		  0x90, 0xe1, 0x92, 0x7a, 0x4e, 0x0c, 0x55, 0xa4),
  47	/* External facing port GUID: efcc06cc-73ac-4bc3-bff0-76143807c389 */
  48	GUID_INIT(0xefcc06cc, 0x73ac, 0x4bc3,
  49		  0xbf, 0xf0, 0x76, 0x14, 0x38, 0x07, 0xc3, 0x89),
  50	/* Thunderbolt GUID for IMR_VALID: c44d002f-69f9-4e7d-a904-a7baabdf43f7 */
  51	GUID_INIT(0xc44d002f, 0x69f9, 0x4e7d,
  52		  0xa9, 0x04, 0xa7, 0xba, 0xab, 0xdf, 0x43, 0xf7),
  53	/* Thunderbolt GUID for WAKE_SUPPORTED: 6c501103-c189-4296-ba72-9bf5a26ebe5d */
  54	GUID_INIT(0x6c501103, 0xc189, 0x4296,
  55		  0xba, 0x72, 0x9b, 0xf5, 0xa2, 0x6e, 0xbe, 0x5d),
  56	/* Storage device needs D3 GUID: 5025030f-842f-4ab4-a561-99a5189762d0 */
  57	GUID_INIT(0x5025030f, 0x842f, 0x4ab4,
  58		  0xa5, 0x61, 0x99, 0xa5, 0x18, 0x97, 0x62, 0xd0),
  59};
  60
  61/* ACPI _DSD data subnodes GUID [1]: dbb8e3e6-5886-4ba6-8795-1319f52a966b */
  62static const guid_t ads_guid =
  63	GUID_INIT(0xdbb8e3e6, 0x5886, 0x4ba6,
  64		  0x87, 0x95, 0x13, 0x19, 0xf5, 0x2a, 0x96, 0x6b);
  65
  66/* ACPI _DSD data buffer GUID [1]: edb12dd0-363d-4085-a3d2-49522ca160c4 */
  67static const guid_t buffer_prop_guid =
  68	GUID_INIT(0xedb12dd0, 0x363d, 0x4085,
  69		  0xa3, 0xd2, 0x49, 0x52, 0x2c, 0xa1, 0x60, 0xc4);
  70
  71static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
  72					   union acpi_object *desc,
  73					   struct acpi_device_data *data,
  74					   struct fwnode_handle *parent);
  75static bool acpi_extract_properties(acpi_handle handle,
  76				    union acpi_object *desc,
  77				    struct acpi_device_data *data);
  78
  79static bool acpi_nondev_subnode_extract(union acpi_object *desc,
  80					acpi_handle handle,
  81					const union acpi_object *link,
  82					struct list_head *list,
  83					struct fwnode_handle *parent)
  84{
  85	struct acpi_data_node *dn;
  86	bool result;
  87
  88	if (acpi_graph_ignore_port(handle))
  89		return false;
  90
  91	dn = kzalloc(sizeof(*dn), GFP_KERNEL);
  92	if (!dn)
  93		return false;
  94
  95	dn->name = link->package.elements[0].string.pointer;
  96	fwnode_init(&dn->fwnode, &acpi_data_fwnode_ops);
  97	dn->parent = parent;
  98	INIT_LIST_HEAD(&dn->data.properties);
  99	INIT_LIST_HEAD(&dn->data.subnodes);
 100
 101	result = acpi_extract_properties(handle, desc, &dn->data);
 102
 103	if (handle) {
 104		acpi_handle scope;
 105		acpi_status status;
 106
 107		/*
 108		 * The scope for the subnode object lookup is the one of the
 109		 * namespace node (device) containing the object that has
 110		 * returned the package.  That is, it's the scope of that
 111		 * object's parent.
 112		 */
 113		status = acpi_get_parent(handle, &scope);
 114		if (ACPI_SUCCESS(status)
 115		    && acpi_enumerate_nondev_subnodes(scope, desc, &dn->data,
 116						      &dn->fwnode))
 117			result = true;
 118	} else if (acpi_enumerate_nondev_subnodes(NULL, desc, &dn->data,
 119						  &dn->fwnode)) {
 120		result = true;
 121	}
 122
 123	if (result) {
 124		dn->handle = handle;
 125		dn->data.pointer = desc;
 126		list_add_tail(&dn->sibling, list);
 127		return true;
 128	}
 129
 130	kfree(dn);
 131	acpi_handle_debug(handle, "Invalid properties/subnodes data, skipping\n");
 132	return false;
 133}
 134
 135static bool acpi_nondev_subnode_data_ok(acpi_handle handle,
 136					const union acpi_object *link,
 137					struct list_head *list,
 138					struct fwnode_handle *parent)
 139{
 140	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 141	acpi_status status;
 142
 143	status = acpi_evaluate_object_typed(handle, NULL, NULL, &buf,
 144					    ACPI_TYPE_PACKAGE);
 145	if (ACPI_FAILURE(status))
 146		return false;
 147
 148	if (acpi_nondev_subnode_extract(buf.pointer, handle, link, list,
 149					parent))
 150		return true;
 151
 152	ACPI_FREE(buf.pointer);
 153	return false;
 154}
 155
 156static bool acpi_nondev_subnode_ok(acpi_handle scope,
 157				   const union acpi_object *link,
 158				   struct list_head *list,
 159				   struct fwnode_handle *parent)
 160{
 161	acpi_handle handle;
 162	acpi_status status;
 163
 164	if (!scope)
 165		return false;
 166
 167	status = acpi_get_handle(scope, link->package.elements[1].string.pointer,
 168				 &handle);
 169	if (ACPI_FAILURE(status))
 170		return false;
 171
 172	return acpi_nondev_subnode_data_ok(handle, link, list, parent);
 173}
 174
 175static bool acpi_add_nondev_subnodes(acpi_handle scope,
 176				     union acpi_object *links,
 177				     struct list_head *list,
 178				     struct fwnode_handle *parent)
 179{
 180	bool ret = false;
 181	int i;
 182
 183	for (i = 0; i < links->package.count; i++) {
 184		union acpi_object *link, *desc;
 185		acpi_handle handle;
 186		bool result;
 187
 188		link = &links->package.elements[i];
 189		/* Only two elements allowed. */
 190		if (link->package.count != 2)
 191			continue;
 192
 193		/* The first one must be a string. */
 194		if (link->package.elements[0].type != ACPI_TYPE_STRING)
 195			continue;
 196
 197		/* The second one may be a string, a reference or a package. */
 198		switch (link->package.elements[1].type) {
 199		case ACPI_TYPE_STRING:
 200			result = acpi_nondev_subnode_ok(scope, link, list,
 201							 parent);
 202			break;
 203		case ACPI_TYPE_LOCAL_REFERENCE:
 204			handle = link->package.elements[1].reference.handle;
 205			result = acpi_nondev_subnode_data_ok(handle, link, list,
 206							     parent);
 207			break;
 208		case ACPI_TYPE_PACKAGE:
 209			desc = &link->package.elements[1];
 210			result = acpi_nondev_subnode_extract(desc, NULL, link,
 211							     list, parent);
 212			break;
 213		default:
 214			result = false;
 215			break;
 216		}
 217		ret = ret || result;
 218	}
 219
 220	return ret;
 221}
 222
 223static bool acpi_enumerate_nondev_subnodes(acpi_handle scope,
 224					   union acpi_object *desc,
 225					   struct acpi_device_data *data,
 226					   struct fwnode_handle *parent)
 227{
 228	int i;
 229
 230	/* Look for the ACPI data subnodes GUID. */
 231	for (i = 0; i < desc->package.count; i += 2) {
 232		const union acpi_object *guid;
 233		union acpi_object *links;
 234
 235		guid = &desc->package.elements[i];
 236		links = &desc->package.elements[i + 1];
 237
 238		/*
 239		 * The first element must be a GUID and the second one must be
 240		 * a package.
 241		 */
 242		if (guid->type != ACPI_TYPE_BUFFER ||
 243		    guid->buffer.length != 16 ||
 244		    links->type != ACPI_TYPE_PACKAGE)
 245			break;
 246
 247		if (!guid_equal((guid_t *)guid->buffer.pointer, &ads_guid))
 248			continue;
 249
 250		return acpi_add_nondev_subnodes(scope, links, &data->subnodes,
 251						parent);
 252	}
 253
 254	return false;
 255}
 256
 257static bool acpi_property_value_ok(const union acpi_object *value)
 258{
 259	int j;
 260
 261	/*
 262	 * The value must be an integer, a string, a reference, or a package
 263	 * whose every element must be an integer, a string, or a reference.
 264	 */
 265	switch (value->type) {
 266	case ACPI_TYPE_INTEGER:
 267	case ACPI_TYPE_STRING:
 268	case ACPI_TYPE_LOCAL_REFERENCE:
 269		return true;
 270
 271	case ACPI_TYPE_PACKAGE:
 272		for (j = 0; j < value->package.count; j++)
 273			switch (value->package.elements[j].type) {
 274			case ACPI_TYPE_INTEGER:
 275			case ACPI_TYPE_STRING:
 276			case ACPI_TYPE_LOCAL_REFERENCE:
 277				continue;
 278
 279			default:
 280				return false;
 281			}
 282
 283		return true;
 284	}
 285	return false;
 286}
 287
 288static bool acpi_properties_format_valid(const union acpi_object *properties)
 289{
 290	int i;
 291
 292	for (i = 0; i < properties->package.count; i++) {
 293		const union acpi_object *property;
 294
 295		property = &properties->package.elements[i];
 296		/*
 297		 * Only two elements allowed, the first one must be a string and
 298		 * the second one has to satisfy certain conditions.
 299		 */
 300		if (property->package.count != 2
 301		    || property->package.elements[0].type != ACPI_TYPE_STRING
 302		    || !acpi_property_value_ok(&property->package.elements[1]))
 303			return false;
 304	}
 305	return true;
 306}
 307
 308static void acpi_init_of_compatible(struct acpi_device *adev)
 309{
 310	const union acpi_object *of_compatible;
 311	int ret;
 312
 313	ret = acpi_data_get_property_array(&adev->data, "compatible",
 314					   ACPI_TYPE_STRING, &of_compatible);
 315	if (ret) {
 316		ret = acpi_dev_get_property(adev, "compatible",
 317					    ACPI_TYPE_STRING, &of_compatible);
 318		if (ret) {
 319			struct acpi_device *parent;
 320
 321			parent = acpi_dev_parent(adev);
 322			if (parent && parent->flags.of_compatible_ok)
 323				goto out;
 324
 325			return;
 326		}
 327	}
 328	adev->data.of_compatible = of_compatible;
 329
 330 out:
 331	adev->flags.of_compatible_ok = 1;
 332}
 333
 334static bool acpi_is_property_guid(const guid_t *guid)
 335{
 336	int i;
 337
 338	for (i = 0; i < ARRAY_SIZE(prp_guids); i++) {
 339		if (guid_equal(guid, &prp_guids[i]))
 340			return true;
 341	}
 342
 343	return false;
 344}
 345
 346struct acpi_device_properties *
 347acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
 348		    union acpi_object *properties)
 349{
 350	struct acpi_device_properties *props;
 351
 352	props = kzalloc(sizeof(*props), GFP_KERNEL);
 353	if (props) {
 354		INIT_LIST_HEAD(&props->list);
 355		props->guid = guid;
 356		props->properties = properties;
 357		list_add_tail(&props->list, &data->properties);
 358	}
 359
 360	return props;
 361}
 362
 363static void acpi_nondev_subnode_tag(acpi_handle handle, void *context)
 364{
 365}
 366
 367static void acpi_untie_nondev_subnodes(struct acpi_device_data *data)
 368{
 369	struct acpi_data_node *dn;
 370
 371	list_for_each_entry(dn, &data->subnodes, sibling) {
 372		acpi_detach_data(dn->handle, acpi_nondev_subnode_tag);
 373
 374		acpi_untie_nondev_subnodes(&dn->data);
 375	}
 376}
 377
 378static bool acpi_tie_nondev_subnodes(struct acpi_device_data *data)
 379{
 380	struct acpi_data_node *dn;
 381
 382	list_for_each_entry(dn, &data->subnodes, sibling) {
 383		acpi_status status;
 384		bool ret;
 385
 386		status = acpi_attach_data(dn->handle, acpi_nondev_subnode_tag, dn);
 387		if (ACPI_FAILURE(status) && status != AE_ALREADY_EXISTS) {
 388			acpi_handle_err(dn->handle, "Can't tag data node\n");
 389			return false;
 390		}
 391
 392		ret = acpi_tie_nondev_subnodes(&dn->data);
 393		if (!ret)
 394			return ret;
 395	}
 396
 397	return true;
 398}
 399
 400static void acpi_data_add_buffer_props(acpi_handle handle,
 401				       struct acpi_device_data *data,
 402				       union acpi_object *properties)
 403{
 404	struct acpi_device_properties *props;
 405	union acpi_object *package;
 406	size_t alloc_size;
 407	unsigned int i;
 408	u32 *count;
 409
 410	if (check_mul_overflow((size_t)properties->package.count,
 411			       sizeof(*package) + sizeof(void *),
 412			       &alloc_size) ||
 413	    check_add_overflow(sizeof(*props) + sizeof(*package), alloc_size,
 414			       &alloc_size)) {
 415		acpi_handle_warn(handle,
 416				 "can't allocate memory for %u buffer props",
 417				 properties->package.count);
 418		return;
 419	}
 420
 421	props = kvzalloc(alloc_size, GFP_KERNEL);
 422	if (!props)
 423		return;
 424
 425	props->guid = &buffer_prop_guid;
 426	props->bufs = (void *)(props + 1);
 427	props->properties = (void *)(props->bufs + properties->package.count);
 428
 429	/* Outer package */
 430	package = props->properties;
 431	package->type = ACPI_TYPE_PACKAGE;
 432	package->package.elements = package + 1;
 433	count = &package->package.count;
 434	*count = 0;
 435
 436	/* Inner packages */
 437	package++;
 438
 439	for (i = 0; i < properties->package.count; i++) {
 440		struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 441		union acpi_object *property = &properties->package.elements[i];
 442		union acpi_object *prop, *obj, *buf_obj;
 443		acpi_status status;
 444
 445		if (property->type != ACPI_TYPE_PACKAGE ||
 446		    property->package.count != 2) {
 447			acpi_handle_warn(handle,
 448					 "buffer property %u has %u entries\n",
 449					 i, property->package.count);
 450			continue;
 451		}
 452
 453		prop = &property->package.elements[0];
 454		obj = &property->package.elements[1];
 455
 456		if (prop->type != ACPI_TYPE_STRING ||
 457		    obj->type != ACPI_TYPE_STRING) {
 458			acpi_handle_warn(handle,
 459					 "wrong object types %u and %u\n",
 460					 prop->type, obj->type);
 461			continue;
 462		}
 463
 464		status = acpi_evaluate_object_typed(handle, obj->string.pointer,
 465						    NULL, &buf,
 466						    ACPI_TYPE_BUFFER);
 467		if (ACPI_FAILURE(status)) {
 468			acpi_handle_warn(handle,
 469					 "can't evaluate \"%*pE\" as buffer\n",
 470					 obj->string.length,
 471					 obj->string.pointer);
 472			continue;
 473		}
 474
 475		package->type = ACPI_TYPE_PACKAGE;
 476		package->package.elements = prop;
 477		package->package.count = 2;
 478
 479		buf_obj = buf.pointer;
 480
 481		/* Replace the string object with a buffer object */
 482		obj->type = ACPI_TYPE_BUFFER;
 483		obj->buffer.length = buf_obj->buffer.length;
 484		obj->buffer.pointer = buf_obj->buffer.pointer;
 485
 486		props->bufs[i] = buf.pointer;
 487		package++;
 488		(*count)++;
 489	}
 490
 491	if (*count)
 492		list_add(&props->list, &data->properties);
 493	else
 494		kvfree(props);
 495}
 496
 497static bool acpi_extract_properties(acpi_handle scope, union acpi_object *desc,
 498				    struct acpi_device_data *data)
 499{
 500	int i;
 501
 502	if (desc->package.count % 2)
 503		return false;
 504
 505	/* Look for the device properties GUID. */
 506	for (i = 0; i < desc->package.count; i += 2) {
 507		const union acpi_object *guid;
 508		union acpi_object *properties;
 509
 510		guid = &desc->package.elements[i];
 511		properties = &desc->package.elements[i + 1];
 512
 513		/*
 514		 * The first element must be a GUID and the second one must be
 515		 * a package.
 516		 */
 517		if (guid->type != ACPI_TYPE_BUFFER ||
 518		    guid->buffer.length != 16 ||
 519		    properties->type != ACPI_TYPE_PACKAGE)
 520			break;
 521
 522		if (guid_equal((guid_t *)guid->buffer.pointer,
 523			       &buffer_prop_guid)) {
 524			acpi_data_add_buffer_props(scope, data, properties);
 525			continue;
 526		}
 527
 528		if (!acpi_is_property_guid((guid_t *)guid->buffer.pointer))
 529			continue;
 530
 531		/*
 532		 * We found the matching GUID. Now validate the format of the
 533		 * package immediately following it.
 534		 */
 535		if (!acpi_properties_format_valid(properties))
 536			continue;
 537
 538		acpi_data_add_props(data, (const guid_t *)guid->buffer.pointer,
 539				    properties);
 540	}
 541
 542	return !list_empty(&data->properties);
 543}
 544
 545void acpi_init_properties(struct acpi_device *adev)
 546{
 547	struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 548	struct acpi_hardware_id *hwid;
 549	acpi_status status;
 550	bool acpi_of = false;
 551
 552	INIT_LIST_HEAD(&adev->data.properties);
 553	INIT_LIST_HEAD(&adev->data.subnodes);
 554
 555	if (!adev->handle)
 556		return;
 557
 558	/*
 559	 * Check if ACPI_DT_NAMESPACE_HID is present and inthat case we fill in
 560	 * Device Tree compatible properties for this device.
 561	 */
 562	list_for_each_entry(hwid, &adev->pnp.ids, list) {
 563		if (!strcmp(hwid->id, ACPI_DT_NAMESPACE_HID)) {
 564			acpi_of = true;
 565			break;
 566		}
 567	}
 568
 569	status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
 570					    ACPI_TYPE_PACKAGE);
 571	if (ACPI_FAILURE(status))
 572		goto out;
 573
 574	if (acpi_extract_properties(adev->handle, buf.pointer, &adev->data)) {
 575		adev->data.pointer = buf.pointer;
 576		if (acpi_of)
 577			acpi_init_of_compatible(adev);
 578	}
 579	if (acpi_enumerate_nondev_subnodes(adev->handle, buf.pointer,
 580					&adev->data, acpi_fwnode_handle(adev)))
 581		adev->data.pointer = buf.pointer;
 582
 583	if (!adev->data.pointer) {
 584		acpi_handle_debug(adev->handle, "Invalid _DSD data, skipping\n");
 585		ACPI_FREE(buf.pointer);
 586	} else {
 587		if (!acpi_tie_nondev_subnodes(&adev->data))
 588			acpi_untie_nondev_subnodes(&adev->data);
 589	}
 590
 591 out:
 592	if (acpi_of && !adev->flags.of_compatible_ok)
 593		acpi_handle_info(adev->handle,
 594			 ACPI_DT_NAMESPACE_HID " requires 'compatible' property\n");
 595
 596	if (!adev->data.pointer)
 597		acpi_extract_apple_properties(adev);
 598}
 599
 600static void acpi_free_device_properties(struct list_head *list)
 601{
 602	struct acpi_device_properties *props, *tmp;
 603
 604	list_for_each_entry_safe(props, tmp, list, list) {
 605		u32 i;
 606
 607		list_del(&props->list);
 608		/* Buffer data properties were separately allocated */
 609		if (props->bufs)
 610			for (i = 0; i < props->properties->package.count; i++)
 611				ACPI_FREE(props->bufs[i]);
 612		kvfree(props);
 613	}
 614}
 615
 616static void acpi_destroy_nondev_subnodes(struct list_head *list)
 617{
 618	struct acpi_data_node *dn, *next;
 619
 620	if (list_empty(list))
 621		return;
 622
 623	list_for_each_entry_safe_reverse(dn, next, list, sibling) {
 624		acpi_destroy_nondev_subnodes(&dn->data.subnodes);
 625		wait_for_completion(&dn->kobj_done);
 626		list_del(&dn->sibling);
 627		ACPI_FREE((void *)dn->data.pointer);
 628		acpi_free_device_properties(&dn->data.properties);
 629		kfree(dn);
 630	}
 631}
 632
 633void acpi_free_properties(struct acpi_device *adev)
 634{
 635	acpi_untie_nondev_subnodes(&adev->data);
 636	acpi_destroy_nondev_subnodes(&adev->data.subnodes);
 637	ACPI_FREE((void *)adev->data.pointer);
 638	adev->data.of_compatible = NULL;
 639	adev->data.pointer = NULL;
 640	acpi_free_device_properties(&adev->data.properties);
 641}
 642
 643/**
 644 * acpi_data_get_property - return an ACPI property with given name
 645 * @data: ACPI device deta object to get the property from
 646 * @name: Name of the property
 647 * @type: Expected property type
 648 * @obj: Location to store the property value (if not %NULL)
 649 *
 650 * Look up a property with @name and store a pointer to the resulting ACPI
 651 * object at the location pointed to by @obj if found.
 652 *
 653 * Callers must not attempt to free the returned objects.  These objects will be
 654 * freed by the ACPI core automatically during the removal of @data.
 655 *
 656 * Return: %0 if property with @name has been found (success),
 657 *         %-EINVAL if the arguments are invalid,
 658 *         %-EINVAL if the property doesn't exist,
 659 *         %-EPROTO if the property value type doesn't match @type.
 660 */
 661static int acpi_data_get_property(const struct acpi_device_data *data,
 662				  const char *name, acpi_object_type type,
 663				  const union acpi_object **obj)
 664{
 665	const struct acpi_device_properties *props;
 
 666
 667	if (!data || !name)
 668		return -EINVAL;
 669
 670	if (!data->pointer || list_empty(&data->properties))
 671		return -EINVAL;
 672
 673	list_for_each_entry(props, &data->properties, list) {
 674		const union acpi_object *properties;
 675		unsigned int i;
 676
 677		properties = props->properties;
 678		for (i = 0; i < properties->package.count; i++) {
 679			const union acpi_object *propname, *propvalue;
 680			const union acpi_object *property;
 681
 682			property = &properties->package.elements[i];
 683
 684			propname = &property->package.elements[0];
 685			propvalue = &property->package.elements[1];
 686
 687			if (!strcmp(name, propname->string.pointer)) {
 688				if (type != ACPI_TYPE_ANY &&
 689				    propvalue->type != type)
 690					return -EPROTO;
 691				if (obj)
 692					*obj = propvalue;
 693
 694				return 0;
 695			}
 
 
 
 
 
 
 
 
 
 
 696		}
 697	}
 698	return -EINVAL;
 699}
 700
 701/**
 702 * acpi_dev_get_property - return an ACPI property with given name.
 703 * @adev: ACPI device to get the property from.
 704 * @name: Name of the property.
 705 * @type: Expected property type.
 706 * @obj: Location to store the property value (if not %NULL).
 707 */
 708int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
 709			  acpi_object_type type, const union acpi_object **obj)
 710{
 711	return adev ? acpi_data_get_property(&adev->data, name, type, obj) : -EINVAL;
 712}
 713EXPORT_SYMBOL_GPL(acpi_dev_get_property);
 714
 715static const struct acpi_device_data *
 716acpi_device_data_of_node(const struct fwnode_handle *fwnode)
 717{
 718	if (is_acpi_device_node(fwnode)) {
 719		const struct acpi_device *adev = to_acpi_device_node(fwnode);
 720		return &adev->data;
 721	}
 722	if (is_acpi_data_node(fwnode)) {
 723		const struct acpi_data_node *dn = to_acpi_data_node(fwnode);
 724		return &dn->data;
 725	}
 726	return NULL;
 727}
 728
 729/**
 730 * acpi_node_prop_get - return an ACPI property with given name.
 731 * @fwnode: Firmware node to get the property from.
 732 * @propname: Name of the property.
 733 * @valptr: Location to store a pointer to the property value (if not %NULL).
 734 */
 735int acpi_node_prop_get(const struct fwnode_handle *fwnode,
 736		       const char *propname, void **valptr)
 737{
 738	return acpi_data_get_property(acpi_device_data_of_node(fwnode),
 739				      propname, ACPI_TYPE_ANY,
 740				      (const union acpi_object **)valptr);
 741}
 742
 743/**
 744 * acpi_data_get_property_array - return an ACPI array property with given name
 745 * @data: ACPI data object to get the property from
 746 * @name: Name of the property
 747 * @type: Expected type of array elements
 748 * @obj: Location to store a pointer to the property value (if not NULL)
 749 *
 750 * Look up an array property with @name and store a pointer to the resulting
 751 * ACPI object at the location pointed to by @obj if found.
 752 *
 753 * Callers must not attempt to free the returned objects.  Those objects will be
 754 * freed by the ACPI core automatically during the removal of @data.
 755 *
 756 * Return: %0 if array property (package) with @name has been found (success),
 757 *         %-EINVAL if the arguments are invalid,
 758 *         %-EINVAL if the property doesn't exist,
 759 *         %-EPROTO if the property is not a package or the type of its elements
 760 *           doesn't match @type.
 761 */
 762static int acpi_data_get_property_array(const struct acpi_device_data *data,
 763					const char *name,
 764					acpi_object_type type,
 765					const union acpi_object **obj)
 766{
 767	const union acpi_object *prop;
 768	int ret, i;
 769
 770	ret = acpi_data_get_property(data, name, ACPI_TYPE_PACKAGE, &prop);
 771	if (ret)
 772		return ret;
 773
 774	if (type != ACPI_TYPE_ANY) {
 775		/* Check that all elements are of correct type. */
 776		for (i = 0; i < prop->package.count; i++)
 777			if (prop->package.elements[i].type != type)
 778				return -EPROTO;
 779	}
 780	if (obj)
 781		*obj = prop;
 782
 783	return 0;
 784}
 785
 786static struct fwnode_handle *
 787acpi_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 788				 const char *childname)
 789{
 790	struct fwnode_handle *child;
 791
 792	fwnode_for_each_child_node(fwnode, child) {
 793		if (is_acpi_data_node(child)) {
 794			if (acpi_data_node_match(child, childname))
 795				return child;
 796			continue;
 797		}
 798
 799		if (!strncmp(acpi_device_bid(to_acpi_device_node(child)),
 800			     childname, ACPI_NAMESEG_SIZE))
 801			return child;
 802	}
 803
 804	return NULL;
 805}
 806
 807static int acpi_get_ref_args(struct fwnode_reference_args *args,
 808			     struct fwnode_handle *ref_fwnode,
 809			     const union acpi_object **element,
 810			     const union acpi_object *end, size_t num_args)
 811{
 812	u32 nargs = 0, i;
 813
 814	/*
 815	 * Assume the following integer elements are all args. Stop counting on
 816	 * the first reference (possibly represented as a string) or end of the
 817	 * package arguments. In case of neither reference, nor integer, return
 818	 * an error, we can't parse it.
 819	 */
 820	for (i = 0; (*element) + i < end && i < num_args; i++) {
 821		acpi_object_type type = (*element)[i].type;
 822
 823		if (type == ACPI_TYPE_LOCAL_REFERENCE || type == ACPI_TYPE_STRING)
 824			break;
 825
 826		if (type == ACPI_TYPE_INTEGER)
 827			nargs++;
 828		else
 829			return -EINVAL;
 830	}
 831
 832	if (nargs > NR_FWNODE_REFERENCE_ARGS)
 833		return -EINVAL;
 834
 835	if (args) {
 836		args->fwnode = ref_fwnode;
 837		args->nargs = nargs;
 838		for (i = 0; i < nargs; i++)
 839			args->args[i] = (*element)[i].integer.value;
 840	}
 841
 842	(*element) += nargs;
 843
 844	return 0;
 845}
 846
 847static struct fwnode_handle *acpi_parse_string_ref(const struct fwnode_handle *fwnode,
 848						   const char *refstring)
 849{
 850	acpi_handle scope, handle;
 851	struct acpi_data_node *dn;
 852	struct acpi_device *device;
 853	acpi_status status;
 854
 855	if (is_acpi_device_node(fwnode)) {
 856		scope = to_acpi_device_node(fwnode)->handle;
 857	} else if (is_acpi_data_node(fwnode)) {
 858		scope = to_acpi_data_node(fwnode)->handle;
 859	} else {
 860		pr_debug("Bad node type for node %pfw\n", fwnode);
 861		return NULL;
 862	}
 863
 864	status = acpi_get_handle(scope, refstring, &handle);
 865	if (ACPI_FAILURE(status)) {
 866		acpi_handle_debug(scope, "Unable to get an ACPI handle for %s\n",
 867				  refstring);
 868		return NULL;
 869	}
 870
 871	device = acpi_fetch_acpi_dev(handle);
 872	if (device)
 873		return acpi_fwnode_handle(device);
 874
 875	status = acpi_get_data_full(handle, acpi_nondev_subnode_tag,
 876				    (void **)&dn, NULL);
 877	if (ACPI_FAILURE(status) || !dn) {
 878		acpi_handle_debug(handle, "Subnode not found\n");
 879		return NULL;
 880	}
 881
 882	return &dn->fwnode;
 883}
 884
 885/**
 886 * __acpi_node_get_property_reference - returns handle to the referenced object
 887 * @fwnode: Firmware node to get the property from
 888 * @propname: Name of the property
 889 * @index: Index of the reference to return
 890 * @num_args: Maximum number of arguments after each reference
 891 * @args: Location to store the returned reference with optional arguments
 892 *	  (may be NULL)
 893 *
 894 * Find property with @name, verifify that it is a package containing at least
 895 * one object reference and if so, store the ACPI device object pointer to the
 896 * target object in @args->adev.  If the reference includes arguments, store
 897 * them in the @args->args[] array.
 898 *
 899 * If there's more than one reference in the property value package, @index is
 900 * used to select the one to return.
 901 *
 902 * It is possible to leave holes in the property value set like in the
 903 * example below:
 904 *
 905 * Package () {
 906 *     "cs-gpios",
 907 *     Package () {
 908 *        ^GPIO, 19, 0, 0,
 909 *        ^GPIO, 20, 0, 0,
 910 *        0,
 911 *        ^GPIO, 21, 0, 0,
 912 *     }
 913 * }
 914 *
 915 * Calling this function with index %2 or index %3 return %-ENOENT. If the
 916 * property does not contain any more values %-ENOENT is returned. The NULL
 917 * entry must be single integer and preferably contain value %0.
 918 *
 919 * Return: %0 on success, negative error code on failure.
 920 */
 921int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
 922	const char *propname, size_t index, size_t num_args,
 923	struct fwnode_reference_args *args)
 924{
 925	const union acpi_object *element, *end;
 926	const union acpi_object *obj;
 927	const struct acpi_device_data *data;
 928	struct fwnode_handle *ref_fwnode;
 929	struct acpi_device *device;
 930	int ret, idx = 0;
 931
 932	data = acpi_device_data_of_node(fwnode);
 933	if (!data)
 934		return -ENOENT;
 935
 936	ret = acpi_data_get_property(data, propname, ACPI_TYPE_ANY, &obj);
 937	if (ret)
 938		return ret == -EINVAL ? -ENOENT : -EINVAL;
 939
 940	switch (obj->type) {
 941	case ACPI_TYPE_LOCAL_REFERENCE:
 942		/* Plain single reference without arguments. */
 
 
 943		if (index)
 944			return -ENOENT;
 945
 946		device = acpi_fetch_acpi_dev(obj->reference.handle);
 947		if (!device)
 948			return -EINVAL;
 949
 950		if (!args)
 951			return 0;
 952
 953		args->fwnode = acpi_fwnode_handle(device);
 954		args->nargs = 0;
 955
 956		return 0;
 957	case ACPI_TYPE_STRING:
 958		if (index)
 959			return -ENOENT;
 960
 961		ref_fwnode = acpi_parse_string_ref(fwnode, obj->string.pointer);
 962		if (!ref_fwnode)
 963			return -EINVAL;
 964
 965		args->fwnode = ref_fwnode;
 966		args->nargs = 0;
 967
 968		return 0;
 969	case ACPI_TYPE_PACKAGE:
 970		/*
 971		 * If it is not a single reference, then it is a package of
 972		 * references, followed by number of ints as follows:
 973		 *
 974		 *  Package () { REF, INT, REF, INT, INT }
 975		 *
 976		 * Here, REF may be either a local reference or a string. The
 977		 * index argument is then used to determine which reference the
 978		 * caller wants (along with the arguments).
 979		 */
 980		break;
 981	default:
 982		return -EINVAL;
 983	}
 984
 
 
 
 
 
 
 
 
 
 
 
 985	if (index >= obj->package.count)
 986		return -ENOENT;
 987
 988	element = obj->package.elements;
 989	end = element + obj->package.count;
 990
 991	while (element < end) {
 992		switch (element->type) {
 993		case ACPI_TYPE_LOCAL_REFERENCE:
 994			device = acpi_fetch_acpi_dev(element->reference.handle);
 995			if (!device)
 
 
 996				return -EINVAL;
 997
 
 998			element++;
 999
1000			ret = acpi_get_ref_args(idx == index ? args : NULL,
1001						acpi_fwnode_handle(device),
1002						&element, end, num_args);
1003			if (ret < 0)
1004				return ret;
1005
1006			if (idx == index)
1007				return 0;
 
 
 
1008
1009			break;
1010		case ACPI_TYPE_STRING:
1011			ref_fwnode = acpi_parse_string_ref(fwnode,
1012							   element->string.pointer);
1013			if (!ref_fwnode)
1014				return -EINVAL;
1015
1016			element++;
1017
1018			ret = acpi_get_ref_args(idx == index ? args : NULL,
1019						ref_fwnode, &element, end,
1020						num_args);
1021			if (ret < 0)
1022				return ret;
1023
1024			if (idx == index)
1025				return 0;
 
1026
1027			break;
1028		case ACPI_TYPE_INTEGER:
1029			if (idx == index)
1030				return -ENOENT;
1031			element++;
1032			break;
1033		default:
1034			return -EINVAL;
1035		}
1036
1037		idx++;
1038	}
1039
1040	return -ENOENT;
1041}
1042EXPORT_SYMBOL_GPL(__acpi_node_get_property_reference);
1043
1044static int acpi_data_prop_read_single(const struct acpi_device_data *data,
1045				      const char *propname,
1046				      enum dev_prop_type proptype, void *val)
1047{
1048	const union acpi_object *obj;
1049	int ret = 0;
1050
1051	if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64)
 
 
 
1052		ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj);
1053	else if (proptype == DEV_PROP_STRING)
1054		ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj);
1055	if (ret)
1056		return ret;
1057
1058	switch (proptype) {
1059	case DEV_PROP_U8:
1060		if (obj->integer.value > U8_MAX)
1061			return -EOVERFLOW;
1062		if (val)
1063			*(u8 *)val = obj->integer.value;
1064		break;
1065	case DEV_PROP_U16:
1066		if (obj->integer.value > U16_MAX)
1067			return -EOVERFLOW;
1068		if (val)
1069			*(u16 *)val = obj->integer.value;
1070		break;
1071	case DEV_PROP_U32:
1072		if (obj->integer.value > U32_MAX)
1073			return -EOVERFLOW;
1074		if (val)
1075			*(u32 *)val = obj->integer.value;
1076		break;
1077	case DEV_PROP_U64:
1078		if (val)
1079			*(u64 *)val = obj->integer.value;
1080		break;
1081	case DEV_PROP_STRING:
1082		if (val)
1083			*(char **)val = obj->string.pointer;
 
 
 
 
 
1084		return 1;
1085	default:
 
 
 
 
 
 
 
 
 
 
 
1086		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1087	}
 
 
 
 
 
 
 
1088
1089	/* When no storage provided return number of available values */
1090	return val ? 0 : 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1091}
1092
1093#define acpi_copy_property_array_uint(items, val, nval)			\
1094	({								\
1095		typeof(items) __items = items;				\
1096		typeof(val) __val = val;				\
1097		typeof(nval) __nval = nval;				\
1098		size_t i;						\
1099		int ret = 0;						\
1100									\
1101		for (i = 0; i < __nval; i++) {				\
1102			if (__items->type == ACPI_TYPE_BUFFER) {	\
1103				__val[i] = __items->buffer.pointer[i];	\
1104				continue;				\
1105			}						\
1106			if (__items[i].type != ACPI_TYPE_INTEGER) {	\
1107				ret = -EPROTO;				\
1108				break;					\
1109			}						\
1110			if (__items[i].integer.value > _Generic(__val,	\
1111								u8 *: U8_MAX, \
1112								u16 *: U16_MAX, \
1113								u32 *: U32_MAX, \
1114								u64 *: U64_MAX)) { \
1115				ret = -EOVERFLOW;			\
1116				break;					\
1117			}						\
1118									\
1119			__val[i] = __items[i].integer.value;		\
1120		}							\
1121		ret;							\
1122	})
1123
1124static int acpi_copy_property_array_string(const union acpi_object *items,
1125					   char **val, size_t nval)
1126{
1127	int i;
1128
1129	for (i = 0; i < nval; i++) {
1130		if (items[i].type != ACPI_TYPE_STRING)
1131			return -EPROTO;
1132
1133		val[i] = items[i].string.pointer;
1134	}
1135	return nval;
1136}
1137
1138static int acpi_data_prop_read(const struct acpi_device_data *data,
1139			       const char *propname,
1140			       enum dev_prop_type proptype,
1141			       void *val, size_t nval)
1142{
1143	const union acpi_object *obj;
1144	const union acpi_object *items;
1145	int ret;
1146
1147	if (nval == 1 || !val) {
1148		ret = acpi_data_prop_read_single(data, propname, proptype, val);
1149		/*
1150		 * The overflow error means that the property is there and it is
1151		 * single-value, but its type does not match, so return.
1152		 */
1153		if (ret >= 0 || ret == -EOVERFLOW)
1154			return ret;
1155
1156		/*
1157		 * Reading this property as a single-value one failed, but its
1158		 * value may still be represented as one-element array, so
1159		 * continue.
1160		 */
1161	}
1162
1163	ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj);
1164	if (ret && proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64)
1165		ret = acpi_data_get_property(data, propname, ACPI_TYPE_BUFFER,
1166					     &obj);
1167	if (ret)
1168		return ret;
1169
1170	if (!val) {
1171		if (obj->type == ACPI_TYPE_BUFFER)
1172			return obj->buffer.length;
1173
1174		return obj->package.count;
1175	}
1176
1177	switch (proptype) {
1178	case DEV_PROP_STRING:
1179		break;
1180	default:
1181		if (obj->type == ACPI_TYPE_BUFFER) {
1182			if (nval > obj->buffer.length)
1183				return -EOVERFLOW;
1184		} else {
1185			if (nval > obj->package.count)
1186				return -EOVERFLOW;
1187		}
1188		break;
1189	}
1190
1191	if (obj->type == ACPI_TYPE_BUFFER) {
1192		if (proptype != DEV_PROP_U8)
1193			return -EPROTO;
1194		items = obj;
1195	} else {
1196		items = obj->package.elements;
1197	}
1198
1199	switch (proptype) {
1200	case DEV_PROP_U8:
1201		ret = acpi_copy_property_array_uint(items, (u8 *)val, nval);
1202		break;
1203	case DEV_PROP_U16:
1204		ret = acpi_copy_property_array_uint(items, (u16 *)val, nval);
1205		break;
1206	case DEV_PROP_U32:
1207		ret = acpi_copy_property_array_uint(items, (u32 *)val, nval);
1208		break;
1209	case DEV_PROP_U64:
1210		ret = acpi_copy_property_array_uint(items, (u64 *)val, nval);
1211		break;
1212	case DEV_PROP_STRING:
1213		nval = min_t(u32, nval, obj->package.count);
1214		if (nval == 0)
1215			return -ENODATA;
1216
1217		ret = acpi_copy_property_array_string(items, (char **)val, nval);
1218		break;
1219	default:
1220		ret = -EINVAL;
1221		break;
1222	}
1223	return ret;
1224}
1225
 
 
 
 
 
 
1226/**
1227 * acpi_node_prop_read - retrieve the value of an ACPI property with given name.
1228 * @fwnode: Firmware node to get the property from.
1229 * @propname: Name of the property.
1230 * @proptype: Expected property type.
1231 * @val: Location to store the property value (if not %NULL).
1232 * @nval: Size of the array pointed to by @val.
1233 *
1234 * If @val is %NULL, return the number of array elements comprising the value
1235 * of the property.  Otherwise, read at most @nval values to the array at the
1236 * location pointed to by @val.
1237 */
1238static int acpi_node_prop_read(const struct fwnode_handle *fwnode,
1239			       const char *propname, enum dev_prop_type proptype,
1240			       void *val, size_t nval)
1241{
1242	return acpi_data_prop_read(acpi_device_data_of_node(fwnode),
1243				   propname, proptype, val, nval);
1244}
1245
1246static int stop_on_next(struct acpi_device *adev, void *data)
1247{
1248	struct acpi_device **ret_p = data;
1249
1250	if (!*ret_p) {
1251		*ret_p = adev;
1252		return 1;
1253	}
1254
1255	/* Skip until the "previous" object is found. */
1256	if (*ret_p == adev)
1257		*ret_p = NULL;
1258
1259	return 0;
1260}
1261
1262/**
1263 * acpi_get_next_subnode - Return the next child node handle for a fwnode
1264 * @fwnode: Firmware node to find the next child node for.
1265 * @child: Handle to one of the device's child nodes or a null handle.
1266 */
1267struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1268					    struct fwnode_handle *child)
1269{
1270	struct acpi_device *adev = to_acpi_device_node(fwnode);
 
 
1271
1272	if ((!child || is_acpi_device_node(child)) && adev) {
1273		struct acpi_device *child_adev = to_acpi_device_node(child);
1274
1275		acpi_dev_for_each_child(adev, stop_on_next, &child_adev);
1276		if (child_adev)
1277			return acpi_fwnode_handle(child_adev);
 
 
 
 
1278
1279		child = NULL;
 
 
 
 
 
 
 
 
 
 
 
 
1280	}
1281
 
1282	if (!child || is_acpi_data_node(child)) {
1283		const struct acpi_data_node *data = to_acpi_data_node(fwnode);
1284		const struct list_head *head;
1285		struct list_head *next;
1286		struct acpi_data_node *dn;
1287
1288		/*
1289		 * We can have a combination of device and data nodes, e.g. with
1290		 * hierarchical _DSD properties. Make sure the adev pointer is
1291		 * restored before going through data nodes, otherwise we will
1292		 * be looking for data_nodes below the last device found instead
1293		 * of the common fwnode shared by device_nodes and data_nodes.
1294		 */
1295		adev = to_acpi_device_node(fwnode);
1296		if (adev)
1297			head = &adev->data.subnodes;
1298		else if (data)
1299			head = &data->data.subnodes;
1300		else
1301			return NULL;
1302
1303		if (list_empty(head))
1304			return NULL;
1305
1306		if (child) {
1307			dn = to_acpi_data_node(child);
1308			next = dn->sibling.next;
1309			if (next == head)
1310				return NULL;
1311
1312			dn = list_entry(next, struct acpi_data_node, sibling);
1313		} else {
1314			dn = list_first_entry(head, struct acpi_data_node, sibling);
1315		}
1316		return &dn->fwnode;
1317	}
1318	return NULL;
1319}
1320
1321/**
1322 * acpi_node_get_parent - Return parent fwnode of this fwnode
1323 * @fwnode: Firmware node whose parent to get
1324 *
1325 * Returns parent node of an ACPI device or data firmware node or %NULL if
1326 * not available.
1327 */
1328static struct fwnode_handle *
1329acpi_node_get_parent(const struct fwnode_handle *fwnode)
1330{
1331	if (is_acpi_data_node(fwnode)) {
1332		/* All data nodes have parent pointer so just return that */
1333		return to_acpi_data_node(fwnode)->parent;
1334	}
1335	if (is_acpi_device_node(fwnode)) {
1336		struct acpi_device *parent;
1337
1338		parent = acpi_dev_parent(to_acpi_device_node(fwnode));
1339		if (parent)
1340			return acpi_fwnode_handle(parent);
 
 
 
 
1341	}
1342
1343	return NULL;
1344}
1345
1346/*
1347 * Return true if the node is an ACPI graph node. Called on either ports
1348 * or endpoints.
1349 */
1350static bool is_acpi_graph_node(struct fwnode_handle *fwnode,
1351			       const char *str)
1352{
1353	unsigned int len = strlen(str);
1354	const char *name;
1355
1356	if (!len || !is_acpi_data_node(fwnode))
1357		return false;
1358
1359	name = to_acpi_data_node(fwnode)->name;
1360
1361	return (fwnode_property_present(fwnode, "reg") &&
1362		!strncmp(name, str, len) && name[len] == '@') ||
1363		fwnode_property_present(fwnode, str);
1364}
1365
1366/**
1367 * acpi_graph_get_next_endpoint - Get next endpoint ACPI firmware node
1368 * @fwnode: Pointer to the parent firmware node
1369 * @prev: Previous endpoint node or %NULL to get the first
1370 *
1371 * Looks up next endpoint ACPI firmware node below a given @fwnode. Returns
1372 * %NULL if there is no next endpoint or in case of error. In case of success
1373 * the next endpoint is returned.
1374 */
1375static struct fwnode_handle *acpi_graph_get_next_endpoint(
1376	const struct fwnode_handle *fwnode, struct fwnode_handle *prev)
1377{
1378	struct fwnode_handle *port = NULL;
1379	struct fwnode_handle *endpoint;
1380
1381	if (!prev) {
1382		do {
1383			port = fwnode_get_next_child_node(fwnode, port);
1384			/*
1385			 * The names of the port nodes begin with "port@"
1386			 * followed by the number of the port node and they also
1387			 * have a "reg" property that also has the number of the
1388			 * port node. For compatibility reasons a node is also
1389			 * recognised as a port node from the "port" property.
1390			 */
1391			if (is_acpi_graph_node(port, "port"))
1392				break;
1393		} while (port);
1394	} else {
1395		port = fwnode_get_parent(prev);
1396	}
1397
1398	if (!port)
1399		return NULL;
1400
1401	endpoint = fwnode_get_next_child_node(port, prev);
1402	while (!endpoint) {
1403		port = fwnode_get_next_child_node(fwnode, port);
1404		if (!port)
1405			break;
1406		if (is_acpi_graph_node(port, "port"))
1407			endpoint = fwnode_get_next_child_node(port, NULL);
1408	}
1409
1410	/*
1411	 * The names of the endpoint nodes begin with "endpoint@" followed by
1412	 * the number of the endpoint node and they also have a "reg" property
1413	 * that also has the number of the endpoint node. For compatibility
1414	 * reasons a node is also recognised as an endpoint node from the
1415	 * "endpoint" property.
1416	 */
1417	if (!is_acpi_graph_node(endpoint, "endpoint"))
1418		return NULL;
1419
1420	return endpoint;
1421}
1422
1423/**
1424 * acpi_graph_get_child_prop_value - Return a child with a given property value
1425 * @fwnode: device fwnode
1426 * @prop_name: The name of the property to look for
1427 * @val: the desired property value
1428 *
1429 * Return the port node corresponding to a given port number. Returns
1430 * the child node on success, NULL otherwise.
1431 */
1432static struct fwnode_handle *acpi_graph_get_child_prop_value(
1433	const struct fwnode_handle *fwnode, const char *prop_name,
1434	unsigned int val)
1435{
1436	struct fwnode_handle *child;
1437
1438	fwnode_for_each_child_node(fwnode, child) {
1439		u32 nr;
1440
1441		if (fwnode_property_read_u32(child, prop_name, &nr))
1442			continue;
1443
1444		if (val == nr)
1445			return child;
1446	}
1447
1448	return NULL;
1449}
1450
1451
1452/**
1453 * acpi_graph_get_remote_endpoint - Parses and returns remote end of an endpoint
1454 * @__fwnode: Endpoint firmware node pointing to a remote device
1455 *
1456 * Returns the remote endpoint corresponding to @__fwnode. NULL on error.
 
 
 
 
 
1457 */
1458static struct fwnode_handle *
1459acpi_graph_get_remote_endpoint(const struct fwnode_handle *__fwnode)
 
 
1460{
1461	struct fwnode_handle *fwnode;
1462	unsigned int port_nr, endpoint_nr;
1463	struct fwnode_reference_args args;
1464	int ret;
1465
1466	memset(&args, 0, sizeof(args));
1467	ret = acpi_node_get_property_reference(__fwnode, "remote-endpoint", 0,
1468					       &args);
1469	if (ret)
1470		return NULL;
1471
1472	/* Direct endpoint reference? */
1473	if (!is_acpi_device_node(args.fwnode))
1474		return args.nargs ? NULL : args.fwnode;
1475
1476	/*
1477	 * Always require two arguments with the reference: port and
1478	 * endpoint indices.
1479	 */
1480	if (args.nargs != 2)
1481		return NULL;
1482
1483	fwnode = args.fwnode;
1484	port_nr = args.args[0];
1485	endpoint_nr = args.args[1];
1486
 
 
 
 
 
 
1487	fwnode = acpi_graph_get_child_prop_value(fwnode, "port", port_nr);
 
 
 
 
 
1488
1489	return acpi_graph_get_child_prop_value(fwnode, "endpoint", endpoint_nr);
 
 
 
 
 
 
 
 
 
 
1490}
1491
1492static bool acpi_fwnode_device_is_available(const struct fwnode_handle *fwnode)
1493{
1494	if (!is_acpi_device_node(fwnode))
1495		return false;
1496
1497	return acpi_device_is_present(to_acpi_device_node(fwnode));
1498}
1499
1500static const void *
1501acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1502				  const struct device *dev)
1503{
1504	return acpi_device_get_match_data(dev);
1505}
1506
1507static bool acpi_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)
1508{
1509	return acpi_dma_supported(to_acpi_device_node(fwnode));
1510}
1511
1512static enum dev_dma_attr
1513acpi_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)
1514{
1515	return acpi_get_dma_attr(to_acpi_device_node(fwnode));
1516}
1517
1518static bool acpi_fwnode_property_present(const struct fwnode_handle *fwnode,
1519					 const char *propname)
1520{
1521	return !acpi_node_prop_get(fwnode, propname, NULL);
1522}
1523
1524static int
1525acpi_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
1526				    const char *propname,
1527				    unsigned int elem_size, void *val,
1528				    size_t nval)
1529{
1530	enum dev_prop_type type;
1531
1532	switch (elem_size) {
1533	case sizeof(u8):
1534		type = DEV_PROP_U8;
1535		break;
1536	case sizeof(u16):
1537		type = DEV_PROP_U16;
1538		break;
1539	case sizeof(u32):
1540		type = DEV_PROP_U32;
1541		break;
1542	case sizeof(u64):
1543		type = DEV_PROP_U64;
1544		break;
1545	default:
1546		return -ENXIO;
1547	}
1548
1549	return acpi_node_prop_read(fwnode, propname, type, val, nval);
1550}
1551
1552static int
1553acpi_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
1554				       const char *propname, const char **val,
1555				       size_t nval)
1556{
1557	return acpi_node_prop_read(fwnode, propname, DEV_PROP_STRING,
1558				   val, nval);
1559}
1560
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1561static int
1562acpi_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
1563			       const char *prop, const char *nargs_prop,
1564			       unsigned int args_count, unsigned int index,
1565			       struct fwnode_reference_args *args)
1566{
1567	return __acpi_node_get_property_reference(fwnode, prop, index,
1568						  args_count, args);
1569}
1570
1571static const char *acpi_fwnode_get_name(const struct fwnode_handle *fwnode)
1572{
1573	const struct acpi_device *adev;
1574	struct fwnode_handle *parent;
 
 
1575
1576	/* Is this the root node? */
1577	parent = fwnode_get_parent(fwnode);
1578	if (!parent)
1579		return "\\";
1580
1581	fwnode_handle_put(parent);
 
1582
1583	if (is_acpi_data_node(fwnode)) {
1584		const struct acpi_data_node *dn = to_acpi_data_node(fwnode);
1585
1586		return dn->name;
1587	}
 
 
 
1588
1589	adev = to_acpi_device_node(fwnode);
1590	if (WARN_ON(!adev))
1591		return NULL;
1592
1593	return acpi_device_bid(adev);
1594}
1595
1596static const char *
1597acpi_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
1598{
1599	struct fwnode_handle *parent;
1600
1601	/* Is this the root node? */
1602	parent = fwnode_get_parent(fwnode);
1603	if (!parent)
1604		return "";
1605
1606	/* Is this 2nd node from the root? */
1607	parent = fwnode_get_next_parent(parent);
1608	if (!parent)
1609		return "";
1610
1611	fwnode_handle_put(parent);
1612
1613	/* ACPI device or data node. */
1614	return ".";
1615}
1616
1617static struct fwnode_handle *
1618acpi_fwnode_get_parent(struct fwnode_handle *fwnode)
1619{
1620	return acpi_node_get_parent(fwnode);
1621}
1622
1623static int acpi_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1624					    struct fwnode_endpoint *endpoint)
1625{
1626	struct fwnode_handle *port_fwnode = fwnode_get_parent(fwnode);
1627
1628	endpoint->local_fwnode = fwnode;
1629
1630	if (fwnode_property_read_u32(port_fwnode, "reg", &endpoint->port))
1631		fwnode_property_read_u32(port_fwnode, "port", &endpoint->port);
1632	if (fwnode_property_read_u32(fwnode, "reg", &endpoint->id))
1633		fwnode_property_read_u32(fwnode, "endpoint", &endpoint->id);
1634
1635	return 0;
1636}
1637
1638static int acpi_fwnode_irq_get(const struct fwnode_handle *fwnode,
1639			       unsigned int index)
 
1640{
1641	struct resource res;
1642	int ret;
1643
1644	ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, &res);
1645	if (ret)
1646		return ret;
1647
1648	return res.start;
1649}
1650
1651#define DECLARE_ACPI_FWNODE_OPS(ops) \
1652	const struct fwnode_operations ops = {				\
1653		.device_is_available = acpi_fwnode_device_is_available, \
1654		.device_get_match_data = acpi_fwnode_device_get_match_data, \
1655		.device_dma_supported =				\
1656			acpi_fwnode_device_dma_supported,		\
1657		.device_get_dma_attr = acpi_fwnode_device_get_dma_attr,	\
1658		.property_present = acpi_fwnode_property_present,	\
1659		.property_read_int_array =				\
1660			acpi_fwnode_property_read_int_array,		\
1661		.property_read_string_array =				\
1662			acpi_fwnode_property_read_string_array,		\
1663		.get_parent = acpi_node_get_parent,			\
1664		.get_next_child_node = acpi_get_next_subnode,		\
1665		.get_named_child_node = acpi_fwnode_get_named_child_node, \
1666		.get_name = acpi_fwnode_get_name,			\
1667		.get_name_prefix = acpi_fwnode_get_name_prefix,		\
1668		.get_reference_args = acpi_fwnode_get_reference_args,	\
1669		.graph_get_next_endpoint =				\
1670			acpi_graph_get_next_endpoint,			\
1671		.graph_get_remote_endpoint =				\
1672			acpi_graph_get_remote_endpoint,			\
1673		.graph_get_port_parent = acpi_fwnode_get_parent,	\
1674		.graph_parse_endpoint = acpi_fwnode_graph_parse_endpoint, \
1675		.irq_get = acpi_fwnode_irq_get,				\
1676	};								\
1677	EXPORT_SYMBOL_GPL(ops)
1678
1679DECLARE_ACPI_FWNODE_OPS(acpi_device_fwnode_ops);
1680DECLARE_ACPI_FWNODE_OPS(acpi_data_fwnode_ops);
1681const struct fwnode_operations acpi_static_fwnode_ops;
1682
1683bool is_acpi_device_node(const struct fwnode_handle *fwnode)
1684{
1685	return !IS_ERR_OR_NULL(fwnode) &&
1686		fwnode->ops == &acpi_device_fwnode_ops;
1687}
1688EXPORT_SYMBOL(is_acpi_device_node);
1689
1690bool is_acpi_data_node(const struct fwnode_handle *fwnode)
1691{
1692	return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &acpi_data_fwnode_ops;
1693}
1694EXPORT_SYMBOL(is_acpi_data_node);