Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 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> |
Simon Glass | afb0215 | 2019-12-28 10:45:01 -0700 | [diff] [blame] | 10 | #include <cpu_func.h> |
Simon Glass | 2dc9c34 | 2020-05-10 11:40:01 -0600 | [diff] [blame] | 11 | #include <image.h> |
Simon Glass | 9758973 | 2020-05-10 11:40:02 -0600 | [diff] [blame] | 12 | #include <init.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 13 | #include <log.h> |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 14 | #include <spl.h> |
Simon Glass | 3ba929a | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 15 | #include <asm/global_data.h> |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 16 | #include "common.h" |
| 17 | #include <dm.h> |
| 18 | #include <remoteproc.h> |
Simon Glass | 274e0b0 | 2020-05-10 11:39:56 -0600 | [diff] [blame] | 19 | #include <asm/cache.h> |
Lokesh Vutla | 28cd824 | 2019-03-08 11:47:33 +0530 | [diff] [blame] | 20 | #include <linux/soc/ti/ti_sci_protocol.h> |
Lokesh Vutla | 16cf5d2 | 2019-03-08 11:47:34 +0530 | [diff] [blame] | 21 | #include <fdt_support.h> |
Andreas Dannenberg | 31175f8 | 2019-06-07 19:24:42 +0530 | [diff] [blame] | 22 | #include <asm/arch/sys_proto.h> |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 23 | #include <asm/hardware.h> |
| 24 | #include <asm/io.h> |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 25 | #include <fs_loader.h> |
| 26 | #include <fs.h> |
| 27 | #include <env.h> |
| 28 | #include <elf.h> |
Dave Gerlach | c74227f | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 29 | #include <soc.h> |
Lokesh Vutla | 28cd824 | 2019-03-08 11:47:33 +0530 | [diff] [blame] | 30 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 31 | #if IS_ENABLED(CONFIG_SYS_K3_SPL_ATF) |
| 32 | enum { |
| 33 | IMAGE_ID_ATF, |
| 34 | IMAGE_ID_OPTEE, |
| 35 | IMAGE_ID_SPL, |
| 36 | IMAGE_ID_DM_FW, |
| 37 | IMAGE_AMT, |
| 38 | }; |
| 39 | |
| 40 | #if CONFIG_IS_ENABLED(FIT_IMAGE_POST_PROCESS) |
| 41 | static const char *image_os_match[IMAGE_AMT] = { |
| 42 | "arm-trusted-firmware", |
| 43 | "tee", |
| 44 | "U-Boot", |
| 45 | "DM", |
| 46 | }; |
| 47 | #endif |
| 48 | |
| 49 | static struct image_info fit_image_info[IMAGE_AMT]; |
| 50 | #endif |
| 51 | |
Lokesh Vutla | 28cd824 | 2019-03-08 11:47:33 +0530 | [diff] [blame] | 52 | struct ti_sci_handle *get_ti_sci_handle(void) |
| 53 | { |
| 54 | struct udevice *dev; |
| 55 | int ret; |
| 56 | |
Lokesh Vutla | 00a1513 | 2019-09-27 13:32:15 +0530 | [diff] [blame] | 57 | ret = uclass_get_device_by_driver(UCLASS_FIRMWARE, |
Simon Glass | 65130cd | 2020-12-28 20:34:56 -0700 | [diff] [blame] | 58 | DM_DRIVER_GET(ti_sci), &dev); |
Lokesh Vutla | 28cd824 | 2019-03-08 11:47:33 +0530 | [diff] [blame] | 59 | if (ret) |
| 60 | panic("Failed to get SYSFW (%d)\n", ret); |
| 61 | |
| 62 | return (struct ti_sci_handle *)ti_sci_get_handle_from_sysfw(dev); |
| 63 | } |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 64 | |
Lokesh Vutla | 5fafe44 | 2020-03-10 16:50:58 +0530 | [diff] [blame] | 65 | void k3_sysfw_print_ver(void) |
| 66 | { |
| 67 | struct ti_sci_handle *ti_sci = get_ti_sci_handle(); |
| 68 | char fw_desc[sizeof(ti_sci->version.firmware_description) + 1]; |
| 69 | |
| 70 | /* |
| 71 | * Output System Firmware version info. Note that since the |
| 72 | * 'firmware_description' field is not guaranteed to be zero- |
| 73 | * terminated we manually add a \0 terminator if needed. Further |
| 74 | * note that we intentionally no longer rely on the extended |
| 75 | * printf() formatter '%.*s' to not having to require a more |
| 76 | * full-featured printf() implementation. |
| 77 | */ |
| 78 | strncpy(fw_desc, ti_sci->version.firmware_description, |
| 79 | sizeof(ti_sci->version.firmware_description)); |
| 80 | fw_desc[sizeof(fw_desc) - 1] = '\0'; |
| 81 | |
| 82 | printf("SYSFW ABI: %d.%d (firmware rev 0x%04x '%s')\n", |
| 83 | ti_sci->version.abi_major, ti_sci->version.abi_minor, |
| 84 | ti_sci->version.firmware_revision, fw_desc); |
| 85 | } |
| 86 | |
Lokesh Vutla | ff7ab09 | 2020-08-05 22:44:17 +0530 | [diff] [blame] | 87 | void mmr_unlock(phys_addr_t base, u32 partition) |
| 88 | { |
| 89 | /* Translate the base address */ |
| 90 | phys_addr_t part_base = base + partition * CTRL_MMR0_PARTITION_SIZE; |
| 91 | |
| 92 | /* Unlock the requested partition if locked using two-step sequence */ |
| 93 | writel(CTRLMMR_LOCK_KICK0_UNLOCK_VAL, part_base + CTRLMMR_LOCK_KICK0); |
| 94 | writel(CTRLMMR_LOCK_KICK1_UNLOCK_VAL, part_base + CTRLMMR_LOCK_KICK1); |
| 95 | } |
| 96 | |
Lokesh Vutla | 8be6bbf | 2020-08-05 22:44:23 +0530 | [diff] [blame] | 97 | bool is_rom_loaded_sysfw(struct rom_extended_boot_data *data) |
| 98 | { |
| 99 | if (strncmp(data->header, K3_ROM_BOOT_HEADER_MAGIC, 7)) |
| 100 | return false; |
| 101 | |
| 102 | return data->num_components > 1; |
| 103 | } |
| 104 | |
Andreas Dannenberg | d13ec8c | 2019-08-15 15:55:28 -0500 | [diff] [blame] | 105 | DECLARE_GLOBAL_DATA_PTR; |
| 106 | |
| 107 | #ifdef CONFIG_K3_EARLY_CONS |
| 108 | int early_console_init(void) |
| 109 | { |
| 110 | struct udevice *dev; |
| 111 | int ret; |
| 112 | |
| 113 | gd->baudrate = CONFIG_BAUDRATE; |
| 114 | |
| 115 | ret = uclass_get_device_by_seq(UCLASS_SERIAL, CONFIG_K3_EARLY_CONS_IDX, |
| 116 | &dev); |
| 117 | if (ret) { |
| 118 | printf("Error getting serial dev for early console! (%d)\n", |
| 119 | ret); |
| 120 | return ret; |
| 121 | } |
| 122 | |
| 123 | gd->cur_serial_dev = dev; |
| 124 | gd->flags |= GD_FLG_SERIAL_READY; |
| 125 | gd->have_console = 1; |
| 126 | |
| 127 | return 0; |
| 128 | } |
| 129 | #endif |
| 130 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 131 | #if IS_ENABLED(CONFIG_SYS_K3_SPL_ATF) |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 132 | |
| 133 | void init_env(void) |
| 134 | { |
| 135 | #ifdef CONFIG_SPL_ENV_SUPPORT |
| 136 | char *part; |
| 137 | |
| 138 | env_init(); |
| 139 | env_relocate(); |
| 140 | switch (spl_boot_device()) { |
| 141 | case BOOT_DEVICE_MMC2: |
| 142 | part = env_get("bootpart"); |
| 143 | env_set("storage_interface", "mmc"); |
| 144 | env_set("fw_dev_part", part); |
| 145 | break; |
| 146 | case BOOT_DEVICE_SPI: |
| 147 | env_set("storage_interface", "ubi"); |
| 148 | env_set("fw_ubi_mtdpart", "UBI"); |
| 149 | env_set("fw_ubi_volume", "UBI0"); |
| 150 | break; |
| 151 | default: |
| 152 | printf("%s from device %u not supported!\n", |
| 153 | __func__, spl_boot_device()); |
| 154 | return; |
| 155 | } |
| 156 | #endif |
| 157 | } |
| 158 | |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 159 | int load_firmware(char *name_fw, char *name_loadaddr, u32 *loadaddr) |
| 160 | { |
| 161 | struct udevice *fsdev; |
| 162 | char *name = NULL; |
| 163 | int size = 0; |
| 164 | |
Keerthy | fe8f609 | 2022-01-27 13:16:53 +0100 | [diff] [blame] | 165 | if (!IS_ENABLED(CONFIG_FS_LOADER)) |
| 166 | return 0; |
| 167 | |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 168 | *loadaddr = 0; |
| 169 | #ifdef CONFIG_SPL_ENV_SUPPORT |
| 170 | switch (spl_boot_device()) { |
| 171 | case BOOT_DEVICE_MMC2: |
| 172 | name = env_get(name_fw); |
| 173 | *loadaddr = env_get_hex(name_loadaddr, *loadaddr); |
| 174 | break; |
| 175 | default: |
| 176 | printf("Loading rproc fw image from device %u not supported!\n", |
| 177 | spl_boot_device()); |
| 178 | return 0; |
| 179 | } |
| 180 | #endif |
| 181 | if (!*loadaddr) |
| 182 | return 0; |
| 183 | |
| 184 | if (!uclass_get_device(UCLASS_FS_FIRMWARE_LOADER, 0, &fsdev)) { |
| 185 | size = request_firmware_into_buf(fsdev, name, (void *)*loadaddr, |
| 186 | 0, 0); |
| 187 | } |
| 188 | |
| 189 | return size; |
| 190 | } |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 191 | |
Suman Anna | 3457410 | 2021-07-27 18:24:40 -0500 | [diff] [blame] | 192 | __weak void release_resources_for_core_shutdown(void) |
| 193 | { |
| 194 | debug("%s not implemented...\n", __func__); |
| 195 | } |
| 196 | |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 197 | void __noreturn jump_to_image_no_args(struct spl_image_info *spl_image) |
| 198 | { |
Keerthy | 20c87b0 | 2020-02-12 13:55:06 +0530 | [diff] [blame] | 199 | typedef void __noreturn (*image_entry_noargs_t)(void); |
Lokesh Vutla | 005476d | 2019-06-07 19:24:43 +0530 | [diff] [blame] | 200 | struct ti_sci_handle *ti_sci = get_ti_sci_handle(); |
Keerthy | 20c87b0 | 2020-02-12 13:55:06 +0530 | [diff] [blame] | 201 | u32 loadaddr = 0; |
Nishanth Menon | 1535e2a | 2021-08-31 13:20:48 -0500 | [diff] [blame] | 202 | int ret, size = 0, shut_cpu = 0; |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 203 | |
Lokesh Vutla | 005476d | 2019-06-07 19:24:43 +0530 | [diff] [blame] | 204 | /* Release all the exclusive devices held by SPL before starting ATF */ |
| 205 | ti_sci->ops.dev_ops.release_exclusive_devices(ti_sci); |
| 206 | |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 207 | ret = rproc_init(); |
| 208 | if (ret) |
| 209 | panic("rproc failed to be initialized (%d)\n", ret); |
| 210 | |
| 211 | init_env(); |
Dave Gerlach | cdd0245 | 2021-06-11 11:45:21 +0300 | [diff] [blame] | 212 | |
| 213 | if (!fit_image_info[IMAGE_ID_DM_FW].image_start) { |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 214 | size = load_firmware("name_mcur5f0_0fw", "addr_mcur5f0_0load", |
| 215 | &loadaddr); |
Dave Gerlach | cdd0245 | 2021-06-11 11:45:21 +0300 | [diff] [blame] | 216 | } |
Keerthy | 7007adc | 2020-02-12 13:55:04 +0530 | [diff] [blame] | 217 | |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 218 | /* |
| 219 | * It is assumed that remoteproc device 1 is the corresponding |
Andreas Dannenberg | 376c0fe | 2019-02-04 12:58:47 -0600 | [diff] [blame] | 220 | * Cortex-A core which runs ATF. Make sure DT reflects the same. |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 221 | */ |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 222 | if (!fit_image_info[IMAGE_ID_ATF].image_start) |
| 223 | fit_image_info[IMAGE_ID_ATF].image_start = |
| 224 | spl_image->entry_point; |
| 225 | |
| 226 | ret = rproc_load(1, fit_image_info[IMAGE_ID_ATF].image_start, 0x200); |
Andreas Dannenberg | 376c0fe | 2019-02-04 12:58:47 -0600 | [diff] [blame] | 227 | if (ret) |
| 228 | panic("%s: ATF failed to load on rproc (%d)\n", __func__, ret); |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 229 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 230 | if (!fit_image_info[IMAGE_ID_DM_FW].image_len && |
| 231 | !(size > 0 && valid_elf_image(loadaddr))) { |
Nishanth Menon | 1535e2a | 2021-08-31 13:20:48 -0500 | [diff] [blame] | 232 | shut_cpu = 1; |
| 233 | goto start_arm64; |
Keerthy | 20c87b0 | 2020-02-12 13:55:06 +0530 | [diff] [blame] | 234 | } |
| 235 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 236 | if (!fit_image_info[IMAGE_ID_DM_FW].image_start) { |
| 237 | loadaddr = load_elf_image_phdr(loadaddr); |
| 238 | } else { |
| 239 | loadaddr = fit_image_info[IMAGE_ID_DM_FW].image_start; |
| 240 | if (valid_elf_image(loadaddr)) |
| 241 | loadaddr = load_elf_image_phdr(loadaddr); |
| 242 | } |
| 243 | |
| 244 | debug("%s: jumping to address %x\n", __func__, loadaddr); |
| 245 | |
Nishanth Menon | 1535e2a | 2021-08-31 13:20:48 -0500 | [diff] [blame] | 246 | start_arm64: |
| 247 | /* Add an extra newline to differentiate the ATF logs from SPL */ |
| 248 | printf("Starting ATF on ARM64 core...\n\n"); |
| 249 | |
| 250 | ret = rproc_start(1); |
| 251 | if (ret) |
| 252 | panic("%s: ATF failed to start on rproc (%d)\n", __func__, ret); |
| 253 | |
| 254 | if (shut_cpu) { |
| 255 | debug("Shutting down...\n"); |
| 256 | release_resources_for_core_shutdown(); |
| 257 | |
| 258 | while (1) |
| 259 | asm volatile("wfe"); |
| 260 | } |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 261 | image_entry_noargs_t image_entry = (image_entry_noargs_t)loadaddr; |
Andreas Dannenberg | 31175f8 | 2019-06-07 19:24:42 +0530 | [diff] [blame] | 262 | |
Keerthy | 20c87b0 | 2020-02-12 13:55:06 +0530 | [diff] [blame] | 263 | image_entry(); |
Lokesh Vutla | 5d83fd2 | 2018-11-02 19:51:05 +0530 | [diff] [blame] | 264 | } |
| 265 | #endif |
Lokesh Vutla | 16cf5d2 | 2019-03-08 11:47:34 +0530 | [diff] [blame] | 266 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 267 | #if CONFIG_IS_ENABLED(FIT_IMAGE_POST_PROCESS) |
| 268 | void board_fit_image_post_process(const void *fit, int node, void **p_image, |
| 269 | size_t *p_size) |
| 270 | { |
| 271 | #if IS_ENABLED(CONFIG_SYS_K3_SPL_ATF) |
| 272 | int len; |
| 273 | int i; |
| 274 | const char *os; |
| 275 | u32 addr; |
| 276 | |
| 277 | os = fdt_getprop(fit, node, "os", &len); |
| 278 | addr = fdt_getprop_u32_default_node(fit, node, 0, "entry", -1); |
| 279 | |
| 280 | debug("%s: processing image: addr=%x, size=%d, os=%s\n", __func__, |
| 281 | addr, *p_size, os); |
| 282 | |
| 283 | for (i = 0; i < IMAGE_AMT; i++) { |
| 284 | if (!strcmp(os, image_os_match[i])) { |
| 285 | fit_image_info[i].image_start = addr; |
| 286 | fit_image_info[i].image_len = *p_size; |
| 287 | debug("%s: matched image for ID %d\n", __func__, i); |
| 288 | break; |
| 289 | } |
| 290 | } |
| 291 | #endif |
| 292 | |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 293 | ti_secure_image_post_process(p_image, p_size); |
Tero Kristo | 738c590 | 2021-06-11 11:45:19 +0300 | [diff] [blame] | 294 | } |
| 295 | #endif |
| 296 | |
Lokesh Vutla | 16cf5d2 | 2019-03-08 11:47:34 +0530 | [diff] [blame] | 297 | #if defined(CONFIG_OF_LIBFDT) |
| 298 | int fdt_fixup_msmc_ram(void *blob, char *parent_path, char *node_name) |
| 299 | { |
| 300 | u64 msmc_start = 0, msmc_end = 0, msmc_size, reg[2]; |
| 301 | struct ti_sci_handle *ti_sci = get_ti_sci_handle(); |
| 302 | int ret, node, subnode, len, prev_node; |
| 303 | u32 range[4], addr, size; |
| 304 | const fdt32_t *sub_reg; |
| 305 | |
| 306 | ti_sci->ops.core_ops.query_msmc(ti_sci, &msmc_start, &msmc_end); |
| 307 | msmc_size = msmc_end - msmc_start + 1; |
| 308 | debug("%s: msmc_start = 0x%llx, msmc_size = 0x%llx\n", __func__, |
| 309 | msmc_start, msmc_size); |
| 310 | |
| 311 | /* find or create "msmc_sram node */ |
| 312 | ret = fdt_path_offset(blob, parent_path); |
| 313 | if (ret < 0) |
| 314 | return ret; |
| 315 | |
| 316 | node = fdt_find_or_add_subnode(blob, ret, node_name); |
| 317 | if (node < 0) |
| 318 | return node; |
| 319 | |
| 320 | ret = fdt_setprop_string(blob, node, "compatible", "mmio-sram"); |
| 321 | if (ret < 0) |
| 322 | return ret; |
| 323 | |
| 324 | reg[0] = cpu_to_fdt64(msmc_start); |
| 325 | reg[1] = cpu_to_fdt64(msmc_size); |
| 326 | ret = fdt_setprop(blob, node, "reg", reg, sizeof(reg)); |
| 327 | if (ret < 0) |
| 328 | return ret; |
| 329 | |
| 330 | fdt_setprop_cell(blob, node, "#address-cells", 1); |
| 331 | fdt_setprop_cell(blob, node, "#size-cells", 1); |
| 332 | |
| 333 | range[0] = 0; |
| 334 | range[1] = cpu_to_fdt32(msmc_start >> 32); |
| 335 | range[2] = cpu_to_fdt32(msmc_start & 0xffffffff); |
| 336 | range[3] = cpu_to_fdt32(msmc_size); |
| 337 | ret = fdt_setprop(blob, node, "ranges", range, sizeof(range)); |
| 338 | if (ret < 0) |
| 339 | return ret; |
| 340 | |
| 341 | subnode = fdt_first_subnode(blob, node); |
| 342 | prev_node = 0; |
| 343 | |
| 344 | /* Look for invalid subnodes and delete them */ |
| 345 | while (subnode >= 0) { |
| 346 | sub_reg = fdt_getprop(blob, subnode, "reg", &len); |
| 347 | addr = fdt_read_number(sub_reg, 1); |
| 348 | sub_reg++; |
| 349 | size = fdt_read_number(sub_reg, 1); |
| 350 | debug("%s: subnode = %d, addr = 0x%x. size = 0x%x\n", __func__, |
| 351 | subnode, addr, size); |
| 352 | if (addr + size > msmc_size || |
| 353 | !strncmp(fdt_get_name(blob, subnode, &len), "sysfw", 5) || |
| 354 | !strncmp(fdt_get_name(blob, subnode, &len), "l3cache", 7)) { |
| 355 | fdt_del_node(blob, subnode); |
| 356 | debug("%s: deleting subnode %d\n", __func__, subnode); |
| 357 | if (!prev_node) |
| 358 | subnode = fdt_first_subnode(blob, node); |
| 359 | else |
| 360 | subnode = fdt_next_subnode(blob, prev_node); |
| 361 | } else { |
| 362 | prev_node = subnode; |
| 363 | subnode = fdt_next_subnode(blob, prev_node); |
| 364 | } |
| 365 | } |
| 366 | |
| 367 | return 0; |
| 368 | } |
Andrew F. Davis | 6c43b52 | 2019-09-17 17:15:40 -0400 | [diff] [blame] | 369 | |
| 370 | int fdt_disable_node(void *blob, char *node_path) |
| 371 | { |
| 372 | int offs; |
| 373 | int ret; |
| 374 | |
| 375 | offs = fdt_path_offset(blob, node_path); |
| 376 | if (offs < 0) { |
Andrew F. Davis | 7e13f2c | 2020-01-07 18:12:40 -0500 | [diff] [blame] | 377 | printf("Node %s not found.\n", node_path); |
| 378 | return offs; |
Andrew F. Davis | 6c43b52 | 2019-09-17 17:15:40 -0400 | [diff] [blame] | 379 | } |
| 380 | ret = fdt_setprop_string(blob, offs, "status", "disabled"); |
| 381 | if (ret < 0) { |
| 382 | printf("Could not add status property to node %s: %s\n", |
| 383 | node_path, fdt_strerror(ret)); |
| 384 | return ret; |
| 385 | } |
| 386 | return 0; |
| 387 | } |
| 388 | |
Lokesh Vutla | 16cf5d2 | 2019-03-08 11:47:34 +0530 | [diff] [blame] | 389 | #endif |
Lokesh Vutla | a228532 | 2019-06-13 10:29:42 +0530 | [diff] [blame] | 390 | |
| 391 | #ifndef CONFIG_SYSRESET |
Harald Seiler | 6f14d5f | 2020-12-15 16:47:52 +0100 | [diff] [blame] | 392 | void reset_cpu(void) |
Lokesh Vutla | a228532 | 2019-06-13 10:29:42 +0530 | [diff] [blame] | 393 | { |
| 394 | } |
| 395 | #endif |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 396 | |
Andrew Davis | f8c9836 | 2022-07-15 11:34:32 -0500 | [diff] [blame] | 397 | enum k3_device_type get_device_type(void) |
| 398 | { |
| 399 | u32 sys_status = readl(K3_SEC_MGR_SYS_STATUS); |
| 400 | |
| 401 | u32 sys_dev_type = (sys_status & SYS_STATUS_DEV_TYPE_MASK) >> |
| 402 | SYS_STATUS_DEV_TYPE_SHIFT; |
| 403 | |
| 404 | u32 sys_sub_type = (sys_status & SYS_STATUS_SUB_TYPE_MASK) >> |
| 405 | SYS_STATUS_SUB_TYPE_SHIFT; |
| 406 | |
| 407 | switch (sys_dev_type) { |
| 408 | case SYS_STATUS_DEV_TYPE_GP: |
| 409 | return K3_DEVICE_TYPE_GP; |
| 410 | case SYS_STATUS_DEV_TYPE_TEST: |
| 411 | return K3_DEVICE_TYPE_TEST; |
| 412 | case SYS_STATUS_DEV_TYPE_EMU: |
| 413 | return K3_DEVICE_TYPE_EMU; |
| 414 | case SYS_STATUS_DEV_TYPE_HS: |
| 415 | if (sys_sub_type == SYS_STATUS_SUB_TYPE_VAL_FS) |
| 416 | return K3_DEVICE_TYPE_HS_FS; |
| 417 | else |
| 418 | return K3_DEVICE_TYPE_HS_SE; |
| 419 | default: |
| 420 | return K3_DEVICE_TYPE_BAD; |
| 421 | } |
| 422 | } |
| 423 | |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 424 | #if defined(CONFIG_DISPLAY_CPUINFO) |
Andrew Davis | f8c9836 | 2022-07-15 11:34:32 -0500 | [diff] [blame] | 425 | static const char *get_device_type_name(void) |
| 426 | { |
| 427 | enum k3_device_type type = get_device_type(); |
| 428 | |
| 429 | switch (type) { |
| 430 | case K3_DEVICE_TYPE_GP: |
| 431 | return "GP"; |
| 432 | case K3_DEVICE_TYPE_TEST: |
| 433 | return "TEST"; |
| 434 | case K3_DEVICE_TYPE_EMU: |
| 435 | return "EMU"; |
| 436 | case K3_DEVICE_TYPE_HS_FS: |
| 437 | return "HS-FS"; |
| 438 | case K3_DEVICE_TYPE_HS_SE: |
| 439 | return "HS-SE"; |
| 440 | default: |
| 441 | return "BAD"; |
| 442 | } |
| 443 | } |
| 444 | |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 445 | int print_cpuinfo(void) |
| 446 | { |
Dave Gerlach | c74227f | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 447 | struct udevice *soc; |
| 448 | char name[64]; |
| 449 | int ret; |
Dave Gerlach | 3373ee0 | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 450 | |
Tom Rini | 5a9ecb2 | 2020-07-24 08:42:06 -0400 | [diff] [blame] | 451 | printf("SoC: "); |
Dave Gerlach | 3373ee0 | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 452 | |
Dave Gerlach | c74227f | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 453 | ret = soc_get(&soc); |
| 454 | if (ret) { |
| 455 | printf("UNKNOWN\n"); |
| 456 | return 0; |
| 457 | } |
| 458 | |
| 459 | ret = soc_get_family(soc, name, 64); |
| 460 | if (!ret) { |
| 461 | printf("%s ", name); |
| 462 | } |
| 463 | |
| 464 | ret = soc_get_revision(soc, name, 64); |
| 465 | if (!ret) { |
Andrew Davis | f8c9836 | 2022-07-15 11:34:32 -0500 | [diff] [blame] | 466 | printf("%s ", name); |
Dave Gerlach | c74227f | 2020-07-15 23:40:04 -0500 | [diff] [blame] | 467 | } |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 468 | |
Andrew Davis | f8c9836 | 2022-07-15 11:34:32 -0500 | [diff] [blame] | 469 | printf("%s\n", get_device_type_name()); |
| 470 | |
Lokesh Vutla | a04cf3b | 2019-09-27 13:32:11 +0530 | [diff] [blame] | 471 | return 0; |
| 472 | } |
| 473 | #endif |
Lokesh Vutla | 362beda | 2019-10-07 13:52:17 +0530 | [diff] [blame] | 474 | |
Lokesh Vutla | 6554994 | 2020-08-05 22:44:19 +0530 | [diff] [blame] | 475 | bool soc_is_j721e(void) |
| 476 | { |
| 477 | u32 soc; |
| 478 | |
| 479 | soc = (readl(CTRLMMR_WKUP_JTAG_ID) & |
| 480 | JTAG_ID_PARTNO_MASK) >> JTAG_ID_PARTNO_SHIFT; |
| 481 | |
| 482 | return soc == J721E; |
| 483 | } |
| 484 | |
Lokesh Vutla | 0318a08 | 2020-08-05 22:44:21 +0530 | [diff] [blame] | 485 | bool soc_is_j7200(void) |
| 486 | { |
| 487 | u32 soc; |
| 488 | |
| 489 | soc = (readl(CTRLMMR_WKUP_JTAG_ID) & |
| 490 | JTAG_ID_PARTNO_MASK) >> JTAG_ID_PARTNO_SHIFT; |
| 491 | |
| 492 | return soc == J7200; |
| 493 | } |
| 494 | |
Lokesh Vutla | 362beda | 2019-10-07 13:52:17 +0530 | [diff] [blame] | 495 | #ifdef CONFIG_ARM64 |
| 496 | void board_prep_linux(bootm_headers_t *images) |
| 497 | { |
| 498 | debug("Linux kernel Image start = 0x%lx end = 0x%lx\n", |
| 499 | images->os.start, images->os.end); |
| 500 | __asm_flush_dcache_range(images->os.start, |
| 501 | ROUND(images->os.end, |
| 502 | CONFIG_SYS_CACHELINE_SIZE)); |
| 503 | } |
| 504 | #endif |
Lokesh Vutla | 5fbd6fe | 2019-12-31 15:49:55 +0530 | [diff] [blame] | 505 | |
| 506 | #ifdef CONFIG_CPU_V7R |
| 507 | void disable_linefill_optimization(void) |
| 508 | { |
| 509 | u32 actlr; |
| 510 | |
| 511 | /* |
| 512 | * On K3 devices there are 2 conditions where R5F can deadlock: |
| 513 | * 1.When software is performing series of store operations to |
| 514 | * cacheable write back/write allocate memory region and later |
| 515 | * on software execute barrier operation (DSB or DMB). R5F may |
| 516 | * hang at the barrier instruction. |
| 517 | * 2.When software is performing a mix of load and store operations |
| 518 | * within a tight loop and store operations are all writing to |
| 519 | * cacheable write back/write allocates memory regions, R5F may |
| 520 | * hang at one of the load instruction. |
| 521 | * |
| 522 | * To avoid the above two conditions disable linefill optimization |
| 523 | * inside Cortex R5F. |
| 524 | */ |
| 525 | asm("mrc p15, 0, %0, c1, c0, 1" : "=r" (actlr)); |
| 526 | actlr |= (1 << 13); /* Set DLFO bit */ |
| 527 | asm("mcr p15, 0, %0, c1, c0, 1" : : "r" (actlr)); |
| 528 | } |
| 529 | #endif |
Andrew F. Davis | f0bcb66 | 2020-01-10 14:35:21 -0500 | [diff] [blame] | 530 | |
| 531 | void remove_fwl_configs(struct fwl_data *fwl_data, size_t fwl_data_size) |
| 532 | { |
| 533 | struct ti_sci_msg_fwl_region region; |
| 534 | struct ti_sci_fwl_ops *fwl_ops; |
| 535 | struct ti_sci_handle *ti_sci; |
| 536 | size_t i, j; |
| 537 | |
| 538 | ti_sci = get_ti_sci_handle(); |
| 539 | fwl_ops = &ti_sci->ops.fwl_ops; |
| 540 | for (i = 0; i < fwl_data_size; i++) { |
| 541 | for (j = 0; j < fwl_data[i].regions; j++) { |
| 542 | region.fwl_id = fwl_data[i].fwl_id; |
| 543 | region.region = j; |
| 544 | region.n_permission_regs = 3; |
| 545 | |
| 546 | fwl_ops->get_fwl_region(ti_sci, ®ion); |
| 547 | |
| 548 | if (region.control != 0) { |
| 549 | pr_debug("Attempting to disable firewall %5d (%25s)\n", |
| 550 | region.fwl_id, fwl_data[i].name); |
| 551 | region.control = 0; |
| 552 | |
| 553 | if (fwl_ops->set_fwl_region(ti_sci, ®ion)) |
| 554 | pr_err("Could not disable firewall %5d (%25s)\n", |
| 555 | region.fwl_id, fwl_data[i].name); |
| 556 | } |
| 557 | } |
| 558 | } |
| 559 | } |
Jan Kiszka | 7ce99f7 | 2020-05-18 07:57:22 +0200 | [diff] [blame] | 560 | |
| 561 | void spl_enable_dcache(void) |
| 562 | { |
| 563 | #if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) |
| 564 | phys_addr_t ram_top = CONFIG_SYS_SDRAM_BASE; |
| 565 | |
Georgi Vlaev | a5076cd | 2022-06-14 17:45:30 +0300 | [diff] [blame] | 566 | dram_init(); |
Jan Kiszka | 7ce99f7 | 2020-05-18 07:57:22 +0200 | [diff] [blame] | 567 | |
| 568 | /* reserve TLB table */ |
| 569 | gd->arch.tlb_size = PGTABLE_SIZE; |
| 570 | |
| 571 | ram_top += get_effective_memsize(); |
| 572 | /* keep ram_top in the 32-bit address space */ |
| 573 | if (ram_top >= 0x100000000) |
| 574 | ram_top = (phys_addr_t) 0x100000000; |
| 575 | |
| 576 | gd->arch.tlb_addr = ram_top - gd->arch.tlb_size; |
| 577 | debug("TLB table from %08lx to %08lx\n", gd->arch.tlb_addr, |
| 578 | gd->arch.tlb_addr + gd->arch.tlb_size); |
| 579 | |
| 580 | dcache_enable(); |
| 581 | #endif |
| 582 | } |
| 583 | |
| 584 | #if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF)) |
| 585 | void spl_board_prepare_for_boot(void) |
| 586 | { |
| 587 | dcache_disable(); |
| 588 | } |
| 589 | |
Patrick Delaunay | 35c949c | 2020-07-07 14:25:15 +0200 | [diff] [blame] | 590 | void spl_board_prepare_for_linux(void) |
Jan Kiszka | 7ce99f7 | 2020-05-18 07:57:22 +0200 | [diff] [blame] | 591 | { |
| 592 | dcache_disable(); |
| 593 | } |
| 594 | #endif |
Vignesh Raghavendra | 030f405 | 2021-12-24 12:55:29 +0530 | [diff] [blame] | 595 | |
| 596 | int misc_init_r(void) |
| 597 | { |
| 598 | if (IS_ENABLED(CONFIG_TI_AM65_CPSW_NUSS)) { |
| 599 | struct udevice *dev; |
| 600 | int ret; |
| 601 | |
| 602 | ret = uclass_get_device_by_driver(UCLASS_MISC, |
| 603 | DM_DRIVER_GET(am65_cpsw_nuss), |
| 604 | &dev); |
| 605 | if (ret) |
| 606 | printf("Failed to probe am65_cpsw_nuss driver\n"); |
| 607 | } |
| 608 | |
| 609 | return 0; |
| 610 | } |