1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2009 Sunplus Core Technology Co., Ltd. 4 * Chen Liqin <liqin.chen@sunplusct.com> 5 * Lennox Wu <lennox.wu@sunplusct.com> 6 * Copyright (C) 2012 Regents of the University of California 7 * Copyright (C) 2020 FORTH-ICS/CARV 8 * Nick Kossifidis <mick@ics.forth.gr> 9 */ 10 11 #include <linux/init.h> 12 #include <linux/mm.h> 13 #include <linux/memblock.h> 14 #include <linux/sched.h> 15 #include <linux/console.h> 16 #include <linux/screen_info.h> 17 #include <linux/of_fdt.h> 18 #include <linux/of_platform.h> 19 #include <linux/sched/task.h> 20 #include <linux/swiotlb.h> 21 #include <linux/smp.h> 22 #include <linux/efi.h> 23 24 #include <asm/cpu_ops.h> 25 #include <asm/early_ioremap.h> 26 #include <asm/setup.h> 27 #include <asm/set_memory.h> 28 #include <asm/sections.h> 29 #include <asm/sbi.h> 30 #include <asm/tlbflush.h> 31 #include <asm/thread_info.h> 32 #include <asm/kasan.h> 33 #include <asm/efi.h> 34 35 #include "head.h" 36 37 #if defined(CONFIG_DUMMY_CONSOLE) || defined(CONFIG_EFI) 38 struct screen_info screen_info __section(".data") = { 39 .orig_video_lines = 30, 40 .orig_video_cols = 80, 41 .orig_video_mode = 0, 42 .orig_video_ega_bx = 0, 43 .orig_video_isVGA = 1, 44 .orig_video_points = 8 45 }; 46 #endif 47 48 /* 49 * The lucky hart to first increment this variable will boot the other cores. 50 * This is used before the kernel initializes the BSS so it can't be in the 51 * BSS. 52 */ 53 atomic_t hart_lottery __section(".sdata"); 54 unsigned long boot_cpu_hartid; 55 static DEFINE_PER_CPU(struct cpu, cpu_devices); 56 57 /* 58 * Place kernel memory regions on the resource tree so that 59 * kexec-tools can retrieve them from /proc/iomem. While there 60 * also add "System RAM" regions for compatibility with other 61 * archs, and the rest of the known regions for completeness. 62 */ 63 static struct resource code_res = { .name = "Kernel code", }; 64 static struct resource data_res = { .name = "Kernel data", }; 65 static struct resource rodata_res = { .name = "Kernel rodata", }; 66 static struct resource bss_res = { .name = "Kernel bss", }; 67 68 static int __init add_resource(struct resource *parent, 69 struct resource *res) 70 { 71 int ret = 0; 72 73 ret = insert_resource(parent, res); 74 if (ret < 0) { 75 pr_err("Failed to add a %s resource at %llx\n", 76 res->name, (unsigned long long) res->start); 77 return ret; 78 } 79 80 return 1; 81 } 82 83 static int __init add_kernel_resources(struct resource *res) 84 { 85 int ret = 0; 86 87 /* 88 * The memory region of the kernel image is continuous and 89 * was reserved on setup_bootmem, find it here and register 90 * it as a resource, then register the various segments of 91 * the image as child nodes 92 */ 93 if (!(res->start <= code_res.start && res->end >= data_res.end)) 94 return 0; 95 96 res->name = "Kernel image"; 97 res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 98 99 /* 100 * We removed a part of this region on setup_bootmem so 101 * we need to expand the resource for the bss to fit in. 102 */ 103 res->end = bss_res.end; 104 105 ret = add_resource(&iomem_resource, res); 106 if (ret < 0) 107 return ret; 108 109 ret = add_resource(res, &code_res); 110 if (ret < 0) 111 return ret; 112 113 ret = add_resource(res, &rodata_res); 114 if (ret < 0) 115 return ret; 116 117 ret = add_resource(res, &data_res); 118 if (ret < 0) 119 return ret; 120 121 ret = add_resource(res, &bss_res); 122 123 return ret; 124 } 125 126 static void __init init_resources(void) 127 { 128 struct memblock_region *region = NULL; 129 struct resource *res = NULL; 130 struct resource *mem_res = NULL; 131 size_t mem_res_sz = 0; 132 int ret = 0, i = 0; 133 134 code_res.start = __pa_symbol(_text); 135 code_res.end = __pa_symbol(_etext) - 1; 136 code_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 137 138 rodata_res.start = __pa_symbol(__start_rodata); 139 rodata_res.end = __pa_symbol(__end_rodata) - 1; 140 rodata_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 141 142 data_res.start = __pa_symbol(_data); 143 data_res.end = __pa_symbol(_edata) - 1; 144 data_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 145 146 bss_res.start = __pa_symbol(__bss_start); 147 bss_res.end = __pa_symbol(__bss_stop) - 1; 148 bss_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 149 150 /* + 1 as memblock_alloc() might increase memblock.reserved.cnt */ 151 mem_res_sz = (memblock.memory.cnt + memblock.reserved.cnt + 1) * sizeof(*mem_res); 152 mem_res = memblock_alloc(mem_res_sz, SMP_CACHE_BYTES); 153 if (!mem_res) 154 panic("%s: Failed to allocate %zu bytes\n", __func__, mem_res_sz); 155 /* 156 * Start by adding the reserved regions, if they overlap 157 * with /memory regions, insert_resource later on will take 158 * care of it. 159 */ 160 for_each_reserved_mem_region(region) { 161 res = &mem_res[i++]; 162 163 res->name = "Reserved"; 164 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 165 res->start = __pfn_to_phys(memblock_region_reserved_base_pfn(region)); 166 res->end = __pfn_to_phys(memblock_region_reserved_end_pfn(region)) - 1; 167 168 ret = add_kernel_resources(res); 169 if (ret < 0) 170 goto error; 171 else if (ret) 172 continue; 173 174 /* 175 * Ignore any other reserved regions within 176 * system memory. 177 */ 178 if (memblock_is_memory(res->start)) { 179 memblock_free((phys_addr_t) res, sizeof(struct resource)); 180 continue; 181 } 182 183 ret = add_resource(&iomem_resource, res); 184 if (ret < 0) 185 goto error; 186 } 187 188 /* Add /memory regions to the resource tree */ 189 for_each_mem_region(region) { 190 res = &mem_res[i++]; 191 192 if (unlikely(memblock_is_nomap(region))) { 193 res->name = "Reserved"; 194 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 195 } else { 196 res->name = "System RAM"; 197 res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY; 198 } 199 200 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); 201 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; 202 203 ret = add_resource(&iomem_resource, res); 204 if (ret < 0) 205 goto error; 206 } 207 208 return; 209 210 error: 211 /* Better an empty resource tree than an inconsistent one */ 212 release_child_resources(&iomem_resource); 213 memblock_free((phys_addr_t) mem_res, mem_res_sz); 214 } 215 216 217 static void __init parse_dtb(void) 218 { 219 /* Early scan of device tree from init memory */ 220 if (early_init_dt_scan(dtb_early_va)) { 221 const char *name = of_flat_dt_get_machine_name(); 222 223 if (name) { 224 pr_info("Machine model: %s\n", name); 225 dump_stack_set_arch_desc("%s (DT)", name); 226 } 227 return; 228 } 229 230 pr_err("No DTB passed to the kernel\n"); 231 #ifdef CONFIG_CMDLINE_FORCE 232 strlcpy(boot_command_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 233 pr_info("Forcing kernel command line to: %s\n", boot_command_line); 234 #endif 235 } 236 237 void __init setup_arch(char **cmdline_p) 238 { 239 parse_dtb(); 240 init_mm.start_code = (unsigned long) _stext; 241 init_mm.end_code = (unsigned long) _etext; 242 init_mm.end_data = (unsigned long) _edata; 243 init_mm.brk = (unsigned long) _end; 244 245 *cmdline_p = boot_command_line; 246 247 early_ioremap_setup(); 248 jump_label_init(); 249 parse_early_param(); 250 251 efi_init(); 252 setup_bootmem(); 253 paging_init(); 254 init_resources(); 255 #if IS_ENABLED(CONFIG_BUILTIN_DTB) 256 unflatten_and_copy_device_tree(); 257 #else 258 if (early_init_dt_verify(__va(dtb_early_pa))) 259 unflatten_device_tree(); 260 else 261 pr_err("No DTB found in kernel mappings\n"); 262 #endif 263 misc_mem_init(); 264 265 sbi_init(); 266 267 if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)) 268 protect_kernel_text_data(); 269 #ifdef CONFIG_SWIOTLB 270 swiotlb_init(1); 271 #endif 272 273 #ifdef CONFIG_KASAN 274 kasan_init(); 275 #endif 276 277 #ifdef CONFIG_SMP 278 setup_smp(); 279 #endif 280 281 riscv_fill_hwcap(); 282 } 283 284 static int __init topology_init(void) 285 { 286 int i, ret; 287 288 for_each_online_node(i) 289 register_one_node(i); 290 291 for_each_possible_cpu(i) { 292 struct cpu *cpu = &per_cpu(cpu_devices, i); 293 294 cpu->hotpluggable = cpu_has_hotplug(i); 295 ret = register_cpu(cpu, i); 296 if (unlikely(ret)) 297 pr_warn("Warning: %s: register_cpu %d failed (%d)\n", 298 __func__, i, ret); 299 } 300 301 return 0; 302 } 303 subsys_initcall(topology_init); 304 305 void free_initmem(void) 306 { 307 unsigned long init_begin = (unsigned long)__init_begin; 308 unsigned long init_end = (unsigned long)__init_end; 309 310 if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)) 311 set_memory_rw_nx(init_begin, (init_end - init_begin) >> PAGE_SHIFT); 312 313 free_initmem_default(POISON_FREE_INITMEM); 314 } 315