1 /* 2 * Initialize machine setup information and I/O. 3 * 4 * After running setup() unit tests may query how many cpus they have 5 * (nr_cpus), how much memory they have (PHYS_END - PHYS_OFFSET), may 6 * use dynamic memory allocation (malloc, etc.), printf, and exit. 7 * Finally, argc and argv are also ready to be passed to main(). 8 * 9 * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com> 10 * 11 * This work is licensed under the terms of the GNU LGPL, version 2. 12 */ 13 #include <libcflat.h> 14 #include <libfdt/libfdt.h> 15 #include <devicetree.h> 16 #include <alloc.h> 17 #include <alloc_phys.h> 18 #include <alloc_page.h> 19 #include <vmalloc.h> 20 #include <auxinfo.h> 21 #include <argv.h> 22 #include <asm/thread_info.h> 23 #include <asm/setup.h> 24 #include <asm/page.h> 25 #include <asm/processor.h> 26 #include <asm/smp.h> 27 #include <asm/timer.h> 28 #include <asm/psci.h> 29 30 #include "io.h" 31 32 #define MAX_DT_MEM_REGIONS 16 33 #define NR_EXTRA_MEM_REGIONS 16 34 #define NR_INITIAL_MEM_REGIONS (MAX_DT_MEM_REGIONS + NR_EXTRA_MEM_REGIONS) 35 36 extern unsigned long etext; 37 38 struct timer_state __timer_state; 39 40 char *initrd; 41 u32 initrd_size; 42 43 u64 cpus[NR_CPUS] = { [0 ... NR_CPUS-1] = (u64)~0 }; 44 int nr_cpus; 45 46 static struct mem_region __initial_mem_regions[NR_INITIAL_MEM_REGIONS + 1]; 47 struct mem_region *mem_regions = __initial_mem_regions; 48 phys_addr_t __phys_offset, __phys_end; 49 50 int mpidr_to_cpu(uint64_t mpidr) 51 { 52 int i; 53 54 for (i = 0; i < nr_cpus; ++i) 55 if (cpus[i] == (mpidr & MPIDR_HWID_BITMASK)) 56 return i; 57 return -1; 58 } 59 60 static void cpu_set(int fdtnode __unused, u64 regval, void *info __unused) 61 { 62 int cpu = nr_cpus++; 63 64 assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS); 65 66 cpus[cpu] = regval; 67 set_cpu_present(cpu, true); 68 } 69 70 static void cpu_init(void) 71 { 72 int ret; 73 74 nr_cpus = 0; 75 ret = dt_for_each_cpu_node(cpu_set, NULL); 76 assert(ret == 0); 77 set_cpu_online(0, true); 78 } 79 80 static void mem_region_add(struct mem_region *r) 81 { 82 struct mem_region *r_next = mem_regions; 83 int i = 0; 84 85 for (; r_next->end; ++r_next, ++i) 86 ; 87 assert(i < NR_INITIAL_MEM_REGIONS); 88 89 *r_next = *r; 90 } 91 92 static void mem_regions_add_dt_regions(void) 93 { 94 struct dt_pbus_reg regs[MAX_DT_MEM_REGIONS]; 95 int nr_regs, i; 96 97 nr_regs = dt_get_memory_params(regs, MAX_DT_MEM_REGIONS); 98 assert(nr_regs > 0); 99 100 for (i = 0; i < nr_regs; ++i) { 101 mem_region_add(&(struct mem_region){ 102 .start = regs[i].addr, 103 .end = regs[i].addr + regs[i].size, 104 }); 105 } 106 } 107 108 struct mem_region *mem_region_find(phys_addr_t paddr) 109 { 110 struct mem_region *r; 111 112 for (r = mem_regions; r->end; ++r) 113 if (paddr >= r->start && paddr < r->end) 114 return r; 115 return NULL; 116 } 117 118 unsigned int mem_region_get_flags(phys_addr_t paddr) 119 { 120 struct mem_region *r = mem_region_find(paddr); 121 return r ? r->flags : MR_F_UNKNOWN; 122 } 123 124 static void mem_regions_add_assumed(void) 125 { 126 phys_addr_t code_end = (phys_addr_t)(unsigned long)&etext; 127 struct mem_region *r; 128 129 r = mem_region_find(code_end - 1); 130 assert(r); 131 132 /* Split the region with the code into two regions; code and data */ 133 mem_region_add(&(struct mem_region){ 134 .start = code_end, 135 .end = r->end, 136 }); 137 *r = (struct mem_region){ 138 .start = r->start, 139 .end = code_end, 140 .flags = MR_F_CODE, 141 }; 142 143 /* 144 * mach-virt I/O regions: 145 * - The first 1G (arm/arm64) 146 * - 512M at 256G (arm64, arm uses highmem=off) 147 * - 512G at 512G (arm64, arm uses highmem=off) 148 */ 149 mem_region_add(&(struct mem_region){ 0, (1ul << 30), MR_F_IO }); 150 #ifdef __aarch64__ 151 mem_region_add(&(struct mem_region){ (1ul << 38), (1ul << 38) | (1ul << 29), MR_F_IO }); 152 mem_region_add(&(struct mem_region){ (1ul << 39), (1ul << 40), MR_F_IO }); 153 #endif 154 } 155 156 static void mem_init(phys_addr_t freemem_start) 157 { 158 phys_addr_t base, top; 159 struct mem_region *freemem, *r, mem = { 160 .start = (phys_addr_t)-1, 161 }; 162 163 freemem = mem_region_find(freemem_start); 164 assert(freemem && !(freemem->flags & (MR_F_IO | MR_F_CODE))); 165 166 for (r = mem_regions; r->end; ++r) { 167 if (!(r->flags & MR_F_IO)) { 168 if (r->start < mem.start) 169 mem.start = r->start; 170 if (r->end > mem.end) 171 mem.end = r->end; 172 } 173 } 174 assert(mem.end && !(mem.start & ~PHYS_MASK)); 175 mem.end &= PHYS_MASK; 176 177 /* Check for holes */ 178 r = mem_region_find(mem.start); 179 while (r && r->end != mem.end) 180 r = mem_region_find(r->end); 181 assert(r); 182 183 /* Ensure our selected freemem range is somewhere in our full range */ 184 assert(freemem_start >= mem.start && freemem->end <= mem.end); 185 186 __phys_offset = mem.start; /* PHYS_OFFSET */ 187 __phys_end = mem.end; /* PHYS_END */ 188 189 phys_alloc_init(freemem_start, freemem->end - freemem_start); 190 phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES); 191 192 phys_alloc_get_unused(&base, &top); 193 base = PAGE_ALIGN(base); 194 top = top & PAGE_MASK; 195 assert(sizeof(long) == 8 || !(base >> 32)); 196 if (sizeof(long) != 8 && (top >> 32) != 0) 197 top = ((uint64_t)1 << 32); 198 page_alloc_init_area(0, base >> PAGE_SHIFT, top >> PAGE_SHIFT); 199 page_alloc_ops_enable(); 200 } 201 202 static void timer_save_state(void) 203 { 204 const struct fdt_property *prop; 205 const void *fdt = dt_fdt(); 206 int node, len; 207 u32 *data; 208 209 node = fdt_node_offset_by_compatible(fdt, -1, "arm,armv8-timer"); 210 assert(node >= 0 || node == -FDT_ERR_NOTFOUND); 211 212 if (node == -FDT_ERR_NOTFOUND) { 213 __timer_state.ptimer.irq = -1; 214 __timer_state.vtimer.irq = -1; 215 return; 216 } 217 218 /* 219 * From Linux devicetree timer binding documentation 220 * 221 * interrupts <type irq flags>: 222 * secure timer irq 223 * non-secure timer irq (ptimer) 224 * virtual timer irq (vtimer) 225 * hypervisor timer irq 226 */ 227 prop = fdt_get_property(fdt, node, "interrupts", &len); 228 assert(prop && len == (4 * 3 * sizeof(u32))); 229 230 data = (u32 *)prop->data; 231 assert(fdt32_to_cpu(data[3]) == 1 /* PPI */); 232 __timer_state.ptimer.irq = fdt32_to_cpu(data[4]); 233 __timer_state.ptimer.irq_flags = fdt32_to_cpu(data[5]); 234 assert(fdt32_to_cpu(data[6]) == 1 /* PPI */); 235 __timer_state.vtimer.irq = fdt32_to_cpu(data[7]); 236 __timer_state.vtimer.irq_flags = fdt32_to_cpu(data[8]); 237 } 238 239 void setup(const void *fdt, phys_addr_t freemem_start) 240 { 241 void *freemem; 242 const char *bootargs, *tmp; 243 u32 fdt_size; 244 int ret; 245 246 assert(sizeof(long) == 8 || freemem_start < (3ul << 30)); 247 freemem = (void *)(unsigned long)freemem_start; 248 249 /* Move the FDT to the base of free memory */ 250 fdt_size = fdt_totalsize(fdt); 251 ret = fdt_move(fdt, freemem, fdt_size); 252 assert(ret == 0); 253 ret = dt_init(freemem); 254 assert(ret == 0); 255 freemem += fdt_size; 256 257 /* Move the initrd to the top of the FDT */ 258 ret = dt_get_initrd(&tmp, &initrd_size); 259 assert(ret == 0 || ret == -FDT_ERR_NOTFOUND); 260 if (ret == 0) { 261 initrd = freemem; 262 memmove(initrd, tmp, initrd_size); 263 freemem += initrd_size; 264 } 265 266 mem_regions_add_dt_regions(); 267 mem_regions_add_assumed(); 268 mem_init(PAGE_ALIGN((unsigned long)freemem)); 269 270 psci_set_conduit(); 271 cpu_init(); 272 273 /* cpu_init must be called before thread_info_init */ 274 thread_info_init(current_thread_info(), 0); 275 276 /* mem_init must be called before io_init */ 277 io_init(); 278 279 timer_save_state(); 280 281 ret = dt_get_bootargs(&bootargs); 282 assert(ret == 0 || ret == -FDT_ERR_NOTFOUND); 283 setup_args_progname(bootargs); 284 285 if (initrd) { 286 /* environ is currently the only file in the initrd */ 287 char *env = malloc(initrd_size); 288 memcpy(env, initrd, initrd_size); 289 setup_env(env, initrd_size); 290 } 291 292 if (!(auxinfo.flags & AUXINFO_MMU_OFF)) 293 setup_vm(); 294 } 295