drivers/of/property.c

   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  */
  41 bool 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 }
  55 EXPORT_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  */
  71 int 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 }
  89 EXPORT_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  */
 107 static 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  */
 144 int 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 }
 159 EXPORT_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  */
 178 int 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 }
 192 EXPORT_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  */
 218 int 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 }
 242 EXPORT_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  */
 268 int 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 }
 292 EXPORT_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  */
 315 int 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 }
 339 EXPORT_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  */
 356 int 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 }
 370 EXPORT_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  */
 393 int 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 }
 419 EXPORT_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  */
 440 int 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         if (!prop)
 445                 return -EINVAL;
 446         if (!prop->length)
 447                 return -ENODATA;
 448         if (strnlen(prop->value, prop->length) >= prop->length)
 449                 return -EILSEQ;
 450         *out_string = prop->value;
 451         return 0;
 452 }
 453 EXPORT_SYMBOL_GPL(of_property_read_string);
 454
 455 /**
 456  * of_property_match_string() - Find string in a list and return index
 457  * @np: pointer to node containing string list property
 458  * @propname: string list property name
 459  * @string: pointer to string to search for in string list
 460  *
 461  * This function searches a string list property and returns the index
 462  * of a specific string value.
 463  */
 464 int of_property_match_string(const struct device_node *np, const char *propname,
 465                              const char *string)
 466 {
 467         const struct property *prop = of_find_property(np, propname, NULL);
 468         size_t l;
 469         int i;
 470         const char *p, *end;
 471
 472         if (!prop)
 473                 return -EINVAL;
 474         if (!prop->value)
 475                 return -ENODATA;
 476
 477         p = prop->value;
 478         end = p + prop->length;
 479
 480         for (i = 0; p < end; i++, p += l) {
 481                 l = strnlen(p, end - p) + 1;
 482                 if (p + l > end)
 483                         return -EILSEQ;
 484                 pr_debug("comparing %s with %s\n", string, p);
 485                 if (strcmp(string, p) == 0)
 486                         return i; /* Found it; return index */
 487         }
 488         return -ENODATA;
 489 }
 490 EXPORT_SYMBOL_GPL(of_property_match_string);
 491
 492 /**
 493  * of_property_read_string_helper() - Utility helper for parsing string properties
 494  * @np:         device node from which the property value is to be read.
 495  * @propname:   name of the property to be searched.
 496  * @out_strs:   output array of string pointers.
 497  * @sz:         number of array elements to read.
 498  * @skip:       Number of strings to skip over at beginning of list.
 499  *
 500  * Don't call this function directly. It is a utility helper for the
 501  * of_property_read_string*() family of functions.
 502  */
 503 int of_property_read_string_helper(const struct device_node *np,
 504                                    const char *propname, const char **out_strs,
 505                                    size_t sz, int skip)
 506 {
 507         const struct property *prop = of_find_property(np, propname, NULL);
 508         int l = 0, i = 0;
 509         const char *p, *end;
 510
 511         if (!prop)
 512                 return -EINVAL;
 513         if (!prop->value)
 514                 return -ENODATA;
 515         p = prop->value;
 516         end = p + prop->length;
 517
 518         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
 519                 l = strnlen(p, end - p) + 1;
 520                 if (p + l > end)
 521                         return -EILSEQ;
 522                 if (out_strs && i >= skip)
 523                         *out_strs++ = p;
 524         }
 525         i -= skip;
 526         return i <= 0 ? -ENODATA : i;
 527 }
 528 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
 529
 530 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
 531                                u32 *pu)
 532 {
 533         const void *curv = cur;
 534
 535         if (!prop)
 536                 return NULL;
 537
 538         if (!cur) {
 539                 curv = prop->value;
 540                 goto out_val;
 541         }
 542
 543         curv += sizeof(*cur);
 544         if (curv >= prop->value + prop->length)
 545                 return NULL;
 546
 547 out_val:
 548         *pu = be32_to_cpup(curv);
 549         return curv;
 550 }
 551 EXPORT_SYMBOL_GPL(of_prop_next_u32);
 552
 553 const char *of_prop_next_string(struct property *prop, const char *cur)
 554 {
 555         const void *curv = cur;
 556
 557         if (!prop)
 558                 return NULL;
 559
 560         if (!cur)
 561                 return prop->value;
 562
 563         curv += strlen(cur) + 1;
 564         if (curv >= prop->value + prop->length)
 565                 return NULL;
 566
 567         return curv;
 568 }
 569 EXPORT_SYMBOL_GPL(of_prop_next_string);
 570
 571 /**
 572  * of_graph_parse_endpoint() - parse common endpoint node properties
 573  * @node: pointer to endpoint device_node
 574  * @endpoint: pointer to the OF endpoint data structure
 575  *
 576  * The caller should hold a reference to @node.
 577  */
 578 int of_graph_parse_endpoint(const struct device_node *node,
 579                             struct of_endpoint *endpoint)
 580 {
 581         struct device_node *port_node = of_get_parent(node);
 582
 583         WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n",
 584                   __func__, node);
 585
 586         memset(endpoint, 0, sizeof(*endpoint));
 587
 588         endpoint->local_node = node;
 589         /*
 590          * It doesn't matter whether the two calls below succeed.
 591          * If they don't then the default value 0 is used.
 592          */
 593         of_property_read_u32(port_node, "reg", &endpoint->port);
 594         of_property_read_u32(node, "reg", &endpoint->id);
 595
 596         of_node_put(port_node);
 597
 598         return 0;
 599 }
 600 EXPORT_SYMBOL(of_graph_parse_endpoint);
 601
 602 /**
 603  * of_graph_get_port_by_id() - get the port matching a given id
 604  * @parent: pointer to the parent device node
 605  * @id: id of the port
 606  *
 607  * Return: A 'port' node pointer with refcount incremented. The caller
 608  * has to use of_node_put() on it when done.
 609  */
 610 struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
 611 {
 612         struct device_node *node, *port;
 613
 614         node = of_get_child_by_name(parent, "ports");
 615         if (node)
 616                 parent = node;
 617
 618         for_each_child_of_node(parent, port) {
 619                 u32 port_id = 0;
 620
 621                 if (!of_node_name_eq(port, "port"))
 622                         continue;
 623                 of_property_read_u32(port, "reg", &port_id);
 624                 if (id == port_id)
 625                         break;
 626         }
 627
 628         of_node_put(node);
 629
 630         return port;
 631 }
 632 EXPORT_SYMBOL(of_graph_get_port_by_id);
 633
 634 /**
 635  * of_graph_get_next_endpoint() - get next endpoint node
 636  * @parent: pointer to the parent device node
 637  * @prev: previous endpoint node, or NULL to get first
 638  *
 639  * Return: An 'endpoint' node pointer with refcount incremented. Refcount
 640  * of the passed @prev node is decremented.
 641  */
 642 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
 643                                         struct device_node *prev)
 644 {
 645         struct device_node *endpoint;
 646         struct device_node *port;
 647
 648         if (!parent)
 649                 return NULL;
 650
 651         /*
 652          * Start by locating the port node. If no previous endpoint is specified
 653          * search for the first port node, otherwise get the previous endpoint
 654          * parent port node.
 655          */
 656         if (!prev) {
 657                 struct device_node *node;
 658
 659                 node = of_get_child_by_name(parent, "ports");
 660                 if (node)
 661                         parent = node;
 662
 663                 port = of_get_child_by_name(parent, "port");
 664                 of_node_put(node);
 665
 666                 if (!port) {
 667                         pr_err("graph: no port node found in %pOF\n", parent);
 668                         return NULL;
 669                 }
 670         } else {
 671                 port = of_get_parent(prev);
 672                 if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n",
 673                               __func__, prev))
 674                         return NULL;
 675         }
 676
 677         while (1) {
 678                 /*
 679                  * Now that we have a port node, get the next endpoint by
 680                  * getting the next child. If the previous endpoint is NULL this
 681                  * will return the first child.
 682                  */
 683                 endpoint = of_get_next_child(port, prev);
 684                 if (endpoint) {
 685                         of_node_put(port);
 686                         return endpoint;
 687                 }
 688
 689                 /* No more endpoints under this port, try the next one. */
 690                 prev = NULL;
 691
 692                 do {
 693                         port = of_get_next_child(parent, port);
 694                         if (!port)
 695                                 return NULL;
 696                 } while (!of_node_name_eq(port, "port"));
 697         }
 698 }
 699 EXPORT_SYMBOL(of_graph_get_next_endpoint);
 700
 701 /**
 702  * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
 703  * @parent: pointer to the parent device node
 704  * @port_reg: identifier (value of reg property) of the parent port node
 705  * @reg: identifier (value of reg property) of the endpoint node
 706  *
 707  * Return: An 'endpoint' node pointer which is identified by reg and at the same
 708  * is the child of a port node identified by port_reg. reg and port_reg are
 709  * ignored when they are -1. Use of_node_put() on the pointer when done.
 710  */
 711 struct device_node *of_graph_get_endpoint_by_regs(
 712         const struct device_node *parent, int port_reg, int reg)
 713 {
 714         struct of_endpoint endpoint;
 715         struct device_node *node = NULL;
 716
 717         for_each_endpoint_of_node(parent, node) {
 718                 of_graph_parse_endpoint(node, &endpoint);
 719                 if (((port_reg == -1) || (endpoint.port == port_reg)) &&
 720                         ((reg == -1) || (endpoint.id == reg)))
 721                         return node;
 722         }
 723
 724         return NULL;
 725 }
 726 EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
 727
 728 /**
 729  * of_graph_get_remote_endpoint() - get remote endpoint node
 730  * @node: pointer to a local endpoint device_node
 731  *
 732  * Return: Remote endpoint node associated with remote endpoint node linked
 733  *         to @node. Use of_node_put() on it when done.
 734  */
 735 struct device_node *of_graph_get_remote_endpoint(const struct device_node *node)
 736 {
 737         /* Get remote endpoint node. */
 738         return of_parse_phandle(node, "remote-endpoint", 0);
 739 }
 740 EXPORT_SYMBOL(of_graph_get_remote_endpoint);
 741
 742 /**
 743  * of_graph_get_port_parent() - get port's parent node
 744  * @node: pointer to a local endpoint device_node
 745  *
 746  * Return: device node associated with endpoint node linked
 747  *         to @node. Use of_node_put() on it when done.
 748  */
 749 struct device_node *of_graph_get_port_parent(struct device_node *node)
 750 {
 751         unsigned int depth;
 752
 753         if (!node)
 754                 return NULL;
 755
 756         /*
 757          * Preserve usecount for passed in node as of_get_next_parent()
 758          * will do of_node_put() on it.
 759          */
 760         of_node_get(node);
 761
 762         /* Walk 3 levels up only if there is 'ports' node. */
 763         for (depth = 3; depth && node; depth--) {
 764                 node = of_get_next_parent(node);
 765                 if (depth == 2 && !of_node_name_eq(node, "ports"))
 766                         break;
 767         }
 768         return node;
 769 }
 770 EXPORT_SYMBOL(of_graph_get_port_parent);
 771
 772 /**
 773  * of_graph_get_remote_port_parent() - get remote port's parent node
 774  * @node: pointer to a local endpoint device_node
 775  *
 776  * Return: Remote device node associated with remote endpoint node linked
 777  *         to @node. Use of_node_put() on it when done.
 778  */
 779 struct device_node *of_graph_get_remote_port_parent(
 780                                const struct device_node *node)
 781 {
 782         struct device_node *np, *pp;
 783
 784         /* Get remote endpoint node. */
 785         np = of_graph_get_remote_endpoint(node);
 786
 787         pp = of_graph_get_port_parent(np);
 788
 789         of_node_put(np);
 790
 791         return pp;
 792 }
 793 EXPORT_SYMBOL(of_graph_get_remote_port_parent);
 794
 795 /**
 796  * of_graph_get_remote_port() - get remote port node
 797  * @node: pointer to a local endpoint device_node
 798  *
 799  * Return: Remote port node associated with remote endpoint node linked
 800  * to @node. Use of_node_put() on it when done.
 801  */
 802 struct device_node *of_graph_get_remote_port(const struct device_node *node)
 803 {
 804         struct device_node *np;
 805
 806         /* Get remote endpoint node. */
 807         np = of_graph_get_remote_endpoint(node);
 808         if (!np)
 809                 return NULL;
 810         return of_get_next_parent(np);
 811 }
 812 EXPORT_SYMBOL(of_graph_get_remote_port);
 813
 814 int of_graph_get_endpoint_count(const struct device_node *np)
 815 {
 816         struct device_node *endpoint;
 817         int num = 0;
 818
 819         for_each_endpoint_of_node(np, endpoint)
 820                 num++;
 821
 822         return num;
 823 }
 824 EXPORT_SYMBOL(of_graph_get_endpoint_count);
 825
 826 /**
 827  * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint
 828  * @node: pointer to parent device_node containing graph port/endpoint
 829  * @port: identifier (value of reg property) of the parent port node
 830  * @endpoint: identifier (value of reg property) of the endpoint node
 831  *
 832  * Return: Remote device node associated with remote endpoint node linked
 833  * to @node. Use of_node_put() on it when done.
 834  */
 835 struct device_node *of_graph_get_remote_node(const struct device_node *node,
 836                                              u32 port, u32 endpoint)
 837 {
 838         struct device_node *endpoint_node, *remote;
 839
 840         endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint);
 841         if (!endpoint_node) {
 842                 pr_debug("no valid endpoint (%d, %d) for node %pOF\n",
 843                          port, endpoint, node);
 844                 return NULL;
 845         }
 846
 847         remote = of_graph_get_remote_port_parent(endpoint_node);
 848         of_node_put(endpoint_node);
 849         if (!remote) {
 850                 pr_debug("no valid remote node\n");
 851                 return NULL;
 852         }
 853
 854         if (!of_device_is_available(remote)) {
 855                 pr_debug("not available for remote node\n");
 856                 of_node_put(remote);
 857                 return NULL;
 858         }
 859
 860         return remote;
 861 }
 862 EXPORT_SYMBOL(of_graph_get_remote_node);
 863
 864 static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode)
 865 {
 866         return of_fwnode_handle(of_node_get(to_of_node(fwnode)));
 867 }
 868
 869 static void of_fwnode_put(struct fwnode_handle *fwnode)
 870 {
 871         of_node_put(to_of_node(fwnode));
 872 }
 873
 874 static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode)
 875 {
 876         return of_device_is_available(to_of_node(fwnode));
 877 }
 878
 879 static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)
 880 {
 881         return true;
 882 }
 883
 884 static enum dev_dma_attr
 885 of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)
 886 {
 887         if (of_dma_is_coherent(to_of_node(fwnode)))
 888                 return DEV_DMA_COHERENT;
 889         else
 890                 return DEV_DMA_NON_COHERENT;
 891 }
 892
 893 static bool of_fwnode_property_present(const struct fwnode_handle *fwnode,
 894                                        const char *propname)
 895 {
 896         return of_property_read_bool(to_of_node(fwnode), propname);
 897 }
 898
 899 static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 900                                              const char *propname,
 901                                              unsigned int elem_size, void *val,
 902                                              size_t nval)
 903 {
 904         const struct device_node *node = to_of_node(fwnode);
 905
 906         if (!val)
 907                 return of_property_count_elems_of_size(node, propname,
 908                                                        elem_size);
 909
 910         switch (elem_size) {
 911         case sizeof(u8):
 912                 return of_property_read_u8_array(node, propname, val, nval);
 913         case sizeof(u16):
 914                 return of_property_read_u16_array(node, propname, val, nval);
 915         case sizeof(u32):
 916                 return of_property_read_u32_array(node, propname, val, nval);
 917         case sizeof(u64):
 918                 return of_property_read_u64_array(node, propname, val, nval);
 919         }
 920
 921         return -ENXIO;
 922 }
 923
 924 static int
 925 of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 926                                      const char *propname, const char **val,
 927                                      size_t nval)
 928 {
 929         const struct device_node *node = to_of_node(fwnode);
 930
 931         return val ?
 932                 of_property_read_string_array(node, propname, val, nval) :
 933                 of_property_count_strings(node, propname);
 934 }
 935
 936 static const char *of_fwnode_get_name(const struct fwnode_handle *fwnode)
 937 {
 938         return kbasename(to_of_node(fwnode)->full_name);
 939 }
 940
 941 static const char *of_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
 942 {
 943         /* Root needs no prefix here (its name is "/"). */
 944         if (!to_of_node(fwnode)->parent)
 945                 return "";
 946
 947         return "/";
 948 }
 949
 950 static struct fwnode_handle *
 951 of_fwnode_get_parent(const struct fwnode_handle *fwnode)
 952 {
 953         return of_fwnode_handle(of_get_parent(to_of_node(fwnode)));
 954 }
 955
 956 static struct fwnode_handle *
 957 of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 958                               struct fwnode_handle *child)
 959 {
 960         return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode),
 961                                                             to_of_node(child)));
 962 }
 963
 964 static struct fwnode_handle *
 965 of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 966                                const char *childname)
 967 {
 968         const struct device_node *node = to_of_node(fwnode);
 969         struct device_node *child;
 970
 971         for_each_available_child_of_node(node, child)
 972                 if (of_node_name_eq(child, childname))
 973                         return of_fwnode_handle(child);
 974
 975         return NULL;
 976 }
 977
 978 static int
 979 of_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
 980                              const char *prop, const char *nargs_prop,
 981                              unsigned int nargs, unsigned int index,
 982                              struct fwnode_reference_args *args)
 983 {
 984         struct of_phandle_args of_args;
 985         unsigned int i;
 986         int ret;
 987
 988         if (nargs_prop)
 989                 ret = of_parse_phandle_with_args(to_of_node(fwnode), prop,
 990                                                  nargs_prop, index, &of_args);
 991         else
 992                 ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop,
 993                                                        nargs, index, &of_args);
 994         if (ret < 0)
 995                 return ret;
 996         if (!args) {
 997                 of_node_put(of_args.np);
 998                 return 0;
 999         }
