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_device.h>
  26 #include <linux/of_graph.h>
  27 #include <linux/string.h>
  28 #include <linux/moduleparam.h>
  29
  30 #include "of_private.h"
  31
  32 /**
  33  * of_property_count_elems_of_size - Count the number of elements in a property
  34  *
  35  * @np:         device node from which the property value is to be read.
  36  * @propname:   name of the property to be searched.
  37  * @elem_size:  size of the individual element
  38  *
  39  * Search for a property in a device node and count the number of elements of
  40  * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
  41  * property does not exist or its length does not match a multiple of elem_size
  42  * and -ENODATA if the property does not have a value.
  43  */
  44 int of_property_count_elems_of_size(const struct device_node *np,
  45                                 const char *propname, int elem_size)
  46 {
  47         struct property *prop = of_find_property(np, propname, NULL);
  48
  49         if (!prop)
  50                 return -EINVAL;
  51         if (!prop->value)
  52                 return -ENODATA;
  53
  54         if (prop->length % elem_size != 0) {
  55                 pr_err("size of %s in node %pOF is not a multiple of %d\n",
  56                        propname, np, elem_size);
  57                 return -EINVAL;
  58         }
  59
  60         return prop->length / elem_size;
  61 }
  62 EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
  63
  64 /**
  65  * of_find_property_value_of_size
  66  *
  67  * @np:         device node from which the property value is to be read.
  68  * @propname:   name of the property to be searched.
  69  * @min:        minimum allowed length of property value
  70  * @max:        maximum allowed length of property value (0 means unlimited)
  71  * @len:        if !=NULL, actual length is written to here
  72  *
  73  * Search for a property in a device node and valid the requested size.
  74  * Returns the property value on success, -EINVAL if the property does not
  75  *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
  76  * property data is too small or too large.
  77  *
  78  */
  79 static void *of_find_property_value_of_size(const struct device_node *np,
  80                         const char *propname, u32 min, u32 max, size_t *len)
  81 {
  82         struct property *prop = of_find_property(np, propname, NULL);
  83
  84         if (!prop)
  85                 return ERR_PTR(-EINVAL);
  86         if (!prop->value)
  87                 return ERR_PTR(-ENODATA);
  88         if (prop->length < min)
  89                 return ERR_PTR(-EOVERFLOW);
  90         if (max && prop->length > max)
  91                 return ERR_PTR(-EOVERFLOW);
  92
  93         if (len)
  94                 *len = prop->length;
  95
  96         return prop->value;
  97 }
  98
  99 /**
 100  * of_property_read_u32_index - Find and read a u32 from a multi-value property.
 101  *
 102  * @np:         device node from which the property value is to be read.
 103  * @propname:   name of the property to be searched.
 104  * @index:      index of the u32 in the list of values
 105  * @out_value:  pointer to return value, modified only if no error.
 106  *
 107  * Search for a property in a device node and read nth 32-bit value from
 108  * it. Returns 0 on success, -EINVAL if the property does not exist,
 109  * -ENODATA if property does not have a value, and -EOVERFLOW if the
 110  * property data isn't large enough.
 111  *
 112  * The out_value is modified only if a valid u32 value can be decoded.
 113  */
 114 int of_property_read_u32_index(const struct device_node *np,
 115                                        const char *propname,
 116                                        u32 index, u32 *out_value)
 117 {
 118         const u32 *val = of_find_property_value_of_size(np, propname,
 119                                         ((index + 1) * sizeof(*out_value)),
 120                                         0,
 121                                         NULL);
 122
 123         if (IS_ERR(val))
 124                 return PTR_ERR(val);
 125
 126         *out_value = be32_to_cpup(((__be32 *)val) + index);
 127         return 0;
 128 }
 129 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
 130
 131 /**
 132  * of_property_read_u64_index - Find and read a u64 from a multi-value property.
 133  *
 134  * @np:         device node from which the property value is to be read.
 135  * @propname:   name of the property to be searched.
 136  * @index:      index of the u64 in the list of values
 137  * @out_value:  pointer to return value, modified only if no error.
 138  *
 139  * Search for a property in a device node and read nth 64-bit value from
 140  * it. Returns 0 on success, -EINVAL if the property does not exist,
 141  * -ENODATA if property does not have a value, and -EOVERFLOW if the
 142  * property data isn't large enough.
 143  *
 144  * The out_value is modified only if a valid u64 value can be decoded.
 145  */
 146 int of_property_read_u64_index(const struct device_node *np,
 147                                        const char *propname,
 148                                        u32 index, u64 *out_value)
 149 {
 150         const u64 *val = of_find_property_value_of_size(np, propname,
 151                                         ((index + 1) * sizeof(*out_value)),
 152                                         0, NULL);
 153
 154         if (IS_ERR(val))
 155                 return PTR_ERR(val);
 156
 157         *out_value = be64_to_cpup(((__be64 *)val) + index);
 158         return 0;
 159 }
 160 EXPORT_SYMBOL_GPL(of_property_read_u64_index);
 161
 162 /**
 163  * of_property_read_variable_u8_array - Find and read an array of u8 from a
 164  * property, with bounds on the minimum and maximum array size.
 165  *
 166  * @np:         device node from which the property value is to be read.
 167  * @propname:   name of the property to be searched.
 168  * @out_values: pointer to return value, modified only if return value is 0.
 169  * @sz_min:     minimum number of array elements to read
 170  * @sz_max:     maximum number of array elements to read, if zero there is no
 171  *              upper limit on the number of elements in the dts entry but only
 172  *              sz_min will be read.
 173  *
 174  * Search for a property in a device node and read 8-bit value(s) from
 175  * it. Returns number of elements read on success, -EINVAL if the property
 176  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
 177  * if the property data is smaller than sz_min or longer than sz_max.
 178  *
 179  * dts entry of array should be like:
 180  *      property = /bits/ 8 <0x50 0x60 0x70>;
 181  *
 182  * The out_values is modified only if a valid u8 value can be decoded.
 183  */
 184 int of_property_read_variable_u8_array(const struct device_node *np,
 185                                         const char *propname, u8 *out_values,
 186                                         size_t sz_min, size_t sz_max)
 187 {
 188         size_t sz, count;
 189         const u8 *val = of_find_property_value_of_size(np, propname,
 190                                                 (sz_min * sizeof(*out_values)),
 191                                                 (sz_max * sizeof(*out_values)),
 192                                                 &sz);
 193
 194         if (IS_ERR(val))
 195                 return PTR_ERR(val);
 196
 197         if (!sz_max)
 198                 sz = sz_min;
 199         else
 200                 sz /= sizeof(*out_values);
 201
 202         count = sz;
 203         while (count--)
 204                 *out_values++ = *val++;
 205
 206         return sz;
 207 }
 208 EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array);
 209
 210 /**
 211  * of_property_read_variable_u16_array - Find and read an array of u16 from a
 212  * property, with bounds on the minimum and maximum array size.
 213  *
 214  * @np:         device node from which the property value is to be read.
 215  * @propname:   name of the property to be searched.
 216  * @out_values: pointer to return value, modified only if return value is 0.
 217  * @sz_min:     minimum number of array elements to read
 218  * @sz_max:     maximum number of array elements to read, if zero there is no
 219  *              upper limit on the number of elements in the dts entry but only
 220  *              sz_min will be read.
 221  *
 222  * Search for a property in a device node and read 16-bit value(s) from
 223  * it. Returns number of elements read on success, -EINVAL if the property
 224  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
 225  * if the property data is smaller than sz_min or longer than sz_max.
 226  *
 227  * dts entry of array should be like:
 228  *      property = /bits/ 16 <0x5000 0x6000 0x7000>;
 229  *
 230  * The out_values is modified only if a valid u16 value can be decoded.
 231  */
 232 int of_property_read_variable_u16_array(const struct device_node *np,
 233                                         const char *propname, u16 *out_values,
 234                                         size_t sz_min, size_t sz_max)
 235 {
 236         size_t sz, count;
 237         const __be16 *val = of_find_property_value_of_size(np, propname,
 238                                                 (sz_min * sizeof(*out_values)),
 239                                                 (sz_max * sizeof(*out_values)),
 240                                                 &sz);
 241
 242         if (IS_ERR(val))
 243                 return PTR_ERR(val);
 244
 245         if (!sz_max)
 246                 sz = sz_min;
 247         else
 248                 sz /= sizeof(*out_values);
 249
 250         count = sz;
 251         while (count--)
 252                 *out_values++ = be16_to_cpup(val++);
 253
 254         return sz;
 255 }
 256 EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array);
 257
 258 /**
 259  * of_property_read_variable_u32_array - Find and read an array of 32 bit
 260  * integers from a property, with bounds on the minimum and maximum array size.
 261  *
 262  * @np:         device node from which the property value is to be read.
 263  * @propname:   name of the property to be searched.
 264  * @out_values: pointer to return value, modified only if return value is 0.
 265  * @sz_min:     minimum number of array elements to read
 266  * @sz_max:     maximum number of array elements to read, if zero there is no
 267  *              upper limit on the number of elements in the dts entry but only
 268  *              sz_min will be read.
 269  *
 270  * Search for a property in a device node and read 32-bit value(s) from
 271  * it. Returns number of elements read on success, -EINVAL if the property
 272  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
 273  * if the property data is smaller than sz_min or longer than sz_max.
 274  *
 275  * The out_values is modified only if a valid u32 value can be decoded.
 276  */
 277 int of_property_read_variable_u32_array(const struct device_node *np,
 278                                const char *propname, u32 *out_values,
 279                                size_t sz_min, size_t sz_max)
 280 {
 281         size_t sz, count;
 282         const __be32 *val = of_find_property_value_of_size(np, propname,
 283                                                 (sz_min * sizeof(*out_values)),
 284                                                 (sz_max * sizeof(*out_values)),
 285                                                 &sz);
 286
 287         if (IS_ERR(val))
 288                 return PTR_ERR(val);
 289
 290         if (!sz_max)
 291                 sz = sz_min;
 292         else
 293                 sz /= sizeof(*out_values);
 294
 295         count = sz;
 296         while (count--)
 297                 *out_values++ = be32_to_cpup(val++);
 298
 299         return sz;
 300 }
 301 EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array);
 302
 303 /**
 304  * of_property_read_u64 - Find and read a 64 bit integer from a property
 305  * @np:         device node from which the property value is to be read.
 306  * @propname:   name of the property to be searched.
 307  * @out_value:  pointer to return value, modified only if return value is 0.
 308  *
 309  * Search for a property in a device node and read a 64-bit value from
 310  * it. Returns 0 on success, -EINVAL if the property does not exist,
 311  * -ENODATA if property does not have a value, and -EOVERFLOW if the
 312  * property data isn't large enough.
 313  *
 314  * The out_value is modified only if a valid u64 value can be decoded.
 315  */
 316 int of_property_read_u64(const struct device_node *np, const char *propname,
 317                          u64 *out_value)
 318 {
 319         const __be32 *val = of_find_property_value_of_size(np, propname,
 320                                                 sizeof(*out_value),
 321                                                 0,
 322                                                 NULL);
 323
 324         if (IS_ERR(val))
 325                 return PTR_ERR(val);
 326
 327         *out_value = of_read_number(val, 2);
 328         return 0;
 329 }
 330 EXPORT_SYMBOL_GPL(of_property_read_u64);
 331
 332 /**
 333  * of_property_read_variable_u64_array - Find and read an array of 64 bit
 334  * integers from a property, with bounds on the minimum and maximum array size.
 335  *
 336  * @np:         device node from which the property value is to be read.
 337  * @propname:   name of the property to be searched.
 338  * @out_values: pointer to return value, modified only if return value is 0.
 339  * @sz_min:     minimum number of array elements to read
 340  * @sz_max:     maximum number of array elements to read, if zero there is no
 341  *              upper limit on the number of elements in the dts entry but only
 342  *              sz_min will be read.
 343  *
 344  * Search for a property in a device node and read 64-bit value(s) from
 345  * it. Returns number of elements read on success, -EINVAL if the property
 346  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
 347  * if the property data is smaller than sz_min or longer than sz_max.
 348  *
 349  * The out_values is modified only if a valid u64 value can be decoded.
 350  */
 351 int of_property_read_variable_u64_array(const struct device_node *np,
 352                                const char *propname, u64 *out_values,
 353                                size_t sz_min, size_t sz_max)
 354 {
 355         size_t sz, count;
 356         const __be32 *val = of_find_property_value_of_size(np, propname,
 357                                                 (sz_min * sizeof(*out_values)),
 358                                                 (sz_max * sizeof(*out_values)),
 359                                                 &sz);
 360
 361         if (IS_ERR(val))
 362                 return PTR_ERR(val);
 363
 364         if (!sz_max)
 365                 sz = sz_min;
 366         else
 367                 sz /= sizeof(*out_values);
 368
 369         count = sz;
 370         while (count--) {
 371                 *out_values++ = of_read_number(val, 2);
 372                 val += 2;
 373         }
 374
 375         return sz;
 376 }
 377 EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array);
 378
 379 /**
 380  * of_property_read_string - Find and read a string from a property
 381  * @np:         device node from which the property value is to be read.
 382  * @propname:   name of the property to be searched.
 383  * @out_string: pointer to null terminated return string, modified only if
 384  *              return value is 0.
 385  *
 386  * Search for a property in a device tree node and retrieve a null
 387  * terminated string value (pointer to data, not a copy). Returns 0 on
 388  * success, -EINVAL if the property does not exist, -ENODATA if property
 389  * does not have a value, and -EILSEQ if the string is not null-terminated
 390  * within the length of the property data.
 391  *
 392  * The out_string pointer is modified only if a valid string can be decoded.
 393  */
 394 int of_property_read_string(const struct device_node *np, const char *propname,
 395                                 const char **out_string)
 396 {
 397         const struct property *prop = of_find_property(np, propname, NULL);
 398         if (!prop)
 399                 return -EINVAL;
 400         if (!prop->value)
 401                 return -ENODATA;
 402         if (strnlen(prop->value, prop->length) >= prop->length)
 403                 return -EILSEQ;
 404         *out_string = prop->value;
 405         return 0;
 406 }
 407 EXPORT_SYMBOL_GPL(of_property_read_string);
 408
 409 /**
 410  * of_property_match_string() - Find string in a list and return index
 411  * @np: pointer to node containing string list property
 412  * @propname: string list property name
 413  * @string: pointer to string to search for in string list
 414  *
 415  * This function searches a string list property and returns the index
 416  * of a specific string value.
 417  */
 418 int of_property_match_string(const struct device_node *np, const char *propname,
 419                              const char *string)
 420 {
 421         const struct property *prop = of_find_property(np, propname, NULL);
 422         size_t l;
 423         int i;
 424         const char *p, *end;
 425
 426         if (!prop)
 427                 return -EINVAL;
 428         if (!prop->value)
 429                 return -ENODATA;
 430
 431         p = prop->value;
 432         end = p + prop->length;
 433
 434         for (i = 0; p < end; i++, p += l) {
 435                 l = strnlen(p, end - p) + 1;
 436                 if (p + l > end)
 437                         return -EILSEQ;
 438                 pr_debug("comparing %s with %s\n", string, p);
 439                 if (strcmp(string, p) == 0)
 440                         return i; /* Found it; return index */
 441         }
 442         return -ENODATA;
 443 }
 444 EXPORT_SYMBOL_GPL(of_property_match_string);
 445
 446 /**
 447  * of_property_read_string_helper() - Utility helper for parsing string properties
 448  * @np:         device node from which the property value is to be read.
 449  * @propname:   name of the property to be searched.
 450  * @out_strs:   output array of string pointers.
 451  * @sz:         number of array elements to read.
 452  * @skip:       Number of strings to skip over at beginning of list.
 453  *
 454  * Don't call this function directly. It is a utility helper for the
 455  * of_property_read_string*() family of functions.
 456  */
 457 int of_property_read_string_helper(const struct device_node *np,
 458                                    const char *propname, const char **out_strs,
 459                                    size_t sz, int skip)
 460 {
 461         const struct property *prop = of_find_property(np, propname, NULL);
 462         int l = 0, i = 0;
 463         const char *p, *end;
 464
 465         if (!prop)
 466                 return -EINVAL;
 467         if (!prop->value)
 468                 return -ENODATA;
 469         p = prop->value;
 470         end = p + prop->length;
 471
 472         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
 473                 l = strnlen(p, end - p) + 1;
 474                 if (p + l > end)
 475                         return -EILSEQ;
 476                 if (out_strs && i >= skip)
 477                         *out_strs++ = p;
 478         }
 479         i -= skip;
 480         return i <= 0 ? -ENODATA : i;
 481 }
 482 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
 483
 484 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
 485                                u32 *pu)
 486 {
 487         const void *curv = cur;
 488
 489         if (!prop)
 490                 return NULL;
 491
 492         if (!cur) {
 493                 curv = prop->value;
 494                 goto out_val;
 495         }
 496
 497         curv += sizeof(*cur);
 498         if (curv >= prop->value + prop->length)
 499                 return NULL;
 500
 501 out_val:
 502         *pu = be32_to_cpup(curv);
 503         return curv;
 504 }
 505 EXPORT_SYMBOL_GPL(of_prop_next_u32);
 506
 507 const char *of_prop_next_string(struct property *prop, const char *cur)
 508 {
 509         const void *curv = cur;
 510
 511         if (!prop)
 512                 return NULL;
 513
 514         if (!cur)
 515                 return prop->value;
 516
 517         curv += strlen(cur) + 1;
 518         if (curv >= prop->value + prop->length)
 519                 return NULL;
 520
 521         return curv;
 522 }
 523 EXPORT_SYMBOL_GPL(of_prop_next_string);
 524
 525 /**
 526  * of_graph_parse_endpoint() - parse common endpoint node properties
 527  * @node: pointer to endpoint device_node
 528  * @endpoint: pointer to the OF endpoint data structure
 529  *
 530  * The caller should hold a reference to @node.
 531  */
 532 int of_graph_parse_endpoint(const struct device_node *node,
 533                             struct of_endpoint *endpoint)
 534 {
 535         struct device_node *port_node = of_get_parent(node);
 536
 537         WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n",
 538                   __func__, node);
 539
 540         memset(endpoint, 0, sizeof(*endpoint));
 541
 542         endpoint->local_node = node;
 543         /*
 544          * It doesn't matter whether the two calls below succeed.
 545          * If they don't then the default value 0 is used.
 546          */
 547         of_property_read_u32(port_node, "reg", &endpoint->port);
 548         of_property_read_u32(node, "reg", &endpoint->id);
 549
 550         of_node_put(port_node);
 551
 552         return 0;
 553 }
 554 EXPORT_SYMBOL(of_graph_parse_endpoint);
 555
 556 /**
 557  * of_graph_get_port_by_id() - get the port matching a given id
 558  * @parent: pointer to the parent device node
 559  * @id: id of the port
 560  *
 561  * Return: A 'port' node pointer with refcount incremented. The caller
 562  * has to use of_node_put() on it when done.
 563  */
 564 struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
 565 {
 566         struct device_node *node, *port;
 567
 568         node = of_get_child_by_name(parent, "ports");
 569         if (node)
 570                 parent = node;
 571
 572         for_each_child_of_node(parent, port) {
 573                 u32 port_id = 0;
 574
 575                 if (!of_node_name_eq(port, "port"))
 576                         continue;
 577                 of_property_read_u32(port, "reg", &port_id);
 578                 if (id == port_id)
 579                         break;
 580         }
 581
 582         of_node_put(node);
 583
 584         return port;
 585 }
 586 EXPORT_SYMBOL(of_graph_get_port_by_id);
 587
 588 /**
 589  * of_graph_get_next_endpoint() - get next endpoint node
 590  * @parent: pointer to the parent device node
 591  * @prev: previous endpoint node, or NULL to get first
 592  *
 593  * Return: An 'endpoint' node pointer with refcount incremented. Refcount
 594  * of the passed @prev node is decremented.
 595  */
 596 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
 597                                         struct device_node *prev)
 598 {
 599         struct device_node *endpoint;
 600         struct device_node *port;
 601
 602         if (!parent)
 603                 return NULL;
 604
 605         /*
 606          * Start by locating the port node. If no previous endpoint is specified
 607          * search for the first port node, otherwise get the previous endpoint
 608          * parent port node.
 609          */
 610         if (!prev) {
 611                 struct device_node *node;
 612
 613                 node = of_get_child_by_name(parent, "ports");
 614                 if (node)
 615                         parent = node;
 616
 617                 port = of_get_child_by_name(parent, "port");
 618                 of_node_put(node);
 619
 620                 if (!port) {
 621                         pr_err("graph: no port node found in %pOF\n", parent);
 622                         return NULL;
 623                 }
 624         } else {
 625                 port = of_get_parent(prev);
 626                 if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n",
 627                               __func__, prev))
 628                         return NULL;
 629         }
 630
 631         while (1) {
 632                 /*
 633                  * Now that we have a port node, get the next endpoint by
 634                  * getting the next child. If the previous endpoint is NULL this
 635                  * will return the first child.
 636                  */
 637                 endpoint = of_get_next_child(port, prev);
 638                 if (endpoint) {
 639                         of_node_put(port);
 640                         return endpoint;
 641                 }
 642
 643                 /* No more endpoints under this port, try the next one. */
 644                 prev = NULL;
 645
 646                 do {
 647                         port = of_get_next_child(parent, port);
 648                         if (!port)
 649                                 return NULL;
 650                 } while (!of_node_name_eq(port, "port"));
 651         }
 652 }
 653 EXPORT_SYMBOL(of_graph_get_next_endpoint);
 654
 655 /**
 656  * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
 657  * @parent: pointer to the parent device node
 658  * @port_reg: identifier (value of reg property) of the parent port node
 659  * @reg: identifier (value of reg property) of the endpoint node
 660  *
 661  * Return: An 'endpoint' node pointer which is identified by reg and at the same
 662  * is the child of a port node identified by port_reg. reg and port_reg are
 663  * ignored when they are -1. Use of_node_put() on the pointer when done.
 664  */
 665 struct device_node *of_graph_get_endpoint_by_regs(
 666         const struct device_node *parent, int port_reg, int reg)
 667 {
 668         struct of_endpoint endpoint;
 669         struct device_node *node = NULL;
 670
 671         for_each_endpoint_of_node(parent, node) {
 672                 of_graph_parse_endpoint(node, &endpoint);
 673                 if (((port_reg == -1) || (endpoint.port == port_reg)) &&
 674                         ((reg == -1) || (endpoint.id == reg)))
 675                         return node;
 676         }
 677
 678         return NULL;
 679 }
 680 EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
 681
 682 /**
 683  * of_graph_get_remote_endpoint() - get remote endpoint node
 684  * @node: pointer to a local endpoint device_node
 685  *
 686  * Return: Remote endpoint node associated with remote endpoint node linked
 687  *         to @node. Use of_node_put() on it when done.
 688  */
 689 struct device_node *of_graph_get_remote_endpoint(const struct device_node *node)
 690 {
 691         /* Get remote endpoint node. */
 692         return of_parse_phandle(node, "remote-endpoint", 0);
 693 }
 694 EXPORT_SYMBOL(of_graph_get_remote_endpoint);
 695
 696 /**
 697  * of_graph_get_port_parent() - get port's parent node
 698  * @node: pointer to a local endpoint device_node
 699  *
 700  * Return: device node associated with endpoint node linked
 701  *         to @node. Use of_node_put() on it when done.
 702  */
 703 struct device_node *of_graph_get_port_parent(struct device_node *node)
 704 {
 705         unsigned int depth;
 706
 707         if (!node)
 708                 return NULL;
 709
 710         /*
 711          * Preserve usecount for passed in node as of_get_next_parent()
 712          * will do of_node_put() on it.
 713          */
 714         of_node_get(node);
 715
 716         /* Walk 3 levels up only if there is 'ports' node. */
 717         for (depth = 3; depth && node; depth--) {
 718                 node = of_get_next_parent(node);
 719                 if (depth == 2 && !of_node_name_eq(node, "ports"))
 720                         break;
 721         }
 722         return node;
 723 }
 724 EXPORT_SYMBOL(of_graph_get_port_parent);
 725
 726 /**
 727  * of_graph_get_remote_port_parent() - get remote port's parent node
 728  * @node: pointer to a local endpoint device_node
 729  *
 730  * Return: Remote device node associated with remote endpoint node linked
 731  *         to @node. Use of_node_put() on it when done.
 732  */
 733 struct device_node *of_graph_get_remote_port_parent(
 734                                const struct device_node *node)
 735 {
 736         struct device_node *np, *pp;
 737
 738         /* Get remote endpoint node. */
 739         np = of_graph_get_remote_endpoint(node);
 740
 741         pp = of_graph_get_port_parent(np);
 742
 743         of_node_put(np);
 744
 745         return pp;
 746 }
 747 EXPORT_SYMBOL(of_graph_get_remote_port_parent);
 748
 749 /**
 750  * of_graph_get_remote_port() - get remote port node
 751  * @node: pointer to a local endpoint device_node
 752  *
 753  * Return: Remote port node associated with remote endpoint node linked
 754  *         to @node. Use of_node_put() on it when done.
 755  */
 756 struct device_node *of_graph_get_remote_port(const struct device_node *node)
 757 {
 758         struct device_node *np;
 759
 760         /* Get remote endpoint node. */
 761         np = of_graph_get_remote_endpoint(node);
 762         if (!np)
 763                 return NULL;
 764         return of_get_next_parent(np);
 765 }
 766 EXPORT_SYMBOL(of_graph_get_remote_port);
 767
 768 int of_graph_get_endpoint_count(const struct device_node *np)
 769 {
 770         struct device_node *endpoint;
 771         int num = 0;
 772
 773         for_each_endpoint_of_node(np, endpoint)
 774                 num++;
 775
 776         return num;
 777 }
 778 EXPORT_SYMBOL(of_graph_get_endpoint_count);
 779
 780 /**
 781  * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint
 782  * @node: pointer to parent device_node containing graph port/endpoint
 783  * @port: identifier (value of reg property) of the parent port node
 784  * @endpoint: identifier (value of reg property) of the endpoint node
 785  *
 786  * Return: Remote device node associated with remote endpoint node linked
 787  *         to @node. Use of_node_put() on it when done.
 788  */
 789 struct device_node *of_graph_get_remote_node(const struct device_node *node,
 790                                              u32 port, u32 endpoint)
 791 {
 792         struct device_node *endpoint_node, *remote;
 793
 794         endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint);
 795         if (!endpoint_node) {
 796                 pr_debug("no valid endpoint (%d, %d) for node %pOF\n",
 797                          port, endpoint, node);
 798                 return NULL;
 799         }
 800
 801         remote = of_graph_get_remote_port_parent(endpoint_node);
 802         of_node_put(endpoint_node);
 803         if (!remote) {
 804                 pr_debug("no valid remote node\n");
 805                 return NULL;
 806         }
 807
 808         if (!of_device_is_available(remote)) {
 809                 pr_debug("not available for remote node\n");
 810                 of_node_put(remote);
 811                 return NULL;
 812         }
 813
 814         return remote;
 815 }
 816 EXPORT_SYMBOL(of_graph_get_remote_node);
 817
 818 static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode)
 819 {
 820         return of_fwnode_handle(of_node_get(to_of_node(fwnode)));
 821 }
 822
 823 static void of_fwnode_put(struct fwnode_handle *fwnode)
 824 {
 825         of_node_put(to_of_node(fwnode));
 826 }
 827
 828 static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode)
 829 {
 830         return of_device_is_available(to_of_node(fwnode));
 831 }
 832
 833 static bool of_fwnode_property_present(const struct fwnode_handle *fwnode,
 834                                        const char *propname)
 835 {
 836         return of_property_read_bool(to_of_node(fwnode), propname);
 837 }
 838
 839 static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 840                                              const char *propname,
 841                                              unsigned int elem_size, void *val,
 842                                              size_t nval)
 843 {
 844         const struct device_node *node = to_of_node(fwnode);
 845
 846         if (!val)
 847                 return of_property_count_elems_of_size(node, propname,
 848                                                        elem_size);
 849
 850         switch (elem_size) {
 851         case sizeof(u8):
 852                 return of_property_read_u8_array(node, propname, val, nval);
 853         case sizeof(u16):
 854                 return of_property_read_u16_array(node, propname, val, nval);
 855         case sizeof(u32):
 856                 return of_property_read_u32_array(node, propname, val, nval);
 857         case sizeof(u64):
 858                 return of_property_read_u64_array(node, propname, val, nval);
 859         }
 860
 861         return -ENXIO;
 862 }
 863
 864 static int
 865 of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 866                                      const char *propname, const char **val,
 867                                      size_t nval)
 868 {
 869         const struct device_node *node = to_of_node(fwnode);
 870
 871         return val ?
 872                 of_property_read_string_array(node, propname, val, nval) :
 873                 of_property_count_strings(node, propname);
 874 }
 875
 876 static struct fwnode_handle *
 877 of_fwnode_get_parent(const struct fwnode_handle *fwnode)
 878 {
 879         return of_fwnode_handle(of_get_parent(to_of_node(fwnode)));
 880 }
 881
 882 static struct fwnode_handle *
 883 of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 884                               struct fwnode_handle *child)
 885 {
 886         return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode),
 887                                                             to_of_node(child)));
 888 }
 889
 890 static struct fwnode_handle *
 891 of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
 892                                const char *childname)
 893 {
 894         const struct device_node *node = to_of_node(fwnode);
 895         struct device_node *child;
 896
 897         for_each_available_child_of_node(node, child)
 898                 if (of_node_name_eq(child, childname))
 899                         return of_fwnode_handle(child);
 900
 901         return NULL;
 902 }
 903
 904 static int
 905 of_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
 906                              const char *prop, const char *nargs_prop,
 907                              unsigned int nargs, unsigned int index,
 908                              struct fwnode_reference_args *args)
 909 {
 910         struct of_phandle_args of_args;
 911         unsigned int i;
 912         int ret;
 913
 914         if (nargs_prop)
 915                 ret = of_parse_phandle_with_args(to_of_node(fwnode), prop,
 916                                                  nargs_prop, index, &of_args);
 917         else
 918                 ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop,
 919                                                        nargs, index, &of_args);
 920         if (ret < 0)
 921                 return ret;
 922         if (!args)
 923                 return 0;
 924
 925         args->nargs = of_args.args_count;
 926         args->fwnode = of_fwnode_handle(of_args.np);
 927
 928         for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++)
 929                 args->args[i] = i < of_args.args_count ? of_args.args[i] : 0;
 930
 931         return 0;
 932 }
 933
 934 static struct fwnode_handle *
 935 of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
 936                                   struct fwnode_handle *prev)
 937 {
 938         return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode),
 939                                                            to_of_node(prev)));
 940 }
 941
 942 static struct fwnode_handle *
 943 of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
 944 {
 945         return of_fwnode_handle(
 946                 of_graph_get_remote_endpoint(to_of_node(fwnode)));
 947 }
 948
 949 static struct fwnode_handle *
 950 of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode)
 951 {
 952         struct device_node *np;
 953
 954         /* Get the parent of the port */
 955         np = of_get_parent(to_of_node(fwnode));
 956         if (!np)
 957                 return NULL;
 958
 959         /* Is this the "ports" node? If not, it's the port parent. */
 960         if (!of_node_name_eq(np, "ports"))
 961                 return of_fwnode_handle(np);
 962
 963         return of_fwnode_handle(of_get_next_parent(np));
 964 }
 965
 966 static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
 967                                           struct fwnode_endpoint *endpoint)
 968 {
 969         const struct device_node *node = to_of_node(fwnode);
 970         struct device_node *port_node = of_get_parent(node);
 971
 972         endpoint->local_fwnode = fwnode;
 973
 974         of_property_read_u32(port_node, "reg", &endpoint->port);
 975         of_property_read_u32(node, "reg", &endpoint->id);
 976
 977         of_node_put(port_node);
 978
 979         return 0;
 980 }
 981
 982 static const void *
 983 of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
 984                                 const struct device *dev)
 985 {
 986         return of_device_get_match_data(dev);
 987 }
 988
 989 static bool of_is_ancestor_of(struct device_node *test_ancestor,
 990                               struct device_node *child)
 991 {
 992         of_node_get(child);
 993         while (child) {
 994                 if (child == test_ancestor) {
 995                         of_node_put(child);
 996                         return false;
 997                 }
 998                 child = of_get_next_parent(child);
 999         }
1000         return true;
1001 }
1002
1003 /**
1004  * of_link_to_phandle - Add device link to supplier from supplier phandle
1005  * @dev: consumer device
1006  * @sup_np: phandle to supplier device tree node
1007  *
1008  * Given a phandle to a supplier device tree node (@sup_np), this function
1009  * finds the device that owns the supplier device tree node and creates a
1010  * device link from @dev consumer device to the supplier device. This function
1011  * doesn't create device links for invalid scenarios such as trying to create a
1012  * link with a parent device as the consumer of its child device. In such
1013  * cases, it returns an error.
1014  *
1015  * Returns:
1016  * - 0 if link successfully created to supplier
1017  * - -EAGAIN if linking to the supplier should be reattempted
1018  * - -EINVAL if the supplier link is invalid and should not be created
1019  * - -ENODEV if there is no device that corresponds to the supplier phandle
1020  */
1021 static int of_link_to_phandle(struct device *dev, struct device_node *sup_np,
1022                               u32 dl_flags)
1023 {
1024         struct device *sup_dev;
1025         int ret = 0;
1026         struct device_node *tmp_np = sup_np;
1027         int is_populated;
1028
1029         of_node_get(sup_np);
1030         /*
1031          * Find the device node that contains the supplier phandle.  It may be
1032          * @sup_np or it may be an ancestor of @sup_np.
1033          */
1034         while (sup_np && !of_find_property(sup_np, "compatible", NULL))
1035                 sup_np = of_get_next_parent(sup_np);
1036         if (!sup_np) {
1037                 dev_dbg(dev, "Not linking to %pOFP - No device\n", tmp_np);
1038                 return -ENODEV;
1039         }
1040
1041         /*
1042          * Don't allow linking a device node as a consumer of one of its
1043          * descendant nodes. By definition, a child node can't be a functional
1044          * dependency for the parent node.
1045          */
1046         if (!of_is_ancestor_of(dev->of_node, sup_np)) {
1047                 dev_dbg(dev, "Not linking to %pOFP - is descendant\n", sup_np);
1048                 of_node_put(sup_np);
1049                 return -EINVAL;
1050         }
1051         sup_dev = get_dev_from_fwnode(&sup_np->fwnode);
1052         is_populated = of_node_check_flag(sup_np, OF_POPULATED);
1053         of_node_put(sup_np);
1054         if (!sup_dev && is_populated) {
1055                 /* Early device without struct device. */
1056                 dev_dbg(dev, "Not linking to %pOFP - No struct device\n",
1057                         sup_np);
1058                 return -ENODEV;
1059         } else if (!sup_dev) {
1060                 return -EAGAIN;
1061         }
1062         if (!device_link_add(dev, sup_dev, dl_flags))
1063                 ret = -EAGAIN;
1064         put_device(sup_dev);
1065         return ret;
1066 }
1067
1068 /**
1069  * parse_prop_cells - Property parsing function for suppliers
1070  *
1071  * @np:         Pointer to device tree node containing a list
1072  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1073  * @index:      For properties holding a list of phandles, this is the index
1074  *              into the list.
1075  * @list_name:  Property name that is known to contain list of phandle(s) to
1076  *              supplier(s)
1077  * @cells_name: property name that specifies phandles' arguments count
1078  *
1079  * This is a helper function to parse properties that have a known fixed name
1080  * and are a list of phandles and phandle arguments.
1081  *
1082  * Returns:
1083  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1084  *   on it when done.
1085  * - NULL if no phandle found at index
1086  */
1087 static struct device_node *parse_prop_cells(struct device_node *np,
1088                                             const char *prop_name, int index,
1089                                             const char *list_name,
1090                                             const char *cells_name)
1091 {
1092         struct of_phandle_args sup_args;
1093
1094         if (strcmp(prop_name, list_name))
1095                 return NULL;
1096
1097         if (of_parse_phandle_with_args(np, list_name, cells_name, index,
1098                                        &sup_args))
1099                 return NULL;
1100
1101         return sup_args.np;
1102 }
1103
1104 #define DEFINE_SIMPLE_PROP(fname, name, cells)                            \
1105 static struct device_node *parse_##fname(struct device_node *np,          \
1106                                         const char *prop_name, int index) \
1107 {                                                                         \
1108         return parse_prop_cells(np, prop_name, index, name, cells);       \
1109 }
1110
1111 static int strcmp_suffix(const char *str, const char *suffix)
1112 {
1113         unsigned int len, suffix_len;
1114
1115         len = strlen(str);
1116         suffix_len = strlen(suffix);
1117         if (len <= suffix_len)
1118                 return -1;
1119         return strcmp(str + len - suffix_len, suffix);
1120 }
1121
1122 /**
1123  * parse_suffix_prop_cells - Suffix property parsing function for suppliers
1124  *
1125  * @np:         Pointer to device tree node containing a list
1126  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1127  * @index:      For properties holding a list of phandles, this is the index
1128  *              into the list.
1129  * @suffix:     Property suffix that is known to contain list of phandle(s) to
1130  *              supplier(s)
1131  * @cells_name: property name that specifies phandles' arguments count
1132  *
1133  * This is a helper function to parse properties that have a known fixed suffix
1134  * and are a list of phandles and phandle arguments.
1135  *
1136  * Returns:
1137  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1138  *   on it when done.
1139  * - NULL if no phandle found at index
1140  */
1141 static struct device_node *parse_suffix_prop_cells(struct device_node *np,
1142                                             const char *prop_name, int index,
1143                                             const char *suffix,
1144                                             const char *cells_name)
1145 {
1146         struct of_phandle_args sup_args;
1147
1148         if (strcmp_suffix(prop_name, suffix))
1149                 return NULL;
1150
1151         if (of_parse_phandle_with_args(np, prop_name, cells_name, index,
1152                                        &sup_args))
1153                 return NULL;
1154
1155         return sup_args.np;
1156 }
1157
1158 #define DEFINE_SUFFIX_PROP(fname, suffix, cells)                             \
1159 static struct device_node *parse_##fname(struct device_node *np,             \
1160                                         const char *prop_name, int index)    \
1161 {                                                                            \
1162         return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \
1163 }
1164
1165 /**
1166  * struct supplier_bindings - Property parsing functions for suppliers
1167  *
1168  * @parse_prop: function name
1169  *      parse_prop() finds the node corresponding to a supplier phandle
1170  * @parse_prop.np: Pointer to device node holding supplier phandle property
1171  * @parse_prop.prop_name: Name of property holding a phandle value
1172  * @parse_prop.index: For properties holding a list of phandles, this is the
1173  *                    index into the list
1174  *
1175  * Returns:
1176  * parse_prop() return values are
1177  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1178  *   on it when done.
1179  * - NULL if no phandle found at index
1180  */
1181 struct supplier_bindings {
1182         struct device_node *(*parse_prop)(struct device_node *np,
1183                                           const char *prop_name, int index);
1184 };
1185
1186 DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells")
1187 DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells")
1188 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
1189
1190 static const struct supplier_bindings of_supplier_bindings[] = {
1191         { .parse_prop = parse_clocks, },
1192         { .parse_prop = parse_interconnects, },
1193         { .parse_prop = parse_regulators, },
1194         {}
1195 };
1196
1197 /**
1198  * of_link_property - Create device links to suppliers listed in a property
1199  * @dev: Consumer device
1200  * @con_np: The consumer device tree node which contains the property
1201  * @prop_name: Name of property to be parsed
1202  *
1203  * This function checks if the property @prop_name that is present in the
1204  * @con_np device tree node is one of the known common device tree bindings
1205  * that list phandles to suppliers. If @prop_name isn't one, this function
1206  * doesn't do anything.
1207  *
1208  * If @prop_name is one, this function attempts to create device links from the
1209  * consumer device @dev to all the devices of the suppliers listed in
1210  * @prop_name.
1211  *
1212  * Any failed attempt to create a device link will NOT result in an immediate
1213  * return.  of_link_property() must create links to all the available supplier
1214  * devices even when attempts to create a link to one or more suppliers fail.
1215  */
1216 static int of_link_property(struct device *dev, struct device_node *con_np,
1217                              const char *prop_name)
1218 {
1219         struct device_node *phandle;
1220         const struct supplier_bindings *s = of_supplier_bindings;
1221         unsigned int i = 0;
1222         bool matched = false;
1223         int ret = 0;
1224         u32 dl_flags;
1225
1226         if (dev->of_node == con_np)
1227                 dl_flags = DL_FLAG_AUTOPROBE_CONSUMER;
1228         else
1229                 dl_flags = DL_FLAG_SYNC_STATE_ONLY;
1230
1231         /* Do not stop at first failed link, link all available suppliers. */
1232         while (!matched && s->parse_prop) {
1233                 while ((phandle = s->parse_prop(con_np, prop_name, i))) {
1234                         matched = true;
1235                         i++;
1236                         if (of_link_to_phandle(dev, phandle, dl_flags)
1237                                                                 == -EAGAIN)
1238                                 ret = -EAGAIN;
1239                         of_node_put(phandle);
1240                 }
1241                 s++;
1242         }
1243         return ret;
1244 }
1245
1246 static int of_link_to_suppliers(struct device *dev,
1247                                   struct device_node *con_np)
1248 {
1249         struct device_node *child;
1250         struct property *p;
1251         int ret = 0;
1252
1253         for_each_property_of_node(con_np, p)
1254                 if (of_link_property(dev, con_np, p->name))
1255                         ret = -ENODEV;
1256
1257         for_each_child_of_node(con_np, child)
1258                 if (of_link_to_suppliers(dev, child) && !ret)
1259                         ret = -EAGAIN;
1260
1261         return ret;
1262 }
1263
1264 static bool of_devlink;
1265 core_param(of_devlink, of_devlink, bool, 0);
1266
1267 static int of_fwnode_add_links(const struct fwnode_handle *fwnode,
1268                                struct device *dev)
1269 {
1270         if (!of_devlink)
1271                 return 0;
1272
1273         if (unlikely(!is_of_node(fwnode)))
1274                 return 0;
1275
1276         return of_link_to_suppliers(dev, to_of_node(fwnode));
1277 }
1278
1279 const struct fwnode_operations of_fwnode_ops = {
1280         .get = of_fwnode_get,
1281         .put = of_fwnode_put,
1282         .device_is_available = of_fwnode_device_is_available,
1283         .device_get_match_data = of_fwnode_device_get_match_data,
1284         .property_present = of_fwnode_property_present,
1285         .property_read_int_array = of_fwnode_property_read_int_array,
1286         .property_read_string_array = of_fwnode_property_read_string_array,
1287         .get_parent = of_fwnode_get_parent,
1288         .get_next_child_node = of_fwnode_get_next_child_node,
1289         .get_named_child_node = of_fwnode_get_named_child_node,
1290         .get_reference_args = of_fwnode_get_reference_args,
1291         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
1292         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
1293         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
1294         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
1295         .add_links = of_fwnode_add_links,
1296 };
1297 EXPORT_SYMBOL_GPL(of_fwnode_ops);