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/etherdevice.h>
  19#include <linux/phy.h>
  20
  21struct fwnode_handle *dev_fwnode(struct device *dev)
  22{
  23	return IS_ENABLED(CONFIG_OF) && dev->of_node ?
  24		&dev->of_node->fwnode : dev->fwnode;
  25}
  26EXPORT_SYMBOL_GPL(dev_fwnode);
 
 
 
 
 
 
 
  27
  28/**
  29 * device_property_present - check if a property of a device is present
  30 * @dev: Device whose property is being checked
  31 * @propname: Name of the property
  32 *
  33 * Check if property @propname is present in the device firmware description.
 
 
  34 */
  35bool device_property_present(struct device *dev, const char *propname)
  36{
  37	return fwnode_property_present(dev_fwnode(dev), propname);
  38}
  39EXPORT_SYMBOL_GPL(device_property_present);
  40
  41/**
  42 * fwnode_property_present - check if a property of a firmware node is present
  43 * @fwnode: Firmware node whose property to check
  44 * @propname: Name of the property
 
 
  45 */
  46bool fwnode_property_present(const struct fwnode_handle *fwnode,
  47			     const char *propname)
  48{
  49	bool ret;
  50
 
 
 
  51	ret = fwnode_call_bool_op(fwnode, property_present, propname);
  52	if (ret == false && !IS_ERR_OR_NULL(fwnode) &&
  53	    !IS_ERR_OR_NULL(fwnode->secondary))
  54		ret = fwnode_call_bool_op(fwnode->secondary, property_present,
  55					 propname);
  56	return ret;
  57}
  58EXPORT_SYMBOL_GPL(fwnode_property_present);
  59
  60/**
  61 * device_property_read_u8_array - return a u8 array property of a device
  62 * @dev: Device to get the property of
  63 * @propname: Name of the property
  64 * @val: The values are stored here or %NULL to return the number of values
  65 * @nval: Size of the @val array
  66 *
  67 * Function reads an array of u8 properties with @propname from the device
  68 * firmware description and stores them to @val if found.
  69 *
 
 
 
  70 * Return: number of values if @val was %NULL,
  71 *         %0 if the property was found (success),
  72 *	   %-EINVAL if given arguments are not valid,
  73 *	   %-ENODATA if the property does not have a value,
  74 *	   %-EPROTO if the property is not an array of numbers,
  75 *	   %-EOVERFLOW if the size of the property is not as expected.
  76 *	   %-ENXIO if no suitable firmware interface is present.
  77 */
  78int device_property_read_u8_array(struct device *dev, const char *propname,
  79				  u8 *val, size_t nval)
  80{
  81	return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
  82}
  83EXPORT_SYMBOL_GPL(device_property_read_u8_array);
  84
  85/**
  86 * device_property_read_u16_array - return a u16 array property of a device
  87 * @dev: Device to get the property of
  88 * @propname: Name of the property
  89 * @val: The values are stored here or %NULL to return the number of values
  90 * @nval: Size of the @val array
  91 *
  92 * Function reads an array of u16 properties with @propname from the device
  93 * firmware description and stores them to @val if found.
  94 *
 
 
 
  95 * Return: number of values if @val was %NULL,
  96 *         %0 if the property was found (success),
  97 *	   %-EINVAL if given arguments are not valid,
  98 *	   %-ENODATA if the property does not have a value,
  99 *	   %-EPROTO if the property is not an array of numbers,
 100 *	   %-EOVERFLOW if the size of the property is not as expected.
 101 *	   %-ENXIO if no suitable firmware interface is present.
 102 */
 103int device_property_read_u16_array(struct device *dev, const char *propname,
 104				   u16 *val, size_t nval)
 105{
 106	return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
 107}
 108EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 109
 110/**
 111 * device_property_read_u32_array - return a u32 array property of a device
 112 * @dev: Device to get the property of
 113 * @propname: Name of the property
 114 * @val: The values are stored here or %NULL to return the number of values
 115 * @nval: Size of the @val array
 116 *
 117 * Function reads an array of u32 properties with @propname from the device
 118 * firmware description and stores them to @val if found.
 119 *
 
 
 
 120 * Return: number of values if @val was %NULL,
 121 *         %0 if the property was found (success),
 122 *	   %-EINVAL if given arguments are not valid,
 123 *	   %-ENODATA if the property does not have a value,
 124 *	   %-EPROTO if the property is not an array of numbers,
 125 *	   %-EOVERFLOW if the size of the property is not as expected.
 126 *	   %-ENXIO if no suitable firmware interface is present.
 127 */
 128int device_property_read_u32_array(struct device *dev, const char *propname,
 129				   u32 *val, size_t nval)
 130{
 131	return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
 132}
 133EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 134
 135/**
 136 * device_property_read_u64_array - return a u64 array property of a device
 137 * @dev: Device to get the property of
 138 * @propname: Name of the property
 139 * @val: The values are stored here or %NULL to return the number of values
 140 * @nval: Size of the @val array
 141 *
 142 * Function reads an array of u64 properties with @propname from the device
 143 * firmware description and stores them to @val if found.
 144 *
 
 
 
 145 * Return: number of values if @val was %NULL,
 146 *         %0 if the property was found (success),
 147 *	   %-EINVAL if given arguments are not valid,
 148 *	   %-ENODATA if the property does not have a value,
 149 *	   %-EPROTO if the property is not an array of numbers,
 150 *	   %-EOVERFLOW if the size of the property is not as expected.
 151 *	   %-ENXIO if no suitable firmware interface is present.
 152 */
 153int device_property_read_u64_array(struct device *dev, const char *propname,
 154				   u64 *val, size_t nval)
 155{
 156	return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
 157}
 158EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 159
 160/**
 161 * device_property_read_string_array - return a string array property of device
 162 * @dev: Device to get the property of
 163 * @propname: Name of the property
 164 * @val: The values are stored here or %NULL to return the number of values
 165 * @nval: Size of the @val array
 166 *
 167 * Function reads an array of string properties with @propname from the device
 168 * firmware description and stores them to @val if found.
 169 *
 
 
 
 170 * Return: number of values read on success if @val is non-NULL,
 171 *	   number of values available on success if @val is NULL,
 172 *	   %-EINVAL if given arguments are not valid,
 173 *	   %-ENODATA if the property does not have a value,
 174 *	   %-EPROTO or %-EILSEQ if the property is not an array of strings,
 175 *	   %-EOVERFLOW if the size of the property is not as expected.
 176 *	   %-ENXIO if no suitable firmware interface is present.
 177 */
 178int device_property_read_string_array(struct device *dev, const char *propname,
 179				      const char **val, size_t nval)
 180{
 181	return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
 182}
 183EXPORT_SYMBOL_GPL(device_property_read_string_array);
 184
 185/**
 186 * device_property_read_string - return a string property of a device
 187 * @dev: Device to get the property of
 188 * @propname: Name of the property
 189 * @val: The value is stored here
 190 *
 191 * Function reads property @propname from the device firmware description and
 192 * stores the value into @val if found. The value is checked to be a string.
 193 *
 194 * Return: %0 if the property was found (success),
 195 *	   %-EINVAL if given arguments are not valid,
 196 *	   %-ENODATA if the property does not have a value,
 197 *	   %-EPROTO or %-EILSEQ if the property type is not a string.
 198 *	   %-ENXIO if no suitable firmware interface is present.
 199 */
 200int device_property_read_string(struct device *dev, const char *propname,
 201				const char **val)
 202{
 203	return fwnode_property_read_string(dev_fwnode(dev), propname, val);
 204}
 205EXPORT_SYMBOL_GPL(device_property_read_string);
 206
 207/**
 208 * device_property_match_string - find a string in an array and return index
 209 * @dev: Device to get the property of
 210 * @propname: Name of the property holding the array
 211 * @string: String to look for
 212 *
 213 * Find a given string in a string array and if it is found return the
 214 * index back.
 215 *
 216 * Return: %0 if the property was found (success),
 217 *	   %-EINVAL if given arguments are not valid,
 218 *	   %-ENODATA if the property does not have a value,
 219 *	   %-EPROTO if the property is not an array of strings,
 220 *	   %-ENXIO if no suitable firmware interface is present.
 221 */
 222int device_property_match_string(struct device *dev, const char *propname,
 223				 const char *string)
 224{
 225	return fwnode_property_match_string(dev_fwnode(dev), propname, string);
 226}
 227EXPORT_SYMBOL_GPL(device_property_match_string);
 228
 229static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 230					  const char *propname,
 231					  unsigned int elem_size, void *val,
 232					  size_t nval)
 233{
 234	int ret;
 235
 
 
 
 236	ret = fwnode_call_int_op(fwnode, property_read_int_array, propname,
 237				 elem_size, val, nval);
 238	if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
 239	    !IS_ERR_OR_NULL(fwnode->secondary))
 240		ret = fwnode_call_int_op(
 241			fwnode->secondary, property_read_int_array, propname,
 242			elem_size, val, nval);
 243
 244	return ret;
 
 245}
 246
 247/**
 248 * fwnode_property_read_u8_array - return a u8 array property of firmware node
 249 * @fwnode: Firmware node to get the property of
 250 * @propname: Name of the property
 251 * @val: The values are stored here or %NULL to return the number of values
 252 * @nval: Size of the @val array
 253 *
 254 * Read an array of u8 properties with @propname from @fwnode and stores them to
 255 * @val if found.
 256 *
 
 
 
 257 * Return: number of values if @val was %NULL,
 258 *         %0 if the property was found (success),
 259 *	   %-EINVAL if given arguments are not valid,
 260 *	   %-ENODATA if the property does not have a value,
 261 *	   %-EPROTO if the property is not an array of numbers,
 262 *	   %-EOVERFLOW if the size of the property is not as expected,
 263 *	   %-ENXIO if no suitable firmware interface is present.
 264 */
 265int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode,
 266				  const char *propname, u8 *val, size_t nval)
 267{
 268	return fwnode_property_read_int_array(fwnode, propname, sizeof(u8),
 269					      val, nval);
 270}
 271EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
 272
 273/**
 274 * fwnode_property_read_u16_array - return a u16 array property of firmware node
 275 * @fwnode: Firmware node to get the property of
 276 * @propname: Name of the property
 277 * @val: The values are stored here or %NULL to return the number of values
 278 * @nval: Size of the @val array
 279 *
 280 * Read an array of u16 properties with @propname from @fwnode and store them to
 281 * @val if found.
 282 *
 
 
 
 283 * Return: number of values if @val was %NULL,
 284 *         %0 if the property was found (success),
 285 *	   %-EINVAL if given arguments are not valid,
 286 *	   %-ENODATA if the property does not have a value,
 287 *	   %-EPROTO if the property is not an array of numbers,
 288 *	   %-EOVERFLOW if the size of the property is not as expected,
 289 *	   %-ENXIO if no suitable firmware interface is present.
 290 */
 291int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode,
 292				   const char *propname, u16 *val, size_t nval)
 293{
 294	return fwnode_property_read_int_array(fwnode, propname, sizeof(u16),
 295					      val, nval);
 296}
 297EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
 298
 299/**
 300 * fwnode_property_read_u32_array - return a u32 array property of firmware node
 301 * @fwnode: Firmware node to get the property of
 302 * @propname: Name of the property
 303 * @val: The values are stored here or %NULL to return the number of values
 304 * @nval: Size of the @val array
 305 *
 306 * Read an array of u32 properties with @propname from @fwnode store them to
 307 * @val if found.
 308 *
 
 
 
 309 * Return: number of values if @val was %NULL,
 310 *         %0 if the property was found (success),
 311 *	   %-EINVAL if given arguments are not valid,
 312 *	   %-ENODATA if the property does not have a value,
 313 *	   %-EPROTO if the property is not an array of numbers,
 314 *	   %-EOVERFLOW if the size of the property is not as expected,
 315 *	   %-ENXIO if no suitable firmware interface is present.
 316 */
 317int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode,
 318				   const char *propname, u32 *val, size_t nval)
 319{
 320	return fwnode_property_read_int_array(fwnode, propname, sizeof(u32),
 321					      val, nval);
 322}
 323EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
 324
 325/**
 326 * fwnode_property_read_u64_array - return a u64 array property firmware node
 327 * @fwnode: Firmware node to get the property of
 328 * @propname: Name of the property
 329 * @val: The values are stored here or %NULL to return the number of values
 330 * @nval: Size of the @val array
 331 *
 332 * Read an array of u64 properties with @propname from @fwnode and store them to
 333 * @val if found.
 334 *
 
 
 
 335 * Return: number of values if @val was %NULL,
 336 *         %0 if the property was found (success),
 337 *	   %-EINVAL if given arguments are not valid,
 338 *	   %-ENODATA if the property does not have a value,
 339 *	   %-EPROTO if the property is not an array of numbers,
 340 *	   %-EOVERFLOW if the size of the property is not as expected,
 341 *	   %-ENXIO if no suitable firmware interface is present.
 342 */
 343int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode,
 344				   const char *propname, u64 *val, size_t nval)
 345{
 346	return fwnode_property_read_int_array(fwnode, propname, sizeof(u64),
 347					      val, nval);
 348}
 349EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
 350
 351/**
 352 * fwnode_property_read_string_array - return string array property of a node
 353 * @fwnode: Firmware node to get the property of
 354 * @propname: Name of the property
 355 * @val: The values are stored here or %NULL to return the number of values
 356 * @nval: Size of the @val array
 357 *
 358 * Read an string list property @propname from the given firmware node and store
 359 * them to @val if found.
 360 *
 
 
 
 361 * Return: number of values read on success if @val is non-NULL,
 362 *	   number of values available on success if @val is NULL,
 363 *	   %-EINVAL if given arguments are not valid,
 364 *	   %-ENODATA if the property does not have a value,
 365 *	   %-EPROTO or %-EILSEQ if the property is not an array of strings,
 366 *	   %-EOVERFLOW if the size of the property is not as expected,
 367 *	   %-ENXIO if no suitable firmware interface is present.
 368 */
 369int fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 370				      const char *propname, const char **val,
 371				      size_t nval)
 372{
 373	int ret;
 374
 
 
 
 375	ret = fwnode_call_int_op(fwnode, property_read_string_array, propname,
 376				 val, nval);
 377	if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
 378	    !IS_ERR_OR_NULL(fwnode->secondary))
 379		ret = fwnode_call_int_op(fwnode->secondary,
 380					 property_read_string_array, propname,
 381					 val, nval);
 382	return ret;
 383}
 384EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
 385
 386/**
 387 * fwnode_property_read_string - return a string property of a firmware node
 388 * @fwnode: Firmware node to get the property of
 389 * @propname: Name of the property
 390 * @val: The value is stored here
 391 *
 392 * Read property @propname from the given firmware node and store the value into
 393 * @val if found.  The value is checked to be a string.
 394 *
 395 * Return: %0 if the property was found (success),
 396 *	   %-EINVAL if given arguments are not valid,
 397 *	   %-ENODATA if the property does not have a value,
 398 *	   %-EPROTO or %-EILSEQ if the property is not a string,
 399 *	   %-ENXIO if no suitable firmware interface is present.
 400 */
 401int fwnode_property_read_string(const struct fwnode_handle *fwnode,
 402				const char *propname, const char **val)
 403{
 404	int ret = fwnode_property_read_string_array(fwnode, propname, val, 1);
 405
 406	return ret < 0 ? ret : 0;
 407}
 408EXPORT_SYMBOL_GPL(fwnode_property_read_string);
 409
 410/**
 411 * fwnode_property_match_string - find a string in an array and return index
 412 * @fwnode: Firmware node to get the property of
 413 * @propname: Name of the property holding the array
 414 * @string: String to look for
 415 *
 416 * Find a given string in a string array and if it is found return the
 417 * index back.
 418 *
 419 * Return: %0 if the property was found (success),
 420 *	   %-EINVAL if given arguments are not valid,
 421 *	   %-ENODATA if the property does not have a value,
 422 *	   %-EPROTO if the property is not an array of strings,
 423 *	   %-ENXIO if no suitable firmware interface is present.
 424 */
 425int fwnode_property_match_string(const struct fwnode_handle *fwnode,
 426	const char *propname, const char *string)
 427{
 428	const char **values;
 429	int nval, ret;
 430
 431	nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0);
 432	if (nval < 0)
 433		return nval;
 434
 435	if (nval == 0)
 436		return -ENODATA;
 437
 438	values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
 439	if (!values)
 440		return -ENOMEM;
 441
 442	ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
 443	if (ret < 0)
 444		goto out;
 445
 446	ret = match_string(values, nval, string);
 447	if (ret < 0)
 448		ret = -ENODATA;
 449out:
 
 450	kfree(values);
 451	return ret;
 452}
 453EXPORT_SYMBOL_GPL(fwnode_property_match_string);
 454
 455/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 456 * fwnode_property_get_reference_args() - Find a reference with arguments
 457 * @fwnode:	Firmware node where to look for the reference
 458 * @prop:	The name of the property
 459 * @nargs_prop:	The name of the property telling the number of
 460 *		arguments in the referred node. NULL if @nargs is known,
 461 *		otherwise @nargs is ignored. Only relevant on OF.
 462 * @nargs:	Number of arguments. Ignored if @nargs_prop is non-NULL.
 463 * @index:	Index of the reference, from zero onwards.
 464 * @args:	Result structure with reference and integer arguments.
 
 465 *
 466 * Obtain a reference based on a named property in an fwnode, with
 467 * integer arguments.
 468 *
 469 * Caller is responsible to call fwnode_handle_put() on the returned
 470 * args->fwnode pointer.
 471 *
 472 * Returns: %0 on success
 473 *	    %-ENOENT when the index is out of bounds, the index has an empty
 474 *		     reference or the property was not found
 475 *	    %-EINVAL on parse error
 476 */
 477int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode,
 478				       const char *prop, const char *nargs_prop,
 479				       unsigned int nargs, unsigned int index,
 480				       struct fwnode_reference_args *args)
 481{
 482	return fwnode_call_int_op(fwnode, get_reference_args, prop, nargs_prop,
 
 
 
 
 
 
 
 
 
 
 
 
 
 483				  nargs, index, args);
 484}
 485EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args);
 486
 487/**
 488 * fwnode_find_reference - Find named reference to a fwnode_handle
 489 * @fwnode: Firmware node where to look for the reference
 490 * @name: The name of the reference
 491 * @index: Index of the reference
 492 *
 493 * @index can be used when the named reference holds a table of references.
 494 *
 495 * Returns pointer to the reference fwnode, or ERR_PTR. Caller is responsible to
 496 * call fwnode_handle_put() on the returned fwnode pointer.
 
 
 
 497 */
 498struct fwnode_handle *fwnode_find_reference(const struct fwnode_handle *fwnode,
 499					    const char *name,
 500					    unsigned int index)
 501{
 502	struct fwnode_reference_args args;
 503	int ret;
 504
 505	ret = fwnode_property_get_reference_args(fwnode, name, NULL, 0, index,
 506						 &args);
 507	return ret ? ERR_PTR(ret) : args.fwnode;
 508}
 509EXPORT_SYMBOL_GPL(fwnode_find_reference);
 510
 511/**
 512 * device_remove_properties - Remove properties from a device object.
 513 * @dev: Device whose properties to remove.
 514 *
 515 * The function removes properties previously associated to the device
 516 * firmware node with device_add_properties(). Memory allocated to the
 517 * properties will also be released.
 518 */
 519void device_remove_properties(struct device *dev)
 520{
 521	struct fwnode_handle *fwnode = dev_fwnode(dev);
 522
 523	if (!fwnode)
 524		return;
 525
 526	if (is_software_node(fwnode->secondary)) {
 527		fwnode_remove_software_node(fwnode->secondary);
 528		set_secondary_fwnode(dev, NULL);
 529	}
 530}
 531EXPORT_SYMBOL_GPL(device_remove_properties);
 532
 533/**
 534 * device_add_properties - Add a collection of properties to a device object.
 535 * @dev: Device to add properties to.
 536 * @properties: Collection of properties to add.
 537 *
 538 * Associate a collection of device properties represented by @properties with
 539 * @dev. The function takes a copy of @properties.
 540 *
 541 * WARNING: The callers should not use this function if it is known that there
 542 * is no real firmware node associated with @dev! In that case the callers
 543 * should create a software node and assign it to @dev directly.
 544 */
 545int device_add_properties(struct device *dev,
 546			  const struct property_entry *properties)
 547{
 548	struct fwnode_handle *fwnode;
 549
 550	fwnode = fwnode_create_software_node(properties, NULL);
 551	if (IS_ERR(fwnode))
 552		return PTR_ERR(fwnode);
 553
 554	set_secondary_fwnode(dev, fwnode);
 555	return 0;
 556}
 557EXPORT_SYMBOL_GPL(device_add_properties);
 558
 559/**
 560 * fwnode_get_name - Return the name of a node
 561 * @fwnode: The firmware node
 562 *
 563 * Returns a pointer to the node name.
 564 */
 565const char *fwnode_get_name(const struct fwnode_handle *fwnode)
 566{
 567	return fwnode_call_ptr_op(fwnode, get_name);
 568}
 569EXPORT_SYMBOL_GPL(fwnode_get_name);
 570
 571/**
 572 * fwnode_get_name_prefix - Return the prefix of node for printing purposes
 573 * @fwnode: The firmware node
 574 *
 575 * Returns the prefix of a node, intended to be printed right before the node.
 576 * The prefix works also as a separator between the nodes.
 577 */
 578const char *fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
 579{
 580	return fwnode_call_ptr_op(fwnode, get_name_prefix);
 581}
 582
 583/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 584 * fwnode_get_parent - Return parent firwmare node
 585 * @fwnode: Firmware whose parent is retrieved
 586 *
 587 * Return parent firmware node of the given node if possible or %NULL if no
 
 
 
 588 * parent was available.
 589 */
 590struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode)
 591{
 592	return fwnode_call_ptr_op(fwnode, get_parent);
 593}
 594EXPORT_SYMBOL_GPL(fwnode_get_parent);
 595
 596/**
 597 * fwnode_get_next_parent - Iterate to the node's parent
 598 * @fwnode: Firmware whose parent is retrieved
 599 *
 600 * This is like fwnode_get_parent() except that it drops the refcount
 601 * on the passed node, making it suitable for iterating through a
 602 * node's parents.
 603 *
 604 * Returns a node pointer with refcount incremented, use
 605 * fwnode_handle_node() on it when done.
 
 
 
 
 606 */
 607struct fwnode_handle *fwnode_get_next_parent(struct fwnode_handle *fwnode)
 608{
 609	struct fwnode_handle *parent = fwnode_get_parent(fwnode);
 610
 611	fwnode_handle_put(fwnode);
 612
 613	return parent;
 614}
 615EXPORT_SYMBOL_GPL(fwnode_get_next_parent);
 616
 617/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 618 * fwnode_count_parents - Return the number of parents a node has
 619 * @fwnode: The node the parents of which are to be counted
 620 *
 621 * Returns the number of parents a node has.
 622 */
 623unsigned int fwnode_count_parents(const struct fwnode_handle *fwnode)
 624{
 625	struct fwnode_handle *__fwnode;
 626	unsigned int count;
 627
 628	__fwnode = fwnode_get_parent(fwnode);
 629
 630	for (count = 0; __fwnode; count++)
 631		__fwnode = fwnode_get_next_parent(__fwnode);
 632
 633	return count;
 634}
 635EXPORT_SYMBOL_GPL(fwnode_count_parents);
 636
 637/**
 638 * fwnode_get_nth_parent - Return an nth parent of a node
 639 * @fwnode: The node the parent of which is requested
 640 * @depth: Distance of the parent from the node
 641 *
 642 * Returns the nth parent of a node. If there is no parent at the requested
 
 
 
 643 * @depth, %NULL is returned. If @depth is 0, the functionality is equivalent to
 644 * fwnode_handle_get(). For @depth == 1, it is fwnode_get_parent() and so on.
 645 *
 646 * The caller is responsible for calling fwnode_handle_put() for the returned
 647 * node.
 648 */
 649struct fwnode_handle *fwnode_get_nth_parent(struct fwnode_handle *fwnode,
 650					    unsigned int depth)
 651{
 652	unsigned int i;
 653
 654	fwnode_handle_get(fwnode);
 
 655
 656	for (i = 0; i < depth && fwnode; i++)
 657		fwnode = fwnode_get_next_parent(fwnode);
 658
 659	return fwnode;
 
 660}
 661EXPORT_SYMBOL_GPL(fwnode_get_nth_parent);
 662
 663/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 664 * fwnode_get_next_child_node - Return the next child node handle for a node
 665 * @fwnode: Firmware node to find the next child node for.
 666 * @child: Handle to one of the node's child nodes or a %NULL handle.
 
 
 
 
 667 */
 668struct fwnode_handle *
 669fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 670			   struct fwnode_handle *child)
 671{
 672	return fwnode_call_ptr_op(fwnode, get_next_child_node, child);
 673}
 674EXPORT_SYMBOL_GPL(fwnode_get_next_child_node);
 675
 676/**
 677 * fwnode_get_next_available_child_node - Return the next
 678 * available child node handle for a node
 679 * @fwnode: Firmware node to find the next child node for.
 680 * @child: Handle to one of the node's child nodes or a %NULL handle.
 
 
 
 
 681 */
 682struct fwnode_handle *
 683fwnode_get_next_available_child_node(const struct fwnode_handle *fwnode,
 684				     struct fwnode_handle *child)
 685{
 686	struct fwnode_handle *next_child = child;
 687
 688	if (!fwnode)
 689		return NULL;
 690
 691	do {
 692		next_child = fwnode_get_next_child_node(fwnode, next_child);
 693
 694		if (!next_child || fwnode_device_is_available(next_child))
 695			break;
 696	} while (next_child);
 697
 698	return next_child;
 699}
 700EXPORT_SYMBOL_GPL(fwnode_get_next_available_child_node);
 701
 702/**
 703 * device_get_next_child_node - Return the next child node handle for a device
 704 * @dev: Device to find the next child node for.
 705 * @child: Handle to one of the device's child nodes or a null handle.
 
 
 
 
 706 */
 707struct fwnode_handle *device_get_next_child_node(struct device *dev,
 708						 struct fwnode_handle *child)
 709{
 710	struct acpi_device *adev = ACPI_COMPANION(dev);
 711	struct fwnode_handle *fwnode = NULL, *next;
 712
 713	if (dev->of_node)
 714		fwnode = &dev->of_node->fwnode;
 715	else if (adev)
 716		fwnode = acpi_fwnode_handle(adev);
 717
 718	/* Try to find a child in primary fwnode */
 719	next = fwnode_get_next_child_node(fwnode, child);
 720	if (next)
 721		return next;
 722
 723	/* When no more children in primary, continue with secondary */
 724	if (fwnode && !IS_ERR_OR_NULL(fwnode->secondary))
 725		next = fwnode_get_next_child_node(fwnode->secondary, child);
 726
 727	return next;
 728}
 729EXPORT_SYMBOL_GPL(device_get_next_child_node);
 730
 731/**
 732 * fwnode_get_named_child_node - Return first matching named child node handle
 733 * @fwnode: Firmware node to find the named child node for.
 734 * @childname: String to match child node name against.
 
 
 
 735 */
 736struct fwnode_handle *
 737fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 738			    const char *childname)
 739{
 740	return fwnode_call_ptr_op(fwnode, get_named_child_node, childname);
 741}
 742EXPORT_SYMBOL_GPL(fwnode_get_named_child_node);
 743
 744/**
 745 * device_get_named_child_node - Return first matching named child node handle
 746 * @dev: Device to find the named child node for.
 747 * @childname: String to match child node name against.
 
 
 
 748 */
 749struct fwnode_handle *device_get_named_child_node(struct device *dev,
 750						  const char *childname)
 751{
 752	return fwnode_get_named_child_node(dev_fwnode(dev), childname);
 753}
 754EXPORT_SYMBOL_GPL(device_get_named_child_node);
 755
 756/**
 757 * fwnode_handle_get - Obtain a reference to a device node
 758 * @fwnode: Pointer to the device node to obtain the reference to.
 759 *
 760 * Returns the fwnode handle.
 
 
 
 761 */
 762struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode)
 763{
 764	if (!fwnode_has_op(fwnode, get))
 765		return fwnode;
 766
 767	return fwnode_call_ptr_op(fwnode, get);
 768}
 769EXPORT_SYMBOL_GPL(fwnode_handle_get);
 770
 771/**
 772 * fwnode_handle_put - Drop reference to a device node
 773 * @fwnode: Pointer to the device node to drop the reference to.
 774 *
 775 * This has to be used when terminating device_for_each_child_node() iteration
 776 * with break or return to prevent stale device node references from being left
 777 * behind.
 778 */
 779void fwnode_handle_put(struct fwnode_handle *fwnode)
 780{
 781	fwnode_call_void_op(fwnode, put);
 782}
 783EXPORT_SYMBOL_GPL(fwnode_handle_put);
 784
 785/**
 786 * fwnode_device_is_available - check if a device is available for use
 787 * @fwnode: Pointer to the fwnode of the device.
 
 
 
 
 
 788 */
 789bool fwnode_device_is_available(const struct fwnode_handle *fwnode)
 790{
 
 
 
 
 
 
 791	return fwnode_call_bool_op(fwnode, device_is_available);
 792}
 793EXPORT_SYMBOL_GPL(fwnode_device_is_available);
 794
 795/**
 796 * device_get_child_node_count - return the number of child nodes for device
 797 * @dev: Device to cound the child nodes for
 
 
 798 */
 799unsigned int device_get_child_node_count(struct device *dev)
 800{
 801	struct fwnode_handle *child;
 802	unsigned int count = 0;
 803
 804	device_for_each_child_node(dev, child)
 805		count++;
 806
 807	return count;
 808}
 809EXPORT_SYMBOL_GPL(device_get_child_node_count);
 810
 811bool device_dma_supported(struct device *dev)
 812{
 813	/* For DT, this is always supported.
 814	 * For ACPI, this depends on CCA, which
 815	 * is determined by the acpi_dma_supported().
 816	 */
 817	if (IS_ENABLED(CONFIG_OF) && dev->of_node)
 818		return true;
 819
 820	return acpi_dma_supported(ACPI_COMPANION(dev));
 821}
 822EXPORT_SYMBOL_GPL(device_dma_supported);
 823
 824enum dev_dma_attr device_get_dma_attr(struct device *dev)
 825{
 826	enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED;
 827
 828	if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
 829		if (of_dma_is_coherent(dev->of_node))
 830			attr = DEV_DMA_COHERENT;
 831		else
 832			attr = DEV_DMA_NON_COHERENT;
 833	} else
 834		attr = acpi_get_dma_attr(ACPI_COMPANION(dev));
 835
 836	return attr;
 837}
 838EXPORT_SYMBOL_GPL(device_get_dma_attr);
 839
 840/**
 841 * fwnode_get_phy_mode - Get phy mode for given firmware node
 842 * @fwnode:	Pointer to the given node
 843 *
 844 * The function gets phy interface string from property 'phy-mode' or
 845 * 'phy-connection-type', and return its index in phy_modes table, or errno in
 846 * error case.
 847 */
 848int fwnode_get_phy_mode(struct fwnode_handle *fwnode)
 849{
 850	const char *pm;
 851	int err, i;
 852
 853	err = fwnode_property_read_string(fwnode, "phy-mode", &pm);
 854	if (err < 0)
 855		err = fwnode_property_read_string(fwnode,
 856						  "phy-connection-type", &pm);
 857	if (err < 0)
 858		return err;
 859
 860	for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
 861		if (!strcasecmp(pm, phy_modes(i)))
 862			return i;
 863
 864	return -ENODEV;
 865}
 866EXPORT_SYMBOL_GPL(fwnode_get_phy_mode);
 867
 868/**
 869 * device_get_phy_mode - Get phy mode for given device
 870 * @dev:	Pointer to the given device
 871 *
 872 * The function gets phy interface string from property 'phy-mode' or
 873 * 'phy-connection-type', and return its index in phy_modes table, or errno in
 874 * error case.
 875 */
 876int device_get_phy_mode(struct device *dev)
 877{
 878	return fwnode_get_phy_mode(dev_fwnode(dev));
 879}
 880EXPORT_SYMBOL_GPL(device_get_phy_mode);
 881
 882static void *fwnode_get_mac_addr(struct fwnode_handle *fwnode,
 883				 const char *name, char *addr,
 884				 int alen)
 885{
 886	int ret = fwnode_property_read_u8_array(fwnode, name, addr, alen);
 887
 888	if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr))
 889		return addr;
 890	return NULL;
 891}
 892
 893/**
 894 * fwnode_get_mac_address - Get the MAC from the firmware node
 895 * @fwnode:	Pointer to the firmware node
 896 * @addr:	Address of buffer to store the MAC in
 897 * @alen:	Length of the buffer pointed to by addr, should be ETH_ALEN
 898 *
 899 * Search the firmware node for the best MAC address to use.  'mac-address' is
 900 * checked first, because that is supposed to contain to "most recent" MAC
 901 * address. If that isn't set, then 'local-mac-address' is checked next,
 902 * because that is the default address.  If that isn't set, then the obsolete
 903 * 'address' is checked, just in case we're using an old device tree.
 904 *
 905 * Note that the 'address' property is supposed to contain a virtual address of
 906 * the register set, but some DTS files have redefined that property to be the
 907 * MAC address.
 908 *
 909 * All-zero MAC addresses are rejected, because those could be properties that
 910 * exist in the firmware tables, but were not updated by the firmware.  For
 911 * example, the DTS could define 'mac-address' and 'local-mac-address', with
 912 * zero MAC addresses.  Some older U-Boots only initialized 'local-mac-address'.
 913 * In this case, the real MAC is in 'local-mac-address', and 'mac-address'
 914 * exists but is all zeros.
 915*/
 916void *fwnode_get_mac_address(struct fwnode_handle *fwnode, char *addr, int alen)
 917{
 918	char *res;
 919
 920	res = fwnode_get_mac_addr(fwnode, "mac-address", addr, alen);
 921	if (res)
 922		return res;
 923
 924	res = fwnode_get_mac_addr(fwnode, "local-mac-address", addr, alen);
 925	if (res)
 926		return res;
 927
 928	return fwnode_get_mac_addr(fwnode, "address", addr, alen);
 929}
 930EXPORT_SYMBOL(fwnode_get_mac_address);
 931
 932/**
 933 * device_get_mac_address - Get the MAC for a given device
 934 * @dev:	Pointer to the device
 935 * @addr:	Address of buffer to store the MAC in
 936 * @alen:	Length of the buffer pointed to by addr, should be ETH_ALEN
 
 937 */
 938void *device_get_mac_address(struct device *dev, char *addr, int alen)
 939{
 940	return fwnode_get_mac_address(dev_fwnode(dev), addr, alen);
 
 
 
 
 
 
 
 941}
 942EXPORT_SYMBOL(device_get_mac_address);
 943
 944/**
 945 * fwnode_irq_get - Get IRQ directly from a fwnode
 946 * @fwnode:	Pointer to the firmware node
 947 * @index:	Zero-based index of the IRQ
 
 
 
 
 
 
 948 *
 949 * Returns Linux IRQ number on success. Other values are determined
 950 * accordingly to acpi_/of_ irq_get() operation.
 951 */
 952int fwnode_irq_get(struct fwnode_handle *fwnode, unsigned int index)
 953{
 954	struct device_node *of_node = to_of_node(fwnode);
 955	struct resource res;
 956	int ret;
 957
 958	if (IS_ENABLED(CONFIG_OF) && of_node)
 959		return of_irq_get(of_node, index);
 960
 961	ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, &res);
 962	if (ret)
 963		return ret;
 964
 965	return res.start;
 966}
 967EXPORT_SYMBOL(fwnode_irq_get);
 968
 969/**
 970 * fwnode_graph_get_next_endpoint - Get next endpoint firmware node
 971 * @fwnode: Pointer to the parent firmware node
 972 * @prev: Previous endpoint node or %NULL to get the first
 973 *
 974 * Returns an endpoint firmware node pointer or %NULL if no more endpoints
 
 
 
 
 975 * are available.
 976 */
 977struct fwnode_handle *
 978fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
 979			       struct fwnode_handle *prev)
 980{
 981	return fwnode_call_ptr_op(fwnode, graph_get_next_endpoint, prev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 982}
 983EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint);
 984
 985/**
 986 * fwnode_graph_get_port_parent - Return the device fwnode of a port endpoint
 987 * @endpoint: Endpoint firmware node of the port
 988 *
 
 
 
 989 * Return: the firmware node of the device the @endpoint belongs to.
 990 */
 991struct fwnode_handle *
 992fwnode_graph_get_port_parent(const struct fwnode_handle *endpoint)
 993{
 994	struct fwnode_handle *port, *parent;
 995
 996	port = fwnode_get_parent(endpoint);
 997	parent = fwnode_call_ptr_op(port, graph_get_port_parent);
 998
 999	fwnode_handle_put(port);
1000
1001	return parent;
1002}
1003EXPORT_SYMBOL_GPL(fwnode_graph_get_port_parent);
1004
1005/**
1006 * fwnode_graph_get_remote_port_parent - Return fwnode of a remote device
1007 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1008 *
1009 * Extracts firmware node of a remote device the @fwnode points to.
 
 
 
1010 */
1011struct fwnode_handle *
1012fwnode_graph_get_remote_port_parent(const struct fwnode_handle *fwnode)
1013{
1014	struct fwnode_handle *endpoint, *parent;
1015
1016	endpoint = fwnode_graph_get_remote_endpoint(fwnode);
1017	parent = fwnode_graph_get_port_parent(endpoint);
1018
1019	fwnode_handle_put(endpoint);
1020
1021	return parent;
1022}
1023EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port_parent);
1024
1025/**
1026 * fwnode_graph_get_remote_port - Return fwnode of a remote port
1027 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1028 *
1029 * Extracts firmware node of a remote port the @fwnode points to.
 
 
 
1030 */
1031struct fwnode_handle *
1032fwnode_graph_get_remote_port(const struct fwnode_handle *fwnode)
1033{
1034	return fwnode_get_next_parent(fwnode_graph_get_remote_endpoint(fwnode));
1035}
1036EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port);
1037
1038/**
1039 * fwnode_graph_get_remote_endpoint - Return fwnode of a remote endpoint
1040 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1041 *
1042 * Extracts firmware node of a remote endpoint the @fwnode points to.
 
 
 
1043 */
1044struct fwnode_handle *
1045fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1046{
1047	return fwnode_call_ptr_op(fwnode, graph_get_remote_endpoint);
1048}
1049EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_endpoint);
1050
1051/**
1052 * fwnode_graph_get_remote_node - get remote parent node for given port/endpoint
1053 * @fwnode: pointer to parent fwnode_handle containing graph port/endpoint
1054 * @port_id: identifier of the parent port node
1055 * @endpoint_id: identifier of the endpoint node
1056 *
1057 * Return: Remote fwnode handle associated with remote endpoint node linked
1058 *	   to @node. Use fwnode_node_put() on it when done.
1059 */
1060struct fwnode_handle *
1061fwnode_graph_get_remote_node(const struct fwnode_handle *fwnode, u32 port_id,
1062			     u32 endpoint_id)
1063{
1064	struct fwnode_handle *endpoint = NULL;
1065
1066	while ((endpoint = fwnode_graph_get_next_endpoint(fwnode, endpoint))) {
1067		struct fwnode_endpoint fwnode_ep;
1068		struct fwnode_handle *remote;
1069		int ret;
1070
1071		ret = fwnode_graph_parse_endpoint(endpoint, &fwnode_ep);
1072		if (ret < 0)
1073			continue;
1074
1075		if (fwnode_ep.port != port_id || fwnode_ep.id != endpoint_id)
1076			continue;
1077
1078		remote = fwnode_graph_get_remote_port_parent(endpoint);
1079		if (!remote)
1080			return NULL;
1081
1082		return fwnode_device_is_available(remote) ? remote : NULL;
1083	}
1084
1085	return NULL;
1086}
1087EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_node);
1088
1089/**
1090 * fwnode_graph_get_endpoint_by_id - get endpoint by port and endpoint numbers
1091 * @fwnode: parent fwnode_handle containing the graph
1092 * @port: identifier of the port node
1093 * @endpoint: identifier of the endpoint node under the port node
1094 * @flags: fwnode lookup flags
1095 *
1096 * Return the fwnode handle of the local endpoint corresponding the port and
1097 * endpoint IDs or NULL if not found.
 
 
 
1098 *
1099 * If FWNODE_GRAPH_ENDPOINT_NEXT is passed in @flags and the specified endpoint
1100 * has not been found, look for the closest endpoint ID greater than the
1101 * specified one and return the endpoint that corresponds to it, if present.
1102 *
1103 * Do not return endpoints that belong to disabled devices, unless
1104 * FWNODE_GRAPH_DEVICE_DISABLED is passed in @flags.
1105 *
1106 * The returned endpoint needs to be released by calling fwnode_handle_put() on
1107 * it when it is not needed any more.
1108 */
1109struct fwnode_handle *
1110fwnode_graph_get_endpoint_by_id(const struct fwnode_handle *fwnode,
1111				u32 port, u32 endpoint, unsigned long flags)
1112{
1113	struct fwnode_handle *ep = NULL, *best_ep = NULL;
1114	unsigned int best_ep_id = 0;
1115	bool endpoint_next = flags & FWNODE_GRAPH_ENDPOINT_NEXT;
1116	bool enabled_only = !(flags & FWNODE_GRAPH_DEVICE_DISABLED);
1117
1118	while ((ep = fwnode_graph_get_next_endpoint(fwnode, ep))) {
1119		struct fwnode_endpoint fwnode_ep = { 0 };
1120		int ret;
1121
1122		if (enabled_only) {
1123			struct fwnode_handle *dev_node;
1124			bool available;
1125
1126			dev_node = fwnode_graph_get_remote_port_parent(ep);
1127			available = fwnode_device_is_available(dev_node);
1128			fwnode_handle_put(dev_node);
1129			if (!available)
1130				continue;
1131		}
1132
1133		ret = fwnode_graph_parse_endpoint(ep, &fwnode_ep);
1134		if (ret < 0)
1135			continue;
1136
1137		if (fwnode_ep.port != port)
1138			continue;
1139
1140		if (fwnode_ep.id == endpoint)
1141			return ep;
1142
1143		if (!endpoint_next)
1144			continue;
1145
1146		/*
1147		 * If the endpoint that has just been found is not the first
1148		 * matching one and the ID of the one found previously is closer
1149		 * to the requested endpoint ID, skip it.
1150		 */
1151		if (fwnode_ep.id < endpoint ||
1152		    (best_ep && best_ep_id < fwnode_ep.id))
1153			continue;
1154
1155		fwnode_handle_put(best_ep);
1156		best_ep = fwnode_handle_get(ep);
1157		best_ep_id = fwnode_ep.id;
1158	}
1159
1160	return best_ep;
1161}
1162EXPORT_SYMBOL_GPL(fwnode_graph_get_endpoint_by_id);
1163
1164/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1165 * fwnode_graph_parse_endpoint - parse common endpoint node properties
1166 * @fwnode: pointer to endpoint fwnode_handle
1167 * @endpoint: pointer to the fwnode endpoint data structure
1168 *
1169 * Parse @fwnode representing a graph endpoint node and store the
1170 * information in @endpoint. The caller must hold a reference to
1171 * @fwnode.
1172 */
1173int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1174				struct fwnode_endpoint *endpoint)
1175{
1176	memset(endpoint, 0, sizeof(*endpoint));
1177
1178	return fwnode_call_int_op(fwnode, graph_parse_endpoint, endpoint);
1179}
1180EXPORT_SYMBOL(fwnode_graph_parse_endpoint);
1181
1182const void *device_get_match_data(struct device *dev)
1183{
1184	return fwnode_call_ptr_op(dev_fwnode(dev), device_get_match_data, dev);
1185}
1186EXPORT_SYMBOL_GPL(device_get_match_data);