1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * property.c - Unified device property interface.
   4 *
   5 * Copyright (C) 2014, Intel Corporation
   6 * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   7 *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8 */
   9
  10#include <linux/acpi.h>
  11#include <linux/export.h>
  12#include <linux/kernel.h>
  13#include <linux/of.h>
  14#include <linux/of_address.h>
  15#include <linux/of_graph.h>
  16#include <linux/of_irq.h>
  17#include <linux/property.h>
  18#include <linux/phy.h>
  19
  20struct fwnode_handle *__dev_fwnode(struct device *dev)
  21{
  22	return IS_ENABLED(CONFIG_OF) && dev->of_node ?
  23		of_fwnode_handle(dev->of_node) : dev->fwnode;
  24}
  25EXPORT_SYMBOL_GPL(__dev_fwnode);
  26
  27const struct fwnode_handle *__dev_fwnode_const(const struct device *dev)
  28{
  29	return IS_ENABLED(CONFIG_OF) && dev->of_node ?
  30		of_fwnode_handle(dev->of_node) : dev->fwnode;
  31}
  32EXPORT_SYMBOL_GPL(__dev_fwnode_const);
  33
  34/**
  35 * device_property_present - check if a property of a device is present
  36 * @dev: Device whose property is being checked
  37 * @propname: Name of the property
  38 *
  39 * Check if property @propname is present in the device firmware description.
  40 *
  41 * Return: true if property @propname is present. Otherwise, returns false.
  42 */
  43bool device_property_present(const struct device *dev, const char *propname)
  44{
  45	return fwnode_property_present(dev_fwnode(dev), propname);
  46}
  47EXPORT_SYMBOL_GPL(device_property_present);
  48
  49/**
  50 * fwnode_property_present - check if a property of a firmware node is present
  51 * @fwnode: Firmware node whose property to check
  52 * @propname: Name of the property
  53 *
  54 * Return: true if property @propname is present. Otherwise, returns false.
  55 */
  56bool fwnode_property_present(const struct fwnode_handle *fwnode,
  57			     const char *propname)
  58{
  59	bool ret;
  60
  61	if (IS_ERR_OR_NULL(fwnode))
  62		return false;
  63
  64	ret = fwnode_call_bool_op(fwnode, property_present, propname);
  65	if (ret)
  66		return ret;
  67
  68	return fwnode_call_bool_op(fwnode->secondary, property_present, propname);
  69}
  70EXPORT_SYMBOL_GPL(fwnode_property_present);
  71
  72/**
  73 * device_property_read_u8_array - return a u8 array property of a device
  74 * @dev: Device to get the property of
  75 * @propname: Name of the property
  76 * @val: The values are stored here or %NULL to return the number of values
  77 * @nval: Size of the @val array
  78 *
  79 * Function reads an array of u8 properties with @propname from the device
  80 * firmware description and stores them to @val if found.
  81 *
  82 * It's recommended to call device_property_count_u8() instead of calling
  83 * this function with @val equals %NULL and @nval equals 0.
  84 *
  85 * Return: number of values if @val was %NULL,
  86 *         %0 if the property was found (success),
  87 *	   %-EINVAL if given arguments are not valid,
  88 *	   %-ENODATA if the property does not have a value,
  89 *	   %-EPROTO if the property is not an array of numbers,
  90 *	   %-EOVERFLOW if the size of the property is not as expected.
  91 *	   %-ENXIO if no suitable firmware interface is present.
  92 */
  93int device_property_read_u8_array(const struct device *dev, const char *propname,
  94				  u8 *val, size_t nval)
  95{
  96	return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
  97}
  98EXPORT_SYMBOL_GPL(device_property_read_u8_array);
  99
 100/**
 101 * device_property_read_u16_array - return a u16 array property of a device
 102 * @dev: Device to get the property of
 103 * @propname: Name of the property
 104 * @val: The values are stored here or %NULL to return the number of values
 105 * @nval: Size of the @val array
 106 *
 107 * Function reads an array of u16 properties with @propname from the device
 108 * firmware description and stores them to @val if found.
 109 *
 110 * It's recommended to call device_property_count_u16() instead of calling
 111 * this function with @val equals %NULL and @nval equals 0.
 112 *
 113 * Return: number of values if @val was %NULL,
 114 *         %0 if the property was found (success),
 115 *	   %-EINVAL if given arguments are not valid,
 116 *	   %-ENODATA if the property does not have a value,
 117 *	   %-EPROTO if the property is not an array of numbers,
 118 *	   %-EOVERFLOW if the size of the property is not as expected.
 119 *	   %-ENXIO if no suitable firmware interface is present.
 120 */
 121int device_property_read_u16_array(const struct device *dev, const char *propname,
 122				   u16 *val, size_t nval)
 123{
 124	return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
 125}
 126EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 127
 128/**
 129 * device_property_read_u32_array - return a u32 array property of a device
 130 * @dev: Device to get the property of
 131 * @propname: Name of the property
 132 * @val: The values are stored here or %NULL to return the number of values
 133 * @nval: Size of the @val array
 134 *
 135 * Function reads an array of u32 properties with @propname from the device
 136 * firmware description and stores them to @val if found.
 137 *
 138 * It's recommended to call device_property_count_u32() instead of calling
 139 * this function with @val equals %NULL and @nval equals 0.
 140 *
 141 * Return: number of values if @val was %NULL,
 142 *         %0 if the property was found (success),
 143 *	   %-EINVAL if given arguments are not valid,
 144 *	   %-ENODATA if the property does not have a value,
 145 *	   %-EPROTO if the property is not an array of numbers,
 146 *	   %-EOVERFLOW if the size of the property is not as expected.
 147 *	   %-ENXIO if no suitable firmware interface is present.
 148 */
 149int device_property_read_u32_array(const struct device *dev, const char *propname,
 150				   u32 *val, size_t nval)
 151{
 152	return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
 153}
 154EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 155
 156/**
 157 * device_property_read_u64_array - return a u64 array property of a device
 158 * @dev: Device to get the property of
 159 * @propname: Name of the property
 160 * @val: The values are stored here or %NULL to return the number of values
 161 * @nval: Size of the @val array
 162 *
 163 * Function reads an array of u64 properties with @propname from the device
 164 * firmware description and stores them to @val if found.
 165 *
 166 * It's recommended to call device_property_count_u64() instead of calling
 167 * this function with @val equals %NULL and @nval equals 0.
 168 *
 169 * Return: number of values if @val was %NULL,
 170 *         %0 if the property was found (success),
 171 *	   %-EINVAL if given arguments are not valid,
 172 *	   %-ENODATA if the property does not have a value,
 173 *	   %-EPROTO if the property is not an array of numbers,
 174 *	   %-EOVERFLOW if the size of the property is not as expected.
 175 *	   %-ENXIO if no suitable firmware interface is present.
 176 */
 177int device_property_read_u64_array(const struct device *dev, const char *propname,
 178				   u64 *val, size_t nval)
 179{
 180	return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
 181}
 182EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 183
 184/**
 185 * device_property_read_string_array - return a string array property of device
 186 * @dev: Device to get the property of
 187 * @propname: Name of the property
 188 * @val: The values are stored here or %NULL to return the number of values
 189 * @nval: Size of the @val array
 190 *
 191 * Function reads an array of string properties with @propname from the device
 192 * firmware description and stores them to @val if found.
 193 *
 194 * It's recommended to call device_property_string_array_count() instead of calling
 195 * this function with @val equals %NULL and @nval equals 0.
 196 *
 197 * Return: number of values read on success if @val is non-NULL,
 198 *	   number of values available on success if @val is NULL,
 199 *	   %-EINVAL if given arguments are not valid,
 200 *	   %-ENODATA if the property does not have a value,
 201 *	   %-EPROTO or %-EILSEQ if the property is not an array of strings,
 202 *	   %-EOVERFLOW if the size of the property is not as expected.
 203 *	   %-ENXIO if no suitable firmware interface is present.
 204 */
 205int device_property_read_string_array(const struct device *dev, const char *propname,
 206				      const char **val, size_t nval)
 207{
 208	return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
 209}
 210EXPORT_SYMBOL_GPL(device_property_read_string_array);
 211
 212/**
 213 * device_property_read_string - return a string property of a device
 214 * @dev: Device to get the property of
 215 * @propname: Name of the property
 216 * @val: The value is stored here
 217 *
 218 * Function reads property @propname from the device firmware description and
 219 * stores the value into @val if found. The value is checked to be a string.
 220 *
 221 * Return: %0 if the property was found (success),
 222 *	   %-EINVAL if given arguments are not valid,
 223 *	   %-ENODATA if the property does not have a value,
 224 *	   %-EPROTO or %-EILSEQ if the property type is not a string.
 225 *	   %-ENXIO if no suitable firmware interface is present.
 226 */
 227int device_property_read_string(const struct device *dev, const char *propname,
 228				const char **val)
 229{
 230	return fwnode_property_read_string(dev_fwnode(dev), propname, val);
 231}
 232EXPORT_SYMBOL_GPL(device_property_read_string);
 233
 234/**
 235 * device_property_match_string - find a string in an array and return index
 236 * @dev: Device to get the property of
 237 * @propname: Name of the property holding the array
 238 * @string: String to look for
 239 *
 240 * Find a given string in a string array and if it is found return the
 241 * index back.
 242 *
 243 * Return: index, starting from %0, if the property was found (success),
 244 *	   %-EINVAL if given arguments are not valid,
 245 *	   %-ENODATA if the property does not have a value,
 246 *	   %-EPROTO if the property is not an array of strings,
 247 *	   %-ENXIO if no suitable firmware interface is present.
 248 */
 249int device_property_match_string(const struct device *dev, const char *propname,
 250				 const char *string)
 251{
 252	return fwnode_property_match_string(dev_fwnode(dev), propname, string);
 253}
 254EXPORT_SYMBOL_GPL(device_property_match_string);
 255
 256static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 257					  const char *propname,
 258					  unsigned int elem_size, void *val,
 259					  size_t nval)
 260{
 261	int ret;
 262
 263	if (IS_ERR_OR_NULL(fwnode))
 264		return -EINVAL;
 265
 266	ret = fwnode_call_int_op(fwnode, property_read_int_array, propname,
 267				 elem_size, val, nval);
 268	if (ret != -EINVAL)
 269		return ret;
 270
 271	return fwnode_call_int_op(fwnode->secondary, property_read_int_array, propname,
 272				  elem_size, val, nval);
 273}
 274
 275/**
 276 * fwnode_property_read_u8_array - return a u8 array property of firmware node
 277 * @fwnode: Firmware node to get the property of
 278 * @propname: Name of the property
 279 * @val: The values are stored here or %NULL to return the number of values
 280 * @nval: Size of the @val array
 281 *
 282 * Read an array of u8 properties with @propname from @fwnode and stores them to
 283 * @val if found.
 284 *
 285 * It's recommended to call fwnode_property_count_u8() instead of calling
 286 * this function with @val equals %NULL and @nval equals 0.
 287 *
 288 * Return: number of values if @val was %NULL,
 289 *         %0 if the property was found (success),
 290 *	   %-EINVAL if given arguments are not valid,
 291 *	   %-ENODATA if the property does not have a value,
 292 *	   %-EPROTO if the property is not an array of numbers,
 293 *	   %-EOVERFLOW if the size of the property is not as expected,
 294 *	   %-ENXIO if no suitable firmware interface is present.
 295 */
 296int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode,
 297				  const char *propname, u8 *val, size_t nval)
 298{
 299	return fwnode_property_read_int_array(fwnode, propname, sizeof(u8),
 300					      val, nval);
 301}
 302EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
 303
 304/**
 305 * fwnode_property_read_u16_array - return a u16 array property of firmware node
 306 * @fwnode: Firmware node to get the property of
 307 * @propname: Name of the property
 308 * @val: The values are stored here or %NULL to return the number of values
 309 * @nval: Size of the @val array
 310 *
 311 * Read an array of u16 properties with @propname from @fwnode and store them to
 312 * @val if found.
 313 *
 314 * It's recommended to call fwnode_property_count_u16() instead of calling
 315 * this function with @val equals %NULL and @nval equals 0.
 316 *
 317 * Return: number of values if @val was %NULL,
 318 *         %0 if the property was found (success),
 319 *	   %-EINVAL if given arguments are not valid,
 320 *	   %-ENODATA if the property does not have a value,
 321 *	   %-EPROTO if the property is not an array of numbers,
 322 *	   %-EOVERFLOW if the size of the property is not as expected,
 323 *	   %-ENXIO if no suitable firmware interface is present.
 324 */
 325int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode,
 326				   const char *propname, u16 *val, size_t nval)
 327{
 328	return fwnode_property_read_int_array(fwnode, propname, sizeof(u16),
 329					      val, nval);
 330}
 331EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
 332
 333/**
 334 * fwnode_property_read_u32_array - return a u32 array property of firmware node
 335 * @fwnode: Firmware node to get the property of
 336 * @propname: Name of the property
 337 * @val: The values are stored here or %NULL to return the number of values
 338 * @nval: Size of the @val array
 339 *
 340 * Read an array of u32 properties with @propname from @fwnode store them to
 341 * @val if found.
 342 *
 343 * It's recommended to call fwnode_property_count_u32() instead of calling
 344 * this function with @val equals %NULL and @nval equals 0.
 345 *
 346 * Return: number of values if @val was %NULL,
 347 *         %0 if the property was found (success),
 348 *	   %-EINVAL if given arguments are not valid,
 349 *	   %-ENODATA if the property does not have a value,
 350 *	   %-EPROTO if the property is not an array of numbers,
 351 *	   %-EOVERFLOW if the size of the property is not as expected,
 352 *	   %-ENXIO if no suitable firmware interface is present.
 353 */
 354int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode,
 355				   const char *propname, u32 *val, size_t nval)
 356{
 357	return fwnode_property_read_int_array(fwnode, propname, sizeof(u32),
 358					      val, nval);
 359}
 360EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
 361
 362/**
 363 * fwnode_property_read_u64_array - return a u64 array property firmware node
 364 * @fwnode: Firmware node to get the property of
 365 * @propname: Name of the property
 366 * @val: The values are stored here or %NULL to return the number of values
 367 * @nval: Size of the @val array
 368 *
 369 * Read an array of u64 properties with @propname from @fwnode and store them to
 370 * @val if found.
 371 *
 372 * It's recommended to call fwnode_property_count_u64() instead of calling
 373 * this function with @val equals %NULL and @nval equals 0.
 374 *
 375 * Return: number of values if @val was %NULL,
 376 *         %0 if the property was found (success),
 377 *	   %-EINVAL if given arguments are not valid,
 378 *	   %-ENODATA if the property does not have a value,
 379 *	   %-EPROTO if the property is not an array of numbers,
 380 *	   %-EOVERFLOW if the size of the property is not as expected,
 381 *	   %-ENXIO if no suitable firmware interface is present.
 382 */
 383int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode,
 384				   const char *propname, u64 *val, size_t nval)
 385{
 386	return fwnode_property_read_int_array(fwnode, propname, sizeof(u64),
 387					      val, nval);
 388}
 389EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
 390
 391/**
 392 * fwnode_property_read_string_array - return string array property of a node
 393 * @fwnode: Firmware node to get the property of
 394 * @propname: Name of the property
 395 * @val: The values are stored here or %NULL to return the number of values
 396 * @nval: Size of the @val array
 397 *
 398 * Read an string list property @propname from the given firmware node and store
 399 * them to @val if found.
 400 *
 401 * It's recommended to call fwnode_property_string_array_count() instead of calling
 402 * this function with @val equals %NULL and @nval equals 0.
 403 *
 404 * Return: number of values read on success if @val is non-NULL,
 405 *	   number of values available on success if @val is NULL,
 406 *	   %-EINVAL if given arguments are not valid,
 407 *	   %-ENODATA if the property does not have a value,
 408 *	   %-EPROTO or %-EILSEQ if the property is not an array of strings,
 409 *	   %-EOVERFLOW if the size of the property is not as expected,
 410 *	   %-ENXIO if no suitable firmware interface is present.
 411 */
 412int fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 413				      const char *propname, const char **val,
 414				      size_t nval)
 415{
 416	int ret;
 417
 418	if (IS_ERR_OR_NULL(fwnode))
 419		return -EINVAL;
 420
 421	ret = fwnode_call_int_op(fwnode, property_read_string_array, propname,
 422				 val, nval);
 423	if (ret != -EINVAL)
 424		return ret;
 425
 426	return fwnode_call_int_op(fwnode->secondary, property_read_string_array, propname,
 427				  val, nval);
 428}
 429EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
 430
 431/**
 432 * fwnode_property_read_string - return a string property of a firmware node
 433 * @fwnode: Firmware node to get the property of
 434 * @propname: Name of the property
 435 * @val: The value is stored here
 436 *
 437 * Read property @propname from the given firmware node and store the value into
 438 * @val if found.  The value is checked to be a string.
 439 *
 440 * Return: %0 if the property was found (success),
 441 *	   %-EINVAL if given arguments are not valid,
 442 *	   %-ENODATA if the property does not have a value,
 443 *	   %-EPROTO or %-EILSEQ if the property is not a string,
 444 *	   %-ENXIO if no suitable firmware interface is present.
 445 */
 446int fwnode_property_read_string(const struct fwnode_handle *fwnode,
 447				const char *propname, const char **val)
 448{
 449	int ret = fwnode_property_read_string_array(fwnode, propname, val, 1);
 450
 451	return ret < 0 ? ret : 0;
 452}
 453EXPORT_SYMBOL_GPL(fwnode_property_read_string);
 454
 455/**
 456 * fwnode_property_match_string - find a string in an array and return index
 457 * @fwnode: Firmware node to get the property of
 458 * @propname: Name of the property holding the array
 459 * @string: String to look for
 460 *
 461 * Find a given string in a string array and if it is found return the
 462 * index back.
 463 *
 464 * Return: index, starting from %0, if the property was found (success),
 465 *	   %-EINVAL if given arguments are not valid,
 466 *	   %-ENODATA if the property does not have a value,
 467 *	   %-EPROTO if the property is not an array of strings,
 468 *	   %-ENXIO if no suitable firmware interface is present.
 469 */
 470int fwnode_property_match_string(const struct fwnode_handle *fwnode,
 471	const char *propname, const char *string)
 472{
 473	const char **values;
 474	int nval, ret;
 475
 476	nval = fwnode_property_string_array_count(fwnode, propname);
 477	if (nval < 0)
 478		return nval;
 479
 480	if (nval == 0)
 481		return -ENODATA;
 482
 483	values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
 484	if (!values)
 485		return -ENOMEM;
 486
 487	ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
 488	if (ret < 0)
 489		goto out_free;
 490
 491	ret = match_string(values, nval, string);
 492	if (ret < 0)
 493		ret = -ENODATA;
 494
 495out_free:
 496	kfree(values);
 497	return ret;
 498}
 499EXPORT_SYMBOL_GPL(fwnode_property_match_string);
 500
 501/**
 502 * fwnode_property_match_property_string - find a property string value in an array and return index
 503 * @fwnode: Firmware node to get the property of
 504 * @propname: Name of the property holding the string value
 505 * @array: String array to search in
 506 * @n: Size of the @array
 507 *
 508 * Find a property string value in a given @array and if it is found return
 509 * the index back.
 510 *
 511 * Return: index, starting from %0, if the string value was found in the @array (success),
 512 *	   %-ENOENT when the string value was not found in the @array,
 513 *	   %-EINVAL if given arguments are not valid,
 514 *	   %-ENODATA if the property does not have a value,
 515 *	   %-EPROTO or %-EILSEQ if the property is not a string,
 516 *	   %-ENXIO if no suitable firmware interface is present.
 517 */
 518int fwnode_property_match_property_string(const struct fwnode_handle *fwnode,
 519	const char *propname, const char * const *array, size_t n)
 520{
 521	const char *string;
 522	int ret;
 523
 524	ret = fwnode_property_read_string(fwnode, propname, &string);
 525	if (ret)
 526		return ret;
 527
 528	ret = match_string(array, n, string);
 529	if (ret < 0)
 530		ret = -ENOENT;
 531
 532	return ret;
 533}
 534EXPORT_SYMBOL_GPL(fwnode_property_match_property_string);
 535
 536/**
 537 * fwnode_property_get_reference_args() - Find a reference with arguments
 538 * @fwnode:	Firmware node where to look for the reference
 539 * @prop:	The name of the property
 540 * @nargs_prop:	The name of the property telling the number of
 541 *		arguments in the referred node. NULL if @nargs is known,
 542 *		otherwise @nargs is ignored. Only relevant on OF.
 543 * @nargs:	Number of arguments. Ignored if @nargs_prop is non-NULL.
 544 * @index:	Index of the reference, from zero onwards.
 545 * @args:	Result structure with reference and integer arguments.
 546 *		May be NULL.
 547 *
 548 * Obtain a reference based on a named property in an fwnode, with
 549 * integer arguments.
 550 *
 551 * The caller is responsible for calling fwnode_handle_put() on the returned
 552 * @args->fwnode pointer.
 553 *
 554 * Return: %0 on success
 555 *	    %-ENOENT when the index is out of bounds, the index has an empty
 556 *		     reference or the property was not found
 557 *	    %-EINVAL on parse error
 558 */
 559int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode,
 560				       const char *prop, const char *nargs_prop,
 561				       unsigned int nargs, unsigned int index,
 562				       struct fwnode_reference_args *args)
 563{
 564	int ret;
 565
 566	if (IS_ERR_OR_NULL(fwnode))
 567		return -ENOENT;
 568
 569	ret = fwnode_call_int_op(fwnode, get_reference_args, prop, nargs_prop,
 570				 nargs, index, args);
 571	if (ret == 0)
 572		return ret;
 573
 574	if (IS_ERR_OR_NULL(fwnode->secondary))
 575		return ret;
 576
 577	return fwnode_call_int_op(fwnode->secondary, get_reference_args, prop, nargs_prop,
 578				  nargs, index, args);
 579}
 580EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args);
 581
 582/**
 583 * fwnode_find_reference - Find named reference to a fwnode_handle
 584 * @fwnode: Firmware node where to look for the reference
 585 * @name: The name of the reference
 586 * @index: Index of the reference
 587 *
 588 * @index can be used when the named reference holds a table of references.
 589 *
 590 * The caller is responsible for calling fwnode_handle_put() on the returned
 591 * fwnode pointer.
 592 *
 593 * Return: a pointer to the reference fwnode, when found. Otherwise,
 594 * returns an error pointer.
 595 */
 596struct fwnode_handle *fwnode_find_reference(const struct fwnode_handle *fwnode,
 597					    const char *name,
 598					    unsigned int index)
 599{
 600	struct fwnode_reference_args args;
 601	int ret;
 602
 603	ret = fwnode_property_get_reference_args(fwnode, name, NULL, 0, index,
 604						 &args);
 605	return ret ? ERR_PTR(ret) : args.fwnode;
 606}
 607EXPORT_SYMBOL_GPL(fwnode_find_reference);
 608
 609/**
 610 * fwnode_get_name - Return the name of a node
 611 * @fwnode: The firmware node
 612 *
 613 * Return: a pointer to the node name, or %NULL.
 614 */
 615const char *fwnode_get_name(const struct fwnode_handle *fwnode)
 616{
 617	return fwnode_call_ptr_op(fwnode, get_name);
 618}
 619EXPORT_SYMBOL_GPL(fwnode_get_name);
 620
 621/**
 622 * fwnode_get_name_prefix - Return the prefix of node for printing purposes
 623 * @fwnode: The firmware node
 624 *
 625 * Return: the prefix of a node, intended to be printed right before the node.
 626 * The prefix works also as a separator between the nodes.
 627 */
 628const char *fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
 629{
 630	return fwnode_call_ptr_op(fwnode, get_name_prefix);
 631}
 632
 633/**
 634 * fwnode_name_eq - Return true if node name is equal
 635 * @fwnode: The firmware node
 636 * @name: The name to which to compare the node name
 637 *
 638 * Compare the name provided as an argument to the name of the node, stopping
 639 * the comparison at either NUL or '@' character, whichever comes first. This
 640 * function is generally used for comparing node names while ignoring the
 641 * possible unit address of the node.
 642 *
 643 * Return: true if the node name matches with the name provided in the @name
 644 * argument, false otherwise.
 645 */
 646bool fwnode_name_eq(const struct fwnode_handle *fwnode, const char *name)
 647{
 648	const char *node_name;
 649	ptrdiff_t len;
 650
 651	node_name = fwnode_get_name(fwnode);
 652	if (!node_name)
 653		return false;
 654
 655	len = strchrnul(node_name, '@') - node_name;
 656
 657	return str_has_prefix(node_name, name) == len;
 658}
 659EXPORT_SYMBOL_GPL(fwnode_name_eq);
 660
 661/**
 662 * fwnode_get_parent - Return parent firwmare node
 663 * @fwnode: Firmware whose parent is retrieved
 664 *
 665 * The caller is responsible for calling fwnode_handle_put() on the returned
 666 * fwnode pointer.
 667 *
 668 * Return: parent firmware node of the given node if possible or %NULL if no
 669 * parent was available.
 670 */
 671struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode)
 672{
 673	return fwnode_call_ptr_op(fwnode, get_parent);
 674}
 675EXPORT_SYMBOL_GPL(fwnode_get_parent);
 676
 677/**
 678 * fwnode_get_next_parent - Iterate to the node's parent
 679 * @fwnode: Firmware whose parent is retrieved
 680 *
 681 * This is like fwnode_get_parent() except that it drops the refcount
 682 * on the passed node, making it suitable for iterating through a
 683 * node's parents.
 684 *
 685 * The caller is responsible for calling fwnode_handle_put() on the returned
 686 * fwnode pointer. Note that this function also puts a reference to @fwnode
 687 * unconditionally.
 688 *
 689 * Return: parent firmware node of the given node if possible or %NULL if no
 690 * parent was available.
 691 */
 692struct fwnode_handle *fwnode_get_next_parent(struct fwnode_handle *fwnode)
 693{
 694	struct fwnode_handle *parent = fwnode_get_parent(fwnode);
 695
 696	fwnode_handle_put(fwnode);
 697
 698	return parent;
 699}
 700EXPORT_SYMBOL_GPL(fwnode_get_next_parent);
 701
 702/**
 703 * fwnode_get_next_parent_dev - Find device of closest ancestor fwnode
 704 * @fwnode: firmware node
 705 *
 706 * Given a firmware node (@fwnode), this function finds its closest ancestor
 707 * firmware node that has a corresponding struct device and returns that struct
 708 * device.
 709 *
 710 * The caller is responsible for calling put_device() on the returned device
 711 * pointer.
 712 *
 713 * Return: a pointer to the device of the @fwnode's closest ancestor.
 714 */
 715struct device *fwnode_get_next_parent_dev(const struct fwnode_handle *fwnode)
 716{
 717	struct fwnode_handle *parent;
 718	struct device *dev;
 719
 720	fwnode_for_each_parent_node(fwnode, parent) {
 721		dev = get_dev_from_fwnode(parent);
 722		if (dev) {
 723			fwnode_handle_put(parent);
 724			return dev;
 725		}
 726	}
 727	return NULL;
 728}
 729
 730/**
 731 * fwnode_count_parents - Return the number of parents a node has
 732 * @fwnode: The node the parents of which are to be counted
 733 *
 734 * Return: the number of parents a node has.
 735 */
 736unsigned int fwnode_count_parents(const struct fwnode_handle *fwnode)
 737{
 738	struct fwnode_handle *parent;
 739	unsigned int count = 0;
 740
 741	fwnode_for_each_parent_node(fwnode, parent)
 742		count++;
 743
 744	return count;
 745}
 746EXPORT_SYMBOL_GPL(fwnode_count_parents);
 747
 748/**
 749 * fwnode_get_nth_parent - Return an nth parent of a node
 750 * @fwnode: The node the parent of which is requested
 751 * @depth: Distance of the parent from the node
 752 *
 753 * The caller is responsible for calling fwnode_handle_put() on the returned
 754 * fwnode pointer.
 755 *
 756 * Return: the nth parent of a node. If there is no parent at the requested
 757 * @depth, %NULL is returned. If @depth is 0, the functionality is equivalent to
 758 * fwnode_handle_get(). For @depth == 1, it is fwnode_get_parent() and so on.
 
 
 
 759 */
 760struct fwnode_handle *fwnode_get_nth_parent(struct fwnode_handle *fwnode,
 761					    unsigned int depth)
 762{
 763	struct fwnode_handle *parent;
 764
 765	if (depth == 0)
 766		return fwnode_handle_get(fwnode);
 767
 768	fwnode_for_each_parent_node(fwnode, parent) {
 769		if (--depth == 0)
 770			return parent;
 771	}
 772	return NULL;
 773}
 774EXPORT_SYMBOL_GPL(fwnode_get_nth_parent);
 775
 776/**
 777 * fwnode_is_ancestor_of - Test if @ancestor is ancestor of @child
 778 * @ancestor: Firmware which is tested for being an ancestor
 779 * @child: Firmware which is tested for being the child
 780 *
 781 * A node is considered an ancestor of itself too.
 782 *
 783 * Return: true if @ancestor is an ancestor of @child. Otherwise, returns false.
 784 */
 785bool fwnode_is_ancestor_of(const struct fwnode_handle *ancestor, const struct fwnode_handle *child)
 786{
 787	struct fwnode_handle *parent;
 788
 789	if (IS_ERR_OR_NULL(ancestor))
 790		return false;
 791
 792	if (child == ancestor)
 793		return true;
 794
 795	fwnode_for_each_parent_node(child, parent) {
 796		if (parent == ancestor) {
 797			fwnode_handle_put(parent);
 798			return true;
 799		}
 800	}
 801	return false;
 802}
 803
 804/**
 805 * fwnode_get_next_child_node - Return the next child node handle for a node
 806 * @fwnode: Firmware node to find the next child node for.
 807 * @child: Handle to one of the node's child nodes or a %NULL handle.
 808 *
 809 * The caller is responsible for calling fwnode_handle_put() on the returned
 810 * fwnode pointer. Note that this function also puts a reference to @child
 811 * unconditionally.
 812 */
 813struct fwnode_handle *
 814fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 815			   struct fwnode_handle *child)
 816{
 817	return fwnode_call_ptr_op(fwnode, get_next_child_node, child);
 818}
 819EXPORT_SYMBOL_GPL(fwnode_get_next_child_node);
 820
 821/**
 822 * fwnode_get_next_available_child_node - Return the next available child node handle for a node
 
 823 * @fwnode: Firmware node to find the next child node for.
 824 * @child: Handle to one of the node's child nodes or a %NULL handle.
 825 *
 826 * The caller is responsible for calling fwnode_handle_put() on the returned
 827 * fwnode pointer. Note that this function also puts a reference to @child
 828 * unconditionally.
 829 */
 830struct fwnode_handle *
 831fwnode_get_next_available_child_node(const struct fwnode_handle *fwnode,
 832				     struct fwnode_handle *child)
 833{
 834	struct fwnode_handle *next_child = child;
 835
 836	if (IS_ERR_OR_NULL(fwnode))
 837		return NULL;
 838
 839	do {
 840		next_child = fwnode_get_next_child_node(fwnode, next_child);
 841		if (!next_child)
 842			return NULL;
 843	} while (!fwnode_device_is_available(next_child));
 844
 845	return next_child;
 846}
 847EXPORT_SYMBOL_GPL(fwnode_get_next_available_child_node);
 848
 849/**
 850 * device_get_next_child_node - Return the next child node handle for a device
 851 * @dev: Device to find the next child node for.
 852 * @child: Handle to one of the device's child nodes or a %NULL handle.
 853 *
 854 * The caller is responsible for calling fwnode_handle_put() on the returned
 855 * fwnode pointer. Note that this function also puts a reference to @child
 856 * unconditionally.
 857 */
 858struct fwnode_handle *device_get_next_child_node(const struct device *dev,
 859						 struct fwnode_handle *child)
 860{
 861	const struct fwnode_handle *fwnode = dev_fwnode(dev);
 862	struct fwnode_handle *next;
 863
 864	if (IS_ERR_OR_NULL(fwnode))
 865		return NULL;
 866
 867	/* Try to find a child in primary fwnode */
 868	next = fwnode_get_next_child_node(fwnode, child);
 869	if (next)
 870		return next;
 871
 872	/* When no more children in primary, continue with secondary */
 873	return fwnode_get_next_child_node(fwnode->secondary, child);
 874}
 875EXPORT_SYMBOL_GPL(device_get_next_child_node);
 876
 877/**
 878 * fwnode_get_named_child_node - Return first matching named child node handle
 879 * @fwnode: Firmware node to find the named child node for.
 880 * @childname: String to match child node name against.
 881 *
 882 * The caller is responsible for calling fwnode_handle_put() on the returned
 883 * fwnode pointer.
 884 */
 885struct fwnode_handle *
 886fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 887			    const char *childname)
 888{
 889	return fwnode_call_ptr_op(fwnode, get_named_child_node, childname);
 890}
 891EXPORT_SYMBOL_GPL(fwnode_get_named_child_node);
 892
 893/**
 894 * device_get_named_child_node - Return first matching named child node handle
 895 * @dev: Device to find the named child node for.
 896 * @childname: String to match child node name against.
 897 *
 898 * The caller is responsible for calling fwnode_handle_put() on the returned
 899 * fwnode pointer.
 900 */
 901struct fwnode_handle *device_get_named_child_node(const struct device *dev,
 902						  const char *childname)
 903{
 904	return fwnode_get_named_child_node(dev_fwnode(dev), childname);
 905}
 906EXPORT_SYMBOL_GPL(device_get_named_child_node);
 907
 908/**
 909 * fwnode_handle_get - Obtain a reference to a device node
 910 * @fwnode: Pointer to the device node to obtain the reference to.
 911 *
 912 * The caller is responsible for calling fwnode_handle_put() on the returned
 913 * fwnode pointer.
 914 *
 915 * Return: the fwnode handle.
 916 */
 917struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode)
 918{
 919	if (!fwnode_has_op(fwnode, get))
 920		return fwnode;
 921
 922	return fwnode_call_ptr_op(fwnode, get);
 923}
 924EXPORT_SYMBOL_GPL(fwnode_handle_get);
 925
 926/**
 927 * fwnode_handle_put - Drop reference to a device node
 928 * @fwnode: Pointer to the device node to drop the reference to.
 929 *
 930 * This has to be used when terminating device_for_each_child_node() iteration
 931 * with break or return to prevent stale device node references from being left
 932 * behind.
 933 */
 934void fwnode_handle_put(struct fwnode_handle *fwnode)
 935{
 936	fwnode_call_void_op(fwnode, put);
 937}
 938EXPORT_SYMBOL_GPL(fwnode_handle_put);
 939
 940/**
 941 * fwnode_device_is_available - check if a device is available for use
 942 * @fwnode: Pointer to the fwnode of the device.
 943 *
 944 * Return: true if device is available for use. Otherwise, returns false.
 945 *
 946 * For fwnode node types that don't implement the .device_is_available()
 947 * operation, this function returns true.
 948 */
 949bool fwnode_device_is_available(const struct fwnode_handle *fwnode)
 950{
 951	if (IS_ERR_OR_NULL(fwnode))
 952		return false;
 953
 954	if (!fwnode_has_op(fwnode, device_is_available))
 955		return true;
 956
 957	return fwnode_call_bool_op(fwnode, device_is_available);
 958}
 959EXPORT_SYMBOL_GPL(fwnode_device_is_available);
 960
 961/**
 962 * device_get_child_node_count - return the number of child nodes for device
 963 * @dev: Device to cound the child nodes for
 964 *
 965 * Return: the number of child nodes for a given device.
 966 */
 967unsigned int device_get_child_node_count(const struct device *dev)
 968{
 969	struct fwnode_handle *child;
 970	unsigned int count = 0;
 971
 972	device_for_each_child_node(dev, child)
 973		count++;
 974
 975	return count;
 976}
 977EXPORT_SYMBOL_GPL(device_get_child_node_count);
 978
 979bool device_dma_supported(const struct device *dev)
 980{
 981	return fwnode_call_bool_op(dev_fwnode(dev), device_dma_supported);
 982}
 983EXPORT_SYMBOL_GPL(device_dma_supported);
 984
 985enum dev_dma_attr device_get_dma_attr(const struct device *dev)
 986{
 987	if (!fwnode_has_op(dev_fwnode(dev), device_get_dma_attr))
 988		return DEV_DMA_NOT_SUPPORTED;
 989
 990	return fwnode_call_int_op(dev_fwnode(dev), device_get_dma_attr);
 991}
 992EXPORT_SYMBOL_GPL(device_get_dma_attr);
 993
 994/**
 995 * fwnode_get_phy_mode - Get phy mode for given firmware node
 996 * @fwnode:	Pointer to the given node
 997 *
 998 * The function gets phy interface string from property 'phy-mode' or
 999 * 'phy-connection-type', and return its index in phy_modes table, or errno in
1000 * error case.
1001 */
1002int fwnode_get_phy_mode(const struct fwnode_handle *fwnode)
1003{
1004	const char *pm;
1005	int err, i;
1006
1007	err = fwnode_property_read_string(fwnode, "phy-mode", &pm);
1008	if (err < 0)
1009		err = fwnode_property_read_string(fwnode,
1010						  "phy-connection-type", &pm);
1011	if (err < 0)
1012		return err;
1013
1014	for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
1015		if (!strcasecmp(pm, phy_modes(i)))
1016			return i;
1017
1018	return -ENODEV;
1019}
1020EXPORT_SYMBOL_GPL(fwnode_get_phy_mode);
1021
1022/**
1023 * device_get_phy_mode - Get phy mode for given device
1024 * @dev:	Pointer to the given device
1025 *
1026 * The function gets phy interface string from property 'phy-mode' or
1027 * 'phy-connection-type', and return its index in phy_modes table, or errno in
1028 * error case.
1029 */
1030int device_get_phy_mode(struct device *dev)
1031{
1032	return fwnode_get_phy_mode(dev_fwnode(dev));
1033}
1034EXPORT_SYMBOL_GPL(device_get_phy_mode);
1035
1036/**
1037 * fwnode_iomap - Maps the memory mapped IO for a given fwnode
1038 * @fwnode:	Pointer to the firmware node
1039 * @index:	Index of the IO range
1040 *
1041 * Return: a pointer to the mapped memory.
1042 */
1043void __iomem *fwnode_iomap(struct fwnode_handle *fwnode, int index)
1044{
1045	return fwnode_call_ptr_op(fwnode, iomap, index);
1046}
1047EXPORT_SYMBOL(fwnode_iomap);
1048
1049/**
1050 * fwnode_irq_get - Get IRQ directly from a fwnode
1051 * @fwnode:	Pointer to the firmware node
1052 * @index:	Zero-based index of the IRQ
1053 *
1054 * Return: Linux IRQ number on success. Negative errno on failure.
 
1055 */
1056int fwnode_irq_get(const struct fwnode_handle *fwnode, unsigned int index)
1057{
1058	int ret;
1059
1060	ret = fwnode_call_int_op(fwnode, irq_get, index);
1061	/* We treat mapping errors as invalid case */
1062	if (ret == 0)
1063		return -EINVAL;
1064
1065	return ret;
1066}
1067EXPORT_SYMBOL(fwnode_irq_get);
1068
1069/**
1070 * fwnode_irq_get_byname - Get IRQ from a fwnode using its name
1071 * @fwnode:	Pointer to the firmware node
1072 * @name:	IRQ name
1073 *
1074 * Description:
1075 * Find a match to the string @name in the 'interrupt-names' string array
1076 * in _DSD for ACPI, or of_node for Device Tree. Then get the Linux IRQ
1077 * number of the IRQ resource corresponding to the index of the matched
1078 * string.
1079 *
1080 * Return: Linux IRQ number on success, or negative errno otherwise.
 
1081 */
1082int fwnode_irq_get_byname(const struct fwnode_handle *fwnode, const char *name)
1083{
1084	int index;
1085
1086	if (!name)
1087		return -EINVAL;
1088
1089	index = fwnode_property_match_string(fwnode, "interrupt-names",  name);
1090	if (index < 0)
1091		return index;
1092
1093	return fwnode_irq_get(fwnode, index);
1094}
1095EXPORT_SYMBOL(fwnode_irq_get_byname);
1096
1097/**
1098 * fwnode_graph_get_next_endpoint - Get next endpoint firmware node
1099 * @fwnode: Pointer to the parent firmware node
1100 * @prev: Previous endpoint node or %NULL to get the first
1101 *
1102 * The caller is responsible for calling fwnode_handle_put() on the returned
1103 * fwnode pointer. Note that this function also puts a reference to @prev
1104 * unconditionally.
1105 *
1106 * Return: an endpoint firmware node pointer or %NULL if no more endpoints
1107 * are available.
1108 */
1109struct fwnode_handle *
1110fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1111			       struct fwnode_handle *prev)
1112{
1113	struct fwnode_handle *ep, *port_parent = NULL;
1114	const struct fwnode_handle *parent;
1115
1116	/*
1117	 * If this function is in a loop and the previous iteration returned
1118	 * an endpoint from fwnode->secondary, then we need to use the secondary
1119	 * as parent rather than @fwnode.
1120	 */
1121	if (prev) {
1122		port_parent = fwnode_graph_get_port_parent(prev);
1123		parent = port_parent;
1124	} else {
1125		parent = fwnode;
1126	}
1127	if (IS_ERR_OR_NULL(parent))
1128		return NULL;
1129
1130	ep = fwnode_call_ptr_op(parent, graph_get_next_endpoint, prev);
1131	if (ep)
1132		goto out_put_port_parent;
1133
1134	ep = fwnode_graph_get_next_endpoint(parent->secondary, NULL);
1135
1136out_put_port_parent:
1137	fwnode_handle_put(port_parent);
1138	return ep;
1139}
1140EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint);
1141
1142/**
1143 * fwnode_graph_get_port_parent - Return the device fwnode of a port endpoint
1144 * @endpoint: Endpoint firmware node of the port
1145 *
1146 * The caller is responsible for calling fwnode_handle_put() on the returned
1147 * fwnode pointer.
1148 *
1149 * Return: the firmware node of the device the @endpoint belongs to.
1150 */
1151struct fwnode_handle *
1152fwnode_graph_get_port_parent(const struct fwnode_handle *endpoint)
1153{
1154	struct fwnode_handle *port, *parent;
1155
1156	port = fwnode_get_parent(endpoint);
1157	parent = fwnode_call_ptr_op(port, graph_get_port_parent);
1158
1159	fwnode_handle_put(port);
1160
1161	return parent;
1162}
1163EXPORT_SYMBOL_GPL(fwnode_graph_get_port_parent);
1164
1165/**
1166 * fwnode_graph_get_remote_port_parent - Return fwnode of a remote device
1167 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1168 *
1169 * Extracts firmware node of a remote device the @fwnode points to.
1170 *
1171 * The caller is responsible for calling fwnode_handle_put() on the returned
1172 * fwnode pointer.
1173 */
1174struct fwnode_handle *
1175fwnode_graph_get_remote_port_parent(const struct fwnode_handle *fwnode)
1176{
1177	struct fwnode_handle *endpoint, *parent;
1178
1179	endpoint = fwnode_graph_get_remote_endpoint(fwnode);
1180	parent = fwnode_graph_get_port_parent(endpoint);
1181
1182	fwnode_handle_put(endpoint);
1183
1184	return parent;
1185}
1186EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port_parent);
1187
1188/**
1189 * fwnode_graph_get_remote_port - Return fwnode of a remote port
1190 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1191 *
1192 * Extracts firmware node of a remote port the @fwnode points to.
1193 *
1194 * The caller is responsible for calling fwnode_handle_put() on the returned
1195 * fwnode pointer.
1196 */
1197struct fwnode_handle *
1198fwnode_graph_get_remote_port(const struct fwnode_handle *fwnode)
1199{
1200	return fwnode_get_next_parent(fwnode_graph_get_remote_endpoint(fwnode));
1201}
1202EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port);
1203
1204/**
1205 * fwnode_graph_get_remote_endpoint - Return fwnode of a remote endpoint
1206 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1207 *
1208 * Extracts firmware node of a remote endpoint the @fwnode points to.
1209 *
1210 * The caller is responsible for calling fwnode_handle_put() on the returned
1211 * fwnode pointer.
1212 */
1213struct fwnode_handle *
1214fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1215{
1216	return fwnode_call_ptr_op(fwnode, graph_get_remote_endpoint);
1217}
1218EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_endpoint);
1219
1220static bool fwnode_graph_remote_available(struct fwnode_handle *ep)
1221{
1222	struct fwnode_handle *dev_node;
1223	bool available;
1224
1225	dev_node = fwnode_graph_get_remote_port_parent(ep);
1226	available = fwnode_device_is_available(dev_node);
1227	fwnode_handle_put(dev_node);
1228
1229	return available;
1230}
1231
1232/**
1233 * fwnode_graph_get_endpoint_by_id - get endpoint by port and endpoint numbers
1234 * @fwnode: parent fwnode_handle containing the graph
1235 * @port: identifier of the port node
1236 * @endpoint: identifier of the endpoint node under the port node
1237 * @flags: fwnode lookup flags
1238 *
1239 * The caller is responsible for calling fwnode_handle_put() on the returned
1240 * fwnode pointer.
1241 *
1242 * Return: the fwnode handle of the local endpoint corresponding the port and
1243 * endpoint IDs or %NULL if not found.
1244 *
1245 * If FWNODE_GRAPH_ENDPOINT_NEXT is passed in @flags and the specified endpoint
1246 * has not been found, look for the closest endpoint ID greater than the
1247 * specified one and return the endpoint that corresponds to it, if present.
1248 *
1249 * Does not return endpoints that belong to disabled devices or endpoints that
1250 * are unconnected, unless FWNODE_GRAPH_DEVICE_DISABLED is passed in @flags.
 
 
 
1251 */
1252struct fwnode_handle *
1253fwnode_graph_get_endpoint_by_id(const struct fwnode_handle *fwnode,
1254				u32 port, u32 endpoint, unsigned long flags)
1255{
1256	struct fwnode_handle *ep, *best_ep = NULL;
1257	unsigned int best_ep_id = 0;
1258	bool endpoint_next = flags & FWNODE_GRAPH_ENDPOINT_NEXT;
1259	bool enabled_only = !(flags & FWNODE_GRAPH_DEVICE_DISABLED);
1260
1261	fwnode_graph_for_each_endpoint(fwnode, ep) {
1262		struct fwnode_endpoint fwnode_ep = { 0 };
1263		int ret;
1264
1265		if (enabled_only && !fwnode_graph_remote_available(ep))
1266			continue;
1267
1268		ret = fwnode_graph_parse_endpoint(ep, &fwnode_ep);
1269		if (ret < 0)
1270			continue;
1271
1272		if (fwnode_ep.port != port)
1273			continue;
1274
1275		if (fwnode_ep.id == endpoint)
1276			return ep;
1277
1278		if (!endpoint_next)
1279			continue;
1280
1281		/*
1282		 * If the endpoint that has just been found is not the first
1283		 * matching one and the ID of the one found previously is closer
1284		 * to the requested endpoint ID, skip it.
1285		 */
1286		if (fwnode_ep.id < endpoint ||
1287		    (best_ep && best_ep_id < fwnode_ep.id))
1288			continue;
1289
1290		fwnode_handle_put(best_ep);
1291		best_ep = fwnode_handle_get(ep);
1292		best_ep_id = fwnode_ep.id;
1293	}
1294
1295	return best_ep;
1296}
1297EXPORT_SYMBOL_GPL(fwnode_graph_get_endpoint_by_id);
1298
1299/**
1300 * fwnode_graph_get_endpoint_count - Count endpoints on a device node
1301 * @fwnode: The node related to a device
1302 * @flags: fwnode lookup flags
1303 * Count endpoints in a device node.
1304 *
1305 * If FWNODE_GRAPH_DEVICE_DISABLED flag is specified, also unconnected endpoints
1306 * and endpoints connected to disabled devices are counted.
1307 */
1308unsigned int fwnode_graph_get_endpoint_count(const struct fwnode_handle *fwnode,
1309					     unsigned long flags)
1310{
1311	struct fwnode_handle *ep;
1312	unsigned int count = 0;
1313
1314	fwnode_graph_for_each_endpoint(fwnode, ep) {
1315		if (flags & FWNODE_GRAPH_DEVICE_DISABLED ||
1316		    fwnode_graph_remote_available(ep))
1317			count++;
1318	}
1319
1320	return count;
1321}
1322EXPORT_SYMBOL_GPL(fwnode_graph_get_endpoint_count);
1323
1324/**
1325 * fwnode_graph_parse_endpoint - parse common endpoint node properties
1326 * @fwnode: pointer to endpoint fwnode_handle
1327 * @endpoint: pointer to the fwnode endpoint data structure
1328 *
1329 * Parse @fwnode representing a graph endpoint node and store the
1330 * information in @endpoint. The caller must hold a reference to
1331 * @fwnode.
1332 */
1333int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1334				struct fwnode_endpoint *endpoint)
1335{
1336	memset(endpoint, 0, sizeof(*endpoint));
1337
1338	return fwnode_call_int_op(fwnode, graph_parse_endpoint, endpoint);
1339}
1340EXPORT_SYMBOL(fwnode_graph_parse_endpoint);
1341
1342const void *device_get_match_data(const struct device *dev)
1343{
1344	return fwnode_call_ptr_op(dev_fwnode(dev), device_get_match_data, dev);
1345}
1346EXPORT_SYMBOL_GPL(device_get_match_data);
1347
1348static unsigned int fwnode_graph_devcon_matches(const struct fwnode_handle *fwnode,
1349						const char *con_id, void *data,
1350						devcon_match_fn_t match,
1351						void **matches,
1352						unsigned int matches_len)
1353{
1354	struct fwnode_handle *node;
1355	struct fwnode_handle *ep;
1356	unsigned int count = 0;
1357	void *ret;
1358
1359	fwnode_graph_for_each_endpoint(fwnode, ep) {
1360		if (matches && count >= matches_len) {
1361			fwnode_handle_put(ep);
1362			break;
1363		}
1364
1365		node = fwnode_graph_get_remote_port_parent(ep);
1366		if (!fwnode_device_is_available(node)) {
1367			fwnode_handle_put(node);
1368			continue;
1369		}
1370
1371		ret = match(node, con_id, data);
1372		fwnode_handle_put(node);
1373		if (ret) {
1374			if (matches)
1375				matches[count] = ret;
1376			count++;
1377		}
1378	}
1379	return count;
1380}
1381
1382static unsigned int fwnode_devcon_matches(const struct fwnode_handle *fwnode,
1383					  const char *con_id, void *data,
1384					  devcon_match_fn_t match,
1385					  void **matches,
1386					  unsigned int matches_len)
1387{
1388	struct fwnode_handle *node;
1389	unsigned int count = 0;
1390	unsigned int i;
1391	void *ret;
1392
1393	for (i = 0; ; i++) {
1394		if (matches && count >= matches_len)
1395			break;
1396
1397		node = fwnode_find_reference(fwnode, con_id, i);
1398		if (IS_ERR(node))
1399			break;
1400
1401		ret = match(node, NULL, data);
1402		fwnode_handle_put(node);
1403		if (ret) {
1404			if (matches)
1405				matches[count] = ret;
1406			count++;
1407		}
1408	}
1409
1410	return count;
1411}
1412
1413/**
1414 * fwnode_connection_find_match - Find connection from a device node
1415 * @fwnode: Device node with the connection
1416 * @con_id: Identifier for the connection
1417 * @data: Data for the match function
1418 * @match: Function to check and convert the connection description
1419 *
1420 * Find a connection with unique identifier @con_id between @fwnode and another
1421 * device node. @match will be used to convert the connection description to
1422 * data the caller is expecting to be returned.
1423 */
1424void *fwnode_connection_find_match(const struct fwnode_handle *fwnode,
1425				   const char *con_id, void *data,
1426				   devcon_match_fn_t match)
1427{
1428	unsigned int count;
1429	void *ret;
1430
1431	if (!fwnode || !match)
1432		return NULL;
1433
1434	count = fwnode_graph_devcon_matches(fwnode, con_id, data, match, &ret, 1);
1435	if (count)
1436		return ret;
1437
1438	count = fwnode_devcon_matches(fwnode, con_id, data, match, &ret, 1);
1439	return count ? ret : NULL;
1440}
1441EXPORT_SYMBOL_GPL(fwnode_connection_find_match);
1442
1443/**
1444 * fwnode_connection_find_matches - Find connections from a device node
1445 * @fwnode: Device node with the connection
1446 * @con_id: Identifier for the connection
1447 * @data: Data for the match function
1448 * @match: Function to check and convert the connection description
1449 * @matches: (Optional) array of pointers to fill with matches
1450 * @matches_len: Length of @matches
1451 *
1452 * Find up to @matches_len connections with unique identifier @con_id between
1453 * @fwnode and other device nodes. @match will be used to convert the
1454 * connection description to data the caller is expecting to be returned
1455 * through the @matches array.
1456 *
1457 * If @matches is %NULL @matches_len is ignored and the total number of resolved
1458 * matches is returned.
1459 *
1460 * Return: Number of matches resolved, or negative errno.
1461 */
1462int fwnode_connection_find_matches(const struct fwnode_handle *fwnode,
1463				   const char *con_id, void *data,
1464				   devcon_match_fn_t match,
1465				   void **matches, unsigned int matches_len)
1466{
1467	unsigned int count_graph;
1468	unsigned int count_ref;
1469
1470	if (!fwnode || !match)
1471		return -EINVAL;
1472
1473	count_graph = fwnode_graph_devcon_matches(fwnode, con_id, data, match,
1474						  matches, matches_len);
1475
1476	if (matches) {
1477		matches += count_graph;
1478		matches_len -= count_graph;
1479	}
1480
1481	count_ref = fwnode_devcon_matches(fwnode, con_id, data, match,
1482					  matches, matches_len);
1483
1484	return count_graph + count_ref;
1485}
1486EXPORT_SYMBOL_GPL(fwnode_connection_find_matches);