LCOV - code coverage report
Current view: top level - drivers/of - fdt.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 277 439 63.1 %
Date: 2020-09-30 20:25:40 Functions: 32 43 74.4 %
Branches: 147 284 51.8 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Functions for working with the Flattened Device Tree data format
       4                 :            :  *
       5                 :            :  * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
       6                 :            :  * benh@kernel.crashing.org
       7                 :            :  */
       8                 :            : 
       9                 :            : #define pr_fmt(fmt)     "OF: fdt: " fmt
      10                 :            : 
      11                 :            : #include <linux/crc32.h>
      12                 :            : #include <linux/kernel.h>
      13                 :            : #include <linux/initrd.h>
      14                 :            : #include <linux/memblock.h>
      15                 :            : #include <linux/mutex.h>
      16                 :            : #include <linux/of.h>
      17                 :            : #include <linux/of_fdt.h>
      18                 :            : #include <linux/of_reserved_mem.h>
      19                 :            : #include <linux/sizes.h>
      20                 :            : #include <linux/string.h>
      21                 :            : #include <linux/errno.h>
      22                 :            : #include <linux/slab.h>
      23                 :            : #include <linux/libfdt.h>
      24                 :            : #include <linux/debugfs.h>
      25                 :            : #include <linux/serial_core.h>
      26                 :            : #include <linux/sysfs.h>
      27                 :            : #include <linux/random.h>
      28                 :            : 
      29                 :            : #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
      30                 :            : #include <asm/page.h>
      31                 :            : 
      32                 :            : #include "of_private.h"
      33                 :            : 
      34                 :            : /*
      35                 :            :  * of_fdt_limit_memory - limit the number of regions in the /memory node
      36                 :            :  * @limit: maximum entries
      37                 :            :  *
      38                 :            :  * Adjust the flattened device tree to have at most 'limit' number of
      39                 :            :  * memory entries in the /memory node. This function may be called
      40                 :            :  * any time after initial_boot_param is set.
      41                 :            :  */
      42                 :          0 : void __init of_fdt_limit_memory(int limit)
      43                 :            : {
      44                 :            :         int memory;
      45                 :            :         int len;
      46                 :            :         const void *val;
      47                 :            :         int nr_address_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
      48                 :            :         int nr_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
      49                 :            :         const __be32 *addr_prop;
      50                 :            :         const __be32 *size_prop;
      51                 :            :         int root_offset;
      52                 :            :         int cell_size;
      53                 :            : 
      54                 :          0 :         root_offset = fdt_path_offset(initial_boot_params, "/");
      55         [ #  # ]:          0 :         if (root_offset < 0)
      56                 :          0 :                 return;
      57                 :            : 
      58                 :          0 :         addr_prop = fdt_getprop(initial_boot_params, root_offset,
      59                 :            :                                 "#address-cells", NULL);
      60         [ #  # ]:          0 :         if (addr_prop)
      61                 :          0 :                 nr_address_cells = fdt32_to_cpu(*addr_prop);
      62                 :            : 
      63                 :          0 :         size_prop = fdt_getprop(initial_boot_params, root_offset,
      64                 :            :                                 "#size-cells", NULL);
      65         [ #  # ]:          0 :         if (size_prop)
      66                 :          0 :                 nr_size_cells = fdt32_to_cpu(*size_prop);
      67                 :            : 
      68                 :          0 :         cell_size = sizeof(uint32_t)*(nr_address_cells + nr_size_cells);
      69                 :            : 
      70                 :          0 :         memory = fdt_path_offset(initial_boot_params, "/memory");
      71         [ #  # ]:          0 :         if (memory > 0) {
      72                 :          0 :                 val = fdt_getprop(initial_boot_params, memory, "reg", &len);
      73         [ #  # ]:          0 :                 if (len > limit*cell_size) {
      74                 :          0 :                         len = limit*cell_size;
      75                 :            :                         pr_debug("Limiting number of entries to %d\n", limit);
      76                 :          0 :                         fdt_setprop(initial_boot_params, memory, "reg", val,
      77                 :            :                                         len);
      78                 :            :                 }
      79                 :            :         }
      80                 :            : }
      81                 :            : 
      82                 :        207 : static bool of_fdt_device_is_available(const void *blob, unsigned long node)
      83                 :            : {
      84                 :        207 :         const char *status = fdt_getprop(blob, node, "status", NULL);
      85                 :            : 
      86         [ -  + ]:        207 :         if (!status)
      87                 :            :                 return true;
      88                 :            : 
      89   [ #  #  #  # ]:          0 :         if (!strcmp(status, "ok") || !strcmp(status, "okay"))
      90                 :            :                 return true;
      91                 :            : 
      92                 :          0 :         return false;
      93                 :            : }
      94                 :            : 
      95                 :            : static void *unflatten_dt_alloc(void **mem, unsigned long size,
      96                 :            :                                        unsigned long align)
      97                 :            : {
      98                 :            :         void *res;
      99                 :            : 
     100                 :     477756 :         *mem = PTR_ALIGN(*mem, align);
     101                 :            :         res = *mem;
     102                 :     477756 :         *mem += size;
     103                 :            : 
     104                 :            :         return res;
     105                 :            : }
     106                 :            : 
     107                 :      58374 : static void populate_properties(const void *blob,
     108                 :            :                                 int offset,
     109                 :            :                                 void **mem,
     110                 :            :                                 struct device_node *np,
     111                 :            :                                 const char *nodename,
     112                 :            :                                 bool dryrun)
     113                 :            : {
     114                 :            :         struct property *pp, **pprev = NULL;
     115                 :            :         int cur;
     116                 :            :         bool has_name = false;
     117                 :            : 
     118                 :      58374 :         pprev = &np->properties;
     119         [ +  + ]:     477756 :         for (cur = fdt_first_property_offset(blob, offset);
     120                 :            :              cur >= 0;
     121                 :     361008 :              cur = fdt_next_property_offset(blob, cur)) {
     122                 :            :                 const __be32 *val;
     123                 :            :                 const char *pname;
     124                 :            :                 u32 sz;
     125                 :            : 
     126                 :     361008 :                 val = fdt_getprop_by_offset(blob, cur, &pname, &sz);
     127         [ -  + ]:     361008 :                 if (!val) {
     128                 :          0 :                         pr_warn("Cannot locate property at 0x%x\n", cur);
     129                 :     180504 :                         continue;
     130                 :            :                 }
     131                 :            : 
     132         [ -  + ]:     361008 :                 if (!pname) {
     133                 :          0 :                         pr_warn("Cannot find property name at 0x%x\n", cur);
     134                 :          0 :                         continue;
     135                 :            :                 }
     136                 :            : 
     137         [ -  + ]:     361008 :                 if (!strcmp(pname, "name"))
     138                 :            :                         has_name = true;
     139                 :            : 
     140                 :            :                 pp = unflatten_dt_alloc(mem, sizeof(struct property),
     141                 :            :                                         __alignof__(struct property));
     142         [ +  + ]:     361008 :                 if (dryrun)
     143                 :     180504 :                         continue;
     144                 :            : 
     145                 :            :                 /* We accept flattened tree phandles either in
     146                 :            :                  * ePAPR-style "phandle" properties, or the
     147                 :            :                  * legacy "linux,phandle" properties.  If both
     148                 :            :                  * appear and have different values, things
     149                 :            :                  * will get weird. Don't do that.
     150                 :            :                  */
     151   [ +  +  -  + ]:     335133 :                 if (!strcmp(pname, "phandle") ||
     152                 :     154629 :                     !strcmp(pname, "linux,phandle")) {
     153         [ +  - ]:      25875 :                         if (!np->phandle)
     154                 :      25875 :                                 np->phandle = be32_to_cpup(val);
     155                 :            :                 }
     156                 :            : 
     157                 :            :                 /* And we process the "ibm,phandle" property
     158                 :            :                  * used in pSeries dynamic device tree
     159                 :            :                  * stuff
     160                 :            :                  */
     161         [ -  + ]:     180504 :                 if (!strcmp(pname, "ibm,phandle"))
     162                 :          0 :                         np->phandle = be32_to_cpup(val);
     163                 :            : 
     164                 :     180504 :                 pp->name   = (char *)pname;
     165                 :     180504 :                 pp->length = sz;
     166                 :     180504 :                 pp->value  = (__be32 *)val;
     167                 :     180504 :                 *pprev     = pp;
     168                 :     180504 :                 pprev      = &pp->next;
     169                 :            :         }
     170                 :            : 
     171                 :            :         /* With version 0x10 we may not have the name property,
     172                 :            :          * recreate it here from the unit name if absent
     173                 :            :          */
     174         [ +  - ]:      58374 :         if (!has_name) {
     175                 :            :                 const char *p = nodename, *ps = p, *pa = NULL;
     176                 :            :                 int len;
     177                 :            : 
     178         [ +  + ]:     685170 :                 while (*p) {
     179         [ +  + ]:     626796 :                         if ((*p) == '@')
     180                 :            :                                 pa = p;
     181         [ -  + ]:     605682 :                         else if ((*p) == '/')
     182                 :          0 :                                 ps = p + 1;
     183                 :     626796 :                         p++;
     184                 :            :                 }
     185                 :            : 
     186         [ +  + ]:      58374 :                 if (pa < ps)
     187                 :      37260 :                         pa = p;
     188                 :      58374 :                 len = (pa - ps) + 1;
     189                 :      58374 :                 pp = unflatten_dt_alloc(mem, sizeof(struct property) + len,
     190                 :            :                                         __alignof__(struct property));
     191         [ +  + ]:      58374 :                 if (!dryrun) {
     192                 :      29187 :                         pp->name   = "name";
     193                 :      29187 :                         pp->length = len;
     194                 :      29187 :                         pp->value  = pp + 1;
     195                 :      29187 :                         *pprev     = pp;
     196                 :      29187 :                         pprev      = &pp->next;
     197                 :      29187 :                         memcpy(pp->value, ps, len - 1);
     198                 :      29187 :                         ((char *)pp->value)[len - 1] = 0;
     199                 :            :                         pr_debug("fixed up name for %s -> %s\n",
     200                 :            :                                  nodename, (char *)pp->value);
     201                 :            :                 }
     202                 :            :         }
     203                 :            : 
     204         [ +  + ]:      58374 :         if (!dryrun)
     205                 :      29187 :                 *pprev = NULL;
     206                 :      58374 : }
     207                 :            : 
     208                 :      58374 : static bool populate_node(const void *blob,
     209                 :            :                           int offset,
     210                 :            :                           void **mem,
     211                 :            :                           struct device_node *dad,
     212                 :            :                           struct device_node **pnp,
     213                 :            :                           bool dryrun)
     214                 :            : {
     215                 :            :         struct device_node *np;
     216                 :            :         const char *pathp;
     217                 :            :         unsigned int l, allocl;
     218                 :            : 
     219                 :      58374 :         pathp = fdt_get_name(blob, offset, &l);
     220         [ -  + ]:      58374 :         if (!pathp) {
     221                 :          0 :                 *pnp = NULL;
     222                 :          0 :                 return false;
     223                 :            :         }
     224                 :            : 
     225                 :      58374 :         allocl = ++l;
     226                 :            : 
     227                 :      58374 :         np = unflatten_dt_alloc(mem, sizeof(struct device_node) + allocl,
     228                 :            :                                 __alignof__(struct device_node));
     229         [ +  + ]:      58374 :         if (!dryrun) {
     230                 :            :                 char *fn;
     231                 :            :                 of_node_init(np);
     232                 :      29187 :                 np->full_name = fn = ((char *)np) + sizeof(*np);
     233                 :            : 
     234                 :      29187 :                 memcpy(fn, pathp, l);
     235                 :            : 
     236         [ +  + ]:      29187 :                 if (dad != NULL) {
     237                 :      28980 :                         np->parent = dad;
     238                 :      28980 :                         np->sibling = dad->child;
     239                 :      28980 :                         dad->child = np;
     240                 :            :                 }
     241                 :            :         }
     242                 :            : 
     243                 :      58374 :         populate_properties(blob, offset, mem, np, pathp, dryrun);
     244         [ +  + ]:      58374 :         if (!dryrun) {
     245                 :      29187 :                 np->name = of_get_property(np, "name", NULL);
     246         [ -  + ]:      29187 :                 if (!np->name)
     247                 :          0 :                         np->name = "<NULL>";
     248                 :            :         }
     249                 :            : 
     250                 :      58374 :         *pnp = np;
     251                 :      58374 :         return true;
     252                 :            : }
     253                 :            : 
     254                 :      29187 : static void reverse_nodes(struct device_node *parent)
     255                 :            : {
     256                 :            :         struct device_node *child, *next;
     257                 :            : 
     258                 :            :         /* In-depth first */
     259                 :      29187 :         child = parent->child;
     260         [ +  + ]:      87354 :         while (child) {
     261                 :      28980 :                 reverse_nodes(child);
     262                 :            : 
     263                 :      28980 :                 child = child->sibling;
     264                 :            :         }
     265                 :            : 
     266                 :            :         /* Reverse the nodes in the child list */
     267                 :      29187 :         child = parent->child;
     268                 :      29187 :         parent->child = NULL;
     269         [ +  + ]:      87354 :         while (child) {
     270                 :      28980 :                 next = child->sibling;
     271                 :            : 
     272                 :      28980 :                 child->sibling = parent->child;
     273                 :      28980 :                 parent->child = child;
     274                 :            :                 child = next;
     275                 :            :         }
     276                 :      29187 : }
     277                 :            : 
     278                 :            : /**
     279                 :            :  * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree
     280                 :            :  * @blob: The parent device tree blob
     281                 :            :  * @mem: Memory chunk to use for allocating device nodes and properties
     282                 :            :  * @dad: Parent struct device_node
     283                 :            :  * @nodepp: The device_node tree created by the call
     284                 :            :  *
     285                 :            :  * It returns the size of unflattened device tree or error code
     286                 :            :  */
     287                 :        414 : static int unflatten_dt_nodes(const void *blob,
     288                 :            :                               void *mem,
     289                 :            :                               struct device_node *dad,
     290                 :            :                               struct device_node **nodepp)
     291                 :            : {
     292                 :            :         struct device_node *root;
     293                 :        414 :         int offset = 0, depth = 0, initial_depth = 0;
     294                 :            : #define FDT_MAX_DEPTH   64
     295                 :            :         struct device_node *nps[FDT_MAX_DEPTH];
     296                 :        414 :         void *base = mem;
     297                 :        414 :         bool dryrun = !base;
     298                 :            : 
     299         [ +  + ]:        414 :         if (nodepp)
     300                 :        207 :                 *nodepp = NULL;
     301                 :            : 
     302                 :            :         /*
     303                 :            :          * We're unflattening device sub-tree if @dad is valid. There are
     304                 :            :          * possibly multiple nodes in the first level of depth. We need
     305                 :            :          * set @depth to 1 to make fdt_next_node() happy as it bails
     306                 :            :          * immediately when negative @depth is found. Otherwise, the device
     307                 :            :          * nodes except the first one won't be unflattened successfully.
     308                 :            :          */
     309         [ -  + ]:        414 :         if (dad)
     310                 :          0 :                 depth = initial_depth = 1;
     311                 :            : 
     312                 :            :         root = dad;
     313                 :        414 :         nps[depth] = dad;
     314                 :            : 
     315         [ +  + ]:      59202 :         for (offset = 0;
     316                 :      58788 :              offset >= 0 && depth >= initial_depth;
     317                 :      58374 :              offset = fdt_next_node(blob, offset, &depth)) {
     318   [ -  +  #  #  :      58374 :                 if (WARN_ON_ONCE(depth >= FDT_MAX_DEPTH))
                   -  + ]
     319                 :          0 :                         continue;
     320                 :            : 
     321                 :            :                 if (!IS_ENABLED(CONFIG_OF_KOBJ) &&
     322                 :            :                     !of_fdt_device_is_available(blob, offset))
     323                 :            :                         continue;
     324                 :            : 
     325         [ -  + ]:     116748 :                 if (!populate_node(blob, offset, &mem, nps[depth],
     326                 :      58374 :                                    &nps[depth+1], dryrun))
     327                 :          0 :                         return mem - base;
     328                 :            : 
     329   [ +  +  +  + ]:      58374 :                 if (!dryrun && nodepp && !*nodepp)
     330                 :        207 :                         *nodepp = nps[depth+1];
     331         [ +  + ]:      58374 :                 if (!dryrun && !root)
     332                 :        207 :                         root = nps[depth+1];
     333                 :            :         }
     334                 :            : 
     335         [ -  + ]:        414 :         if (offset < 0 && offset != -FDT_ERR_NOTFOUND) {
     336                 :          0 :                 pr_err("Error %d processing FDT\n", offset);
     337                 :          0 :                 return -EINVAL;
     338                 :            :         }
     339                 :            : 
     340                 :            :         /*
     341                 :            :          * Reverse the child list. Some drivers assumes node order matches .dts
     342                 :            :          * node order
     343                 :            :          */
     344         [ +  + ]:        414 :         if (!dryrun)
     345                 :        207 :                 reverse_nodes(root);
     346                 :            : 
     347                 :        414 :         return mem - base;
     348                 :            : }
     349                 :            : 
     350                 :            : /**
     351                 :            :  * __unflatten_device_tree - create tree of device_nodes from flat blob
     352                 :            :  *
     353                 :            :  * unflattens a device-tree, creating the
     354                 :            :  * tree of struct device_node. It also fills the "name" and "type"
     355                 :            :  * pointers of the nodes so the normal device-tree walking functions
     356                 :            :  * can be used.
     357                 :            :  * @blob: The blob to expand
     358                 :            :  * @dad: Parent device node
     359                 :            :  * @mynodes: The device_node tree created by the call
     360                 :            :  * @dt_alloc: An allocator that provides a virtual address to memory
     361                 :            :  * for the resulting tree
     362                 :            :  * @detached: if true set OF_DETACHED on @mynodes
     363                 :            :  *
     364                 :            :  * Returns NULL on failure or the memory chunk containing the unflattened
     365                 :            :  * device tree on success.
     366                 :            :  */
     367                 :        207 : void *__unflatten_device_tree(const void *blob,
     368                 :            :                               struct device_node *dad,
     369                 :            :                               struct device_node **mynodes,
     370                 :            :                               void *(*dt_alloc)(u64 size, u64 align),
     371                 :            :                               bool detached)
     372                 :            : {
     373                 :            :         int size;
     374                 :            :         void *mem;
     375                 :            : 
     376                 :            :         pr_debug(" -> unflatten_device_tree()\n");
     377                 :            : 
     378         [ +  - ]:        207 :         if (!blob) {
     379                 :            :                 pr_debug("No device tree pointer\n");
     380                 :            :                 return NULL;
     381                 :            :         }
     382                 :            : 
     383                 :            :         pr_debug("Unflattening device tree:\n");
     384                 :            :         pr_debug("magic: %08x\n", fdt_magic(blob));
     385                 :            :         pr_debug("size: %08x\n", fdt_totalsize(blob));
     386                 :            :         pr_debug("version: %08x\n", fdt_version(blob));
     387                 :            : 
     388         [ -  + ]:        207 :         if (fdt_check_header(blob)) {
     389                 :          0 :                 pr_err("Invalid device tree blob header\n");
     390                 :          0 :                 return NULL;
     391                 :            :         }
     392                 :            : 
     393                 :            :         /* First pass, scan for size */
     394                 :        207 :         size = unflatten_dt_nodes(blob, NULL, dad, NULL);
     395         [ +  - ]:        207 :         if (size < 0)
     396                 :            :                 return NULL;
     397                 :            : 
     398                 :        207 :         size = ALIGN(size, 4);
     399                 :            :         pr_debug("  size is %d, allocating...\n", size);
     400                 :            : 
     401                 :            :         /* Allocate memory for the expanded device tree */
     402                 :        207 :         mem = dt_alloc(size + 4, __alignof__(struct device_node));
     403         [ +  - ]:        207 :         if (!mem)
     404                 :            :                 return NULL;
     405                 :            : 
     406                 :        207 :         memset(mem, 0, size);
     407                 :            : 
     408                 :        207 :         *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
     409                 :            : 
     410                 :            :         pr_debug("  unflattening %p...\n", mem);
     411                 :            : 
     412                 :            :         /* Second pass, do actual unflattening */
     413                 :        207 :         unflatten_dt_nodes(blob, mem, dad, mynodes);
     414         [ -  + ]:        207 :         if (be32_to_cpup(mem + size) != 0xdeadbeef)
     415                 :          0 :                 pr_warning("End of tree marker overwritten: %08x\n",
     416                 :            :                            be32_to_cpup(mem + size));
     417                 :            : 
     418         [ -  + ]:        207 :         if (detached && mynodes) {
     419                 :          0 :                 of_node_set_flag(*mynodes, OF_DETACHED);
     420                 :            :                 pr_debug("unflattened tree is detached\n");
     421                 :            :         }
     422                 :            : 
     423                 :            :         pr_debug(" <- unflatten_device_tree()\n");
     424                 :        207 :         return mem;
     425                 :            : }
     426                 :            : 
     427                 :          0 : static void *kernel_tree_alloc(u64 size, u64 align)
     428                 :            : {
     429                 :          0 :         return kzalloc(size, GFP_KERNEL);
     430                 :            : }
     431                 :            : 
     432                 :            : static DEFINE_MUTEX(of_fdt_unflatten_mutex);
     433                 :            : 
     434                 :            : /**
     435                 :            :  * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
     436                 :            :  * @blob: Flat device tree blob
     437                 :            :  * @dad: Parent device node
     438                 :            :  * @mynodes: The device tree created by the call
     439                 :            :  *
     440                 :            :  * unflattens the device-tree passed by the firmware, creating the
     441                 :            :  * tree of struct device_node. It also fills the "name" and "type"
     442                 :            :  * pointers of the nodes so the normal device-tree walking functions
     443                 :            :  * can be used.
     444                 :            :  *
     445                 :            :  * Returns NULL on failure or the memory chunk containing the unflattened
     446                 :            :  * device tree on success.
     447                 :            :  */
     448                 :          0 : void *of_fdt_unflatten_tree(const unsigned long *blob,
     449                 :            :                             struct device_node *dad,
     450                 :            :                             struct device_node **mynodes)
     451                 :            : {
     452                 :            :         void *mem;
     453                 :            : 
     454                 :          0 :         mutex_lock(&of_fdt_unflatten_mutex);
     455                 :          0 :         mem = __unflatten_device_tree(blob, dad, mynodes, &kernel_tree_alloc,
     456                 :            :                                       true);
     457                 :          0 :         mutex_unlock(&of_fdt_unflatten_mutex);
     458                 :            : 
     459                 :          0 :         return mem;
     460                 :            : }
     461                 :            : EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
     462                 :            : 
     463                 :            : /* Everything below here references initial_boot_params directly. */
     464                 :            : int __initdata dt_root_addr_cells;
     465                 :            : int __initdata dt_root_size_cells;
     466                 :            : 
     467                 :            : void *initial_boot_params __ro_after_init;
     468                 :            : 
     469                 :            : #ifdef CONFIG_OF_EARLY_FLATTREE
     470                 :            : 
     471                 :            : static u32 of_fdt_crc32;
     472                 :            : 
     473                 :            : /**
     474                 :            :  * res_mem_reserve_reg() - reserve all memory described in 'reg' property
     475                 :            :  */
     476                 :        207 : static int __init __reserved_mem_reserve_reg(unsigned long node,
     477                 :            :                                              const char *uname)
     478                 :            : {
     479                 :        207 :         int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
     480                 :            :         phys_addr_t base, size;
     481                 :            :         int len;
     482                 :            :         const __be32 *prop;
     483                 :            :         int first = 1;
     484                 :            :         bool nomap;
     485                 :            : 
     486                 :        207 :         prop = of_get_flat_dt_prop(node, "reg", &len);
     487         [ -  + ]:        207 :         if (!prop)
     488                 :            :                 return -ENOENT;
     489                 :            : 
     490   [ #  #  #  # ]:          0 :         if (len && len % t_len != 0) {
     491                 :          0 :                 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
     492                 :            :                        uname);
     493                 :          0 :                 return -EINVAL;
     494                 :            :         }
     495                 :            : 
     496                 :          0 :         nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
     497                 :            : 
     498         [ #  # ]:          0 :         while (len >= t_len) {
     499                 :          0 :                 base = dt_mem_next_cell(dt_root_addr_cells, &prop);
     500                 :          0 :                 size = dt_mem_next_cell(dt_root_size_cells, &prop);
     501                 :            : 
     502   [ #  #  #  # ]:          0 :                 if (size &&
     503                 :          0 :                     early_init_dt_reserve_memory_arch(base, size, nomap) == 0)
     504                 :            :                         pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
     505                 :            :                                 uname, &base, (unsigned long)size / SZ_1M);
     506                 :            :                 else
     507                 :          0 :                         pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
     508                 :            :                                 uname, &base, (unsigned long)size / SZ_1M);
     509                 :            : 
     510                 :          0 :                 len -= t_len;
     511         [ #  # ]:          0 :                 if (first) {
     512                 :          0 :                         fdt_reserved_mem_save_node(node, uname, base, size);
     513                 :            :                         first = 0;
     514                 :            :                 }
     515                 :            :         }
     516                 :            :         return 0;
     517                 :            : }
     518                 :            : 
     519                 :            : /**
     520                 :            :  * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
     521                 :            :  * in /reserved-memory matches the values supported by the current implementation,
     522                 :            :  * also check if ranges property has been provided
     523                 :            :  */
     524                 :        207 : static int __init __reserved_mem_check_root(unsigned long node)
     525                 :            : {
     526                 :            :         const __be32 *prop;
     527                 :            : 
     528                 :        207 :         prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
     529   [ +  -  +  - ]:        414 :         if (!prop || be32_to_cpup(prop) != dt_root_size_cells)
     530                 :            :                 return -EINVAL;
     531                 :            : 
     532                 :        207 :         prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
     533   [ +  -  +  - ]:        414 :         if (!prop || be32_to_cpup(prop) != dt_root_addr_cells)
     534                 :            :                 return -EINVAL;
     535                 :            : 
     536                 :        207 :         prop = of_get_flat_dt_prop(node, "ranges", NULL);
     537         [ +  - ]:        207 :         if (!prop)
     538                 :            :                 return -EINVAL;
     539                 :        207 :         return 0;
     540                 :            : }
     541                 :            : 
     542                 :            : /**
     543                 :            :  * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
     544                 :            :  */
     545                 :       1863 : static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname,
     546                 :            :                                           int depth, void *data)
     547                 :            : {
     548                 :            :         static int found;
     549                 :            :         int err;
     550                 :            : 
     551   [ +  +  +  +  :       1863 :         if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
                   +  + ]
     552         [ -  + ]:        207 :                 if (__reserved_mem_check_root(node) != 0) {
     553                 :          0 :                         pr_err("Reserved memory: unsupported node format, ignoring\n");
     554                 :            :                         /* break scan */
     555                 :          0 :                         return 1;
     556                 :            :                 }
     557                 :        207 :                 found = 1;
     558                 :            :                 /* scan next node */
     559                 :        207 :                 return 0;
     560         [ +  + ]:       1656 :         } else if (!found) {
     561                 :            :                 /* scan next node */
     562                 :            :                 return 0;
     563   [ +  -  +  + ]:        414 :         } else if (found && depth < 2) {
     564                 :            :                 /* scanning of /reserved-memory has been finished */
     565                 :            :                 return 1;
     566                 :            :         }
     567                 :            : 
     568         [ +  - ]:        207 :         if (!of_fdt_device_is_available(initial_boot_params, node))
     569                 :            :                 return 0;
     570                 :            : 
     571                 :        207 :         err = __reserved_mem_reserve_reg(node, uname);
     572   [ +  -  +  - ]:        207 :         if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
     573                 :        207 :                 fdt_reserved_mem_save_node(node, uname, 0, 0);
     574                 :            : 
     575                 :            :         /* scan next node */
     576                 :            :         return 0;
     577                 :            : }
     578                 :            : 
     579                 :            : /**
     580                 :            :  * early_init_fdt_scan_reserved_mem() - create reserved memory regions
     581                 :            :  *
     582                 :            :  * This function grabs memory from early allocator for device exclusive use
     583                 :            :  * defined in device tree structures. It should be called by arch specific code
     584                 :            :  * once the early allocator (i.e. memblock) has been fully activated.
     585                 :            :  */
     586                 :        207 : void __init early_init_fdt_scan_reserved_mem(void)
     587                 :            : {
     588                 :            :         int n;
     589                 :            :         u64 base, size;
     590                 :            : 
     591         [ +  - ]:        207 :         if (!initial_boot_params)
     592                 :          0 :                 return;
     593                 :            : 
     594                 :            :         /* Process header /memreserve/ fields */
     595                 :        207 :         for (n = 0; ; n++) {
     596                 :        414 :                 fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
     597         [ +  + ]:        414 :                 if (!size)
     598                 :            :                         break;
     599                 :        207 :                 early_init_dt_reserve_memory_arch(base, size, false);
     600                 :        207 :         }
     601                 :            : 
     602                 :        207 :         of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
     603                 :        207 :         fdt_init_reserved_mem();
     604                 :            : }
     605                 :            : 
     606                 :            : /**
     607                 :            :  * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
     608                 :            :  */
     609                 :        207 : void __init early_init_fdt_reserve_self(void)
     610                 :            : {
     611         [ +  - ]:        207 :         if (!initial_boot_params)
     612                 :        207 :                 return;
     613                 :            : 
     614                 :            :         /* Reserve the dtb region */
     615                 :        414 :         early_init_dt_reserve_memory_arch(__pa(initial_boot_params),
     616                 :            :                                           fdt_totalsize(initial_boot_params),
     617                 :            :                                           false);
     618                 :            : }
     619                 :            : 
     620                 :            : /**
     621                 :            :  * of_scan_flat_dt - scan flattened tree blob and call callback on each.
     622                 :            :  * @it: callback function
     623                 :            :  * @data: context data pointer
     624                 :            :  *
     625                 :            :  * This function is used to scan the flattened device-tree, it is
     626                 :            :  * used to extract the memory information at boot before we can
     627                 :            :  * unflatten the tree
     628                 :            :  */
     629                 :       1035 : int __init of_scan_flat_dt(int (*it)(unsigned long node,
     630                 :            :                                      const char *uname, int depth,
     631                 :            :                                      void *data),
     632                 :            :                            void *data)
     633                 :            : {
     634                 :       1035 :         const void *blob = initial_boot_params;
     635                 :            :         const char *pathp;
     636                 :       1035 :         int offset, rc = 0, depth = -1;
     637                 :            : 
     638         [ +  - ]:       1035 :         if (!blob)
     639                 :            :                 return 0;
     640                 :            : 
     641         [ +  - ]:      53613 :         for (offset = fdt_next_node(blob, -1, &depth);
     642   [ +  +  +  + ]:      52578 :              offset >= 0 && depth >= 0 && !rc;
     643                 :      51543 :              offset = fdt_next_node(blob, offset, &depth)) {
     644                 :            : 
     645                 :      51543 :                 pathp = fdt_get_name(blob, offset, NULL);
     646         [ -  + ]:      51543 :                 if (*pathp == '/')
     647                 :            :                         pathp = kbasename(pathp);
     648                 :      51543 :                 rc = it(offset, pathp, depth, data);
     649                 :            :         }
     650                 :       1035 :         return rc;
     651                 :            : }
     652                 :            : 
     653                 :            : /**
     654                 :            :  * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
     655                 :            :  * @it: callback function
     656                 :            :  * @data: context data pointer
     657                 :            :  *
     658                 :            :  * This function is used to scan sub-nodes of a node.
     659                 :            :  */
     660                 :          0 : int __init of_scan_flat_dt_subnodes(unsigned long parent,
     661                 :            :                                     int (*it)(unsigned long node,
     662                 :            :                                               const char *uname,
     663                 :            :                                               void *data),
     664                 :            :                                     void *data)
     665                 :            : {
     666                 :          0 :         const void *blob = initial_boot_params;
     667                 :            :         int node;
     668                 :            : 
     669         [ #  # ]:          0 :         fdt_for_each_subnode(node, blob, parent) {
     670                 :            :                 const char *pathp;
     671                 :            :                 int rc;
     672                 :            : 
     673                 :          0 :                 pathp = fdt_get_name(blob, node, NULL);
     674         [ #  # ]:          0 :                 if (*pathp == '/')
     675                 :            :                         pathp = kbasename(pathp);
     676                 :          0 :                 rc = it(node, pathp, data);
     677         [ #  # ]:          0 :                 if (rc)
     678                 :          0 :                         return rc;
     679                 :            :         }
     680                 :            :         return 0;
     681                 :            : }
     682                 :            : 
     683                 :            : /**
     684                 :            :  * of_get_flat_dt_subnode_by_name - get the subnode by given name
     685                 :            :  *
     686                 :            :  * @node: the parent node
     687                 :            :  * @uname: the name of subnode
     688                 :            :  * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
     689                 :            :  */
     690                 :            : 
     691                 :        207 : int __init of_get_flat_dt_subnode_by_name(unsigned long node, const char *uname)
     692                 :            : {
     693                 :        207 :         return fdt_subnode_offset(initial_boot_params, node, uname);
     694                 :            : }
     695                 :            : 
     696                 :            : /**
     697                 :            :  * of_get_flat_dt_root - find the root node in the flat blob
     698                 :            :  */
     699                 :        207 : unsigned long __init of_get_flat_dt_root(void)
     700                 :            : {
     701                 :        207 :         return 0;
     702                 :            : }
     703                 :            : 
     704                 :            : /**
     705                 :            :  * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
     706                 :            :  *
     707                 :            :  * This function can be used within scan_flattened_dt callback to get
     708                 :            :  * access to properties
     709                 :            :  */
     710                 :      34983 : const void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
     711                 :            :                                        int *size)
     712                 :            : {
     713                 :      34983 :         return fdt_getprop(initial_boot_params, node, name, size);
     714                 :            : }
     715                 :            : 
     716                 :            : /**
     717                 :            :  * of_fdt_is_compatible - Return true if given node from the given blob has
     718                 :            :  * compat in its compatible list
     719                 :            :  * @blob: A device tree blob
     720                 :            :  * @node: node to test
     721                 :            :  * @compat: compatible string to compare with compatible list.
     722                 :            :  *
     723                 :            :  * On match, returns a non-zero value with smaller values returned for more
     724                 :            :  * specific compatible values.
     725                 :            :  */
     726                 :      20079 : static int of_fdt_is_compatible(const void *blob,
     727                 :            :                       unsigned long node, const char *compat)
     728                 :            : {
     729                 :            :         const char *cp;
     730                 :            :         int cplen;
     731                 :            :         unsigned long l, score = 0;
     732                 :            : 
     733                 :      20079 :         cp = fdt_getprop(blob, node, "compatible", &cplen);
     734         [ +  + ]:      20079 :         if (cp == NULL)
     735                 :            :                 return 0;
     736         [ +  + ]:      13869 :         while (cplen > 0) {
     737                 :       7866 :                 score++;
     738         [ +  + ]:       7866 :                 if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
     739                 :        828 :                         return score;
     740                 :       7038 :                 l = strlen(cp) + 1;
     741                 :       7038 :                 cp += l;
     742                 :       7038 :                 cplen -= l;
     743                 :            :         }
     744                 :            : 
     745                 :            :         return 0;
     746                 :            : }
     747                 :            : 
     748                 :            : /**
     749                 :            :  * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
     750                 :            :  * @node: node to test
     751                 :            :  * @compat: compatible string to compare with compatible list.
     752                 :            :  */
     753                 :      19458 : int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
     754                 :            : {
     755                 :      19458 :         return of_fdt_is_compatible(initial_boot_params, node, compat);
     756                 :            : }
     757                 :            : 
     758                 :            : /**
     759                 :            :  * of_flat_dt_match - Return true if node matches a list of compatible values
     760                 :            :  */
     761                 :        621 : static int __init of_flat_dt_match(unsigned long node, const char *const *compat)
     762                 :            : {
     763                 :            :         unsigned int tmp, score = 0;
     764                 :            : 
     765         [ +  + ]:        621 :         if (!compat)
     766                 :            :                 return 0;
     767                 :            : 
     768         [ +  + ]:       1035 :         while (*compat) {
     769                 :        621 :                 tmp = of_fdt_is_compatible(initial_boot_params, node, *compat);
     770   [ +  +  +  - ]:        621 :                 if (tmp && (score == 0 || (tmp < score)))
     771                 :            :                         score = tmp;
     772                 :        621 :                 compat++;
     773                 :            :         }
     774                 :            : 
     775                 :        414 :         return score;
     776                 :            : }
     777                 :            : 
     778                 :            : /**
     779                 :            :  * of_get_flat_dt_prop - Given a node in the flat blob, return the phandle
     780                 :            :  */
     781                 :          0 : uint32_t __init of_get_flat_dt_phandle(unsigned long node)
     782                 :            : {
     783                 :          0 :         return fdt_get_phandle(initial_boot_params, node);
     784                 :            : }
     785                 :            : 
     786                 :            : struct fdt_scan_status {
     787                 :            :         const char *name;
     788                 :            :         int namelen;
     789                 :            :         int depth;
     790                 :            :         int found;
     791                 :            :         int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
     792                 :            :         void *data;
     793                 :            : };
     794                 :            : 
     795                 :        207 : const char * __init of_flat_dt_get_machine_name(void)
     796                 :            : {
     797                 :            :         const char *name;
     798                 :            :         unsigned long dt_root = of_get_flat_dt_root();
     799                 :            : 
     800                 :        207 :         name = of_get_flat_dt_prop(dt_root, "model", NULL);
     801         [ -  + ]:        207 :         if (!name)
     802                 :          0 :                 name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
     803                 :        207 :         return name;
     804                 :            : }
     805                 :            : 
     806                 :            : /**
     807                 :            :  * of_flat_dt_match_machine - Iterate match tables to find matching machine.
     808                 :            :  *
     809                 :            :  * @default_match: A machine specific ptr to return in case of no match.
     810                 :            :  * @get_next_compat: callback function to return next compatible match table.
     811                 :            :  *
     812                 :            :  * Iterate through machine match tables to find the best match for the machine
     813                 :            :  * compatible string in the FDT.
     814                 :            :  */
     815                 :        207 : const void * __init of_flat_dt_match_machine(const void *default_match,
     816                 :            :                 const void * (*get_next_compat)(const char * const**))
     817                 :            : {
     818                 :            :         const void *data = NULL;
     819                 :            :         const void *best_data = default_match;
     820                 :            :         const char *const *compat;
     821                 :            :         unsigned long dt_root;
     822                 :            :         unsigned int best_score = ~1, score = 0;
     823                 :            : 
     824                 :            :         dt_root = of_get_flat_dt_root();
     825         [ +  + ]:       1035 :         while ((data = get_next_compat(&compat))) {
     826                 :        621 :                 score = of_flat_dt_match(dt_root, compat);
     827         [ +  + ]:        621 :                 if (score > 0 && score < best_score) {
     828                 :            :                         best_data = data;
     829                 :            :                         best_score = score;
     830                 :            :                 }
     831                 :            :         }
     832         [ -  + ]:        207 :         if (!best_data) {
     833                 :            :                 const char *prop;
     834                 :            :                 int size;
     835                 :            : 
     836                 :          0 :                 pr_err("\n unrecognized device tree list:\n[ ");
     837                 :            : 
     838                 :          0 :                 prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
     839         [ #  # ]:          0 :                 if (prop) {
     840         [ #  # ]:          0 :                         while (size > 0) {
     841                 :          0 :                                 printk("'%s' ", prop);
     842                 :          0 :                                 size -= strlen(prop) + 1;
     843                 :          0 :                                 prop += strlen(prop) + 1;
     844                 :            :                         }
     845                 :            :                 }
     846                 :          0 :                 printk("]\n\n");
     847                 :            :                 return NULL;
     848                 :            :         }
     849                 :            : 
     850                 :        207 :         pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
     851                 :            : 
     852                 :        207 :         return best_data;
     853                 :            : }
     854                 :            : 
     855                 :            : #ifdef CONFIG_BLK_DEV_INITRD
     856                 :          0 : static void __early_init_dt_declare_initrd(unsigned long start,
     857                 :            :                                            unsigned long end)
     858                 :            : {
     859                 :            :         /* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
     860                 :            :          * enabled since __va() is called too early. ARM64 does make use
     861                 :            :          * of phys_initrd_start/phys_initrd_size so we can skip this
     862                 :            :          * conversion.
     863                 :            :          */
     864                 :            :         if (!IS_ENABLED(CONFIG_ARM64)) {
     865                 :          0 :                 initrd_start = (unsigned long)__va(start);
     866                 :          0 :                 initrd_end = (unsigned long)__va(end);
     867                 :          0 :                 initrd_below_start_ok = 1;
     868                 :            :         }
     869                 :          0 : }
     870                 :            : 
     871                 :            : /**
     872                 :            :  * early_init_dt_check_for_initrd - Decode initrd location from flat tree
     873                 :            :  * @node: reference to node containing initrd location ('chosen')
     874                 :            :  */
     875                 :        207 : static void __init early_init_dt_check_for_initrd(unsigned long node)
     876                 :            : {
     877                 :            :         u64 start, end;
     878                 :            :         int len;
     879                 :            :         const __be32 *prop;
     880                 :            : 
     881                 :            :         pr_debug("Looking for initrd properties... ");
     882                 :            : 
     883                 :        207 :         prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
     884         [ -  + ]:        207 :         if (!prop)
     885                 :        207 :                 return;
     886                 :          0 :         start = of_read_number(prop, len/4);
     887                 :            : 
     888                 :          0 :         prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
     889         [ #  # ]:          0 :         if (!prop)
     890                 :            :                 return;
     891                 :          0 :         end = of_read_number(prop, len/4);
     892                 :            : 
     893                 :          0 :         __early_init_dt_declare_initrd(start, end);
     894                 :          0 :         phys_initrd_start = start;
     895                 :          0 :         phys_initrd_size = end - start;
     896                 :            : 
     897                 :            :         pr_debug("initrd_start=0x%llx  initrd_end=0x%llx\n",
     898                 :            :                  (unsigned long long)start, (unsigned long long)end);
     899                 :            : }
     900                 :            : #else
     901                 :            : static inline void early_init_dt_check_for_initrd(unsigned long node)
     902                 :            : {
     903                 :            : }
     904                 :            : #endif /* CONFIG_BLK_DEV_INITRD */
     905                 :            : 
     906                 :            : #ifdef CONFIG_SERIAL_EARLYCON
     907                 :            : 
     908                 :          0 : int __init early_init_dt_scan_chosen_stdout(void)
     909                 :            : {
     910                 :            :         int offset;
     911                 :            :         const char *p, *q, *options = NULL;
     912                 :            :         int l;
     913                 :            :         const struct earlycon_id **p_match;
     914                 :          0 :         const void *fdt = initial_boot_params;
     915                 :            : 
     916                 :          0 :         offset = fdt_path_offset(fdt, "/chosen");
     917         [ #  # ]:          0 :         if (offset < 0)
     918                 :          0 :                 offset = fdt_path_offset(fdt, "/chosen@0");
     919         [ #  # ]:          0 :         if (offset < 0)
     920                 :            :                 return -ENOENT;
     921                 :            : 
     922                 :          0 :         p = fdt_getprop(fdt, offset, "stdout-path", &l);
     923         [ #  # ]:          0 :         if (!p)
     924                 :          0 :                 p = fdt_getprop(fdt, offset, "linux,stdout-path", &l);
     925   [ #  #  #  # ]:          0 :         if (!p || !l)
     926                 :            :                 return -ENOENT;
     927                 :            : 
     928                 :          0 :         q = strchrnul(p, ':');
     929         [ #  # ]:          0 :         if (*q != '\0')
     930                 :          0 :                 options = q + 1;
     931                 :          0 :         l = q - p;
     932                 :            : 
     933                 :            :         /* Get the node specified by stdout-path */
     934                 :          0 :         offset = fdt_path_offset_namelen(fdt, p, l);
     935         [ #  # ]:          0 :         if (offset < 0) {
     936                 :          0 :                 pr_warn("earlycon: stdout-path %.*s not found\n", l, p);
     937                 :          0 :                 return 0;
     938                 :            :         }
     939                 :            : 
     940         [ #  # ]:          0 :         for (p_match = __earlycon_table; p_match < __earlycon_table_end;
     941                 :          0 :              p_match++) {
     942                 :          0 :                 const struct earlycon_id *match = *p_match;
     943                 :            : 
     944         [ #  # ]:          0 :                 if (!match->compatible[0])
     945                 :          0 :                         continue;
     946                 :            : 
     947         [ #  # ]:          0 :                 if (fdt_node_check_compatible(fdt, offset, match->compatible))
     948                 :          0 :                         continue;
     949                 :            : 
     950                 :          0 :                 of_setup_earlycon(match, offset, options);
     951                 :          0 :                 return 0;
     952                 :            :         }
     953                 :            :         return -ENODEV;
     954                 :            : }
     955                 :            : #endif
     956                 :            : 
     957                 :            : /**
     958                 :            :  * early_init_dt_scan_root - fetch the top level address and size cells
     959                 :            :  */
     960                 :        207 : int __init early_init_dt_scan_root(unsigned long node, const char *uname,
     961                 :            :                                    int depth, void *data)
     962                 :            : {
     963                 :            :         const __be32 *prop;
     964                 :            : 
     965         [ +  - ]:        207 :         if (depth != 0)
     966                 :            :                 return 0;
     967                 :            : 
     968                 :        207 :         dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
     969                 :        207 :         dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
     970                 :            : 
     971                 :        207 :         prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
     972         [ +  - ]:        207 :         if (prop)
     973                 :        207 :                 dt_root_size_cells = be32_to_cpup(prop);
     974                 :            :         pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
     975                 :            : 
     976                 :        207 :         prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
     977         [ +  - ]:        207 :         if (prop)
     978                 :        207 :                 dt_root_addr_cells = be32_to_cpup(prop);
     979                 :            :         pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
     980                 :            : 
     981                 :            :         /* break now */
     982                 :            :         return 1;
     983                 :            : }
     984                 :            : 
     985                 :        621 : u64 __init dt_mem_next_cell(int s, const __be32 **cellp)
     986                 :            : {
     987                 :        621 :         const __be32 *p = *cellp;
     988                 :            : 
     989                 :        621 :         *cellp = p + s;
     990                 :        621 :         return of_read_number(p, s);
     991                 :            : }
     992                 :            : 
     993                 :            : /**
     994                 :            :  * early_init_dt_scan_memory - Look for and parse memory nodes
     995                 :            :  */
     996                 :      29187 : int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
     997                 :            :                                      int depth, void *data)
     998                 :            : {
     999                 :      29187 :         const char *type = of_get_flat_dt_prop(node, "device_type", NULL);
    1000                 :            :         const __be32 *reg, *endp;
    1001                 :            :         int l;
    1002                 :            :         bool hotpluggable;
    1003                 :            : 
    1004                 :            :         /* We are scanning "memory" nodes only */
    1005   [ +  +  +  + ]:      29187 :         if (type == NULL || strcmp(type, "memory") != 0)
    1006                 :            :                 return 0;
    1007                 :            : 
    1008                 :        207 :         reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
    1009         [ +  - ]:        207 :         if (reg == NULL)
    1010                 :        207 :                 reg = of_get_flat_dt_prop(node, "reg", &l);
    1011         [ +  - ]:        207 :         if (reg == NULL)
    1012                 :            :                 return 0;
    1013                 :            : 
    1014                 :        207 :         endp = reg + (l / sizeof(__be32));
    1015                 :        207 :         hotpluggable = of_get_flat_dt_prop(node, "hotpluggable", NULL);
    1016                 :            : 
    1017                 :            :         pr_debug("memory scan node %s, reg size %d,\n", uname, l);
    1018                 :            : 
    1019         [ +  + ]:        621 :         while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
    1020                 :            :                 u64 base, size;
    1021                 :            : 
    1022                 :        207 :                 base = dt_mem_next_cell(dt_root_addr_cells, &reg);
    1023                 :        207 :                 size = dt_mem_next_cell(dt_root_size_cells, &reg);
    1024                 :            : 
    1025         [ -  + ]:        207 :                 if (size == 0)
    1026                 :          0 :                         continue;
    1027                 :            :                 pr_debug(" - %llx ,  %llx\n", (unsigned long long)base,
    1028                 :            :                     (unsigned long long)size);
    1029                 :            : 
    1030                 :        207 :                 early_init_dt_add_memory_arch(base, size);
    1031                 :            : 
    1032         [ +  - ]:        207 :                 if (!hotpluggable)
    1033                 :        207 :                         continue;
    1034                 :            : 
    1035         [ #  # ]:          0 :                 if (early_init_dt_mark_hotplug_memory_arch(base, size))
    1036                 :          0 :                         pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
    1037                 :            :                                 base, base + size);
    1038                 :            :         }
    1039                 :            : 
    1040                 :            :         return 0;
    1041                 :            : }
    1042                 :            : 
    1043                 :       1242 : int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
    1044                 :            :                                      int depth, void *data)
    1045                 :            : {
    1046                 :            :         int l;
    1047                 :            :         const char *p;
    1048                 :            :         const void *rng_seed;
    1049                 :            : 
    1050                 :            :         pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
    1051                 :            : 
    1052   [ +  +  +  + ]:       2070 :         if (depth != 1 || !data ||
    1053         [ -  + ]:       1449 :             (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
    1054                 :            :                 return 0;
    1055                 :            : 
    1056                 :        207 :         early_init_dt_check_for_initrd(node);
    1057                 :            : 
    1058                 :            :         /* Retrieve command line */
    1059                 :        207 :         p = of_get_flat_dt_prop(node, "bootargs", &l);
    1060   [ +  -  +  - ]:        207 :         if (p != NULL && l > 0)
    1061                 :        207 :                 strlcpy(data, p, min(l, COMMAND_LINE_SIZE));
    1062                 :            : 
    1063                 :            :         /*
    1064                 :            :          * CONFIG_CMDLINE is meant to be a default in case nothing else
    1065                 :            :          * managed to set the command line, unless CONFIG_CMDLINE_FORCE
    1066                 :            :          * is set in which case we override whatever was found earlier.
    1067                 :            :          */
    1068                 :            : #ifdef CONFIG_CMDLINE
    1069                 :            : #if defined(CONFIG_CMDLINE_EXTEND)
    1070                 :            :         strlcat(data, " ", COMMAND_LINE_SIZE);
    1071                 :            :         strlcat(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
    1072                 :            : #elif defined(CONFIG_CMDLINE_FORCE)
    1073                 :            :         strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
    1074                 :            : #else
    1075                 :            :         /* No arguments from boot loader, use kernel's  cmdl*/
    1076         [ -  + ]:        207 :         if (!((char *)data)[0])
    1077                 :          0 :                 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
    1078                 :            : #endif
    1079                 :            : #endif /* CONFIG_CMDLINE */
    1080                 :            : 
    1081                 :            :         pr_debug("Command line is: %s\n", (char*)data);
    1082                 :            : 
    1083                 :        207 :         rng_seed = of_get_flat_dt_prop(node, "rng-seed", &l);
    1084   [ -  +  #  # ]:        207 :         if (rng_seed && l > 0) {
    1085                 :          0 :                 add_bootloader_randomness(rng_seed, l);
    1086                 :            : 
    1087                 :            :                 /* try to clear seed so it won't be found. */
    1088                 :          0 :                 fdt_nop_property(initial_boot_params, node, "rng-seed");
    1089                 :            : 
    1090                 :            :                 /* update CRC check value */
    1091                 :          0 :                 of_fdt_crc32 = crc32_be(~0, initial_boot_params,
    1092                 :          0 :                                 fdt_totalsize(initial_boot_params));
    1093                 :            :         }
    1094                 :            : 
    1095                 :            :         /* break now */
    1096                 :            :         return 1;
    1097                 :            : }
    1098                 :            : 
    1099                 :            : #ifndef MIN_MEMBLOCK_ADDR
    1100                 :            : #define MIN_MEMBLOCK_ADDR       __pa(PAGE_OFFSET)
    1101                 :            : #endif
    1102                 :            : #ifndef MAX_MEMBLOCK_ADDR
    1103                 :            : #define MAX_MEMBLOCK_ADDR       ((phys_addr_t)~0)
    1104                 :            : #endif
    1105                 :            : 
    1106                 :        207 : void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
    1107                 :            : {
    1108                 :        207 :         const u64 phys_offset = MIN_MEMBLOCK_ADDR;
    1109                 :            : 
    1110         [ -  + ]:        207 :         if (size < PAGE_SIZE - (base & ~PAGE_MASK)) {
    1111                 :          0 :                 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
    1112                 :            :                         base, base + size);
    1113                 :          0 :                 return;
    1114                 :            :         }
    1115                 :            : 
    1116         [ -  + ]:        207 :         if (!PAGE_ALIGNED(base)) {
    1117                 :          0 :                 size -= PAGE_SIZE - (base & ~PAGE_MASK);
    1118                 :          0 :                 base = PAGE_ALIGN(base);
    1119                 :            :         }
    1120                 :        207 :         size &= PAGE_MASK;
    1121                 :            : 
    1122         [ -  + ]:        207 :         if (base > MAX_MEMBLOCK_ADDR) {
    1123                 :          0 :                 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
    1124                 :            :                                 base, base + size);
    1125                 :          0 :                 return;
    1126                 :            :         }
    1127                 :            : 
    1128         [ -  + ]:        207 :         if (base + size - 1 > MAX_MEMBLOCK_ADDR) {
    1129                 :          0 :                 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
    1130                 :            :                                 ((u64)MAX_MEMBLOCK_ADDR) + 1, base + size);
    1131                 :          0 :                 size = MAX_MEMBLOCK_ADDR - base + 1;
    1132                 :            :         }
    1133                 :            : 
    1134         [ -  + ]:        207 :         if (base + size < phys_offset) {
    1135                 :          0 :                 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
    1136                 :            :                            base, base + size);
    1137                 :          0 :                 return;
    1138                 :            :         }
    1139         [ -  + ]:        207 :         if (base < phys_offset) {
    1140                 :          0 :                 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
    1141                 :            :                            base, phys_offset);
    1142                 :          0 :                 size -= phys_offset - base;
    1143                 :            :                 base = phys_offset;
    1144                 :            :         }
    1145                 :        207 :         memblock_add(base, size);
    1146                 :            : }
    1147                 :            : 
    1148                 :          0 : int __init __weak early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size)
    1149                 :            : {
    1150                 :          0 :         return memblock_mark_hotplug(base, size);
    1151                 :            : }
    1152                 :            : 
    1153                 :        414 : int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
    1154                 :            :                                         phys_addr_t size, bool nomap)
    1155                 :            : {
    1156         [ -  + ]:        414 :         if (nomap)
    1157                 :          0 :                 return memblock_remove(base, size);
    1158                 :        414 :         return memblock_reserve(base, size);
    1159                 :            : }
    1160                 :            : 
    1161                 :       3105 : static void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
    1162                 :            : {
    1163                 :       3105 :         void *ptr = memblock_alloc(size, align);
    1164                 :            : 
    1165         [ -  + ]:       3105 :         if (!ptr)
    1166                 :          0 :                 panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
    1167                 :            :                       __func__, size, align);
    1168                 :            : 
    1169                 :       3105 :         return ptr;
    1170                 :            : }
    1171                 :            : 
    1172                 :        207 : bool __init early_init_dt_verify(void *params)
    1173                 :            : {
    1174         [ +  - ]:        207 :         if (!params)
    1175                 :            :                 return false;
    1176                 :            : 
    1177                 :            :         /* check device tree validity */
    1178         [ +  - ]:        207 :         if (fdt_check_header(params))
    1179                 :            :                 return false;
    1180                 :            : 
    1181                 :            :         /* Setup flat device-tree pointer */
    1182                 :        207 :         initial_boot_params = params;
    1183                 :        207 :         of_fdt_crc32 = crc32_be(~0, initial_boot_params,
    1184                 :            :                                 fdt_totalsize(initial_boot_params));
    1185                 :        207 :         return true;
    1186                 :            : }
    1187                 :            : 
    1188                 :            : 
    1189                 :        207 : void __init early_init_dt_scan_nodes(void)
    1190                 :            : {
    1191                 :            :         int rc = 0;
    1192                 :            : 
    1193                 :            :         /* Retrieve various information from the /chosen node */
    1194                 :        207 :         rc = of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
    1195         [ -  + ]:        207 :         if (!rc)
    1196                 :          0 :                 pr_warn("No chosen node found, continuing without\n");
    1197                 :            : 
    1198                 :            :         /* Initialize {size,address}-cells info */
    1199                 :        207 :         of_scan_flat_dt(early_init_dt_scan_root, NULL);
    1200                 :            : 
    1201                 :            :         /* Setup memory, calling early_init_dt_add_memory_arch */
    1202                 :        207 :         of_scan_flat_dt(early_init_dt_scan_memory, NULL);
    1203                 :        207 : }
    1204                 :            : 
    1205                 :          0 : bool __init early_init_dt_scan(void *params)
    1206                 :            : {
    1207                 :            :         bool status;
    1208                 :            : 
    1209                 :          0 :         status = early_init_dt_verify(params);
    1210         [ #  # ]:          0 :         if (!status)
    1211                 :            :                 return false;
    1212                 :            : 
    1213                 :          0 :         early_init_dt_scan_nodes();
    1214                 :          0 :         return true;
    1215                 :            : }
    1216                 :            : 
    1217                 :            : /**
    1218                 :            :  * unflatten_device_tree - create tree of device_nodes from flat blob
    1219                 :            :  *
    1220                 :            :  * unflattens the device-tree passed by the firmware, creating the
    1221                 :            :  * tree of struct device_node. It also fills the "name" and "type"
    1222                 :            :  * pointers of the nodes so the normal device-tree walking functions
    1223                 :            :  * can be used.
    1224                 :            :  */
    1225                 :        207 : void __init unflatten_device_tree(void)
    1226                 :            : {
    1227                 :        207 :         __unflatten_device_tree(initial_boot_params, NULL, &of_root,
    1228                 :            :                                 early_init_dt_alloc_memory_arch, false);
    1229                 :            : 
    1230                 :            :         /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
    1231                 :        207 :         of_alias_scan(early_init_dt_alloc_memory_arch);
    1232                 :            : 
    1233                 :            :         unittest_unflatten_overlay_base();
    1234                 :        207 : }
    1235                 :            : 
    1236                 :            : /**
    1237                 :            :  * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
    1238                 :            :  *
    1239                 :            :  * Copies and unflattens the device-tree passed by the firmware, creating the
    1240                 :            :  * tree of struct device_node. It also fills the "name" and "type"
    1241                 :            :  * pointers of the nodes so the normal device-tree walking functions
    1242                 :            :  * can be used. This should only be used when the FDT memory has not been
    1243                 :            :  * reserved such is the case when the FDT is built-in to the kernel init
    1244                 :            :  * section. If the FDT memory is reserved already then unflatten_device_tree
    1245                 :            :  * should be used instead.
    1246                 :            :  */
    1247                 :          0 : void __init unflatten_and_copy_device_tree(void)
    1248                 :            : {
    1249                 :            :         int size;
    1250                 :            :         void *dt;
    1251                 :            : 
    1252         [ #  # ]:          0 :         if (!initial_boot_params) {
    1253                 :          0 :                 pr_warn("No valid device tree found, continuing without\n");
    1254                 :          0 :                 return;
    1255                 :            :         }
    1256                 :            : 
    1257                 :          0 :         size = fdt_totalsize(initial_boot_params);
    1258                 :          0 :         dt = early_init_dt_alloc_memory_arch(size,
    1259                 :            :                                              roundup_pow_of_two(FDT_V17_SIZE));
    1260                 :            : 
    1261         [ #  # ]:          0 :         if (dt) {
    1262                 :          0 :                 memcpy(dt, initial_boot_params, size);
    1263                 :          0 :                 initial_boot_params = dt;
    1264                 :            :         }
    1265                 :          0 :         unflatten_device_tree();
    1266                 :            : }
    1267                 :            : 
    1268                 :            : #ifdef CONFIG_SYSFS
    1269                 :          0 : static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj,
    1270                 :            :                                struct bin_attribute *bin_attr,
    1271                 :            :                                char *buf, loff_t off, size_t count)
    1272                 :            : {
    1273                 :          0 :         memcpy(buf, initial_boot_params + off, count);
    1274                 :          0 :         return count;
    1275                 :            : }
    1276                 :            : 
    1277                 :        207 : static int __init of_fdt_raw_init(void)
    1278                 :            : {
    1279                 :            :         static struct bin_attribute of_fdt_raw_attr =
    1280                 :            :                 __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0);
    1281                 :            : 
    1282         [ +  - ]:        207 :         if (!initial_boot_params)
    1283                 :            :                 return 0;
    1284                 :            : 
    1285         [ -  + ]:        207 :         if (of_fdt_crc32 != crc32_be(~0, initial_boot_params,
    1286                 :            :                                      fdt_totalsize(initial_boot_params))) {
    1287                 :          0 :                 pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
    1288                 :          0 :                 return 0;
    1289                 :            :         }
    1290                 :        207 :         of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params);
    1291                 :        207 :         return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr);
    1292                 :            : }
    1293                 :            : late_initcall(of_fdt_raw_init);
    1294                 :            : #endif
    1295                 :            : 
    1296                 :            : #endif /* CONFIG_OF_EARLY_FLATTREE */

Generated by: LCOV version 1.14