arch/arm/mach-k3/common.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * K3: Common Architecture initialization
   4  *
   5  * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
   6  *      Lokesh Vutla <lokeshvutla@ti.com>
   7  */
   8
   9 #include <common.h>
  10 #include <spl.h>
  11 #include "common.h"
  12 #include <dm.h>
  13 #include <remoteproc.h>
  14 #include <linux/soc/ti/ti_sci_protocol.h>
  15 #include <fdt_support.h>
  16 #include <asm/arch/sys_proto.h>
  17
  18 struct ti_sci_handle *get_ti_sci_handle(void)
  19 {
  20         struct udevice *dev;
  21         int ret;
  22
  23         ret = uclass_get_device(UCLASS_FIRMWARE, 0, &dev);
  24         if (ret)
  25                 panic("Failed to get SYSFW (%d)\n", ret);
  26
  27         return (struct ti_sci_handle *)ti_sci_get_handle_from_sysfw(dev);
  28 }
  29
  30 DECLARE_GLOBAL_DATA_PTR;
  31
  32 #ifdef CONFIG_K3_EARLY_CONS
  33 int early_console_init(void)
  34 {
  35         struct udevice *dev;
  36         int ret;
  37
  38         gd->baudrate = CONFIG_BAUDRATE;
  39
  40         ret = uclass_get_device_by_seq(UCLASS_SERIAL, CONFIG_K3_EARLY_CONS_IDX,
  41                                        &dev);
  42         if (ret) {
  43                 printf("Error getting serial dev for early console! (%d)\n",
  44                        ret);
  45                 return ret;
  46         }
  47
  48         gd->cur_serial_dev = dev;
  49         gd->flags |= GD_FLG_SERIAL_READY;
  50         gd->have_console = 1;
  51
  52         return 0;
  53 }
  54 #endif
  55
  56 #ifdef CONFIG_SYS_K3_SPL_ATF
  57 void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
  58 {
  59         struct ti_sci_handle *ti_sci = get_ti_sci_handle();
  60         int ret;
  61
  62         /* Release all the exclusive devices held by SPL before starting ATF */
  63         ti_sci->ops.dev_ops.release_exclusive_devices(ti_sci);
  64
  65         /*
  66          * It is assumed that remoteproc device 1 is the corresponding
  67          * Cortex-A core which runs ATF. Make sure DT reflects the same.
  68          */
  69         ret = rproc_dev_init(1);
  70         if (ret)
  71                 panic("%s: ATF failed to initialize on rproc (%d)\n", __func__,
  72                       ret);
  73
  74         ret = rproc_load(1, spl_image->entry_point, 0x200);
  75         if (ret)
  76                 panic("%s: ATF failed to load on rproc (%d)\n", __func__, ret);
  77
  78         /* Add an extra newline to differentiate the ATF logs from SPL */
  79         printf("Starting ATF on ARM64 core...\n\n");
  80
  81         ret = rproc_start(1);
  82         if (ret)
  83                 panic("%s: ATF failed to start on rproc (%d)\n", __func__, ret);
  84
  85         debug("Releasing resources...\n");
  86         release_resources_for_core_shutdown();
  87
  88         debug("Finalizing core shutdown...\n");
  89         while (1)
  90                 asm volatile("wfe");
  91 }
  92 #endif
  93
  94 #if defined(CONFIG_OF_LIBFDT)
  95 int fdt_fixup_msmc_ram(void *blob, char *parent_path, char *node_name)
  96 {
  97         u64 msmc_start = 0, msmc_end = 0, msmc_size, reg[2];
  98         struct ti_sci_handle *ti_sci = get_ti_sci_handle();
  99         int ret, node, subnode, len, prev_node;
 100         u32 range[4], addr, size;
 101         const fdt32_t *sub_reg;
 102
 103         ti_sci->ops.core_ops.query_msmc(ti_sci, &msmc_start, &msmc_end);
 104         msmc_size = msmc_end - msmc_start + 1;
 105         debug("%s: msmc_start = 0x%llx, msmc_size = 0x%llx\n", __func__,
 106               msmc_start, msmc_size);
 107
 108         /* find or create "msmc_sram node */
 109         ret = fdt_path_offset(blob, parent_path);
 110         if (ret < 0)
 111                 return ret;
 112
 113         node = fdt_find_or_add_subnode(blob, ret, node_name);
 114         if (node < 0)
 115                 return node;
 116
 117         ret = fdt_setprop_string(blob, node, "compatible", "mmio-sram");
 118         if (ret < 0)
 119                 return ret;
 120
 121         reg[0] = cpu_to_fdt64(msmc_start);
 122         reg[1] = cpu_to_fdt64(msmc_size);
 123         ret = fdt_setprop(blob, node, "reg", reg, sizeof(reg));
 124         if (ret < 0)
 125                 return ret;
 126
 127         fdt_setprop_cell(blob, node, "#address-cells", 1);
 128         fdt_setprop_cell(blob, node, "#size-cells", 1);
 129
 130         range[0] = 0;
 131         range[1] = cpu_to_fdt32(msmc_start >> 32);
 132         range[2] = cpu_to_fdt32(msmc_start & 0xffffffff);
 133         range[3] = cpu_to_fdt32(msmc_size);
 134         ret = fdt_setprop(blob, node, "ranges", range, sizeof(range));
 135         if (ret < 0)
 136                 return ret;
 137
 138         subnode = fdt_first_subnode(blob, node);
 139         prev_node = 0;
 140
 141         /* Look for invalid subnodes and delete them */
 142         while (subnode >= 0) {
 143                 sub_reg = fdt_getprop(blob, subnode, "reg", &len);
 144                 addr = fdt_read_number(sub_reg, 1);
 145                 sub_reg++;
 146                 size = fdt_read_number(sub_reg, 1);
 147                 debug("%s: subnode = %d, addr = 0x%x. size = 0x%x\n", __func__,
 148                       subnode, addr, size);
 149                 if (addr + size > msmc_size ||
 150                     !strncmp(fdt_get_name(blob, subnode, &len), "sysfw", 5) ||
 151                     !strncmp(fdt_get_name(blob, subnode, &len), "l3cache", 7)) {
 152                         fdt_del_node(blob, subnode);
 153                         debug("%s: deleting subnode %d\n", __func__, subnode);
 154                         if (!prev_node)
 155                                 subnode = fdt_first_subnode(blob, node);
 156                         else
 157                                 subnode = fdt_next_subnode(blob, prev_node);
 158                 } else {
 159                         prev_node = subnode;
 160                         subnode = fdt_next_subnode(blob, prev_node);
 161                 }
 162         }
 163
 164         return 0;
 165 }
 166
 167 int fdt_disable_node(void *blob, char *node_path)
 168 {
 169         int offs;
 170         int ret;
 171
 172         offs = fdt_path_offset(blob, node_path);
 173         if (offs < 0) {
 174                 debug("Node %s not found.\n", node_path);
 175                 return 0;
 176         }
 177         ret = fdt_setprop_string(blob, offs, "status", "disabled");
 178         if (ret < 0) {
 179                 printf("Could not add status property to node %s: %s\n",
 180                        node_path, fdt_strerror(ret));
 181                 return ret;
 182         }
 183         return 0;
 184 }
 185
 186 #endif
 187
 188 #ifndef CONFIG_SYSRESET
 189 void reset_cpu(ulong ignored)
 190 {
 191 }
 192 #endif