drivers/core/of_access.c

   1 /*
   2  * Originally from Linux v4.9
   3  * Paul Mackerras       August 1996.
   4  * Copyright (C) 1996-2005 Paul Mackerras.
   5  *
   6  * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   7  *   {engebret|bergner}@us.ibm.com
   8  *
   9  * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
  10  *
  11  * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
  12  * Grant Likely.
  13  *
  14  * Modified for U-Boot
  15  * Copyright (c) 2017 Google, Inc
  16  *
  17  * This file follows drivers/of/base.c with functions in the same order as the
  18  * Linux version.
  19  *
  20  * SPDX-License-Identifier:     GPL-2.0+
  21  */
  22
  23 #include <common.h>
  24 #include <libfdt.h>
  25 #include <dm/of_access.h>
  26 #include <linux/ctype.h>
  27 #include <linux/err.h>
  28 #include <linux/ioport.h>
  29
  30 DECLARE_GLOBAL_DATA_PTR;
  31
  32 /* list of struct alias_prop aliases */
  33 LIST_HEAD(aliases_lookup);
  34
  35 /* "/aliaes" node */
  36 static struct device_node *of_aliases;
  37
  38 /* "/chosen" node */
  39 static struct device_node *of_chosen;
  40
  41 /* node pointed to by the stdout-path alias */
  42 static struct device_node *of_stdout;
  43
  44 /* pointer to options given after the alias (separated by :) or NULL if none */
  45 static const char *of_stdout_options;
  46
  47 /**
  48  * struct alias_prop - Alias property in 'aliases' node
  49  *
  50  * The structure represents one alias property of 'aliases' node as
  51  * an entry in aliases_lookup list.
  52  *
  53  * @link:       List node to link the structure in aliases_lookup list
  54  * @alias:      Alias property name
  55  * @np:         Pointer to device_node that the alias stands for
  56  * @id:         Index value from end of alias name
  57  * @stem:       Alias string without the index
  58  */
  59 struct alias_prop {
  60         struct list_head link;
  61         const char *alias;
  62         struct device_node *np;
  63         int id;
  64         char stem[0];
  65 };
  66
  67 int of_n_addr_cells(const struct device_node *np)
  68 {
  69         const __be32 *ip;
  70
  71         do {
  72                 if (np->parent)
  73                         np = np->parent;
  74                 ip = of_get_property(np, "#address-cells", NULL);
  75                 if (ip)
  76                         return be32_to_cpup(ip);
  77         } while (np->parent);
  78
  79         /* No #address-cells property for the root node */
  80         return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
  81 }
  82
  83 int of_n_size_cells(const struct device_node *np)
  84 {
  85         const __be32 *ip;
  86
  87         do {
  88                 if (np->parent)
  89                         np = np->parent;
  90                 ip = of_get_property(np, "#size-cells", NULL);
  91                 if (ip)
  92                         return be32_to_cpup(ip);
  93         } while (np->parent);
  94
  95         /* No #size-cells property for the root node */
  96         return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
  97 }
  98
  99 struct property *of_find_property(const struct device_node *np,
 100                                   const char *name, int *lenp)
 101 {
 102         struct property *pp;
 103
 104         if (!np)
 105                 return NULL;
 106
 107         for (pp = np->properties; pp; pp = pp->next) {
 108                 if (strcmp(pp->name, name) == 0) {
 109                         if (lenp)
 110                                 *lenp = pp->length;
 111                         break;
 112                 }
 113         }
 114         if (!pp && lenp)
 115                 *lenp = -FDT_ERR_NOTFOUND;
 116
 117         return pp;
 118 }
 119
 120 struct device_node *of_find_all_nodes(struct device_node *prev)
 121 {
 122         struct device_node *np;
 123
 124         if (!prev) {
 125                 np = gd->of_root;
 126         } else if (prev->child) {
 127                 np = prev->child;
 128         } else {
 129                 /*
 130                  * Walk back up looking for a sibling, or the end of the
 131                  * structure
 132                  */
 133                 np = prev;
 134                 while (np->parent && !np->sibling)
 135                         np = np->parent;
 136                 np = np->sibling; /* Might be null at the end of the tree */
 137         }
 138
 139         return np;
 140 }
 141
 142 const void *of_get_property(const struct device_node *np, const char *name,
 143                             int *lenp)
 144 {
 145         struct property *pp = of_find_property(np, name, lenp);
 146
 147         return pp ? pp->value : NULL;
 148 }
 149
 150 static const char *of_prop_next_string(struct property *prop, const char *cur)
 151 {
 152         const void *curv = cur;
 153
 154         if (!prop)
 155                 return NULL;
 156
 157         if (!cur)
 158                 return prop->value;
 159
 160         curv += strlen(cur) + 1;
 161         if (curv >= prop->value + prop->length)
 162                 return NULL;
 163
 164         return curv;
 165 }
 166
 167 int of_device_is_compatible(const struct device_node *device,
 168                             const char *compat, const char *type,
 169                             const char *name)
 170 {
 171         struct property *prop;
 172         const char *cp;
 173         int index = 0, score = 0;
 174
 175         /* Compatible match has highest priority */
 176         if (compat && compat[0]) {
 177                 prop = of_find_property(device, "compatible", NULL);
 178                 for (cp = of_prop_next_string(prop, NULL); cp;
 179                      cp = of_prop_next_string(prop, cp), index++) {
 180                         if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
 181                                 score = INT_MAX/2 - (index << 2);
 182                                 break;
 183                         }
 184                 }
 185                 if (!score)
 186                         return 0;
 187         }
 188
 189         /* Matching type is better than matching name */
 190         if (type && type[0]) {
 191                 if (!device->type || of_node_cmp(type, device->type))
 192                         return 0;
 193                 score += 2;
 194         }
 195
 196         /* Matching name is a bit better than not */
 197         if (name && name[0]) {
 198                 if (!device->name || of_node_cmp(name, device->name))
 199                         return 0;
 200                 score++;
 201         }
 202
 203         return score;
 204 }
 205
 206 bool of_device_is_available(const struct device_node *device)
 207 {
 208         const char *status;
 209         int statlen;
 210
 211         if (!device)
 212                 return false;
 213
 214         status = of_get_property(device, "status", &statlen);
 215         if (status == NULL)
 216                 return true;
 217
 218         if (statlen > 0) {
 219                 if (!strcmp(status, "okay"))
 220                         return true;
 221         }
 222
 223         return false;
 224 }
 225
 226 struct device_node *of_get_parent(const struct device_node *node)
 227 {
 228         const struct device_node *np;
 229
 230         if (!node)
 231                 return NULL;
 232
 233         np = of_node_get(node->parent);
 234
 235         return (struct device_node *)np;
 236 }
 237
 238 static struct device_node *__of_get_next_child(const struct device_node *node,
 239                                                struct device_node *prev)
 240 {
 241         struct device_node *next;
 242
 243         if (!node)
 244                 return NULL;
 245
 246         next = prev ? prev->sibling : node->child;
 247         /*
 248          * coverity[dead_error_line : FALSE]
 249          * Dead code here since our current implementation of of_node_get()
 250          * always returns NULL (Coverity CID 163245). But we leave it as is
 251          * since we may want to implement get/put later.
 252          */
 253         for (; next; next = next->sibling)
 254                 if (of_node_get(next))
 255                         break;
 256         of_node_put(prev);
 257         return next;
 258 }
 259
 260 #define __for_each_child_of_node(parent, child) \
 261         for (child = __of_get_next_child(parent, NULL); child != NULL; \
 262              child = __of_get_next_child(parent, child))
 263
 264 static struct device_node *__of_find_node_by_path(struct device_node *parent,
 265                                                   const char *path)
 266 {
 267         struct device_node *child;
 268         int len;
 269
 270         len = strcspn(path, "/:");
 271         if (!len)
 272                 return NULL;
 273
 274         __for_each_child_of_node(parent, child) {
 275                 const char *name = strrchr(child->full_name, '/');
 276
 277                 name++;
 278                 if (strncmp(path, name, len) == 0 && (strlen(name) == len))
 279                         return child;
 280         }
 281         return NULL;
 282 }
 283
 284 #define for_each_property_of_node(dn, pp) \
 285         for (pp = dn->properties; pp != NULL; pp = pp->next)
 286
 287 struct device_node *of_find_node_opts_by_path(const char *path,
 288                                               const char **opts)
 289 {
 290         struct device_node *np = NULL;
 291         struct property *pp;
 292         const char *separator = strchr(path, ':');
 293
 294         if (opts)
 295                 *opts = separator ? separator + 1 : NULL;
 296
 297         if (strcmp(path, "/") == 0)
 298                 return of_node_get(gd->of_root);
 299
 300         /* The path could begin with an alias */
 301         if (*path != '/') {
 302                 int len;
 303                 const char *p = separator;
 304
 305                 if (!p)
 306                         p = strchrnul(path, '/');
 307                 len = p - path;
 308
 309                 /* of_aliases must not be NULL */
 310                 if (!of_aliases)
 311                         return NULL;
 312
 313                 for_each_property_of_node(of_aliases, pp) {
 314                         if (strlen(pp->name) == len && !strncmp(pp->name, path,
 315                                                                 len)) {
 316                                 np = of_find_node_by_path(pp->value);
 317                                 break;
 318                         }
 319                 }
 320                 if (!np)
 321                         return NULL;
 322                 path = p;
 323         }
 324
 325         /* Step down the tree matching path components */
 326         if (!np)
 327                 np = of_node_get(gd->of_root);
 328         while (np && *path == '/') {
 329                 struct device_node *tmp = np;
 330
 331                 path++; /* Increment past '/' delimiter */
 332                 np = __of_find_node_by_path(np, path);
 333                 of_node_put(tmp);
 334                 path = strchrnul(path, '/');
 335                 if (separator && separator < path)
 336                         break;
 337         }
 338
 339         return np;
 340 }
 341
 342 struct device_node *of_find_compatible_node(struct device_node *from,
 343                 const char *type, const char *compatible)
 344 {
 345         struct device_node *np;
 346
 347         for_each_of_allnodes_from(from, np)
 348                 if (of_device_is_compatible(np, compatible, type, NULL) &&
 349                     of_node_get(np))
 350                         break;
 351         of_node_put(from);
 352
 353         return np;
 354 }
 355
 356 struct device_node *of_find_node_by_phandle(phandle handle)
 357 {
 358         struct device_node *np;
 359
 360         if (!handle)
 361                 return NULL;
 362
 363         for_each_of_allnodes(np)
 364                 if (np->phandle == handle)
 365                         break;
 366         (void)of_node_get(np);
 367
 368         return np;
 369 }
 370
 371 /**
 372  * of_find_property_value_of_size() - find property of given size
 373  *
 374  * Search for a property in a device node and validate the requested 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  * @len:        requested length of property value
 379  *
 380  * @return the property value on success, -EINVAL if the property does not
 381  * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
 382  * property data isn't large enough.
 383  */
 384 static void *of_find_property_value_of_size(const struct device_node *np,
 385                                             const char *propname, u32 len)
 386 {
 387         struct property *prop = of_find_property(np, propname, NULL);
 388
 389         if (!prop)
 390                 return ERR_PTR(-EINVAL);
 391         if (!prop->value)
 392                 return ERR_PTR(-ENODATA);
 393         if (len > prop->length)
 394                 return ERR_PTR(-EOVERFLOW);
 395
 396         return prop->value;
 397 }
 398
 399 int of_read_u32(const struct device_node *np, const char *propname, u32 *outp)
 400 {
 401         const __be32 *val;
 402
 403         debug("%s: %s: ", __func__, propname);
 404         if (!np)
 405                 return -EINVAL;
 406         val = of_find_property_value_of_size(np, propname, sizeof(*outp));
 407         if (IS_ERR(val)) {
 408                 debug("(not found)\n");
 409                 return PTR_ERR(val);
 410         }
 411
 412         *outp = be32_to_cpup(val);
 413         debug("%#x (%d)\n", *outp, *outp);
 414
 415         return 0;
 416 }
 417
 418 int of_read_u32_array(const struct device_node *np, const char *propname,
 419                       u32 *out_values, size_t sz)
 420 {
 421         const __be32 *val;
 422
 423         debug("%s: %s: ", __func__, propname);
 424         val = of_find_property_value_of_size(np, propname,
 425                                              sz * sizeof(*out_values));
 426
 427         if (IS_ERR(val))
 428                 return PTR_ERR(val);
 429
 430         debug("size %zd\n", sz);
 431         while (sz--)
 432                 *out_values++ = be32_to_cpup(val++);
 433
 434         return 0;
 435 }
 436
 437 int of_property_match_string(const struct device_node *np, const char *propname,
 438                              const char *string)
 439 {
 440         const struct property *prop = of_find_property(np, propname, NULL);
 441         size_t l;
 442         int i;
 443         const char *p, *end;
 444
 445         if (!prop)
 446                 return -EINVAL;
 447         if (!prop->value)
 448                 return -ENODATA;
 449
 450         p = prop->value;
 451         end = p + prop->length;
 452
 453         for (i = 0; p < end; i++, p += l) {
 454                 l = strnlen(p, end - p) + 1;
 455                 if (p + l > end)
 456                         return -EILSEQ;
 457                 debug("comparing %s with %s\n", string, p);
 458                 if (strcmp(string, p) == 0)
 459                         return i; /* Found it; return index */
 460         }
 461         return -ENODATA;
 462 }
 463
 464 /**
 465  * of_property_read_string_helper() - Utility helper for parsing string properties
 466  * @np:         device node from which the property value is to be read.
 467  * @propname:   name of the property to be searched.
 468  * @out_strs:   output array of string pointers.
 469  * @sz:         number of array elements to read.
 470  * @skip:       Number of strings to skip over at beginning of list.
 471  *
 472  * Don't call this function directly. It is a utility helper for the
 473  * of_property_read_string*() family of functions.
 474  */
 475 int of_property_read_string_helper(const struct device_node *np,
 476                                    const char *propname, const char **out_strs,
 477                                    size_t sz, int skip)
 478 {
 479         const struct property *prop = of_find_property(np, propname, NULL);
 480         int l = 0, i = 0;
 481         const char *p, *end;
 482
 483         if (!prop)
 484                 return -EINVAL;
 485         if (!prop->value)
 486                 return -ENODATA;
 487         p = prop->value;
 488         end = p + prop->length;
 489
 490         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
 491                 l = strnlen(p, end - p) + 1;
 492                 if (p + l > end)
 493                         return -EILSEQ;
 494                 if (out_strs && i >= skip)
 495                         *out_strs++ = p;
 496         }
 497         i -= skip;
 498         return i <= 0 ? -ENODATA : i;
 499 }
 500
 501 static int __of_parse_phandle_with_args(const struct device_node *np,
 502                                         const char *list_name,
 503                                         const char *cells_name,
 504                                         int cell_count, int index,
 505                                         struct of_phandle_args *out_args)
 506 {
 507         const __be32 *list, *list_end;
 508         int rc = 0, cur_index = 0;
 509         uint32_t count = 0;
 510         struct device_node *node = NULL;
 511         phandle phandle;
 512         int size;
 513
 514         /* Retrieve the phandle list property */
 515         list = of_get_property(np, list_name, &size);
 516         if (!list)
 517                 return -ENOENT;
 518         list_end = list + size / sizeof(*list);
 519
 520         /* Loop over the phandles until all the requested entry is found */
 521         while (list < list_end) {
 522                 rc = -EINVAL;
 523                 count = 0;
 524
 525                 /*
 526                  * If phandle is 0, then it is an empty entry with no
 527                  * arguments.  Skip forward to the next entry.
 528                  */
 529                 phandle = be32_to_cpup(list++);
 530                 if (phandle) {
 531                         /*
 532                          * Find the provider node and parse the #*-cells
 533                          * property to determine the argument length.
 534                          *
 535                          * This is not needed if the cell count is hard-coded
 536                          * (i.e. cells_name not set, but cell_count is set),
 537                          * except when we're going to return the found node
 538                          * below.
 539                          */
 540                         if (cells_name || cur_index == index) {
 541                                 node = of_find_node_by_phandle(phandle);
 542                                 if (!node) {
 543                                         debug("%s: could not find phandle\n",
 544                                               np->full_name);
 545                                         goto err;
 546                                 }
 547                         }
 548
 549                         if (cells_name) {
 550                                 if (of_read_u32(node, cells_name, &count)) {
 551                                         debug("%s: could not get %s for %s\n",
 552                                               np->full_name, cells_name,
 553                                               node->full_name);
 554                                         goto err;
 555                                 }
 556                         } else {
 557                                 count = cell_count;
 558                         }
 559
 560                         /*
 561                          * Make sure that the arguments actually fit in the
 562                          * remaining property data length
 563                          */
 564                         if (list + count > list_end) {
 565                                 debug("%s: arguments longer than property\n",
 566                                       np->full_name);
 567                                 goto err;
 568                         }
 569                 }
 570
 571                 /*
 572                  * All of the error cases above bail out of the loop, so at
 573                  * this point, the parsing is successful. If the requested
 574                  * index matches, then fill the out_args structure and return,
 575                  * or return -ENOENT for an empty entry.
 576                  */
 577                 rc = -ENOENT;
 578                 if (cur_index == index) {
 579                         if (!phandle)
 580                                 goto err;
 581
 582                         if (out_args) {
 583                                 int i;
 584                                 if (WARN_ON(count > OF_MAX_PHANDLE_ARGS))
 585                                         count = OF_MAX_PHANDLE_ARGS;
 586                                 out_args->np = node;
 587                                 out_args->args_count = count;
 588                                 for (i = 0; i < count; i++)
 589                                         out_args->args[i] =
 590                                                         be32_to_cpup(list++);
 591                         } else {
 592                                 of_node_put(node);
 593                         }
 594
 595                         /* Found it! return success */
 596                         return 0;
 597                 }
 598
 599                 of_node_put(node);
 600                 node = NULL;
 601                 list += count;
 602                 cur_index++;
 603         }
 604
 605         /*
 606          * Unlock node before returning result; will be one of:
 607          * -ENOENT : index is for empty phandle
 608          * -EINVAL : parsing error on data
 609          * [1..n]  : Number of phandle (count mode; when index = -1)
 610          */
 611         rc = index < 0 ? cur_index : -ENOENT;
 612  err:
 613         if (node)
 614                 of_node_put(node);
 615         return rc;
 616 }
 617
 618 struct device_node *of_parse_phandle(const struct device_node *np,
 619                                      const char *phandle_name, int index)
 620 {
 621         struct of_phandle_args args;
 622
 623         if (index < 0)
 624                 return NULL;
 625
 626         if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0, index,
 627                                          &args))
 628                 return NULL;
 629
 630         return args.np;
 631 }
 632
 633 int of_parse_phandle_with_args(const struct device_node *np,
 634                                const char *list_name, const char *cells_name,
 635                                int index, struct of_phandle_args *out_args)
 636 {
 637         if (index < 0)
 638                 return -EINVAL;
 639
 640         return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
 641                                             index, out_args);
 642 }
 643
 644 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
 645                          int id, const char *stem, int stem_len)
 646 {
 647         ap->np = np;
 648         ap->id = id;
 649         strncpy(ap->stem, stem, stem_len);
 650         ap->stem[stem_len] = 0;
 651         list_add_tail(&ap->link, &aliases_lookup);
 652         debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
 653               ap->alias, ap->stem, ap->id, of_node_full_name(np));
 654 }
 655
 656 int of_alias_scan(void)
 657 {
 658         struct property *pp;
 659
 660         of_aliases = of_find_node_by_path("/aliases");
 661         of_chosen = of_find_node_by_path("/chosen");
 662         if (of_chosen == NULL)
 663                 of_chosen = of_find_node_by_path("/chosen@0");
 664
 665         if (of_chosen) {
 666                 const char *name;
 667
 668                 name = of_get_property(of_chosen, "stdout-path", NULL);
 669                 if (name)
 670                         of_stdout = of_find_node_opts_by_path(name,
 671                                                         &of_stdout_options);
 672         }
 673
 674         if (!of_aliases)
 675                 return 0;
 676
 677         for_each_property_of_node(of_aliases, pp) {
 678                 const char *start = pp->name;
 679                 const char *end = start + strlen(start);
 680                 struct device_node *np;
 681                 struct alias_prop *ap;
 682                 ulong id;
 683                 int len;
 684
 685                 /* Skip those we do not want to proceed */
 686                 if (!strcmp(pp->name, "name") ||
 687                     !strcmp(pp->name, "phandle") ||
 688                     !strcmp(pp->name, "linux,phandle"))
 689                         continue;
 690
 691                 np = of_find_node_by_path(pp->value);
 692                 if (!np)
 693                         continue;
 694
 695                 /*
 696                  * walk the alias backwards to extract the id and work out
 697                  * the 'stem' string
 698                  */
 699                 while (isdigit(*(end-1)) && end > start)
 700                         end--;
 701                 len = end - start;
 702
 703                 if (strict_strtoul(end, 10, &id) < 0)
 704                         continue;
 705
 706                 /* Allocate an alias_prop with enough space for the stem */
 707                 ap = malloc(sizeof(*ap) + len + 1);
 708                 if (!ap)
 709                         return -ENOMEM;
 710                 memset(ap, 0, sizeof(*ap) + len + 1);
 711                 ap->alias = start;
 712                 of_alias_add(ap, np, id, start, len);
 713         }
 714
 715         return 0;
 716 }
 717
 718 int of_alias_get_id(const struct device_node *np, const char *stem)
 719 {
 720         struct alias_prop *app;
 721         int id = -ENODEV;
 722
 723         mutex_lock(&of_mutex);
 724         list_for_each_entry(app, &aliases_lookup, link) {
 725                 if (strcmp(app->stem, stem) != 0)
 726                         continue;
 727
 728                 if (np == app->np) {
 729                         id = app->id;
 730                         break;
 731                 }
 732         }
 733         mutex_unlock(&of_mutex);
 734
 735         return id;
 736 }
 737
 738 struct device_node *of_get_stdout(void)
 739 {
 740         return of_stdout;
 741 }