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 bool of_is_ancestor_of(struct device_node *test_ancestor,
1066                               struct device_node *child)
1067 {
1068         of_node_get(child);
1069         while (child) {
1070                 if (child == test_ancestor) {
1071                         of_node_put(child);
1072                         return true;
1073                 }
1074                 child = of_get_next_parent(child);
1075         }
1076         return false;
1077 }
1078
1079 static struct device_node *of_get_compat_node(struct device_node *np)
1080 {
1081         of_node_get(np);
1082
1083         while (np) {
1084                 if (!of_device_is_available(np)) {
1085                         of_node_put(np);
1086                         np = NULL;
1087                 }
1088
1089                 if (of_find_property(np, "compatible", NULL))
1090                         break;
1091
1092                 np = of_get_next_parent(np);
1093         }
1094
1095         return np;
1096 }
1097
1098 static struct device_node *of_get_compat_node_parent(struct device_node *np)
1099 {
1100         struct device_node *parent, *node;
1101
1102         parent = of_get_parent(np);
1103         node = of_get_compat_node(parent);
1104         of_node_put(parent);
1105
1106         return node;
1107 }
1108
1109 /**
1110  * of_link_to_phandle - Add fwnode link to supplier from supplier phandle
1111  * @con_np: consumer device tree node
1112  * @sup_np: supplier device tree node
1113  *
1114  * Given a phandle to a supplier device tree node (@sup_np), this function
1115  * finds the device that owns the supplier device tree node and creates a
1116  * device link from @dev consumer device to the supplier device. This function
1117  * doesn't create device links for invalid scenarios such as trying to create a
1118  * link with a parent device as the consumer of its child device. In such
1119  * cases, it returns an error.
1120  *
1121  * Returns:
1122  * - 0 if fwnode link successfully created to supplier
1123  * - -EINVAL if the supplier link is invalid and should not be created
1124  * - -ENODEV if struct device will never be create for supplier
1125  */
1126 static int of_link_to_phandle(struct device_node *con_np,
1127                               struct device_node *sup_np)
1128 {
1129         struct device *sup_dev;
1130         struct device_node *tmp_np = sup_np;
1131
1132         /*
1133          * Find the device node that contains the supplier phandle.  It may be
1134          * @sup_np or it may be an ancestor of @sup_np.
1135          */
1136         sup_np = of_get_compat_node(sup_np);
1137         if (!sup_np) {
1138                 pr_debug("Not linking %pOFP to %pOFP - No device\n",
1139                          con_np, tmp_np);
1140                 return -ENODEV;
1141         }
1142
1143         /*
1144          * Don't allow linking a device node as a consumer of one of its
1145          * descendant nodes. By definition, a child node can't be a functional
1146          * dependency for the parent node.
1147          */
1148         if (of_is_ancestor_of(con_np, sup_np)) {
1149                 pr_debug("Not linking %pOFP to %pOFP - is descendant\n",
1150                          con_np, sup_np);
1151                 of_node_put(sup_np);
1152                 return -EINVAL;
1153         }
1154
1155         /*
1156          * Don't create links to "early devices" that won't have struct devices
1157          * created for them.
1158          */
1159         sup_dev = get_dev_from_fwnode(&sup_np->fwnode);
1160         if (!sup_dev &&
1161             (of_node_check_flag(sup_np, OF_POPULATED) ||
1162              sup_np->fwnode.flags & FWNODE_FLAG_NOT_DEVICE)) {
1163                 pr_debug("Not linking %pOFP to %pOFP - No struct device\n",
1164                          con_np, sup_np);
1165                 of_node_put(sup_np);
1166                 return -ENODEV;
1167         }
1168         put_device(sup_dev);
1169
1170         fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np));
1171         of_node_put(sup_np);
1172
1173         return 0;
1174 }
1175
1176 /**
1177  * parse_prop_cells - Property parsing function for suppliers
1178  *
1179  * @np:         Pointer to device tree node containing a list
1180  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1181  * @index:      For properties holding a list of phandles, this is the index
1182  *              into the list.
1183  * @list_name:  Property name that is known to contain list of phandle(s) to
1184  *              supplier(s)
1185  * @cells_name: property name that specifies phandles' arguments count
1186  *
1187  * This is a helper function to parse properties that have a known fixed name
1188  * and are a list of phandles and phandle arguments.
1189  *
1190  * Returns:
1191  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1192  *   on it when done.
1193  * - NULL if no phandle found at index
1194  */
1195 static struct device_node *parse_prop_cells(struct device_node *np,
1196                                             const char *prop_name, int index,
1197                                             const char *list_name,
1198                                             const char *cells_name)
1199 {
1200         struct of_phandle_args sup_args;
1201
1202         if (strcmp(prop_name, list_name))
1203                 return NULL;
1204
1205         if (of_parse_phandle_with_args(np, list_name, cells_name, index,
1206                                        &sup_args))
1207                 return NULL;
1208
1209         return sup_args.np;
1210 }
1211
1212 #define DEFINE_SIMPLE_PROP(fname, name, cells)                            \
1213 static struct device_node *parse_##fname(struct device_node *np,          \
1214                                         const char *prop_name, int index) \
1215 {                                                                         \
1216         return parse_prop_cells(np, prop_name, index, name, cells);       \
1217 }
1218
1219 static int strcmp_suffix(const char *str, const char *suffix)
1220 {
1221         unsigned int len, suffix_len;
1222
1223         len = strlen(str);
1224         suffix_len = strlen(suffix);
1225         if (len <= suffix_len)
1226                 return -1;
1227         return strcmp(str + len - suffix_len, suffix);
1228 }
1229
1230 /**
1231  * parse_suffix_prop_cells - Suffix property parsing function for suppliers
1232  *
1233  * @np:         Pointer to device tree node containing a list
1234  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1235  * @index:      For properties holding a list of phandles, this is the index
1236  *              into the list.
1237  * @suffix:     Property suffix that is known to contain list of phandle(s) to
1238  *              supplier(s)
1239  * @cells_name: property name that specifies phandles' arguments count
1240  *
1241  * This is a helper function to parse properties that have a known fixed suffix
1242  * and are a list of phandles and phandle arguments.
1243  *
1244  * Returns:
1245  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1246  *   on it when done.
1247  * - NULL if no phandle found at index
1248  */
1249 static struct device_node *parse_suffix_prop_cells(struct device_node *np,
1250                                             const char *prop_name, int index,
1251                                             const char *suffix,
1252                                             const char *cells_name)
1253 {
1254         struct of_phandle_args sup_args;
1255
1256         if (strcmp_suffix(prop_name, suffix))
1257                 return NULL;
1258
1259         if (of_parse_phandle_with_args(np, prop_name, cells_name, index,
1260                                        &sup_args))
1261                 return NULL;
1262
1263         return sup_args.np;
1264 }
1265
1266 #define DEFINE_SUFFIX_PROP(fname, suffix, cells)                             \
1267 static struct device_node *parse_##fname(struct device_node *np,             \
1268                                         const char *prop_name, int index)    \
1269 {                                                                            \
1270         return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \
1271 }
1272
1273 /**
1274  * struct supplier_bindings - Property parsing functions for suppliers
1275  *
1276  * @parse_prop: function name
1277  *      parse_prop() finds the node corresponding to a supplier phandle
1278  * @parse_prop.np: Pointer to device node holding supplier phandle property
1279  * @parse_prop.prop_name: Name of property holding a phandle value
1280  * @parse_prop.index: For properties holding a list of phandles, this is the
1281  *                    index into the list
1282  * @optional: Describes whether a supplier is mandatory or not
1283  * @node_not_dev: The consumer node containing the property is never converted
1284  *                to a struct device. Instead, parse ancestor nodes for the
1285  *                compatible property to find a node corresponding to a device.
1286  *
1287  * Returns:
1288  * parse_prop() return values are
1289  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1290  *   on it when done.
1291  * - NULL if no phandle found at index
1292  */
1293 struct supplier_bindings {
1294         struct device_node *(*parse_prop)(struct device_node *np,
1295                                           const char *prop_name, int index);
1296         bool optional;
1297         bool node_not_dev;
1298 };
1299
1300 DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells")
1301 DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells")
1302 DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells")
1303 DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells")
1304 DEFINE_SIMPLE_PROP(io_channels, "io-channel", "#io-channel-cells")
1305 DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL)
1306 DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells")
1307 DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells")
1308 DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells")
1309 DEFINE_SIMPLE_PROP(extcon, "extcon", NULL)
1310 DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", NULL)
1311 DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells")
1312 DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL)
1313 DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL)
1314 DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL)
1315 DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL)
1316 DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL)
1317 DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL)
1318 DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL)
1319 DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL)
1320 DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL)
1321 DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL)
1322 DEFINE_SIMPLE_PROP(remote_endpoint, "remote-endpoint", NULL)
1323 DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells")
1324 DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells")
1325 DEFINE_SIMPLE_PROP(leds, "leds", NULL)
1326 DEFINE_SIMPLE_PROP(backlight, "backlight", NULL)
1327 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
1328 DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells")
1329
1330 static struct device_node *parse_gpios(struct device_node *np,
1331                                        const char *prop_name, int index)
1332 {
1333         if (!strcmp_suffix(prop_name, ",nr-gpios"))
1334                 return NULL;
1335
1336         return parse_suffix_prop_cells(np, prop_name, index, "-gpios",
1337                                        "#gpio-cells");
1338 }
1339
1340 static struct device_node *parse_iommu_maps(struct device_node *np,
1341                                             const char *prop_name, int index)
1342 {
1343         if (strcmp(prop_name, "iommu-map"))
1344                 return NULL;
1345
1346         return of_parse_phandle(np, prop_name, (index * 4) + 1);
1347 }
1348
1349 static struct device_node *parse_gpio_compat(struct device_node *np,
1350                                              const char *prop_name, int index)
1351 {
1352         struct of_phandle_args sup_args;
1353
1354         if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios"))
1355                 return NULL;
1356
1357         /*
1358          * Ignore node with gpio-hog property since its gpios are all provided
1359          * by its parent.
1360          */
1361         if (of_find_property(np, "gpio-hog", NULL))
1362                 return NULL;
1363
1364         if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index,
1365                                        &sup_args))
1366                 return NULL;
1367
1368         return sup_args.np;
1369 }
1370
1371 static struct device_node *parse_interrupts(struct device_node *np,
1372                                             const char *prop_name, int index)
1373 {
1374         struct of_phandle_args sup_args;
1375
1376         if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC))
1377                 return NULL;
1378
1379         if (strcmp(prop_name, "interrupts") &&
1380             strcmp(prop_name, "interrupts-extended"))
1381                 return NULL;
1382
1383         return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np;
1384 }
1385
1386 static const struct supplier_bindings of_supplier_bindings[] = {
1387         { .parse_prop = parse_clocks, },
1388         { .parse_prop = parse_interconnects, },
1389         { .parse_prop = parse_iommus, .optional = true, },
1390         { .parse_prop = parse_iommu_maps, .optional = true, },
1391         { .parse_prop = parse_mboxes, },
1392         { .parse_prop = parse_io_channels, },
1393         { .parse_prop = parse_interrupt_parent, },
1394         { .parse_prop = parse_dmas, .optional = true, },
1395         { .parse_prop = parse_power_domains, },
1396         { .parse_prop = parse_hwlocks, },
1397         { .parse_prop = parse_extcon, },
1398         { .parse_prop = parse_nvmem_cells, },
1399         { .parse_prop = parse_phys, },
1400         { .parse_prop = parse_wakeup_parent, },
1401         { .parse_prop = parse_pinctrl0, },
1402         { .parse_prop = parse_pinctrl1, },
1403         { .parse_prop = parse_pinctrl2, },
1404         { .parse_prop = parse_pinctrl3, },
1405         { .parse_prop = parse_pinctrl4, },
1406         { .parse_prop = parse_pinctrl5, },
1407         { .parse_prop = parse_pinctrl6, },
1408         { .parse_prop = parse_pinctrl7, },
1409         { .parse_prop = parse_pinctrl8, },
1410         { .parse_prop = parse_remote_endpoint, .node_not_dev = true, },
1411         { .parse_prop = parse_pwms, },
1412         { .parse_prop = parse_resets, },
1413         { .parse_prop = parse_leds, },
1414         { .parse_prop = parse_backlight, },
1415         { .parse_prop = parse_gpio_compat, },
1416         { .parse_prop = parse_interrupts, },
1417         { .parse_prop = parse_regulators, },
1418         { .parse_prop = parse_gpio, },
1419         { .parse_prop = parse_gpios, },
1420         {}
1421 };
1422
1423 /**
1424  * of_link_property - Create device links to suppliers listed in a property
1425  * @con_np: The consumer device tree node which contains the property
1426  * @prop_name: Name of property to be parsed
1427  *
1428  * This function checks if the property @prop_name that is present in the
1429  * @con_np device tree node is one of the known common device tree bindings
1430  * that list phandles to suppliers. If @prop_name isn't one, this function
1431  * doesn't do anything.
1432  *
1433  * If @prop_name is one, this function attempts to create fwnode links from the
1434  * consumer device tree node @con_np to all the suppliers device tree nodes
1435  * listed in @prop_name.
1436  *
1437  * Any failed attempt to create a fwnode link will NOT result in an immediate
1438  * return.  of_link_property() must create links to all the available supplier
1439  * device tree nodes even when attempts to create a link to one or more
1440  * suppliers fail.
1441  */
1442 static int of_link_property(struct device_node *con_np, const char *prop_name)
1443 {
1444         struct device_node *phandle;
1445         const struct supplier_bindings *s = of_supplier_bindings;
1446         unsigned int i = 0;
1447         bool matched = false;
1448
1449         /* Do not stop at first failed link, link all available suppliers. */
1450         while (!matched && s->parse_prop) {
1451                 if (s->optional && !fw_devlink_is_strict()) {
1452                         s++;
1453                         continue;
1454                 }
1455
1456                 while ((phandle = s->parse_prop(con_np, prop_name, i))) {
1457                         struct device_node *con_dev_np;
1458
1459                         con_dev_np = s->node_not_dev
1460                                         ? of_get_compat_node_parent(con_np)
1461                                         : of_node_get(con_np);
1462                         matched = true;
1463                         i++;
1464                         of_link_to_phandle(con_dev_np, phandle);
1465                         of_node_put(phandle);
1466                         of_node_put(con_dev_np);
1467                 }
1468                 s++;
1469         }
1470         return 0;
1471 }
1472
1473 static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index)
1474 {
1475 #ifdef CONFIG_OF_ADDRESS
1476         return of_iomap(to_of_node(fwnode), index);
1477 #else
1478         return NULL;
1479 #endif
1480 }
1481
1482 static int of_fwnode_irq_get(const struct fwnode_handle *fwnode,
1483                              unsigned int index)
1484 {
1485         return of_irq_get(to_of_node(fwnode), index);
1486 }
1487
1488 static int of_fwnode_add_links(struct fwnode_handle *fwnode)
1489 {
1490         struct property *p;
1491         struct device_node *con_np = to_of_node(fwnode);
1492
1493         if (IS_ENABLED(CONFIG_X86))
1494                 return 0;
1495
1496         if (!con_np)
1497                 return -EINVAL;
1498
1499         for_each_property_of_node(con_np, p)
1500                 of_link_property(con_np, p->name);
1501
1502         return 0;
1503 }
1504
1505 const struct fwnode_operations of_fwnode_ops = {
1506         .get = of_fwnode_get,
1507         .put = of_fwnode_put,
1508         .device_is_available = of_fwnode_device_is_available,
1509         .device_get_match_data = of_fwnode_device_get_match_data,
1510         .device_dma_supported = of_fwnode_device_dma_supported,
1511         .device_get_dma_attr = of_fwnode_device_get_dma_attr,
1512         .property_present = of_fwnode_property_present,
1513         .property_read_int_array = of_fwnode_property_read_int_array,
1514         .property_read_string_array = of_fwnode_property_read_string_array,
1515         .get_name = of_fwnode_get_name,
1516         .get_name_prefix = of_fwnode_get_name_prefix,
1517         .get_parent = of_fwnode_get_parent,
1518         .get_next_child_node = of_fwnode_get_next_child_node,
1519         .get_named_child_node = of_fwnode_get_named_child_node,
1520         .get_reference_args = of_fwnode_get_reference_args,
1521         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
1522         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
1523         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
1524         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
1525         .iomap = of_fwnode_iomap,
1526         .irq_get = of_fwnode_irq_get,
1527         .add_links = of_fwnode_add_links,
1528 };
1529 EXPORT_SYMBOL_GPL(of_fwnode_ops);