LXR uboot/board/renesas/rcar-common/common.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * board/renesas/rcar-common/common.c
   4 *
   5 * Copyright (C) 2013 Renesas Electronics Corporation
   6 * Copyright (C) 2013 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
   7 * Copyright (C) 2015 Nobuhiro Iwamatsu <iwamatsu@nigauri.org>
   8 */
   9
  10#include <common.h>
  11#include <dm.h>
  12#include <init.h>
  13#include <asm/global_data.h>
  14#include <dm/uclass-internal.h>
  15#include <asm/arch/rmobile.h>
  16#include <linux/libfdt.h>
  17
  18#ifdef CONFIG_RCAR_GEN3
  19
  20DECLARE_GLOBAL_DATA_PTR;
  21
  22/* If the firmware passed a device tree use it for U-Boot DRAM setup. */
  23extern u64 rcar_atf_boot_args[];
  24
  25int fdtdec_board_setup(const void *fdt_blob)
  26{
  27        void *atf_fdt_blob = (void *)(rcar_atf_boot_args[1]);
  28
  29        if (fdt_magic(atf_fdt_blob) == FDT_MAGIC)
  30                fdt_overlay_apply_node((void *)fdt_blob, 0, atf_fdt_blob, 0);
  31
  32        return 0;
  33}
  34
  35int dram_init(void)
  36{
  37        return fdtdec_setup_mem_size_base();
  38}
  39
  40int dram_init_banksize(void)
  41{
  42        fdtdec_setup_memory_banksize();
  43
  44        return 0;
  45}
  46
  47#if defined(CONFIG_OF_BOARD_SETUP)
  48static int is_mem_overlap(void *blob, int first_mem_node, int curr_mem_node)
  49{
  50        struct fdt_resource first_mem_res, curr_mem_res;
  51        int curr_mem_reg, first_mem_reg = 0;
  52        int ret;
  53
  54        for (;;) {
  55                ret = fdt_get_resource(blob, first_mem_node, "reg",
  56                                       first_mem_reg++, &first_mem_res);
  57                if (ret) /* No more entries, no overlap found */
  58                        return 0;
  59
  60                curr_mem_reg = 0;
  61                for (;;) {
  62                        ret = fdt_get_resource(blob, curr_mem_node, "reg",
  63                                               curr_mem_reg++, &curr_mem_res);
  64                        if (ret) /* No more entries, check next tuple */
  65                                break;
  66
  67                        if (curr_mem_res.end < first_mem_res.start)
  68                                continue;
  69
  70                        if (curr_mem_res.start >= first_mem_res.end)
  71                                continue;
  72
  73                        printf("Overlap found: 0x%llx..0x%llx / 0x%llx..0x%llx\n",
  74                                first_mem_res.start, first_mem_res.end,
  75                                curr_mem_res.start, curr_mem_res.end);
  76
  77                        return 1;
  78                }
  79        }
  80
  81        return 0;
  82}
  83
  84int ft_board_setup(void *blob, struct bd_info *bd)
  85{
  86        /*
  87         * Scrub duplicate /memory@* node entries here. Some R-Car DTs might
  88         * contain multiple /memory@* nodes, however fdt_fixup_memory_banks()
  89         * either generates single /memory node or updates the first /memory
  90         * node. Any remaining memory nodes are thus potential duplicates.
  91         *
  92         * However, it is not possible to delete all the memory nodes right
  93         * away, since some of those might not be DRAM memory nodes, but some
  94         * sort of other memory. Thus, delete only the memory nodes which are
  95         * in the R-Car3 DBSC ranges.
  96         */
  97        int mem = 0, first_mem_node = 0;
  98
  99        for (;;) {
 100                mem = fdt_node_offset_by_prop_value(blob, mem,
 101                                                    "device_type", "memory", 7);
 102                if (mem < 0)
 103                        break;
 104                if (!fdtdec_get_is_enabled(blob, mem))
 105                        continue;
 106
 107                /* First memory node, patched by U-Boot */
 108                if (!first_mem_node) {
 109                        first_mem_node = mem;
 110                        continue;
 111                }
 112
 113                /* Check the remaining nodes and delete duplicates */
 114                if (!is_mem_overlap(blob, first_mem_node, mem))
 115                        continue;
 116
 117                /* Delete duplicate node, start again */
 118                fdt_del_node(blob, mem);
 119                first_mem_node = 0;
 120                mem = 0;
 121        }
 122
 123        return 0;
 124}
 125#endif
 126#endif
 127