arch/riscv/kernel/setup.c

   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         int ret = 0;
 131
 132         code_res.start = __pa_symbol(_text);
 133         code_res.end = __pa_symbol(_etext) - 1;
 134         code_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 135
 136         rodata_res.start = __pa_symbol(__start_rodata);
 137         rodata_res.end = __pa_symbol(__end_rodata) - 1;
 138         rodata_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 139
 140         data_res.start = __pa_symbol(_data);
 141         data_res.end = __pa_symbol(_edata) - 1;
 142         data_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 143
 144         bss_res.start = __pa_symbol(__bss_start);
 145         bss_res.end = __pa_symbol(__bss_stop) - 1;
 146         bss_res.flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 147
 148         /*
 149          * Start by adding the reserved regions, if they overlap
 150          * with /memory regions, insert_resource later on will take
 151          * care of it.
 152          */
 153         for_each_reserved_mem_region(region) {
 154                 res = memblock_alloc(sizeof(struct resource), SMP_CACHE_BYTES);
 155                 if (!res)
 156                         panic("%s: Failed to allocate %zu bytes\n", __func__,
 157                               sizeof(struct resource));
 158
 159                 res->name = "Reserved";
 160                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 161                 res->start = __pfn_to_phys(memblock_region_reserved_base_pfn(region));
 162                 res->end = __pfn_to_phys(memblock_region_reserved_end_pfn(region)) - 1;
 163
 164                 ret = add_kernel_resources(res);
 165                 if (ret < 0)
 166                         goto error;
 167                 else if (ret)
 168                         continue;
 169
 170                 /*
 171                  * Ignore any other reserved regions within
 172                  * system memory.
 173                  */
 174                 if (memblock_is_memory(res->start))
 175                         continue;
 176
 177                 ret = add_resource(&iomem_resource, res);
 178                 if (ret < 0)
 179                         goto error;
 180         }
 181
 182         /* Add /memory regions to the resource tree */
 183         for_each_mem_region(region) {
 184                 res = memblock_alloc(sizeof(struct resource), SMP_CACHE_BYTES);
 185                 if (!res)
 186                         panic("%s: Failed to allocate %zu bytes\n", __func__,
 187                               sizeof(struct resource));
 188
 189                 if (unlikely(memblock_is_nomap(region))) {
 190                         res->name = "Reserved";
 191                         res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 192                 } else {
 193                         res->name = "System RAM";
 194                         res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 195                 }
 196
 197                 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
 198                 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
 199
 200                 ret = add_resource(&iomem_resource, res);
 201                 if (ret < 0)
 202                         goto error;
 203         }
 204
 205         return;
 206
 207  error:
 208         memblock_free((phys_addr_t) res, sizeof(struct resource));
 209         /* Better an empty resource tree than an inconsistent one */
 210         release_child_resources(&iomem_resource);
 211 }
 212
 213
 214 static void __init parse_dtb(void)
 215 {
 216         /* Early scan of device tree from init memory */
 217         if (early_init_dt_scan(dtb_early_va))
 218                 return;
 219
 220         pr_err("No DTB passed to the kernel\n");
 221 #ifdef CONFIG_CMDLINE_FORCE
 222         strlcpy(boot_command_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
 223         pr_info("Forcing kernel command line to: %s\n", boot_command_line);
 224 #endif
 225 }
 226
 227 void __init setup_arch(char **cmdline_p)
 228 {
 229         parse_dtb();
 230         init_mm.start_code = (unsigned long) _stext;
 231         init_mm.end_code   = (unsigned long) _etext;
 232         init_mm.end_data   = (unsigned long) _edata;
 233         init_mm.brk        = (unsigned long) _end;
 234
 235         *cmdline_p = boot_command_line;
 236
 237         early_ioremap_setup();
 238         jump_label_init();
 239         parse_early_param();
 240
 241         efi_init();
 242         setup_bootmem();
 243         paging_init();
 244         init_resources();
 245 #if IS_ENABLED(CONFIG_BUILTIN_DTB)
 246         unflatten_and_copy_device_tree();
 247 #else
 248         if (early_init_dt_verify(__va(dtb_early_pa)))
 249                 unflatten_device_tree();
 250         else
 251                 pr_err("No DTB found in kernel mappings\n");
 252 #endif
 253
 254         if (IS_ENABLED(CONFIG_RISCV_SBI))
 255                 sbi_init();
 256
 257         if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX))
 258                 protect_kernel_text_data();
 259 #ifdef CONFIG_SWIOTLB
 260         swiotlb_init(1);
 261 #endif
 262
 263 #ifdef CONFIG_KASAN
 264         kasan_init();
 265 #endif
 266
 267 #ifdef CONFIG_SMP
 268         setup_smp();
 269 #endif
 270
 271         riscv_fill_hwcap();
 272 }
 273
 274 static int __init topology_init(void)
 275 {
 276         int i;
 277
 278         for_each_possible_cpu(i) {
 279                 struct cpu *cpu = &per_cpu(cpu_devices, i);
 280
 281                 cpu->hotpluggable = cpu_has_hotplug(i);
 282                 register_cpu(cpu, i);
 283         }
 284
 285         return 0;
 286 }
 287 subsys_initcall(topology_init);
 288
 289 void free_initmem(void)
 290 {
 291         unsigned long init_begin = (unsigned long)__init_begin;
 292         unsigned long init_end = (unsigned long)__init_end;
 293
 294         set_memory_rw_nx(init_begin, (init_end - init_begin) >> PAGE_SHIFT);
 295         free_initmem_default(POISON_FREE_INITMEM);
 296 }