Merge tag 'u-boot-rockchip-20200501' of https://gitlab.denx.de/u-boot/custodians...

[oweals/u-boot.git] / common / fdt_support.c

diff --git a/common/fdt_support.c b/common/fdt_support.c
index ab08a0114feea8f2b726fd50829fc58cf92b72dd..02cf5c6241b2c2961b31c7aec8879025e36ffc50 100644 (file)
--- a/common/fdt_support.c
+++ b/common/fdt_support.c
@@ -7,6 +7,7 @@
  */
 
 #include <common.h>
+#include <env.h>
 #include <mapmem.h>
 #include <stdio_dev.h>
 #include <linux/ctype.h>
@@ -466,6 +467,41 @@ int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks)
        }
        return 0;
 }
+
+int fdt_set_usable_memory(void *blob, u64 start[], u64 size[], int areas)
+{
+       int err, nodeoffset;
+       int len;
+       u8 tmp[8 * 16]; /* Up to 64-bit address + 64-bit size */
+
+       if (areas > 8) {
+               printf("%s: num areas %d exceeds hardcoded limit %d\n",
+                      __func__, areas, 8);
+               return -1;
+       }
+
+       err = fdt_check_header(blob);
+       if (err < 0) {
+               printf("%s: %s\n", __func__, fdt_strerror(err));
+               return err;
+       }
+
+       /* find or create "/memory" node. */
+       nodeoffset = fdt_find_or_add_subnode(blob, 0, "memory");
+       if (nodeoffset < 0)
+               return nodeoffset;
+
+       len = fdt_pack_reg(blob, tmp, start, size, areas);
+
+       err = fdt_setprop(blob, nodeoffset, "linux,usable-memory", tmp, len);
+       if (err < 0) {
+               printf("WARNING: could not set %s %s.\n",
+                      "reg", fdt_strerror(err));
+               return err;
+       }
+
+       return 0;
+}
 #endif
 
 int fdt_fixup_memory(void *blob, u64 start, u64 size)
@@ -597,6 +633,7 @@ int fdt_shrink_to_minimum(void *blob, uint extrasize)
        uint64_t addr, size;
        int total, ret;
        uint actualsize;
+       int fdt_memrsv = 0;
 
        if (!blob)
                return 0;
@@ -606,6 +643,7 @@ int fdt_shrink_to_minimum(void *blob, uint extrasize)
                fdt_get_mem_rsv(blob, i, &addr, &size);
                if (addr == (uintptr_t)blob) {
                        fdt_del_mem_rsv(blob, i);
+                       fdt_memrsv = 1;
                        break;
                }
        }
@@ -627,10 +665,12 @@ int fdt_shrink_to_minimum(void *blob, uint extrasize)
        /* Change the fdt header to reflect the correct size */
        fdt_set_totalsize(blob, actualsize);
 
-       /* Add the new reservation */
-       ret = fdt_add_mem_rsv(blob, map_to_sysmem(blob), actualsize);
-       if (ret < 0)
-               return ret;
+       if (fdt_memrsv) {
+               /* Add the new reservation */
+               ret = fdt_add_mem_rsv(blob, map_to_sysmem(blob), actualsize);
+               if (ret < 0)
+                       return ret;
+       }
 
        return actualsize;
 }
