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