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 <cpu_func.h>
  11 #include <image.h>
  12 #include <spl.h>
  13 #include "common.h"
  14 #include <dm.h>
  15 #include <remoteproc.h>
  16 #include <asm/cache.h>
  17 #include <linux/soc/ti/ti_sci_protocol.h>
  18 #include <fdt_support.h>
  19 #include <asm/arch/sys_proto.h>
  20 #include <asm/hardware.h>
  21 #include <asm/io.h>
  22 #include <fs_loader.h>
  23 #include <fs.h>
  24 #include <env.h>
  25 #include <elf.h>
  26
  27 struct ti_sci_handle *get_ti_sci_handle(void)
  28 {
  29         struct udevice *dev;
  30         int ret;
  31
  32         ret = uclass_get_device_by_driver(UCLASS_FIRMWARE,
  33                                           DM_GET_DRIVER(ti_sci), &dev);
  34         if (ret)
  35                 panic("Failed to get SYSFW (%d)\n", ret);
  36
  37         return (struct ti_sci_handle *)ti_sci_get_handle_from_sysfw(dev);
  38 }
  39
  40 void k3_sysfw_print_ver(void)
  41 {
  42         struct ti_sci_handle *ti_sci = get_ti_sci_handle();
  43         char fw_desc[sizeof(ti_sci->version.firmware_description) + 1];
  44
  45         /*
  46          * Output System Firmware version info. Note that since the
  47          * 'firmware_description' field is not guaranteed to be zero-
  48          * terminated we manually add a \0 terminator if needed. Further
  49          * note that we intentionally no longer rely on the extended
  50          * printf() formatter '%.*s' to not having to require a more
  51          * full-featured printf() implementation.
  52          */
  53         strncpy(fw_desc, ti_sci->version.firmware_description,
  54                 sizeof(ti_sci->version.firmware_description));
  55         fw_desc[sizeof(fw_desc) - 1] = '\0';
  56
  57         printf("SYSFW ABI: %d.%d (firmware rev 0x%04x '%s')\n",
  58                ti_sci->version.abi_major, ti_sci->version.abi_minor,
  59                ti_sci->version.firmware_revision, fw_desc);
  60 }
  61
  62 DECLARE_GLOBAL_DATA_PTR;
  63
  64 #ifdef CONFIG_K3_EARLY_CONS
  65 int early_console_init(void)
  66 {
  67         struct udevice *dev;
  68         int ret;
  69
  70         gd->baudrate = CONFIG_BAUDRATE;
  71
  72         ret = uclass_get_device_by_seq(UCLASS_SERIAL, CONFIG_K3_EARLY_CONS_IDX,
  73                                        &dev);
  74         if (ret) {
  75                 printf("Error getting serial dev for early console! (%d)\n",
  76                        ret);
  77                 return ret;
  78         }
  79
  80         gd->cur_serial_dev = dev;
  81         gd->flags |= GD_FLG_SERIAL_READY;
  82         gd->have_console = 1;
  83
  84         return 0;
  85 }
  86 #endif
  87
  88 #ifdef CONFIG_SYS_K3_SPL_ATF
  89
  90 void init_env(void)
  91 {
  92 #ifdef CONFIG_SPL_ENV_SUPPORT
  93         char *part;
  94
  95         env_init();
  96         env_relocate();
  97         switch (spl_boot_device()) {
  98         case BOOT_DEVICE_MMC2:
  99                 part = env_get("bootpart");
 100                 env_set("storage_interface", "mmc");
 101                 env_set("fw_dev_part", part);
 102                 break;
 103         case BOOT_DEVICE_SPI:
 104                 env_set("storage_interface", "ubi");
 105                 env_set("fw_ubi_mtdpart", "UBI");
 106                 env_set("fw_ubi_volume", "UBI0");
 107                 break;
 108         default:
 109                 printf("%s from device %u not supported!\n",
 110                        __func__, spl_boot_device());
 111                 return;
 112         }
 113 #endif
 114 }
 115
 116 #ifdef CONFIG_FS_LOADER
 117 int load_firmware(char *name_fw, char *name_loadaddr, u32 *loadaddr)
 118 {
 119         struct udevice *fsdev;
 120         char *name = NULL;
 121         int size = 0;
 122
 123         *loadaddr = 0;
 124 #ifdef CONFIG_SPL_ENV_SUPPORT
 125         switch (spl_boot_device()) {
 126         case BOOT_DEVICE_MMC2:
 127                 name = env_get(name_fw);
 128                 *loadaddr = env_get_hex(name_loadaddr, *loadaddr);
 129                 break;
 130         default:
 131                 printf("Loading rproc fw image from device %u not supported!\n",
 132                        spl_boot_device());
 133                 return 0;
 134         }
 135 #endif
 136         if (!*loadaddr)
 137                 return 0;
 138
 139         if (!uclass_get_device(UCLASS_FS_FIRMWARE_LOADER, 0, &fsdev)) {
 140                 size = request_firmware_into_buf(fsdev, name, (void *)*loadaddr,
 141                                                  0, 0);
 142         }
 143
 144         return size;
 145 }
 146 #else
 147 int load_firmware(char *name_fw, char *name_loadaddr, u32 *loadaddr)
 148 {
 149         return 0;
 150 }
 151 #endif
 152
 153 __weak void start_non_linux_remote_cores(void)
 154 {
 155 }
 156
 157 void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image)
 158 {
 159         typedef void __noreturn (*image_entry_noargs_t)(void);
 160         struct ti_sci_handle *ti_sci = get_ti_sci_handle();
 161         u32 loadaddr = 0;
 162         int ret, size;
 163
 164         /* Release all the exclusive devices held by SPL before starting ATF */
 165         ti_sci->ops.dev_ops.release_exclusive_devices(ti_sci);
 166
 167         ret = rproc_init();
 168         if (ret)
 169                 panic("rproc failed to be initialized (%d)\n", ret);
 170
 171         init_env();
 172         start_non_linux_remote_cores();
 173         size = load_firmware("name_mcur5f0_0fw", "addr_mcur5f0_0load",
 174                              &loadaddr);
 175
 176
 177         /*
 178          * It is assumed that remoteproc device 1 is the corresponding
 179          * Cortex-A core which runs ATF. Make sure DT reflects the same.
 180          */
 181         ret = rproc_load(1, spl_image->entry_point, 0x200);
 182         if (ret)
 183                 panic("%s: ATF failed to load on rproc (%d)\n", __func__, ret);
 184
 185         /* Add an extra newline to differentiate the ATF logs from SPL */
 186         printf("Starting ATF on ARM64 core...\n\n");
 187
 188         ret = rproc_start(1);
 189         if (ret)
 190                 panic("%s: ATF failed to start on rproc (%d)\n", __func__, ret);
 191         if (!(size > 0 && valid_elf_image(loadaddr))) {
 192                 debug("Shutting down...\n");
 193                 release_resources_for_core_shutdown();
 194
 195                 while (1)
 196                         asm volatile("wfe");
 197         }
 198
 199         image_entry_noargs_t image_entry =
 200                 (image_entry_noargs_t)load_elf_image_phdr(loadaddr);
 201
 202         image_entry();
 203 }
 204 #endif
 205
 206 #if defined(CONFIG_OF_LIBFDT)
 207 int fdt_fixup_msmc_ram(void *blob, char *parent_path, char *node_name)
 208 {
 209         u64 msmc_start = 0, msmc_end = 0, msmc_size, reg[2];
 210         struct ti_sci_handle *ti_sci = get_ti_sci_handle();
 211         int ret, node, subnode, len, prev_node;
 212         u32 range[4], addr, size;
 213         const fdt32_t *sub_reg;
 214
 215         ti_sci->ops.core_ops.query_msmc(ti_sci, &msmc_start, &msmc_end);
 216         msmc_size = msmc_end - msmc_start + 1;
 217         debug("%s: msmc_start = 0x%llx, msmc_size = 0x%llx\n", __func__,
 218               msmc_start, msmc_size);
 219
 220         /* find or create "msmc_sram node */
 221         ret = fdt_path_offset(blob, parent_path);
 222         if (ret < 0)
 223                 return ret;
 224
 225         node = fdt_find_or_add_subnode(blob, ret, node_name);
 226         if (node < 0)
 227                 return node;
 228
 229         ret = fdt_setprop_string(blob, node, "compatible", "mmio-sram");
 230         if (ret < 0)
 231                 return ret;
 232
 233         reg[0] = cpu_to_fdt64(msmc_start);
 234         reg[1] = cpu_to_fdt64(msmc_size);
 235         ret = fdt_setprop(blob, node, "reg", reg, sizeof(reg));
 236         if (ret < 0)
 237                 return ret;
 238
 239         fdt_setprop_cell(blob, node, "#address-cells", 1);
 240         fdt_setprop_cell(blob, node, "#size-cells", 1);
 241
 242         range[0] = 0;
 243         range[1] = cpu_to_fdt32(msmc_start >> 32);
 244         range[2] = cpu_to_fdt32(msmc_start & 0xffffffff);
 245         range[3] = cpu_to_fdt32(msmc_size);
 246         ret = fdt_setprop(blob, node, "ranges", range, sizeof(range));
 247         if (ret < 0)
 248                 return ret;
 249
 250         subnode = fdt_first_subnode(blob, node);
 251         prev_node = 0;
 252
 253         /* Look for invalid subnodes and delete them */
 254         while (subnode >= 0) {
 255                 sub_reg = fdt_getprop(blob, subnode, "reg", &len);
 256                 addr = fdt_read_number(sub_reg, 1);
 257                 sub_reg++;
 258                 size = fdt_read_number(sub_reg, 1);
 259                 debug("%s: subnode = %d, addr = 0x%x. size = 0x%x\n", __func__,
 260                       subnode, addr, size);
 261                 if (addr + size > msmc_size ||
 262                     !strncmp(fdt_get_name(blob, subnode, &len), "sysfw", 5) ||
 263                     !strncmp(fdt_get_name(blob, subnode, &len), "l3cache", 7)) {
 264                         fdt_del_node(blob, subnode);
 265                         debug("%s: deleting subnode %d\n", __func__, subnode);
 266                         if (!prev_node)
 267                                 subnode = fdt_first_subnode(blob, node);
 268                         else
 269                                 subnode = fdt_next_subnode(blob, prev_node);
 270                 } else {
 271                         prev_node = subnode;
 272                         subnode = fdt_next_subnode(blob, prev_node);
 273                 }
 274         }
 275
 276         return 0;
 277 }
 278
 279 int fdt_disable_node(void *blob, char *node_path)
 280 {
 281         int offs;
 282         int ret;
 283
 284         offs = fdt_path_offset(blob, node_path);
 285         if (offs < 0) {
 286                 printf("Node %s not found.\n", node_path);
 287                 return offs;
 288         }
 289         ret = fdt_setprop_string(blob, offs, "status", "disabled");
 290         if (ret < 0) {
 291                 printf("Could not add status property to node %s: %s\n",
 292                        node_path, fdt_strerror(ret));
 293                 return ret;
 294         }
 295         return 0;
 296 }
 297
 298 #endif
 299
 300 #ifndef CONFIG_SYSRESET
 301 void reset_cpu(ulong ignored)
 302 {
 303 }
 304 #endif
 305
 306 #if defined(CONFIG_DISPLAY_CPUINFO)
 307 int print_cpuinfo(void)
 308 {
 309         u32 soc, rev;
 310         char *name;
 311
 312         soc = (readl(CTRLMMR_WKUP_JTAG_ID) &
 313                 JTAG_ID_PARTNO_MASK) >> JTAG_ID_PARTNO_SHIFT;
 314         rev = (readl(CTRLMMR_WKUP_JTAG_ID) &
 315                 JTAG_ID_VARIANT_MASK) >> JTAG_ID_VARIANT_SHIFT;
 316
 317         printf("SoC:   ");
 318         switch (soc) {
 319         case AM65X:
 320                 name = "AM65x";
 321                 break;
 322         case J721E:
 323                 name = "J721E";
 324                 break;
 325         default:
 326                 name = "Unknown Silicon";
 327         };
 328
 329         printf("%s SR ", name);
 330         switch (rev) {
 331         case REV_PG1_0:
 332                 name = "1.0";
 333                 break;
 334         case REV_PG2_0:
 335                 name = "2.0";
 336                 break;
 337         default:
 338                 name = "Unknown Revision";
 339         };
 340         printf("%s\n", name);
 341
 342         return 0;
 343 }
 344 #endif
 345
 346 #ifdef CONFIG_ARM64
 347 void board_prep_linux(bootm_headers_t *images)
 348 {
 349         debug("Linux kernel Image start = 0x%lx end = 0x%lx\n",
 350               images->os.start, images->os.end);
 351         __asm_flush_dcache_range(images->os.start,
 352                                  ROUND(images->os.end,
 353                                        CONFIG_SYS_CACHELINE_SIZE));
 354 }
 355 #endif
 356
 357 #ifdef CONFIG_CPU_V7R
 358 void disable_linefill_optimization(void)
 359 {
 360         u32 actlr;
 361
 362         /*
 363          * On K3 devices there are 2 conditions where R5F can deadlock:
 364          * 1.When software is performing series of store operations to
 365          *   cacheable write back/write allocate memory region and later
 366          *   on software execute barrier operation (DSB or DMB). R5F may
 367          *   hang at the barrier instruction.
 368          * 2.When software is performing a mix of load and store operations
 369          *   within a tight loop and store operations are all writing to
 370          *   cacheable write back/write allocates memory regions, R5F may
 371          *   hang at one of the load instruction.
 372          *
 373          * To avoid the above two conditions disable linefill optimization
 374          * inside Cortex R5F.
 375          */
 376         asm("mrc p15, 0, %0, c1, c0, 1" : "=r" (actlr));
 377         actlr |= (1 << 13); /* Set DLFO bit  */
 378         asm("mcr p15, 0, %0, c1, c0, 1" : : "r" (actlr));
 379 }
 380 #endif
 381
 382 void remove_fwl_configs(struct fwl_data *fwl_data, size_t fwl_data_size)
 383 {
 384         struct ti_sci_msg_fwl_region region;
 385         struct ti_sci_fwl_ops *fwl_ops;
 386         struct ti_sci_handle *ti_sci;
 387         size_t i, j;
 388
 389         ti_sci = get_ti_sci_handle();
 390         fwl_ops = &ti_sci->ops.fwl_ops;
 391         for (i = 0; i < fwl_data_size; i++) {
 392                 for (j = 0; j <  fwl_data[i].regions; j++) {
 393                         region.fwl_id = fwl_data[i].fwl_id;
 394                         region.region = j;
 395                         region.n_permission_regs = 3;
 396
 397                         fwl_ops->get_fwl_region(ti_sci, &region);
 398
 399                         if (region.control != 0) {
 400                                 pr_debug("Attempting to disable firewall %5d (%25s)\n",
 401                                          region.fwl_id, fwl_data[i].name);
 402                                 region.control = 0;
 403
 404                                 if (fwl_ops->set_fwl_region(ti_sci, &region))
 405                                         pr_err("Could not disable firewall %5d (%25s)\n",
 406                                                region.fwl_id, fwl_data[i].name);
 407                         }
 408                 }
 409         }
 410 }