1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * drivers/of/property.c - Procedures for accessing and interpreting 4 * Devicetree properties and graphs. 5 * 6 * Initially created by copying procedures from drivers/of/base.c. This 7 * file contains the OF property as well as the OF graph interface 8 * functions. 9 * 10 * Paul Mackerras August 1996. 11 * Copyright (C) 1996-2005 Paul Mackerras. 12 * 13 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 14 * {engebret|bergner}@us.ibm.com 15 * 16 * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net 17 * 18 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and 19 * Grant Likely. 20 */ 21 22#define pr_fmt(fmt) "OF: " fmt 23 24#include <linux/of.h> 25#include <linux/of_address.h> 26#include <linux/of_device.h> 27#include <linux/of_graph.h> 28#include <linux/of_irq.h> 29#include <linux/string.h> 30#include <linux/moduleparam.h> 31 32#include "of_private.h" 33 34/** 35 * of_graph_is_present() - check graph's presence 36 * @node: pointer to device_node containing graph port 37 * 38 * Return: True if @node has a port or ports (with a port) sub-node, 39 * false otherwise. 40 */ 41bool of_graph_is_present(const struct device_node *node) 42{ 43 struct device_node *ports, *port; 44 45 ports = of_get_child_by_name(node, "ports"); 46 if (ports) 47 node = ports; 48 49 port = of_get_child_by_name(node, "port"); 50 of_node_put(ports); 51 of_node_put(port); 52 53 return !!port; 54} 55EXPORT_SYMBOL(of_graph_is_present); 56 57/** 58 * of_property_count_elems_of_size - Count the number of elements in a property 59 * 60 * @np: device node from which the property value is to be read. 61 * @propname: name of the property to be searched. 62 * @elem_size: size of the individual element 63 * 64 * Search for a property in a device node and count the number of elements of 65 * size elem_size in it. 66 * 67 * Return: The number of elements on sucess, -EINVAL if the property does not 68 * exist or its length does not match a multiple of elem_size and -ENODATA if 69 * the property does not have a value. 70 */ 71int of_property_count_elems_of_size(const struct device_node *np, 72 const char *propname, int elem_size) 73{ 74 struct property *prop = of_find_property(np, propname, NULL); 75 76 if (!prop) 77 return -EINVAL; 78 if (!prop->value) 79 return -ENODATA; 80 81 if (prop->length % elem_size != 0) { 82 pr_err("size of %s in node %pOF is not a multiple of %d\n", 83 propname, np, elem_size); 84 return -EINVAL; 85 } 86 87 return prop->length / elem_size; 88} 89EXPORT_SYMBOL_GPL(of_property_count_elems_of_size); 90 91/** 92 * of_find_property_value_of_size 93 * 94 * @np: device node from which the property value is to be read. 95 * @propname: name of the property to be searched. 96 * @min: minimum allowed length of property value 97 * @max: maximum allowed length of property value (0 means unlimited) 98 * @len: if !=NULL, actual length is written to here 99 * 100 * Search for a property in a device node and valid the requested size. 101 * 102 * Return: The property value on success, -EINVAL if the property does not 103 * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the 104 * property data is too small or too large. 105 * 106 */ 107static void *of_find_property_value_of_size(const struct device_node *np, 108 const char *propname, u32 min, u32 max, size_t *len) 109{ 110 struct property *prop = of_find_property(np, propname, NULL); 111 112 if (!prop) 113 return ERR_PTR(-EINVAL); 114 if (!prop->value) 115 return ERR_PTR(-ENODATA); 116 if (prop->length < min) 117 return ERR_PTR(-EOVERFLOW); 118 if (max && prop->length > max) 119 return ERR_PTR(-EOVERFLOW); 120 121 if (len) 122 *len = prop->length; 123 124 return prop->value; 125} 126 127/** 128 * of_property_read_u32_index - Find and read a u32 from a multi-value property. 129 * 130 * @np: device node from which the property value is to be read. 131 * @propname: name of the property to be searched. 132 * @index: index of the u32 in the list of values 133 * @out_value: pointer to return value, modified only if no error. 134 * 135 * Search for a property in a device node and read nth 32-bit value from 136 * it. 137 * 138 * Return: 0 on success, -EINVAL if the property does not exist, 139 * -ENODATA if property does not have a value, and -EOVERFLOW if the 140 * property data isn't large enough. 141 * 142 * The out_value is modified only if a valid u32 value can be decoded. 143 */ 144int of_property_read_u32_index(const struct device_node *np, 145 const char *propname, 146 u32 index, u32 *out_value) 147{ 148 const u32 *val = of_find_property_value_of_size(np, propname, 149 ((index + 1) * sizeof(*out_value)), 150 0, 151 NULL); 152 153 if (IS_ERR(val)) 154 return PTR_ERR(val); 155 156 *out_value = be32_to_cpup(((__be32 *)val) + index); 157 return 0; 158} 159EXPORT_SYMBOL_GPL(of_property_read_u32_index); 160 161/** 162 * of_property_read_u64_index - Find and read a u64 from a multi-value property. 163 * 164 * @np: device node from which the property value is to be read. 165 * @propname: name of the property to be searched. 166 * @index: index of the u64 in the list of values 167 * @out_value: pointer to return value, modified only if no error. 168 * 169 * Search for a property in a device node and read nth 64-bit value from 170 * it. 171 * 172 * Return: 0 on success, -EINVAL if the property does not exist, 173 * -ENODATA if property does not have a value, and -EOVERFLOW if the 174 * property data isn't large enough. 175 * 176 * The out_value is modified only if a valid u64 value can be decoded. 177 */ 178int of_property_read_u64_index(const struct device_node *np, 179 const char *propname, 180 u32 index, u64 *out_value) 181{ 182 const u64 *val = of_find_property_value_of_size(np, propname, 183 ((index + 1) * sizeof(*out_value)), 184 0, NULL); 185 186 if (IS_ERR(val)) 187 return PTR_ERR(val); 188 189 *out_value = be64_to_cpup(((__be64 *)val) + index); 190 return 0; 191} 192EXPORT_SYMBOL_GPL(of_property_read_u64_index); 193 194/** 195 * of_property_read_variable_u8_array - Find and read an array of u8 from a 196 * property, with bounds on the minimum and maximum array size. 197 * 198 * @np: device node from which the property value is to be read. 199 * @propname: name of the property to be searched. 200 * @out_values: pointer to found values. 201 * @sz_min: minimum number of array elements to read 202 * @sz_max: maximum number of array elements to read, if zero there is no 203 * upper limit on the number of elements in the dts entry but only 204 * sz_min will be read. 205 * 206 * Search for a property in a device node and read 8-bit value(s) from 207 * it. 208 * 209 * dts entry of array should be like: 210 * ``property = /bits/ 8 <0x50 0x60 0x70>;`` 211 * 212 * Return: The number of elements read on success, -EINVAL if the property 213 * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 214 * if the property data is smaller than sz_min or longer than sz_max. 215 * 216 * The out_values is modified only if a valid u8 value can be decoded. 217 */ 218int of_property_read_variable_u8_array(const struct device_node *np, 219 const char *propname, u8 *out_values, 220 size_t sz_min, size_t sz_max) 221{ 222 size_t sz, count; 223 const u8 *val = of_find_property_value_of_size(np, propname, 224 (sz_min * sizeof(*out_values)), 225 (sz_max * sizeof(*out_values)), 226 &sz); 227 228 if (IS_ERR(val)) 229 return PTR_ERR(val); 230 231 if (!sz_max) 232 sz = sz_min; 233 else 234 sz /= sizeof(*out_values); 235 236 count = sz; 237 while (count--) 238 *out_values++ = *val++; 239 240 return sz; 241} 242EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array); 243 244/** 245 * of_property_read_variable_u16_array - Find and read an array of u16 from a 246 * property, with bounds on the minimum and maximum array size. 247 * 248 * @np: device node from which the property value is to be read. 249 * @propname: name of the property to be searched. 250 * @out_values: pointer to found values. 251 * @sz_min: minimum number of array elements to read 252 * @sz_max: maximum number of array elements to read, if zero there is no 253 * upper limit on the number of elements in the dts entry but only 254 * sz_min will be read. 255 * 256 * Search for a property in a device node and read 16-bit value(s) from 257 * it. 258 * 259 * dts entry of array should be like: 260 * ``property = /bits/ 16 <0x5000 0x6000 0x7000>;`` 261 * 262 * Return: The number of elements read on success, -EINVAL if the property 263 * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 264 * if the property data is smaller than sz_min or longer than sz_max. 265 * 266 * The out_values is modified only if a valid u16 value can be decoded. 267 */ 268int of_property_read_variable_u16_array(const struct device_node *np, 269 const char *propname, u16 *out_values, 270 size_t sz_min, size_t sz_max) 271{ 272 size_t sz, count; 273 const __be16 *val = of_find_property_value_of_size(np, propname, 274 (sz_min * sizeof(*out_values)), 275 (sz_max * sizeof(*out_values)), 276 &sz); 277 278 if (IS_ERR(val)) 279 return PTR_ERR(val); 280 281 if (!sz_max) 282 sz = sz_min; 283 else 284 sz /= sizeof(*out_values); 285 286 count = sz; 287 while (count--) 288 *out_values++ = be16_to_cpup(val++); 289 290 return sz; 291} 292EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array); 293 294/** 295 * of_property_read_variable_u32_array - Find and read an array of 32 bit 296 * integers from a property, with bounds on the minimum and maximum array size. 297 * 298 * @np: device node from which the property value is to be read. 299 * @propname: name of the property to be searched. 300 * @out_values: pointer to return found values. 301 * @sz_min: minimum number of array elements to read 302 * @sz_max: maximum number of array elements to read, if zero there is no 303 * upper limit on the number of elements in the dts entry but only 304 * sz_min will be read. 305 * 306 * Search for a property in a device node and read 32-bit value(s) from 307 * it. 308 * 309 * Return: The number of elements read on success, -EINVAL if the property 310 * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 311 * if the property data is smaller than sz_min or longer than sz_max. 312 * 313 * The out_values is modified only if a valid u32 value can be decoded. 314 */ 315int of_property_read_variable_u32_array(const struct device_node *np, 316 const char *propname, u32 *out_values, 317 size_t sz_min, size_t sz_max) 318{ 319 size_t sz, count; 320 const __be32 *val = of_find_property_value_of_size(np, propname, 321 (sz_min * sizeof(*out_values)), 322 (sz_max * sizeof(*out_values)), 323 &sz); 324 325 if (IS_ERR(val)) 326 return PTR_ERR(val); 327 328 if (!sz_max) 329 sz = sz_min; 330 else 331 sz /= sizeof(*out_values); 332 333 count = sz; 334 while (count--) 335 *out_values++ = be32_to_cpup(val++); 336 337 return sz; 338} 339EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array); 340 341/** 342 * of_property_read_u64 - Find and read a 64 bit integer from a property 343 * @np: device node from which the property value is to be read. 344 * @propname: name of the property to be searched. 345 * @out_value: pointer to return value, modified only if return value is 0. 346 * 347 * Search for a property in a device node and read a 64-bit value from 348 * it. 349 * 350 * Return: 0 on success, -EINVAL if the property does not exist, 351 * -ENODATA if property does not have a value, and -EOVERFLOW if the 352 * property data isn't large enough. 353 * 354 * The out_value is modified only if a valid u64 value can be decoded. 355 */ 356int of_property_read_u64(const struct device_node *np, const char *propname, 357 u64 *out_value) 358{ 359 const __be32 *val = of_find_property_value_of_size(np, propname, 360 sizeof(*out_value), 361 0, 362 NULL); 363 364 if (IS_ERR(val)) 365 return PTR_ERR(val); 366 367 *out_value = of_read_number(val, 2); 368 return 0; 369} 370EXPORT_SYMBOL_GPL(of_property_read_u64); 371 372/** 373 * of_property_read_variable_u64_array - Find and read an array of 64 bit 374 * integers from a property, with bounds on the minimum and maximum array size. 375 * 376 * @np: device node from which the property value is to be read. 377 * @propname: name of the property to be searched. 378 * @out_values: pointer to found values. 379 * @sz_min: minimum number of array elements to read 380 * @sz_max: maximum number of array elements to read, if zero there is no 381 * upper limit on the number of elements in the dts entry but only 382 * sz_min will be read. 383 * 384 * Search for a property in a device node and read 64-bit value(s) from 385 * it. 386 * 387 * Return: The number of elements read on success, -EINVAL if the property 388 * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 389 * if the property data is smaller than sz_min or longer than sz_max. 390 * 391 * The out_values is modified only if a valid u64 value can be decoded. 392 */ 393int of_property_read_variable_u64_array(const struct device_node *np, 394 const char *propname, u64 *out_values, 395 size_t sz_min, size_t sz_max) 396{ 397 size_t sz, count; 398 const __be32 *val = of_find_property_value_of_size(np, propname, 399 (sz_min * sizeof(*out_values)), 400 (sz_max * sizeof(*out_values)), 401 &sz); 402 403 if (IS_ERR(val)) 404 return PTR_ERR(val); 405 406 if (!sz_max) 407 sz = sz_min; 408 else 409 sz /= sizeof(*out_values); 410 411 count = sz; 412 while (count--) { 413 *out_values++ = of_read_number(val, 2); 414 val += 2; 415 } 416 417 return sz; 418} 419EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array); 420 421/** 422 * of_property_read_string - Find and read a string from a property 423 * @np: device node from which the property value is to be read. 424 * @propname: name of the property to be searched. 425 * @out_string: pointer to null terminated return string, modified only if 426 * return value is 0. 427 * 428 * Search for a property in a device tree node and retrieve a null 429 * terminated string value (pointer to data, not a copy). 430 * 431 * Return: 0 on success, -EINVAL if the property does not exist, -ENODATA if 432 * property does not have a value, and -EILSEQ if the string is not 433 * null-terminated within the length of the property data. 434 * 435 * Note that the empty string "" has length of 1, thus -ENODATA cannot 436 * be interpreted as an empty string. 437 * 438 * The out_string pointer is modified only if a valid string can be decoded. 439 */ 440int of_property_read_string(const struct device_node *np, const char *propname, 441 const char **out_string) 442{ 443 const struct property *prop = of_find_property(np, propname, NULL); 444 445 if (!prop) 446 return -EINVAL; 447 if (!prop->length) 448 return -ENODATA; 449 if (strnlen(prop->value, prop->length) >= prop->length) 450 return -EILSEQ; 451 *out_string = prop->value; 452 return 0; 453} 454EXPORT_SYMBOL_GPL(of_property_read_string); 455 456/** 457 * of_property_match_string() - Find string in a list and return index 458 * @np: pointer to node containing string list property 459 * @propname: string list property name 460 * @string: pointer to string to search for in string list 461 * 462 * This function searches a string list property and returns the index 463 * of a specific string value. 464 */ 465int of_property_match_string(const struct device_node *np, const char *propname, 466 const char *string) 467{ 468 const struct property *prop = of_find_property(np, propname, NULL); 469 size_t l; 470 int i; 471 const char *p, *end; 472 473 if (!prop) 474 return -EINVAL; 475 if (!prop->value) 476 return -ENODATA; 477 478 p = prop->value; 479 end = p + prop->length; 480 481 for (i = 0; p < end; i++, p += l) { 482 l = strnlen(p, end - p) + 1; 483 if (p + l > end) 484 return -EILSEQ; 485 pr_debug("comparing %s with %s\n", string, p); 486 if (strcmp(string, p) == 0) 487 return i; /* Found it; return index */ 488 } 489 return -ENODATA; 490} 491EXPORT_SYMBOL_GPL(of_property_match_string); 492 493/** 494 * of_property_read_string_helper() - Utility helper for parsing string properties 495 * @np: device node from which the property value is to be read. 496 * @propname: name of the property to be searched. 497 * @out_strs: output array of string pointers. 498 * @sz: number of array elements to read. 499 * @skip: Number of strings to skip over at beginning of list. 500 * 501 * Don't call this function directly. It is a utility helper for the 502 * of_property_read_string*() family of functions. 503 */ 504int of_property_read_string_helper(const struct device_node *np, 505 const char *propname, const char **out_strs, 506 size_t sz, int skip) 507{ 508 const struct property *prop = of_find_property(np, propname, NULL); 509 int l = 0, i = 0; 510 const char *p, *end; 511 512 if (!prop) 513 return -EINVAL; 514 if (!prop->value) 515 return -ENODATA; 516 p = prop->value; 517 end = p + prop->length; 518 519 for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) { 520 l = strnlen(p, end - p) + 1; 521 if (p + l > end) 522 return -EILSEQ; 523 if (out_strs && i >= skip) 524 *out_strs++ = p; 525 } 526 i -= skip; 527 return i <= 0 ? -ENODATA : i; 528} 529EXPORT_SYMBOL_GPL(of_property_read_string_helper); 530 531const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 532 u32 *pu) 533{ 534 const void *curv = cur; 535 536 if (!prop) 537 return NULL; 538 539 if (!cur) { 540 curv = prop->value; 541 goto out_val; 542 } 543 544 curv += sizeof(*cur); 545 if (curv >= prop->value + prop->length) 546 return NULL; 547 548out_val: 549 *pu = be32_to_cpup(curv); 550 return curv; 551} 552EXPORT_SYMBOL_GPL(of_prop_next_u32); 553 554const char *of_prop_next_string(struct property *prop, const char *cur) 555{ 556 const void *curv = cur; 557 558 if (!prop) 559 return NULL; 560 561 if (!cur) 562 return prop->value; 563 564 curv += strlen(cur) + 1; 565 if (curv >= prop->value + prop->length) 566 return NULL; 567 568 return curv; 569} 570EXPORT_SYMBOL_GPL(of_prop_next_string); 571 572/** 573 * of_graph_parse_endpoint() - parse common endpoint node properties 574 * @node: pointer to endpoint device_node 575 * @endpoint: pointer to the OF endpoint data structure 576 * 577 * The caller should hold a reference to @node. 578 */ 579int of_graph_parse_endpoint(const struct device_node *node, 580 struct of_endpoint *endpoint) 581{ 582 struct device_node *port_node = of_get_parent(node); 583 584 WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n", 585 __func__, node); 586 587 memset(endpoint, 0, sizeof(*endpoint)); 588 589 endpoint->local_node = node; 590 /* 591 * It doesn't matter whether the two calls below succeed. 592 * If they don't then the default value 0 is used. 593 */ 594 of_property_read_u32(port_node, "reg", &endpoint->port); 595 of_property_read_u32(node, "reg", &endpoint->id); 596 597 of_node_put(port_node); 598 599 return 0; 600} 601EXPORT_SYMBOL(of_graph_parse_endpoint); 602 603/** 604 * of_graph_get_port_by_id() - get the port matching a given id 605 * @parent: pointer to the parent device node 606 * @id: id of the port 607 * 608 * Return: A 'port' node pointer with refcount incremented. The caller 609 * has to use of_node_put() on it when done. 610 */ 611struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id) 612{ 613 struct device_node *node, *port; 614 615 node = of_get_child_by_name(parent, "ports"); 616 if (node) 617 parent = node; 618 619 for_each_child_of_node(parent, port) { 620 u32 port_id = 0; 621 622 if (!of_node_name_eq(port, "port")) 623 continue; 624 of_property_read_u32(port, "reg", &port_id); 625 if (id == port_id) 626 break; 627 } 628 629 of_node_put(node); 630 631 return port; 632} 633EXPORT_SYMBOL(of_graph_get_port_by_id); 634 635/** 636 * of_graph_get_next_endpoint() - get next endpoint node 637 * @parent: pointer to the parent device node 638 * @prev: previous endpoint node, or NULL to get first 639 * 640 * Return: An 'endpoint' node pointer with refcount incremented. Refcount 641 * of the passed @prev node is decremented. 642 */ 643struct device_node *of_graph_get_next_endpoint(const struct device_node *parent, 644 struct device_node *prev) 645{ 646 struct device_node *endpoint; 647 struct device_node *port; 648 649 if (!parent) 650 return NULL; 651 652 /* 653 * Start by locating the port node. If no previous endpoint is specified 654 * search for the first port node, otherwise get the previous endpoint 655 * parent port node. 656 */ 657 if (!prev) { 658 struct device_node *node; 659 660 node = of_get_child_by_name(parent, "ports"); 661 if (node) 662 parent = node; 663 664 port = of_get_child_by_name(parent, "port"); 665 of_node_put(node); 666 667 if (!port) { 668 pr_debug("graph: no port node found in %pOF\n", parent); 669 return NULL; 670 } 671 } else { 672 port = of_get_parent(prev); 673 if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n", 674 __func__, prev)) 675 return NULL; 676 } 677 678 while (1) { 679 /* 680 * Now that we have a port node, get the next endpoint by 681 * getting the next child. If the previous endpoint is NULL this 682 * will return the first child. 683 */ 684 endpoint = of_get_next_child(port, prev); 685 if (endpoint) { 686 of_node_put(port); 687 return endpoint; 688 } 689 690 /* No more endpoints under this port, try the next one. */ 691 prev = NULL; 692 693 do { 694 port = of_get_next_child(parent, port); 695 if (!port) 696 return NULL; 697 } while (!of_node_name_eq(port, "port")); 698 } 699} 700EXPORT_SYMBOL(of_graph_get_next_endpoint); 701 702/** 703 * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers 704 * @parent: pointer to the parent device node 705 * @port_reg: identifier (value of reg property) of the parent port node 706 * @reg: identifier (value of reg property) of the endpoint node 707 * 708 * Return: An 'endpoint' node pointer which is identified by reg and at the same 709 * is the child of a port node identified by port_reg. reg and port_reg are 710 * ignored when they are -1. Use of_node_put() on the pointer when done. 711 */ 712struct device_node *of_graph_get_endpoint_by_regs( 713 const struct device_node *parent, int port_reg, int reg) 714{ 715 struct of_endpoint endpoint; 716 struct device_node *node = NULL; 717 718 for_each_endpoint_of_node(parent, node) { 719 of_graph_parse_endpoint(node, &endpoint); 720 if (((port_reg == -1) || (endpoint.port == port_reg)) && 721 ((reg == -1) || (endpoint.id == reg))) 722 return node; 723 } 724 725 return NULL; 726} 727EXPORT_SYMBOL(of_graph_get_endpoint_by_regs); 728 729/** 730 * of_graph_get_remote_endpoint() - get remote endpoint node 731 * @node: pointer to a local endpoint device_node 732 * 733 * Return: Remote endpoint node associated with remote endpoint node linked 734 * to @node. Use of_node_put() on it when done. 735 */ 736struct device_node *of_graph_get_remote_endpoint(const struct device_node *node) 737{ 738 /* Get remote endpoint node. */ 739 return of_parse_phandle(node, "remote-endpoint", 0); 740} 741EXPORT_SYMBOL(of_graph_get_remote_endpoint); 742 743/** 744 * of_graph_get_port_parent() - get port's parent node 745 * @node: pointer to a local endpoint device_node 746 * 747 * Return: device node associated with endpoint node linked 748 * to @node. Use of_node_put() on it when done. 749 */ 750struct device_node *of_graph_get_port_parent(struct device_node *node) 751{ 752 unsigned int depth; 753 754 if (!node) 755 return NULL; 756 757 /* 758 * Preserve usecount for passed in node as of_get_next_parent() 759 * will do of_node_put() on it. 760 */ 761 of_node_get(node); 762 763 /* Walk 3 levels up only if there is 'ports' node. */ 764 for (depth = 3; depth && node; depth--) { 765 node = of_get_next_parent(node); 766 if (depth == 2 && !of_node_name_eq(node, "ports") && 767 !of_node_name_eq(node, "in-ports") && 768 !of_node_name_eq(node, "out-ports")) 769 break; 770 } 771 return node; 772} 773EXPORT_SYMBOL(of_graph_get_port_parent); 774 775/** 776 * of_graph_get_remote_port_parent() - get remote port's parent node 777 * @node: pointer to a local endpoint device_node 778 * 779 * Return: Remote device node associated with remote endpoint node linked 780 * to @node. Use of_node_put() on it when done. 781 */ 782struct device_node *of_graph_get_remote_port_parent( 783 const struct device_node *node) 784{ 785 struct device_node *np, *pp; 786 787 /* Get remote endpoint node. */ 788 np = of_graph_get_remote_endpoint(node); 789 790 pp = of_graph_get_port_parent(np); 791 792 of_node_put(np); 793 794 return pp; 795} 796EXPORT_SYMBOL(of_graph_get_remote_port_parent); 797 798/** 799 * of_graph_get_remote_port() - get remote port node 800 * @node: pointer to a local endpoint device_node 801 * 802 * Return: Remote port node associated with remote endpoint node linked 803 * to @node. Use of_node_put() on it when done. 804 */ 805struct device_node *of_graph_get_remote_port(const struct device_node *node) 806{ 807 struct device_node *np; 808 809 /* Get remote endpoint node. */ 810 np = of_graph_get_remote_endpoint(node); 811 if (!np) 812 return NULL; 813 return of_get_next_parent(np); 814} 815EXPORT_SYMBOL(of_graph_get_remote_port); 816 817/** 818 * of_graph_get_endpoint_count() - get the number of endpoints in a device node 819 * @np: parent device node containing ports and endpoints 820 * 821 * Return: count of endpoint of this device node 822 */ 823unsigned int of_graph_get_endpoint_count(const struct device_node *np) 824{ 825 struct device_node *endpoint; 826 unsigned int num = 0; 827 828 for_each_endpoint_of_node(np, endpoint) 829 num++; 830 831 return num; 832} 833EXPORT_SYMBOL(of_graph_get_endpoint_count); 834 835/** 836 * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint 837 * @node: pointer to parent device_node containing graph port/endpoint 838 * @port: identifier (value of reg property) of the parent port node 839 * @endpoint: identifier (value of reg property) of the endpoint node 840 * 841 * Return: Remote device node associated with remote endpoint node linked 842 * to @node. Use of_node_put() on it when done. 843 */ 844struct device_node *of_graph_get_remote_node(const struct device_node *node, 845 u32 port, u32 endpoint) 846{ 847 struct device_node *endpoint_node, *remote; 848 849 endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint); 850 if (!endpoint_node) { 851 pr_debug("no valid endpoint (%d, %d) for node %pOF\n", 852 port, endpoint, node); 853 return NULL; 854 } 855 856 remote = of_graph_get_remote_port_parent(endpoint_node); 857 of_node_put(endpoint_node); 858 if (!remote) { 859 pr_debug("no valid remote node\n"); 860 return NULL; 861 } 862 863 if (!of_device_is_available(remote)) { 864 pr_debug("not available for remote node\n"); 865 of_node_put(remote); 866 return NULL; 867 } 868 869 return remote; 870} 871EXPORT_SYMBOL(of_graph_get_remote_node); 872 873static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode) 874{ 875 return of_fwnode_handle(of_node_get(to_of_node(fwnode))); 876} 877 878static void of_fwnode_put(struct fwnode_handle *fwnode) 879{ 880 of_node_put(to_of_node(fwnode)); 881} 882 883static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode) 884{ 885 return of_device_is_available(to_of_node(fwnode)); 886} 887 888static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode) 889{ 890 return true; 891} 892 893static enum dev_dma_attr 894of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode) 895{ 896 if (of_dma_is_coherent(to_of_node(fwnode))) 897 return DEV_DMA_COHERENT; 898 else 899 return DEV_DMA_NON_COHERENT; 900} 901 902static bool of_fwnode_property_present(const struct fwnode_handle *fwnode, 903 const char *propname) 904{ 905 return of_property_read_bool(to_of_node(fwnode), propname); 906} 907 908static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode, 909 const char *propname, 910 unsigned int elem_size, void *val, 911 size_t nval) 912{ 913 const struct device_node *node = to_of_node(fwnode); 914 915 if (!val) 916 return of_property_count_elems_of_size(node, propname, 917 elem_size); 918 919 switch (elem_size) { 920 case sizeof(u8): 921 return of_property_read_u8_array(node, propname, val, nval); 922 case sizeof(u16): 923 return of_property_read_u16_array(node, propname, val, nval); 924 case sizeof(u32): 925 return of_property_read_u32_array(node, propname, val, nval); 926 case sizeof(u64): 927 return of_property_read_u64_array(node, propname, val, nval); 928 } 929 930 return -ENXIO; 931} 932 933static int 934of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode, 935 const char *propname, const char **val, 936 size_t nval) 937{ 938 const struct device_node *node = to_of_node(fwnode); 939 940 return val ? 941 of_property_read_string_array(node, propname, val, nval) : 942 of_property_count_strings(node, propname); 943} 944 945static const char *of_fwnode_get_name(const struct fwnode_handle *fwnode) 946{ 947 return kbasename(to_of_node(fwnode)->full_name); 948} 949 950static const char *of_fwnode_get_name_prefix(const struct fwnode_handle *fwnode) 951{ 952 /* Root needs no prefix here (its name is "/"). */ 953 if (!to_of_node(fwnode)->parent) 954 return ""; 955 956 return "/"; 957} 958 959static struct fwnode_handle * 960of_fwnode_get_parent(const struct fwnode_handle *fwnode) 961{ 962 return of_fwnode_handle(of_get_parent(to_of_node(fwnode))); 963} 964 965static struct fwnode_handle * 966of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode, 967 struct fwnode_handle *child) 968{ 969 return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode), 970 to_of_node(child))); 971} 972 973static struct fwnode_handle * 974of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode, 975 const char *childname) 976{ 977 const struct device_node *node = to_of_node(fwnode); 978 struct device_node *child; 979 980 for_each_available_child_of_node(node, child) 981 if (of_node_name_eq(child, childname)) 982 return of_fwnode_handle(child); 983 984 return NULL; 985} 986 987static int 988of_fwnode_get_reference_args(const struct fwnode_handle *fwnode, 989 const char *prop, const char *nargs_prop, 990 unsigned int nargs, unsigned int index, 991 struct fwnode_reference_args *args) 992{ 993 struct of_phandle_args of_args; 994 unsigned int i; 995 int ret; 996 997 if (nargs_prop) 998 ret = of_parse_phandle_with_args(to_of_node(fwnode), prop, 999 nargs_prop, index, &of_args); 1000 else 1001 ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop, 1002 nargs, index, &of_args); 1003 if (ret < 0) 1004 return ret; 1005 if (!args) { 1006 of_node_put(of_args.np); 1007 return 0; 1008 } 1009 1010 args->nargs = of_args.args_count; 1011 args->fwnode = of_fwnode_handle(of_args.np); 1012 1013 for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++) 1014 args->args[i] = i < of_args.args_count ? of_args.args[i] : 0; 1015 1016 return 0; 1017} 1018 1019static struct fwnode_handle * 1020of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 1021 struct fwnode_handle *prev) 1022{ 1023 return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode), 1024 to_of_node(prev))); 1025} 1026 1027static struct fwnode_handle * 1028of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode) 1029{ 1030 return of_fwnode_handle( 1031 of_graph_get_remote_endpoint(to_of_node(fwnode))); 1032} 1033 1034static struct fwnode_handle * 1035of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode) 1036{ 1037 struct device_node *np; 1038 1039 /* Get the parent of the port */ 1040 np = of_get_parent(to_of_node(fwnode)); 1041 if (!np) 1042 return NULL; 1043 1044 /* Is this the "ports" node? If not, it's the port parent. */ 1045 if (!of_node_name_eq(np, "ports")) 1046 return of_fwnode_handle(np); 1047 1048 return of_fwnode_handle(of_get_next_parent(np)); 1049} 1050 1051static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, 1052 struct fwnode_endpoint *endpoint) 1053{ 1054 const struct device_node *node = to_of_node(fwnode); 1055 struct device_node *port_node = of_get_parent(node); 1056 1057 endpoint->local_fwnode = fwnode; 1058 1059 of_property_read_u32(port_node, "reg", &endpoint->port); 1060 of_property_read_u32(node, "reg", &endpoint->id); 1061 1062 of_node_put(port_node); 1063 1064 return 0; 1065} 1066 1067static const void * 1068of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode, 1069 const struct device *dev) 1070{ 1071 return of_device_get_match_data(dev); 1072} 1073 1074static void of_link_to_phandle(struct device_node *con_np, 1075 struct device_node *sup_np, 1076 u8 flags) 1077{ 1078 struct device_node *tmp_np = of_node_get(sup_np); 1079 1080 /* Check that sup_np and its ancestors are available. */ 1081 while (tmp_np) { 1082 if (of_fwnode_handle(tmp_np)->dev) { 1083 of_node_put(tmp_np); 1084 break; 1085 } 1086 1087 if (!of_device_is_available(tmp_np)) { 1088 of_node_put(tmp_np); 1089 return; 1090 } 1091 1092 tmp_np = of_get_next_parent(tmp_np); 1093 } 1094 1095 fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np), flags); 1096} 1097 1098/** 1099 * parse_prop_cells - Property parsing function for suppliers 1100 * 1101 * @np: Pointer to device tree node containing a list 1102 * @prop_name: Name of property to be parsed. Expected to hold phandle values 1103 * @index: For properties holding a list of phandles, this is the index 1104 * into the list. 1105 * @list_name: Property name that is known to contain list of phandle(s) to 1106 * supplier(s) 1107 * @cells_name: property name that specifies phandles' arguments count 1108 * 1109 * This is a helper function to parse properties that have a known fixed name 1110 * and are a list of phandles and phandle arguments. 1111 * 1112 * Returns: 1113 * - phandle node pointer with refcount incremented. Caller must of_node_put() 1114 * on it when done. 1115 * - NULL if no phandle found at index 1116 */ 1117static struct device_node *parse_prop_cells(struct device_node *np, 1118 const char *prop_name, int index, 1119 const char *list_name, 1120 const char *cells_name) 1121{ 1122 struct of_phandle_args sup_args; 1123 1124 if (strcmp(prop_name, list_name)) 1125 return NULL; 1126 1127 if (__of_parse_phandle_with_args(np, list_name, cells_name, 0, index, 1128 &sup_args)) 1129 return NULL; 1130 1131 return sup_args.np; 1132} 1133 1134#define DEFINE_SIMPLE_PROP(fname, name, cells) \ 1135static struct device_node *parse_##fname(struct device_node *np, \ 1136 const char *prop_name, int index) \ 1137{ \ 1138 return parse_prop_cells(np, prop_name, index, name, cells); \ 1139} 1140 1141static int strcmp_suffix(const char *str, const char *suffix) 1142{ 1143 unsigned int len, suffix_len; 1144 1145 len = strlen(str); 1146 suffix_len = strlen(suffix); 1147 if (len <= suffix_len) 1148 return -1; 1149 return strcmp(str + len - suffix_len, suffix); 1150} 1151 1152/** 1153 * parse_suffix_prop_cells - Suffix property parsing function for suppliers 1154 * 1155 * @np: Pointer to device tree node containing a list 1156 * @prop_name: Name of property to be parsed. Expected to hold phandle values 1157 * @index: For properties holding a list of phandles, this is the index 1158 * into the list. 1159 * @suffix: Property suffix that is known to contain list of phandle(s) to 1160 * supplier(s) 1161 * @cells_name: property name that specifies phandles' arguments count 1162 * 1163 * This is a helper function to parse properties that have a known fixed suffix 1164 * and are a list of phandles and phandle arguments. 1165 * 1166 * Returns: 1167 * - phandle node pointer with refcount incremented. Caller must of_node_put() 1168 * on it when done. 1169 * - NULL if no phandle found at index 1170 */ 1171static struct device_node *parse_suffix_prop_cells(struct device_node *np, 1172 const char *prop_name, int index, 1173 const char *suffix, 1174 const char *cells_name) 1175{ 1176 struct of_phandle_args sup_args; 1177 1178 if (strcmp_suffix(prop_name, suffix)) 1179 return NULL; 1180 1181 if (of_parse_phandle_with_args(np, prop_name, cells_name, index, 1182 &sup_args)) 1183 return NULL; 1184 1185 return sup_args.np; 1186} 1187 1188#define DEFINE_SUFFIX_PROP(fname, suffix, cells) \ 1189static struct device_node *parse_##fname(struct device_node *np, \ 1190 const char *prop_name, int index) \ 1191{ \ 1192 return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \ 1193} 1194 1195/** 1196 * struct supplier_bindings - Property parsing functions for suppliers 1197 * 1198 * @parse_prop: function name 1199 * parse_prop() finds the node corresponding to a supplier phandle 1200 * parse_prop.np: Pointer to device node holding supplier phandle property 1201 * parse_prop.prop_name: Name of property holding a phandle value 1202 * parse_prop.index: For properties holding a list of phandles, this is the 1203 * index into the list 1204 * @get_con_dev: If the consumer node containing the property is never converted 1205 * to a struct device, implement this ops so fw_devlink can use it 1206 * to find the true consumer. 1207 * @optional: Describes whether a supplier is mandatory or not 1208 * @fwlink_flags: Optional fwnode link flags to use when creating a fwnode link 1209 * for this property. 1210 * 1211 * Returns: 1212 * parse_prop() return values are 1213 * - phandle node pointer with refcount incremented. Caller must of_node_put() 1214 * on it when done. 1215 * - NULL if no phandle found at index 1216 */ 1217struct supplier_bindings { 1218 struct device_node *(*parse_prop)(struct device_node *np, 1219 const char *prop_name, int index); 1220 struct device_node *(*get_con_dev)(struct device_node *np); 1221 bool optional; 1222 u8 fwlink_flags; 1223}; 1224 1225DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells") 1226DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells") 1227DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells") 1228DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells") 1229DEFINE_SIMPLE_PROP(io_channels, "io-channels", "#io-channel-cells") 1230DEFINE_SIMPLE_PROP(io_backends, "io-backends", "#io-backend-cells") 1231DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL) 1232DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells") 1233DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells") 1234DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells") 1235DEFINE_SIMPLE_PROP(extcon, "extcon", NULL) 1236DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", "#nvmem-cell-cells") 1237DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells") 1238DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL) 1239DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL) 1240DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL) 1241DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL) 1242DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL) 1243DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL) 1244DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL) 1245DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL) 1246DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL) 1247DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL) 1248DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells") 1249DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells") 1250DEFINE_SIMPLE_PROP(leds, "leds", NULL) 1251DEFINE_SIMPLE_PROP(backlight, "backlight", NULL) 1252DEFINE_SIMPLE_PROP(panel, "panel", NULL) 1253DEFINE_SIMPLE_PROP(msi_parent, "msi-parent", "#msi-cells") 1254DEFINE_SIMPLE_PROP(post_init_providers, "post-init-providers", NULL) 1255DEFINE_SUFFIX_PROP(regulators, "-supply", NULL) 1256DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells") 1257 1258static struct device_node *parse_gpios(struct device_node *np, 1259 const char *prop_name, int index) 1260{ 1261 if (!strcmp_suffix(prop_name, ",nr-gpios")) 1262 return NULL; 1263 1264 return parse_suffix_prop_cells(np, prop_name, index, "-gpios", 1265 "#gpio-cells"); 1266} 1267 1268static struct device_node *parse_iommu_maps(struct device_node *np, 1269 const char *prop_name, int index) 1270{ 1271 if (strcmp(prop_name, "iommu-map")) 1272 return NULL; 1273 1274 return of_parse_phandle(np, prop_name, (index * 4) + 1); 1275} 1276 1277static struct device_node *parse_gpio_compat(struct device_node *np, 1278 const char *prop_name, int index) 1279{ 1280 struct of_phandle_args sup_args; 1281 1282 if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios")) 1283 return NULL; 1284 1285 /* 1286 * Ignore node with gpio-hog property since its gpios are all provided 1287 * by its parent. 1288 */ 1289 if (of_property_read_bool(np, "gpio-hog")) 1290 return NULL; 1291 1292 if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index, 1293 &sup_args)) 1294 return NULL; 1295 1296 return sup_args.np; 1297} 1298 1299static struct device_node *parse_interrupts(struct device_node *np, 1300 const char *prop_name, int index) 1301{ 1302 struct of_phandle_args sup_args; 1303 1304 if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC)) 1305 return NULL; 1306 1307 if (strcmp(prop_name, "interrupts") && 1308 strcmp(prop_name, "interrupts-extended")) 1309 return NULL; 1310 1311 return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np; 1312} 1313 1314static struct device_node *parse_remote_endpoint(struct device_node *np, 1315 const char *prop_name, 1316 int index) 1317{ 1318 /* Return NULL for index > 0 to signify end of remote-endpoints. */ 1319 if (index > 0 || strcmp(prop_name, "remote-endpoint")) 1320 return NULL; 1321 1322 return of_graph_get_remote_port_parent(np); 1323} 1324 1325static const struct supplier_bindings of_supplier_bindings[] = { 1326 { .parse_prop = parse_clocks, }, 1327 { .parse_prop = parse_interconnects, }, 1328 { .parse_prop = parse_iommus, .optional = true, }, 1329 { .parse_prop = parse_iommu_maps, .optional = true, }, 1330 { .parse_prop = parse_mboxes, }, 1331 { .parse_prop = parse_io_channels, }, 1332 { .parse_prop = parse_io_backends, }, 1333 { .parse_prop = parse_interrupt_parent, }, 1334 { .parse_prop = parse_dmas, .optional = true, }, 1335 { .parse_prop = parse_power_domains, }, 1336 { .parse_prop = parse_hwlocks, }, 1337 { .parse_prop = parse_extcon, }, 1338 { .parse_prop = parse_nvmem_cells, }, 1339 { .parse_prop = parse_phys, }, 1340 { .parse_prop = parse_wakeup_parent, }, 1341 { .parse_prop = parse_pinctrl0, }, 1342 { .parse_prop = parse_pinctrl1, }, 1343 { .parse_prop = parse_pinctrl2, }, 1344 { .parse_prop = parse_pinctrl3, }, 1345 { .parse_prop = parse_pinctrl4, }, 1346 { .parse_prop = parse_pinctrl5, }, 1347 { .parse_prop = parse_pinctrl6, }, 1348 { .parse_prop = parse_pinctrl7, }, 1349 { .parse_prop = parse_pinctrl8, }, 1350 { 1351 .parse_prop = parse_remote_endpoint, 1352 .get_con_dev = of_graph_get_port_parent, 1353 }, 1354 { .parse_prop = parse_pwms, }, 1355 { .parse_prop = parse_resets, }, 1356 { .parse_prop = parse_leds, }, 1357 { .parse_prop = parse_backlight, }, 1358 { .parse_prop = parse_panel, }, 1359 { .parse_prop = parse_msi_parent, }, 1360 { .parse_prop = parse_gpio_compat, }, 1361 { .parse_prop = parse_interrupts, }, 1362 { .parse_prop = parse_regulators, }, 1363 { .parse_prop = parse_gpio, }, 1364 { .parse_prop = parse_gpios, }, 1365 { 1366 .parse_prop = parse_post_init_providers, 1367 .fwlink_flags = FWLINK_FLAG_IGNORE, 1368 }, 1369 {} 1370}; 1371 1372/** 1373 * of_link_property - Create device links to suppliers listed in a property 1374 * @con_np: The consumer device tree node which contains the property 1375 * @prop_name: Name of property to be parsed 1376 * 1377 * This function checks if the property @prop_name that is present in the 1378 * @con_np device tree node is one of the known common device tree bindings 1379 * that list phandles to suppliers. If @prop_name isn't one, this function 1380 * doesn't do anything. 1381 * 1382 * If @prop_name is one, this function attempts to create fwnode links from the 1383 * consumer device tree node @con_np to all the suppliers device tree nodes 1384 * listed in @prop_name. 1385 * 1386 * Any failed attempt to create a fwnode link will NOT result in an immediate 1387 * return. of_link_property() must create links to all the available supplier 1388 * device tree nodes even when attempts to create a link to one or more 1389 * suppliers fail. 1390 */ 1391static int of_link_property(struct device_node *con_np, const char *prop_name) 1392{ 1393 struct device_node *phandle; 1394 const struct supplier_bindings *s = of_supplier_bindings; 1395 unsigned int i = 0; 1396 bool matched = false; 1397 1398 /* Do not stop at first failed link, link all available suppliers. */ 1399 while (!matched && s->parse_prop) { 1400 if (s->optional && !fw_devlink_is_strict()) { 1401 s++; 1402 continue; 1403 } 1404 1405 while ((phandle = s->parse_prop(con_np, prop_name, i))) { 1406 struct device_node *con_dev_np; 1407 1408 con_dev_np = s->get_con_dev 1409 ? s->get_con_dev(con_np) 1410 : of_node_get(con_np); 1411 matched = true; 1412 i++; 1413 of_link_to_phandle(con_dev_np, phandle, s->fwlink_flags); 1414 of_node_put(phandle); 1415 of_node_put(con_dev_np); 1416 } 1417 s++; 1418 } 1419 return 0; 1420} 1421 1422static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index) 1423{ 1424#ifdef CONFIG_OF_ADDRESS 1425 return of_iomap(to_of_node(fwnode), index); 1426#else 1427 return NULL; 1428#endif 1429} 1430 1431static int of_fwnode_irq_get(const struct fwnode_handle *fwnode, 1432 unsigned int index) 1433{ 1434 return of_irq_get(to_of_node(fwnode), index); 1435} 1436 1437static int of_fwnode_add_links(struct fwnode_handle *fwnode) 1438{ 1439 struct property *p; 1440 struct device_node *con_np = to_of_node(fwnode); 1441 1442 if (IS_ENABLED(CONFIG_X86)) 1443 return 0; 1444 1445 if (!con_np) 1446 return -EINVAL; 1447 1448 for_each_property_of_node(con_np, p) 1449 of_link_property(con_np, p->name); 1450 1451 return 0; 1452} 1453 1454const struct fwnode_operations of_fwnode_ops = { 1455 .get = of_fwnode_get, 1456 .put = of_fwnode_put, 1457 .device_is_available = of_fwnode_device_is_available, 1458 .device_get_match_data = of_fwnode_device_get_match_data, 1459 .device_dma_supported = of_fwnode_device_dma_supported, 1460 .device_get_dma_attr = of_fwnode_device_get_dma_attr, 1461 .property_present = of_fwnode_property_present, 1462 .property_read_int_array = of_fwnode_property_read_int_array, 1463 .property_read_string_array = of_fwnode_property_read_string_array, 1464 .get_name = of_fwnode_get_name, 1465 .get_name_prefix = of_fwnode_get_name_prefix, 1466 .get_parent = of_fwnode_get_parent, 1467 .get_next_child_node = of_fwnode_get_next_child_node, 1468 .get_named_child_node = of_fwnode_get_named_child_node, 1469 .get_reference_args = of_fwnode_get_reference_args, 1470 .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint, 1471 .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint, 1472 .graph_get_port_parent = of_fwnode_graph_get_port_parent, 1473 .graph_parse_endpoint = of_fwnode_graph_parse_endpoint, 1474 .iomap = of_fwnode_iomap, 1475 .irq_get = of_fwnode_irq_get, 1476 .add_links = of_fwnode_add_links, 1477}; 1478EXPORT_SYMBOL_GPL(of_fwnode_ops); 1479