1000
1001         args->nargs = of_args.args_count;
1002         args->fwnode = of_fwnode_handle(of_args.np);
1003
1004         for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++)
1005                 args->args[i] = i < of_args.args_count ? of_args.args[i] : 0;
1006
1007         return 0;
1008 }
1009
1010 static struct fwnode_handle *
1011 of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1012                                   struct fwnode_handle *prev)
1013 {
1014         return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode),
1015                                                            to_of_node(prev)));
1016 }
1017
1018 static struct fwnode_handle *
1019 of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1020 {
1021         return of_fwnode_handle(
1022                 of_graph_get_remote_endpoint(to_of_node(fwnode)));
1023 }
1024
1025 static struct fwnode_handle *
1026 of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode)
1027 {
1028         struct device_node *np;
1029
1030         /* Get the parent of the port */
1031         np = of_get_parent(to_of_node(fwnode));
1032         if (!np)
1033                 return NULL;
1034
1035         /* Is this the "ports" node? If not, it's the port parent. */
1036         if (!of_node_name_eq(np, "ports"))
1037                 return of_fwnode_handle(np);
1038
1039         return of_fwnode_handle(of_get_next_parent(np));
1040 }
1041
1042 static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1043                                           struct fwnode_endpoint *endpoint)
1044 {
1045         const struct device_node *node = to_of_node(fwnode);
1046         struct device_node *port_node = of_get_parent(node);
1047
1048         endpoint->local_fwnode = fwnode;
1049
1050         of_property_read_u32(port_node, "reg", &endpoint->port);
1051         of_property_read_u32(node, "reg", &endpoint->id);
1052
1053         of_node_put(port_node);
1054
1055         return 0;
1056 }
1057
1058 static const void *
1059 of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1060                                 const struct device *dev)
1061 {
1062         return of_device_get_match_data(dev);
1063 }
1064
1065 static struct device_node *of_get_compat_node(struct device_node *np)
1066 {
1067         of_node_get(np);
1068
1069         while (np) {
1070                 if (!of_device_is_available(np)) {
1071                         of_node_put(np);
1072                         np = NULL;
1073                 }
1074
1075                 if (of_property_present(np, "compatible"))
1076                         break;
1077
1078                 np = of_get_next_parent(np);
1079         }
1080
1081         return np;
1082 }
1083
1084 static struct device_node *of_get_compat_node_parent(struct device_node *np)
1085 {
1086         struct device_node *parent, *node;
1087
1088         parent = of_get_parent(np);
1089         node = of_get_compat_node(parent);
1090         of_node_put(parent);
1091
1092         return node;
1093 }
1094
1095 static void of_link_to_phandle(struct device_node *con_np,
1096                               struct device_node *sup_np)
1097 {
1098         struct device_node *tmp_np = of_node_get(sup_np);
1099
1100         /* Check that sup_np and its ancestors are available. */
1101         while (tmp_np) {
1102                 if (of_fwnode_handle(tmp_np)->dev) {
1103                         of_node_put(tmp_np);
1104                         break;
1105                 }
1106
1107                 if (!of_device_is_available(tmp_np)) {
1108                         of_node_put(tmp_np);
1109                         return;
1110                 }
1111
1112                 tmp_np = of_get_next_parent(tmp_np);
1113         }
1114
1115         fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np));
1116 }
1117
1118 /**
1119  * parse_prop_cells - Property parsing function for suppliers
1120  *
1121  * @np:         Pointer to device tree node containing a list
1122  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1123  * @index:      For properties holding a list of phandles, this is the index
1124  *              into the list.
1125  * @list_name:  Property name that is known to contain list of phandle(s) to
1126  *              supplier(s)
1127  * @cells_name: property name that specifies phandles' arguments count
1128  *
1129  * This is a helper function to parse properties that have a known fixed name
1130  * and are a list of phandles and phandle arguments.
1131  *
1132  * Returns:
1133  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1134  *   on it when done.
1135  * - NULL if no phandle found at index
1136  */
1137 static struct device_node *parse_prop_cells(struct device_node *np,
1138                                             const char *prop_name, int index,
1139                                             const char *list_name,
1140                                             const char *cells_name)
1141 {
1142         struct of_phandle_args sup_args;
1143
1144         if (strcmp(prop_name, list_name))
1145                 return NULL;
1146
1147         if (__of_parse_phandle_with_args(np, list_name, cells_name, 0, index,
1148                                          &sup_args))
1149                 return NULL;
1150
1151         return sup_args.np;
1152 }
1153
1154 #define DEFINE_SIMPLE_PROP(fname, name, cells)                            \
1155 static struct device_node *parse_##fname(struct device_node *np,          \
1156                                         const char *prop_name, int index) \
1157 {                                                                         \
1158         return parse_prop_cells(np, prop_name, index, name, cells);       \
1159 }
1160
1161 static int strcmp_suffix(const char *str, const char *suffix)
1162 {
1163         unsigned int len, suffix_len;
1164
1165         len = strlen(str);
1166         suffix_len = strlen(suffix);
1167         if (len <= suffix_len)
1168                 return -1;
1169         return strcmp(str + len - suffix_len, suffix);
1170 }
1171
1172 /**
1173  * parse_suffix_prop_cells - Suffix property parsing function for suppliers
1174  *
1175  * @np:         Pointer to device tree node containing a list
1176  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1177  * @index:      For properties holding a list of phandles, this is the index
1178  *              into the list.
1179  * @suffix:     Property suffix that is known to contain list of phandle(s) to
1180  *              supplier(s)
1181  * @cells_name: property name that specifies phandles' arguments count
1182  *
1183  * This is a helper function to parse properties that have a known fixed suffix
1184  * and are a list of phandles and phandle arguments.
1185  *
1186  * Returns:
1187  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1188  *   on it when done.
1189  * - NULL if no phandle found at index
1190  */
1191 static struct device_node *parse_suffix_prop_cells(struct device_node *np,
1192                                             const char *prop_name, int index,
1193                                             const char *suffix,
1194                                             const char *cells_name)
1195 {
1196         struct of_phandle_args sup_args;
1197
1198         if (strcmp_suffix(prop_name, suffix))
1199                 return NULL;
1200
1201         if (of_parse_phandle_with_args(np, prop_name, cells_name, index,
1202                                        &sup_args))
1203                 return NULL;
1204
1205         return sup_args.np;
1206 }
1207
1208 #define DEFINE_SUFFIX_PROP(fname, suffix, cells)                             \
1209 static struct device_node *parse_##fname(struct device_node *np,             \
1210                                         const char *prop_name, int index)    \
1211 {                                                                            \
1212         return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \
1213 }
1214
1215 /**
1216  * struct supplier_bindings - Property parsing functions for suppliers
1217  *
1218  * @parse_prop: function name
1219  *      parse_prop() finds the node corresponding to a supplier phandle
1220  * @parse_prop.np: Pointer to device node holding supplier phandle property
1221  * @parse_prop.prop_name: Name of property holding a phandle value
1222  * @parse_prop.index: For properties holding a list of phandles, this is the
1223  *                    index into the list
1224  * @optional: Describes whether a supplier is mandatory or not
1225  * @node_not_dev: The consumer node containing the property is never converted
1226  *                to a struct device. Instead, parse ancestor nodes for the
1227  *                compatible property to find a node corresponding to a device.
1228  *
1229  * Returns:
1230  * parse_prop() return values are
1231  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1232  *   on it when done.
1233  * - NULL if no phandle found at index
1234  */
1235 struct supplier_bindings {
1236         struct device_node *(*parse_prop)(struct device_node *np,
1237                                           const char *prop_name, int index);
1238         bool optional;
1239         bool node_not_dev;
1240 };
1241
1242 DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells")
1243 DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells")
1244 DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells")
1245 DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells")
1246 DEFINE_SIMPLE_PROP(io_channels, "io-channel", "#io-channel-cells")
1247 DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL)
1248 DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells")
1249 DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells")
1250 DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells")
1251 DEFINE_SIMPLE_PROP(extcon, "extcon", NULL)
1252 DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", "#nvmem-cell-cells")
1253 DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells")
1254 DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL)
1255 DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL)
1256 DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL)
1257 DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL)
1258 DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL)
1259 DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL)
1260 DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL)
1261 DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL)
1262 DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL)
1263 DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL)
1264 DEFINE_SIMPLE_PROP(remote_endpoint, "remote-endpoint", NULL)
1265 DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells")
1266 DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells")
1267 DEFINE_SIMPLE_PROP(leds, "leds", NULL)
1268 DEFINE_SIMPLE_PROP(backlight, "backlight", NULL)
1269 DEFINE_SIMPLE_PROP(panel, "panel", NULL)
1270 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
1271 DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells")
1272
1273 static struct device_node *parse_gpios(struct device_node *np,
1274                                        const char *prop_name, int index)
1275 {
1276         if (!strcmp_suffix(prop_name, ",nr-gpios"))
1277                 return NULL;
1278
1279         return parse_suffix_prop_cells(np, prop_name, index, "-gpios",
1280                                        "#gpio-cells");
1281 }
1282
1283 static struct device_node *parse_iommu_maps(struct device_node *np,
1284                                             const char *prop_name, int index)
1285 {
1286         if (strcmp(prop_name, "iommu-map"))
1287                 return NULL;
1288
1289         return of_parse_phandle(np, prop_name, (index * 4) + 1);
1290 }
1291
1292 static struct device_node *parse_gpio_compat(struct device_node *np,
1293                                              const char *prop_name, int index)
1294 {
1295         struct of_phandle_args sup_args;
1296
1297         if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios"))
1298                 return NULL;
1299
1300         /*
1301          * Ignore node with gpio-hog property since its gpios are all provided
1302          * by its parent.
1303          */
1304         if (of_property_read_bool(np, "gpio-hog"))
1305                 return NULL;
1306
1307         if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index,
1308                                        &sup_args))
1309                 return NULL;
1310
1311         return sup_args.np;
1312 }
1313
1314 static struct device_node *parse_interrupts(struct device_node *np,
1315                                             const char *prop_name, int index)
1316 {
1317         struct of_phandle_args sup_args;
1318
1319         if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC))
1320                 return NULL;
1321
1322         if (strcmp(prop_name, "interrupts") &&
1323             strcmp(prop_name, "interrupts-extended"))
1324                 return NULL;
1325
1326         return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np;
1327 }
1328
1329 static const struct supplier_bindings of_supplier_bindings[] = {
1330         { .parse_prop = parse_clocks, },
1331         { .parse_prop = parse_interconnects, },
1332         { .parse_prop = parse_iommus, .optional = true, },
1333         { .parse_prop = parse_iommu_maps, .optional = true, },
1334         { .parse_prop = parse_mboxes, },
1335         { .parse_prop = parse_io_channels, },
1336         { .parse_prop = parse_interrupt_parent, },
1337         { .parse_prop = parse_dmas, .optional = true, },
1338         { .parse_prop = parse_power_domains, },
1339         { .parse_prop = parse_hwlocks, },
1340         { .parse_prop = parse_extcon, },
1341         { .parse_prop = parse_nvmem_cells, },
1342         { .parse_prop = parse_phys, },
1343         { .parse_prop = parse_wakeup_parent, },
1344         { .parse_prop = parse_pinctrl0, },
1345         { .parse_prop = parse_pinctrl1, },
1346         { .parse_prop = parse_pinctrl2, },
1347         { .parse_prop = parse_pinctrl3, },
1348         { .parse_prop = parse_pinctrl4, },
1349         { .parse_prop = parse_pinctrl5, },
1350         { .parse_prop = parse_pinctrl6, },
1351         { .parse_prop = parse_pinctrl7, },
1352         { .parse_prop = parse_pinctrl8, },
1353         { .parse_prop = parse_remote_endpoint, .node_not_dev = true, },
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_gpio_compat, },
1360         { .parse_prop = parse_interrupts, },
1361         { .parse_prop = parse_regulators, },
1362         { .parse_prop = parse_gpio, },
1363         { .parse_prop = parse_gpios, },
1364         {}
1365 };
1366
1367 /**
1368  * of_link_property - Create device links to suppliers listed in a property
1369  * @con_np: The consumer device tree node which contains the property
1370  * @prop_name: Name of property to be parsed
1371  *
1372  * This function checks if the property @prop_name that is present in the
1373  * @con_np device tree node is one of the known common device tree bindings
1374  * that list phandles to suppliers. If @prop_name isn't one, this function
1375  * doesn't do anything.
1376  *
1377  * If @prop_name is one, this function attempts to create fwnode links from the
1378  * consumer device tree node @con_np to all the suppliers device tree nodes
1379  * listed in @prop_name.
1380  *
1381  * Any failed attempt to create a fwnode link will NOT result in an immediate
1382  * return.  of_link_property() must create links to all the available supplier
1383  * device tree nodes even when attempts to create a link to one or more
1384  * suppliers fail.
1385  */
1386 static int of_link_property(struct device_node *con_np, const char *prop_name)
1387 {
1388         struct device_node *phandle;
1389         const struct supplier_bindings *s = of_supplier_bindings;
1390         unsigned int i = 0;
1391         bool matched = false;
1392
1393         /* Do not stop at first failed link, link all available suppliers. */
1394         while (!matched && s->parse_prop) {
1395                 if (s->optional && !fw_devlink_is_strict()) {
1396                         s++;
1397                         continue;
1398                 }
1399
1400                 while ((phandle = s->parse_prop(con_np, prop_name, i))) {
1401                         struct device_node *con_dev_np;
1402
1403                         con_dev_np = s->node_not_dev
1404                                         ? of_get_compat_node_parent(con_np)
1405                                         : of_node_get(con_np);
1406                         matched = true;
1407                         i++;
1408                         of_link_to_phandle(con_dev_np, phandle);
1409                         of_node_put(phandle);
1410                         of_node_put(con_dev_np);
1411                 }
1412                 s++;
1413         }
1414         return 0;
1415 }
1416
1417 static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index)
1418 {
1419 #ifdef CONFIG_OF_ADDRESS
1420         return of_iomap(to_of_node(fwnode), index);
1421 #else
1422         return NULL;
1423 #endif
1424 }
1425
1426 static int of_fwnode_irq_get(const struct fwnode_handle *fwnode,
1427                              unsigned int index)
1428 {
1429         return of_irq_get(to_of_node(fwnode), index);
1430 }
1431
1432 static int of_fwnode_add_links(struct fwnode_handle *fwnode)
1433 {
1434         struct property *p;
1435         struct device_node *con_np = to_of_node(fwnode);
1436
1437         if (IS_ENABLED(CONFIG_X86))
1438                 return 0;
1439
1440         if (!con_np)
1441                 return -EINVAL;
1442
1443         for_each_property_of_node(con_np, p)
1444                 of_link_property(con_np, p->name);
1445
1446         return 0;
1447 }
1448
1449 const struct fwnode_operations of_fwnode_ops = {
1450         .get = of_fwnode_get,
1451         .put = of_fwnode_put,
1452         .device_is_available = of_fwnode_device_is_available,
1453         .device_get_match_data = of_fwnode_device_get_match_data,
1454         .device_dma_supported = of_fwnode_device_dma_supported,
1455         .device_get_dma_attr = of_fwnode_device_get_dma_attr,
1456         .property_present = of_fwnode_property_present,
1457         .property_read_int_array = of_fwnode_property_read_int_array,
1458         .property_read_string_array = of_fwnode_property_read_string_array,
1459         .get_name = of_fwnode_get_name,
1460         .get_name_prefix = of_fwnode_get_name_prefix,
1461         .get_parent = of_fwnode_get_parent,
1462         .get_next_child_node = of_fwnode_get_next_child_node,
1463         .get_named_child_node = of_fwnode_get_named_child_node,
1464         .get_reference_args = of_fwnode_get_reference_args,
1465         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
1466         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
1467         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
1468         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
1469         .iomap = of_fwnode_iomap,
1470         .irq_get = of_fwnode_irq_get,
1471         .add_links = of_fwnode_add_links,
1472 };
1473 EXPORT_SYMBOL_GPL(of_fwnode_ops);