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
 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 }
 454 EXPORT_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  */
 465 int 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 }
 491 EXPORT_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  */
 504 int 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 }
 529 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
 530
 531 const __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
 548 out_val:
 549         *pu = be32_to_cpup(curv);
 550         return curv;
 551 }
 552 EXPORT_SYMBOL_GPL(of_prop_next_u32);
 553
 554 const 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 }
 570 EXPORT_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  */
 579 int 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 }
 601 EXPORT_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  */
 611 struct 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 }
 633 EXPORT_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  */
 643 struct 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_err("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 }
 700 EXPORT_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  */
 712 struct 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 }
 727 EXPORT_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  */
 736 struct 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 }
 741 EXPORT_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  */
 750 struct 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 }
 773 EXPORT_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  */
 782 struct 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 }
 796 EXPORT_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  */
 805 struct 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 }
 815 EXPORT_SYMBOL(of_graph_get_remote_port);
 816
 817 int of_graph_get_endpoint_count(const struct device_node *np)
 818 {
 819         struct device_node *endpoint;
 820         int num = 0;
 821
 822         for_each_endpoint_of_node(np, endpoint)
 823                 num++;
 824
 825         return num;
 826 }
 827 EXPORT_SYMBOL(of_graph_get_endpoint_count);
 828
 829 /**
 830  * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint
 831  * @node: pointer to parent device_node containing graph port/endpoint
 832  * @port: identifier (value of reg property) of the parent port node
 833  * @endpoint: identifier (value of reg property) of the endpoint node
 834  *
 835  * Return: Remote device node associated with remote endpoint node linked
 836  * to @node. Use of_node_put() on it when done.
 837  */
 838 struct device_node *of_graph_get_remote_node(const struct device_node *node,
 839                                              u32 port, u32 endpoint)
 840 {
 841         struct device_node *endpoint_node, *remote;
 842
 843         endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint);
 844         if (!endpoint_node) {
 845                 pr_debug("no valid endpoint (%d, %d) for node %pOF\n",
 846                          port, endpoint, node);
 847                 return NULL;
 848         }
 849
 850         remote = of_graph_get_remote_port_parent(endpoint_node);
 851         of_node_put(endpoint_node);
 852         if (!remote) {
 853                 pr_debug("no valid remote node\n");
 854                 return NULL;
 855         }
 856
 857         if (!of_device_is_available(remote)) {
 858                 pr_debug("not available for remote node\n");
 859                 of_node_put(remote);
 860                 return NULL;
 861         }
 862
 863         return remote;
 864 }
 865 EXPORT_SYMBOL(of_graph_get_remote_node);
 866
 867 static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode)
 868 {
 869         return of_fwnode_handle(of_node_get(to_of_node(fwnode)));
 870 }
 871
 872 static void of_fwnode_put(struct fwnode_handle *fwnode)
 873 {
 874         of_node_put(to_of_node(fwnode));
 875 }
 876
 877 static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode)
 878 {
 879         return of_device_is_available(to_of_node(fwnode));
 880 }
 881
 882 static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)
 883 {
 884         return true;
 885 }
 886
 887 static enum dev_dma_attr
 888 of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)
 889 {
 890         if (of_dma_is_coherent(to_of_node(fwnode)))
 891                 return DEV_DMA_COHERENT;
 892         else
 893                 return DEV_DMA_NON_COHERENT;
 894 }
 895
 896 static bool of_fwnode_property_present(const struct fwnode_handle *fwnode,
 897                                        const char *propname)
 898 {
 899         return of_property_read_bool(to_of_node(fwnode), propname);
 900 }
 901
 902 static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 903                                              const char *propname,
 904                                              unsigned int elem_size, void *val,
 905                                              size_t nval)
 906 {
 907         const struct device_node *node = to_of_node(fwnode);
 908
 909         if (!val)
 910                 return of_property_count_elems_of_size(node, propname,
 911                                                        elem_size);
 912
 913         switch (elem_size) {
 914         case sizeof(u8):
 915                 return of_property_read_u8_array(node, propname, val, nval);
 916         case sizeof(u16):
 917                 return of_property_read_u16_array(node, propname, val, nval);
 918         case sizeof(u32):
 919                 return of_property_read_u32_array(node, propname, val, nval);
 920         case sizeof(u64):
 921                 return of_property_read_u64_array(node, propname, val, nval);
 922         }
 923
 924         return -ENXIO;
 925 }
 926
 927 static int
 928 of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 929                                      const char *propname, const char **val,
 930                                      size_t nval)
 931 {
 932         const struct device_node *node = to_of_node(fwnode);
 933
 934         return val ?
 935                 of_property_read_string_array(node, propname, val, nval) :
 936                 of_property_count_strings(node, propname);
 937 }
 938
 939 static const char *of_fwnode_get_name(const struct fwnode_handle *fwnode)
 940 {
 941         return kbasename(to_of_node(fwnode)->full_name);
 942 }
 943
 944 static const char *of_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
 945 {
 946         /* Root needs no prefix here (its name is "/"). */
 947         if (!to_of_node(fwnode)->parent)
 948                 return "";
 949
 950         return "/";
 951 }
 952
 953 static struct fwnode_handle *
 954 of_fwnode_get_parent(const struct fwnode_handle *fwnode)
 955 {
 956         return of_fwnode_handle(of_get_parent(to_of_node(fwnode)));
 957 }
 958
 959 static struct fwnode_handle *
 960 of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 961                               struct fwnode_handle *child)
 962 {
 963         return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode),
 964                                                             to_of_node(child)));
 965 }
 966
 967 static struct fwnode_handle *
 968 of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 969                                const char *childname)
 970 {
 971         const struct device_node *node = to_of_node(fwnode);
 972         struct device_node *child;
 973
 974         for_each_available_child_of_node(node, child)
 975                 if (of_node_name_eq(child, childname))
 976                         return of_fwnode_handle(child);
 977
 978         return NULL;
 979 }
 980
 981 static int
 982 of_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
 983                              const char *prop, const char *nargs_prop,
 984                              unsigned int nargs, unsigned int index,
 985                              struct fwnode_reference_args *args)
 986 {
 987         struct of_phandle_args of_args;
 988         unsigned int i;
 989         int ret;
 990
 991         if (nargs_prop)
 992                 ret = of_parse_phandle_with_args(to_of_node(fwnode), prop,
 993                                                  nargs_prop, index, &of_args);
 994         else
 995                 ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop,
 996                                                        nargs, index, &of_args);
 997         if (ret < 0)
 998                 return ret;
 999         if (!args) {
1000                 of_node_put(of_args.np);
1001                 return 0;
1002         }
1003
1004         args->nargs = of_args.args_count;
1005         args->fwnode = of_fwnode_handle(of_args.np);
1006
1007         for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++)
1008                 args->args[i] = i < of_args.args_count ? of_args.args[i] : 0;
1009
1010         return 0;
1011 }
1012
1013 static struct fwnode_handle *
1014 of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1015                                   struct fwnode_handle *prev)
1016 {
1017         return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode),
1018                                                            to_of_node(prev)));
1019 }
1020
1021 static struct fwnode_handle *
1022 of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1023 {
1024         return of_fwnode_handle(
1025                 of_graph_get_remote_endpoint(to_of_node(fwnode)));
1026 }
1027
1028 static struct fwnode_handle *
1029 of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode)
1030 {
1031         struct device_node *np;
1032
1033         /* Get the parent of the port */
1034         np = of_get_parent(to_of_node(fwnode));
1035         if (!np)
1036                 return NULL;
1037
1038         /* Is this the "ports" node? If not, it's the port parent. */
1039         if (!of_node_name_eq(np, "ports"))
1040                 return of_fwnode_handle(np);
1041
1042         return of_fwnode_handle(of_get_next_parent(np));
1043 }
1044
1045 static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1046                                           struct fwnode_endpoint *endpoint)
1047 {
1048         const struct device_node *node = to_of_node(fwnode);
1049         struct device_node *port_node = of_get_parent(node);
1050
1051         endpoint->local_fwnode = fwnode;
1052
1053         of_property_read_u32(port_node, "reg", &endpoint->port);
1054         of_property_read_u32(node, "reg", &endpoint->id);
1055
1056         of_node_put(port_node);
1057
1058         return 0;
1059 }
1060
1061 static const void *
1062 of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1063                                 const struct device *dev)
1064 {
1065         return of_device_get_match_data(dev);
1066 }
1067
1068 static void of_link_to_phandle(struct device_node *con_np,
1069                               struct device_node *sup_np)
1070 {
1071         struct device_node *tmp_np = of_node_get(sup_np);
1072
1073         /* Check that sup_np and its ancestors are available. */
1074         while (tmp_np) {
1075                 if (of_fwnode_handle(tmp_np)->dev) {
1076                         of_node_put(tmp_np);
1077                         break;
1078                 }
1079
1080                 if (!of_device_is_available(tmp_np)) {
1081                         of_node_put(tmp_np);
1082                         return;
1083                 }
1084
1085                 tmp_np = of_get_next_parent(tmp_np);
1086         }
1087
1088         fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np));
1089 }
1090
1091 /**
1092  * parse_prop_cells - Property parsing function for suppliers
1093  *
1094  * @np:         Pointer to device tree node containing a list
1095  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1096  * @index:      For properties holding a list of phandles, this is the index
1097  *              into the list.
1098  * @list_name:  Property name that is known to contain list of phandle(s) to
1099  *              supplier(s)
1100  * @cells_name: property name that specifies phandles' arguments count
1101  *
1102  * This is a helper function to parse properties that have a known fixed name
1103  * and are a list of phandles and phandle arguments.
1104  *
1105  * Returns:
1106  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1107  *   on it when done.
1108  * - NULL if no phandle found at index
1109  */
1110 static struct device_node *parse_prop_cells(struct device_node *np,
1111                                             const char *prop_name, int index,
1112                                             const char *list_name,
1113                                             const char *cells_name)
1114 {
1115         struct of_phandle_args sup_args;
1116
1117         if (strcmp(prop_name, list_name))
1118                 return NULL;
1119
1120         if (__of_parse_phandle_with_args(np, list_name, cells_name, 0, index,
1121                                          &sup_args))
1122                 return NULL;
1123
1124         return sup_args.np;
1125 }
1126
1127 #define DEFINE_SIMPLE_PROP(fname, name, cells)                            \
1128 static struct device_node *parse_##fname(struct device_node *np,          \
1129                                         const char *prop_name, int index) \
1130 {                                                                         \
1131         return parse_prop_cells(np, prop_name, index, name, cells);       \
1132 }
1133
1134 static int strcmp_suffix(const char *str, const char *suffix)
1135 {
1136         unsigned int len, suffix_len;
1137
1138         len = strlen(str);
1139         suffix_len = strlen(suffix);
1140         if (len <= suffix_len)
1141                 return -1;
1142         return strcmp(str + len - suffix_len, suffix);
1143 }
1144
1145 /**
1146  * parse_suffix_prop_cells - Suffix property parsing function for suppliers
1147  *
1148  * @np:         Pointer to device tree node containing a list
1149  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1150  * @index:      For properties holding a list of phandles, this is the index
1151  *              into the list.
1152  * @suffix:     Property suffix that is known to contain list of phandle(s) to
1153  *              supplier(s)
1154  * @cells_name: property name that specifies phandles' arguments count
1155  *
1156  * This is a helper function to parse properties that have a known fixed suffix
1157  * and are a list of phandles and phandle arguments.
1158  *
1159  * Returns:
1160  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1161  *   on it when done.
1162  * - NULL if no phandle found at index
1163  */
1164 static struct device_node *parse_suffix_prop_cells(struct device_node *np,
1165                                             const char *prop_name, int index,
1166                                             const char *suffix,
1167                                             const char *cells_name)
1168 {
1169         struct of_phandle_args sup_args;
1170
1171         if (strcmp_suffix(prop_name, suffix))
1172                 return NULL;
1173
1174         if (of_parse_phandle_with_args(np, prop_name, cells_name, index,
1175                                        &sup_args))
1176                 return NULL;
1177
1178         return sup_args.np;
1179 }
1180
1181 #define DEFINE_SUFFIX_PROP(fname, suffix, cells)                             \
1182 static struct device_node *parse_##fname(struct device_node *np,             \
1183                                         const char *prop_name, int index)    \
1184 {                                                                            \
1185         return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \
1186 }
1187
1188 /**
1189  * struct supplier_bindings - Property parsing functions for suppliers
1190  *
1191  * @parse_prop: function name
1192  *      parse_prop() finds the node corresponding to a supplier phandle
1193  *  parse_prop.np: Pointer to device node holding supplier phandle property
1194  *  parse_prop.prop_name: Name of property holding a phandle value
1195  *  parse_prop.index: For properties holding a list of phandles, this is the
1196  *                    index into the list
1197  * @get_con_dev: If the consumer node containing the property is never converted
1198  *               to a struct device, implement this ops so fw_devlink can use it
1199  *               to find the true consumer.
1200  * @optional: Describes whether a supplier is mandatory or not
1201  *
1202  * Returns:
1203  * parse_prop() return values are
1204  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1205  *   on it when done.
1206  * - NULL if no phandle found at index
1207  */
1208 struct supplier_bindings {
1209         struct device_node *(*parse_prop)(struct device_node *np,
1210                                           const char *prop_name, int index);
1211         struct device_node *(*get_con_dev)(struct device_node *np);
1212         bool optional;
1213 };
1214
1215 DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells")
1216 DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells")
1217 DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells")
1218 DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells")
1219 DEFINE_SIMPLE_PROP(io_channels, "io-channels", "#io-channel-cells")
1220 DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL)
1221 DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells")
1222 DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells")
1223 DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells")
1224 DEFINE_SIMPLE_PROP(extcon, "extcon", NULL)
1225 DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", "#nvmem-cell-cells")
1226 DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells")
1227 DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL)
1228 DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL)
1229 DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL)
1230 DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL)
1231 DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL)
1232 DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL)
1233 DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL)
1234 DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL)
1235 DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL)
1236 DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL)
1237 DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells")
1238 DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells")
1239 DEFINE_SIMPLE_PROP(leds, "leds", NULL)
1240 DEFINE_SIMPLE_PROP(backlight, "backlight", NULL)
1241 DEFINE_SIMPLE_PROP(panel, "panel", NULL)
1242 DEFINE_SIMPLE_PROP(msi_parent, "msi-parent", "#msi-cells")
1243 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
1244 DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells")
1245
1246 static struct device_node *parse_gpios(struct device_node *np,
1247                                        const char *prop_name, int index)
1248 {
1249         if (!strcmp_suffix(prop_name, ",nr-gpios"))
1250                 return NULL;
1251
1252         return parse_suffix_prop_cells(np, prop_name, index, "-gpios",
1253                                        "#gpio-cells");
1254 }
1255
1256 static struct device_node *parse_iommu_maps(struct device_node *np,
1257                                             const char *prop_name, int index)
1258 {
1259         if (strcmp(prop_name, "iommu-map"))
1260                 return NULL;
1261
1262         return of_parse_phandle(np, prop_name, (index * 4) + 1);
1263 }
1264
1265 static struct device_node *parse_gpio_compat(struct device_node *np,
1266                                              const char *prop_name, int index)
1267 {
1268         struct of_phandle_args sup_args;
1269
1270         if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios"))
1271                 return NULL;
1272
1273         /*
1274          * Ignore node with gpio-hog property since its gpios are all provided
1275          * by its parent.
1276          */
1277         if (of_property_read_bool(np, "gpio-hog"))
1278                 return NULL;
1279
1280         if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index,
1281                                        &sup_args))
1282                 return NULL;
1283
1284         return sup_args.np;
1285 }
1286
1287 static struct device_node *parse_interrupts(struct device_node *np,
1288                                             const char *prop_name, int index)
1289 {
1290         struct of_phandle_args sup_args;
1291
1292         if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC))
1293                 return NULL;
1294
1295         if (strcmp(prop_name, "interrupts") &&
1296             strcmp(prop_name, "interrupts-extended"))
1297                 return NULL;
1298
1299         return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np;
1300 }
1301
1302 static struct device_node *parse_remote_endpoint(struct device_node *np,
1303                                                  const char *prop_name,
1304                                                  int index)
1305 {
1306         /* Return NULL for index > 0 to signify end of remote-endpoints. */
1307         if (index > 0 || strcmp(prop_name, "remote-endpoint"))
1308                 return NULL;
1309
1310         return of_graph_get_remote_port_parent(np);
1311 }
1312
1313 static const struct supplier_bindings of_supplier_bindings[] = {
1314         { .parse_prop = parse_clocks, },
1315         { .parse_prop = parse_interconnects, },
1316         { .parse_prop = parse_iommus, .optional = true, },
1317         { .parse_prop = parse_iommu_maps, .optional = true, },
1318         { .parse_prop = parse_mboxes, },
1319         { .parse_prop = parse_io_channels, },
1320         { .parse_prop = parse_interrupt_parent, },
1321         { .parse_prop = parse_dmas, .optional = true, },
1322         { .parse_prop = parse_power_domains, },
1323         { .parse_prop = parse_hwlocks, },
1324         { .parse_prop = parse_extcon, },
1325         { .parse_prop = parse_nvmem_cells, },
1326         { .parse_prop = parse_phys, },
1327         { .parse_prop = parse_wakeup_parent, },
1328         { .parse_prop = parse_pinctrl0, },
1329         { .parse_prop = parse_pinctrl1, },
1330         { .parse_prop = parse_pinctrl2, },
1331         { .parse_prop = parse_pinctrl3, },
1332         { .parse_prop = parse_pinctrl4, },
1333         { .parse_prop = parse_pinctrl5, },
1334         { .parse_prop = parse_pinctrl6, },
1335         { .parse_prop = parse_pinctrl7, },
1336         { .parse_prop = parse_pinctrl8, },
1337         {
1338                 .parse_prop = parse_remote_endpoint,
1339                 .get_con_dev = of_graph_get_port_parent,
1340         },
1341         { .parse_prop = parse_pwms, },
1342         { .parse_prop = parse_resets, },
1343         { .parse_prop = parse_leds, },
1344         { .parse_prop = parse_backlight, },
1345         { .parse_prop = parse_panel, },
1346         { .parse_prop = parse_msi_parent, },
1347         { .parse_prop = parse_gpio_compat, },
1348         { .parse_prop = parse_interrupts, },
1349         { .parse_prop = parse_regulators, },
1350         { .parse_prop = parse_gpio, },
1351         { .parse_prop = parse_gpios, },
1352         {}
1353 };
1354
1355 /**
1356  * of_link_property - Create device links to suppliers listed in a property
1357  * @con_np: The consumer device tree node which contains the property
1358  * @prop_name: Name of property to be parsed
1359  *
1360  * This function checks if the property @prop_name that is present in the
1361  * @con_np device tree node is one of the known common device tree bindings
1362  * that list phandles to suppliers. If @prop_name isn't one, this function
1363  * doesn't do anything.
1364  *
1365  * If @prop_name is one, this function attempts to create fwnode links from the
1366  * consumer device tree node @con_np to all the suppliers device tree nodes
1367  * listed in @prop_name.
1368  *
1369  * Any failed attempt to create a fwnode link will NOT result in an immediate
1370  * return.  of_link_property() must create links to all the available supplier
1371  * device tree nodes even when attempts to create a link to one or more
1372  * suppliers fail.
1373  */
1374 static int of_link_property(struct device_node *con_np, const char *prop_name)
1375 {
1376         struct device_node *phandle;
1377         const struct supplier_bindings *s = of_supplier_bindings;
1378         unsigned int i = 0;
1379         bool matched = false;
1380
1381         /* Do not stop at first failed link, link all available suppliers. */
1382         while (!matched && s->parse_prop) {
1383                 if (s->optional && !fw_devlink_is_strict()) {
1384                         s++;
1385                         continue;
1386                 }
1387
1388                 while ((phandle = s->parse_prop(con_np, prop_name, i))) {
1389                         struct device_node *con_dev_np;
1390
1391                         con_dev_np = s->get_con_dev
1392                                         ? s->get_con_dev(con_np)
1393                                         : of_node_get(con_np);
1394                         matched = true;
1395                         i++;
1396                         of_link_to_phandle(con_dev_np, phandle);
1397                         of_node_put(phandle);
1398                         of_node_put(con_dev_np);
1399                 }
1400                 s++;
1401         }
1402         return 0;
1403 }
1404
1405 static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index)
1406 {
1407 #ifdef CONFIG_OF_ADDRESS
1408         return of_iomap(to_of_node(fwnode), index);
1409 #else
1410         return NULL;
1411 #endif
1412 }
1413
1414 static int of_fwnode_irq_get(const struct fwnode_handle *fwnode,
1415                              unsigned int index)
1416 {
1417         return of_irq_get(to_of_node(fwnode), index);
1418 }
1419
1420 static int of_fwnode_add_links(struct fwnode_handle *fwnode)
1421 {
1422         struct property *p;
1423         struct device_node *con_np = to_of_node(fwnode);
1424
1425         if (IS_ENABLED(CONFIG_X86))
1426                 return 0;
1427
1428         if (!con_np)
1429                 return -EINVAL;
1430
1431         for_each_property_of_node(con_np, p)
1432                 of_link_property(con_np, p->name);
1433
1434         return 0;
1435 }
1436
1437 const struct fwnode_operations of_fwnode_ops = {
1438         .get = of_fwnode_get,
1439         .put = of_fwnode_put,
1440         .device_is_available = of_fwnode_device_is_available,
1441         .device_get_match_data = of_fwnode_device_get_match_data,
1442         .device_dma_supported = of_fwnode_device_dma_supported,
1443         .device_get_dma_attr = of_fwnode_device_get_dma_attr,
1444         .property_present = of_fwnode_property_present,
1445         .property_read_int_array = of_fwnode_property_read_int_array,
1446         .property_read_string_array = of_fwnode_property_read_string_array,
1447         .get_name = of_fwnode_get_name,
1448         .get_name_prefix = of_fwnode_get_name_prefix,
1449         .get_parent = of_fwnode_get_parent,
1450         .get_next_child_node = of_fwnode_get_next_child_node,
1451         .get_named_child_node = of_fwnode_get_named_child_node,
1452         .get_reference_args = of_fwnode_get_reference_args,
1453         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
1454         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
1455         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
1456         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
1457         .iomap = of_fwnode_iomap,
1458         .irq_get = of_fwnode_irq_get,
1459         .add_links = of_fwnode_add_links,
1460 };
1461 EXPORT_SYMBOL_GPL(of_fwnode_ops);