@@ -667,30 +707,33 @@ int fdt_pci_dma_ranges(void *blob, int phb_off, struct pci_controller *hose) {
 
                dma_range[0] = 0;
                if (size >= 0x100000000ull)
-                       dma_range[0] |= FDT_PCI_MEM64;
+                       dma_range[0] |= cpu_to_fdt32(FDT_PCI_MEM64);
                else
-                       dma_range[0] |= FDT_PCI_MEM32;
+                       dma_range[0] |= cpu_to_fdt32(FDT_PCI_MEM32);
                if (hose->regions[r].flags & PCI_REGION_PREFETCH)
-                       dma_range[0] |= FDT_PCI_PREFETCH;
+                       dma_range[0] |= cpu_to_fdt32(FDT_PCI_PREFETCH);
 #ifdef CONFIG_SYS_PCI_64BIT
-               dma_range[1] = bus_start >> 32;
+               dma_range[1] = cpu_to_fdt32(bus_start >> 32);
 #else
                dma_range[1] = 0;
 #endif
-               dma_range[2] = bus_start & 0xffffffff;
+               dma_range[2] = cpu_to_fdt32(bus_start & 0xffffffff);
 
                if (addrcell == 2) {
-                       dma_range[3] = phys_start >> 32;
-                       dma_range[4] = phys_start & 0xffffffff;
+                       dma_range[3] = cpu_to_fdt32(phys_start >> 32);
+                       dma_range[4] = cpu_to_fdt32(phys_start & 0xffffffff);
                } else {
-                       dma_range[3] = phys_start & 0xffffffff;
+                       dma_range[3] = cpu_to_fdt32(phys_start & 0xffffffff);
                }
 
                if (sizecell == 2) {
-                       dma_range[3 + addrcell + 0] = size >> 32;
-                       dma_range[3 + addrcell + 1] = size & 0xffffffff;
+                       dma_range[3 + addrcell + 0] =
+                               cpu_to_fdt32(size >> 32);
+                       dma_range[3 + addrcell + 1] =
+                               cpu_to_fdt32(size & 0xffffffff);
                } else {
-                       dma_range[3 + addrcell + 0] = size & 0xffffffff;
+                       dma_range[3 + addrcell + 0] =
+                               cpu_to_fdt32(size & 0xffffffff);
                }
 
                dma_range += (3 + addrcell + sizecell);
@@ -718,11 +761,6 @@ int fdt_increase_size(void *fdt, int add_len)
 #include <jffs2/load_kernel.h>
 #include <mtd_node.h>
 
-struct reg_cell {
-       unsigned int r0;
-       unsigned int r1;
-};
-
 static int fdt_del_subnodes(const void *blob, int parent_offset)
 {
        int off, ndepth;
@@ -781,15 +819,22 @@ int fdt_node_set_part_info(void *blob, int parent_offset,
 {
        struct list_head *pentry;
        struct part_info *part;
-       struct reg_cell cell;
        int off, ndepth = 0;
        int part_num, ret;
+       int sizecell;
        char buf[64];
 
        ret = fdt_del_partitions(blob, parent_offset);
        if (ret < 0)
                return ret;
 
+       /*
+        * Check if size/address is 1 or 2 cells.
+        * We assume #address-cells and #size-cells have same value.
+        */
+       sizecell = fdt_getprop_u32_default_node(blob, parent_offset,
+                                               0, "#size-cells", 1);
+
        /*
         * Check if it is nand {}; subnode, adjust
         * the offset in this case
@@ -838,10 +883,21 @@ add_ro:
                                goto err_prop;
                }
 
-               cell.r0 = cpu_to_fdt32(part->offset);
-               cell.r1 = cpu_to_fdt32(part->size);
 add_reg:
-               ret = fdt_setprop(blob, newoff, "reg", &cell, sizeof(cell));
+               if (sizecell == 2) {
+                       ret = fdt_setprop_u64(blob, newoff,
+                                             "reg", part->offset);
+                       if (!ret)
+                               ret = fdt_appendprop_u64(blob, newoff,
+                                                        "reg", part->size);
+               } else {
+                       ret = fdt_setprop_u32(blob, newoff,
+                                             "reg", part->offset);
+                       if (!ret)
+                               ret = fdt_appendprop_u32(blob, newoff,
+                                                        "reg", part->size);
+               }
+
                if (ret == -FDT_ERR_NOSPACE) {
                        ret = fdt_increase_size(blob, 512);
                        if (!ret)
@@ -1275,6 +1331,12 @@ u64 fdt_translate_address(const void *blob, int node_offset,
        return __of_translate_address(blob, node_offset, in_addr, "ranges");
 }
 
+u64 fdt_translate_dma_address(const void *blob, int node_offset,
+                             const fdt32_t *in_addr)
+{
+       return __of_translate_address(blob, node_offset, in_addr, "dma-ranges");
+}
+
 /**
  * fdt_node_offset_by_compat_reg: Find a node that matches compatiable and
  * who's reg property matches a physical cpu address
@@ -1529,7 +1591,7 @@ u64 fdt_get_base_address(const void *fdt, int node)
 
        prop = fdt_getprop(fdt, node, "reg", &size);
 
-       return prop ? fdt_translate_address(fdt, node, prop) : 0;
+       return prop ? fdt_translate_address(fdt, node, prop) : OF_BAD_ADDR;
 }
 
 /*
@@ -1539,7 +1601,7 @@ static int fdt_read_prop(const fdt32_t *prop, int prop_len, int cell_off,
                         uint64_t *val, int cells)
 {
        const fdt32_t *prop32 = &prop[cell_off];
-       const fdt64_t *prop64 = (const fdt64_t *)&prop[cell_off];
+       const unaligned_fdt64_t *prop64 = (const fdt64_t *)&prop[cell_off];
 
        if ((cell_off + cells) > prop_len)
                return -FDT_ERR_NOSPACE;