Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 1 | /* |
Kumar Gala | 4c8d3d9 | 2005-11-13 16:06:30 -0800 | [diff] [blame] | 2 | * Modifications by Kumar Gala (galak@kernel.crashing.org) to support |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 3 | * E500 Book E processors. |
| 4 | * |
Kumar Gala | 78f6223 | 2010-05-13 14:38:21 -0500 | [diff] [blame] | 5 | * Copyright 2004,2010 Freescale Semiconductor, Inc. |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 6 | * |
| 7 | * This file contains the routines for initializing the MMU |
| 8 | * on the 4xx series of chips. |
| 9 | * -- paulus |
| 10 | * |
| 11 | * Derived from arch/ppc/mm/init.c: |
| 12 | * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) |
| 13 | * |
| 14 | * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au) |
| 15 | * and Cort Dougan (PReP) (cort@cs.nmt.edu) |
| 16 | * Copyright (C) 1996 Paul Mackerras |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 17 | * |
| 18 | * Derived from "arch/i386/mm/init.c" |
| 19 | * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds |
| 20 | * |
| 21 | * This program is free software; you can redistribute it and/or |
| 22 | * modify it under the terms of the GNU General Public License |
| 23 | * as published by the Free Software Foundation; either version |
| 24 | * 2 of the License, or (at your option) any later version. |
| 25 | * |
| 26 | */ |
| 27 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 28 | #include <linux/signal.h> |
| 29 | #include <linux/sched.h> |
| 30 | #include <linux/kernel.h> |
| 31 | #include <linux/errno.h> |
| 32 | #include <linux/string.h> |
| 33 | #include <linux/types.h> |
| 34 | #include <linux/ptrace.h> |
| 35 | #include <linux/mman.h> |
| 36 | #include <linux/mm.h> |
| 37 | #include <linux/swap.h> |
| 38 | #include <linux/stddef.h> |
| 39 | #include <linux/vmalloc.h> |
| 40 | #include <linux/init.h> |
| 41 | #include <linux/delay.h> |
| 42 | #include <linux/highmem.h> |
Benjamin Herrenschmidt | e63075a | 2010-07-06 15:39:01 -0700 | [diff] [blame] | 43 | #include <linux/memblock.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 44 | |
| 45 | #include <asm/pgalloc.h> |
| 46 | #include <asm/prom.h> |
| 47 | #include <asm/io.h> |
| 48 | #include <asm/mmu_context.h> |
| 49 | #include <asm/pgtable.h> |
| 50 | #include <asm/mmu.h> |
| 51 | #include <asm/uaccess.h> |
| 52 | #include <asm/smp.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 53 | #include <asm/machdep.h> |
| 54 | #include <asm/setup.h> |
Scott Wood | 28efc35 | 2013-10-11 19:22:38 -0500 | [diff] [blame] | 55 | #include <asm/paca.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 56 | |
Kumar Gala | 99c62dd7 | 2008-04-16 05:52:21 +1000 | [diff] [blame] | 57 | #include "mmu_decl.h" |
| 58 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 59 | unsigned int tlbcam_index; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 60 | |
Kumar Gala | 78f6223 | 2010-05-13 14:38:21 -0500 | [diff] [blame] | 61 | #define NUM_TLBCAMS (64) |
| 62 | struct tlbcam TLBCAM[NUM_TLBCAMS]; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 63 | |
| 64 | struct tlbcamrange { |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 65 | unsigned long start; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 66 | unsigned long limit; |
| 67 | phys_addr_t phys; |
| 68 | } tlbcam_addrs[NUM_TLBCAMS]; |
| 69 | |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 70 | unsigned long tlbcam_sz(int idx) |
| 71 | { |
| 72 | return tlbcam_addrs[idx].limit - tlbcam_addrs[idx].start + 1; |
| 73 | } |
| 74 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 75 | /* |
| 76 | * Return PA for this VA if it is mapped by a CAM, or 0 |
| 77 | */ |
Kumar Gala | 6c24b17 | 2009-02-09 21:08:07 -0600 | [diff] [blame] | 78 | phys_addr_t v_mapped_by_tlbcam(unsigned long va) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 79 | { |
| 80 | int b; |
| 81 | for (b = 0; b < tlbcam_index; ++b) |
| 82 | if (va >= tlbcam_addrs[b].start && va < tlbcam_addrs[b].limit) |
| 83 | return tlbcam_addrs[b].phys + (va - tlbcam_addrs[b].start); |
| 84 | return 0; |
| 85 | } |
| 86 | |
| 87 | /* |
| 88 | * Return VA for a given PA or 0 if not mapped |
| 89 | */ |
Kumar Gala | 6c24b17 | 2009-02-09 21:08:07 -0600 | [diff] [blame] | 90 | unsigned long p_mapped_by_tlbcam(phys_addr_t pa) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 91 | { |
| 92 | int b; |
| 93 | for (b = 0; b < tlbcam_index; ++b) |
| 94 | if (pa >= tlbcam_addrs[b].phys |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 95 | && pa < (tlbcam_addrs[b].limit-tlbcam_addrs[b].start) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 96 | +tlbcam_addrs[b].phys) |
| 97 | return tlbcam_addrs[b].start+(pa-tlbcam_addrs[b].phys); |
| 98 | return 0; |
| 99 | } |
| 100 | |
| 101 | /* |
Becky Bruce | d10ac37 | 2010-06-30 10:23:31 +0000 | [diff] [blame] | 102 | * Set up a variable-size TLB entry (tlbcam). The parameters are not checked; |
Becky Bruce | 4559424 | 2011-10-12 16:17:02 -0500 | [diff] [blame] | 103 | * in particular size must be a power of 4 between 4k and the max supported by |
| 104 | * an implementation; max may further be limited by what can be represented in |
| 105 | * an unsigned long (for example, 32-bit implementations cannot support a 4GB |
| 106 | * size). |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 107 | */ |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 108 | static void settlbcam(int index, unsigned long virt, phys_addr_t phys, |
| 109 | unsigned long size, unsigned long flags, unsigned int pid) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 110 | { |
Becky Bruce | 4559424 | 2011-10-12 16:17:02 -0500 | [diff] [blame] | 111 | unsigned int tsize; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 112 | |
Becky Bruce | 4559424 | 2011-10-12 16:17:02 -0500 | [diff] [blame] | 113 | tsize = __ilog2(size) - 10; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 114 | |
Scott Wood | c602320 | 2015-07-18 14:24:58 -0500 | [diff] [blame] | 115 | #if defined(CONFIG_SMP) || defined(CONFIG_PPC_E500MC) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 116 | if ((flags & _PAGE_NO_CACHE) == 0) |
| 117 | flags |= _PAGE_COHERENT; |
| 118 | #endif |
| 119 | |
| 120 | TLBCAM[index].MAS0 = MAS0_TLBSEL(1) | MAS0_ESEL(index) | MAS0_NV(index+1); |
| 121 | TLBCAM[index].MAS1 = MAS1_VALID | MAS1_IPROT | MAS1_TSIZE(tsize) | MAS1_TID(pid); |
| 122 | TLBCAM[index].MAS2 = virt & PAGE_MASK; |
| 123 | |
| 124 | TLBCAM[index].MAS2 |= (flags & _PAGE_WRITETHRU) ? MAS2_W : 0; |
| 125 | TLBCAM[index].MAS2 |= (flags & _PAGE_NO_CACHE) ? MAS2_I : 0; |
| 126 | TLBCAM[index].MAS2 |= (flags & _PAGE_COHERENT) ? MAS2_M : 0; |
| 127 | TLBCAM[index].MAS2 |= (flags & _PAGE_GUARDED) ? MAS2_G : 0; |
| 128 | TLBCAM[index].MAS2 |= (flags & _PAGE_ENDIAN) ? MAS2_E : 0; |
| 129 | |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 130 | TLBCAM[index].MAS3 = (phys & MAS3_RPN) | MAS3_SX | MAS3_SR; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 131 | TLBCAM[index].MAS3 |= ((flags & _PAGE_RW) ? MAS3_SW : 0); |
Becky Bruce | e813734 | 2010-04-12 11:21:50 -0500 | [diff] [blame] | 132 | if (mmu_has_feature(MMU_FTR_BIG_PHYS)) |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 133 | TLBCAM[index].MAS7 = (u64)phys >> 32; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 134 | |
Paul Gortmaker | 92437d4 | 2010-09-24 12:44:52 -0400 | [diff] [blame] | 135 | /* Below is unlikely -- only for large user pages or similar */ |
| 136 | if (pte_user(flags)) { |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 137 | TLBCAM[index].MAS3 |= MAS3_UX | MAS3_UR; |
| 138 | TLBCAM[index].MAS3 |= ((flags & _PAGE_RW) ? MAS3_UW : 0); |
| 139 | } |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 140 | |
| 141 | tlbcam_addrs[index].start = virt; |
| 142 | tlbcam_addrs[index].limit = virt + size - 1; |
| 143 | tlbcam_addrs[index].phys = phys; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 144 | } |
| 145 | |
Kumar Gala | 1dc91c3 | 2011-09-16 10:39:59 -0500 | [diff] [blame] | 146 | unsigned long calc_cam_sz(unsigned long ram, unsigned long virt, |
| 147 | phys_addr_t phys) |
| 148 | { |
Kumar Gala | f0b8b34 | 2012-01-05 12:37:16 -0600 | [diff] [blame] | 149 | unsigned int camsize = __ilog2(ram); |
| 150 | unsigned int align = __ffs(virt | phys); |
| 151 | unsigned long max_cam; |
Kumar Gala | 1dc91c3 | 2011-09-16 10:39:59 -0500 | [diff] [blame] | 152 | |
Kumar Gala | f0b8b34 | 2012-01-05 12:37:16 -0600 | [diff] [blame] | 153 | if ((mfspr(SPRN_MMUCFG) & MMUCFG_MAVN) == MMUCFG_MAVN_V1) { |
| 154 | /* Convert (4^max) kB to (2^max) bytes */ |
| 155 | max_cam = ((mfspr(SPRN_TLB1CFG) >> 16) & 0xf) * 2 + 10; |
| 156 | camsize &= ~1U; |
| 157 | align &= ~1U; |
| 158 | } else { |
| 159 | /* Convert (2^max) kB to (2^max) bytes */ |
| 160 | max_cam = __ilog2(mfspr(SPRN_TLB1PS)) + 10; |
| 161 | } |
Kumar Gala | 1dc91c3 | 2011-09-16 10:39:59 -0500 | [diff] [blame] | 162 | |
| 163 | if (camsize > align) |
| 164 | camsize = align; |
| 165 | if (camsize > max_cam) |
| 166 | camsize = max_cam; |
| 167 | |
| 168 | return 1UL << camsize; |
| 169 | } |
| 170 | |
Kevin Hao | 813125d | 2013-12-24 15:12:09 +0800 | [diff] [blame] | 171 | static unsigned long map_mem_in_cams_addr(phys_addr_t phys, unsigned long virt, |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 172 | unsigned long ram, int max_cam_idx, |
| 173 | bool dryrun) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 174 | { |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 175 | int i; |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 176 | unsigned long amount_mapped = 0; |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 177 | |
| 178 | /* Calculate CAM values */ |
| 179 | for (i = 0; ram && i < max_cam_idx; i++) { |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 180 | unsigned long cam_sz; |
| 181 | |
Kumar Gala | 1dc91c3 | 2011-09-16 10:39:59 -0500 | [diff] [blame] | 182 | cam_sz = calc_cam_sz(ram, virt, phys); |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 183 | if (!dryrun) |
| 184 | settlbcam(i, virt, phys, cam_sz, |
| 185 | pgprot_val(PAGE_KERNEL_X), 0); |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 186 | |
| 187 | ram -= cam_sz; |
| 188 | amount_mapped += cam_sz; |
| 189 | virt += cam_sz; |
| 190 | phys += cam_sz; |
| 191 | } |
Scott Wood | d9e1831 | 2015-10-06 22:48:09 -0500 | [diff] [blame] | 192 | |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 193 | if (dryrun) |
| 194 | return amount_mapped; |
| 195 | |
Scott Wood | d9e1831 | 2015-10-06 22:48:09 -0500 | [diff] [blame] | 196 | loadcam_multi(0, i, max_cam_idx); |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 197 | tlbcam_index = i; |
| 198 | |
Scott Wood | 28efc35 | 2013-10-11 19:22:38 -0500 | [diff] [blame] | 199 | #ifdef CONFIG_PPC64 |
| 200 | get_paca()->tcd.esel_next = i; |
| 201 | get_paca()->tcd.esel_max = mfspr(SPRN_TLB1CFG) & TLBnCFG_N_ENTRY; |
| 202 | get_paca()->tcd.esel_first = i; |
| 203 | #endif |
| 204 | |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 205 | return amount_mapped; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 206 | } |
| 207 | |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 208 | unsigned long map_mem_in_cams(unsigned long ram, int max_cam_idx, bool dryrun) |
Kevin Hao | 813125d | 2013-12-24 15:12:09 +0800 | [diff] [blame] | 209 | { |
| 210 | unsigned long virt = PAGE_OFFSET; |
| 211 | phys_addr_t phys = memstart_addr; |
| 212 | |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 213 | return map_mem_in_cams_addr(phys, virt, ram, max_cam_idx, dryrun); |
Kevin Hao | 813125d | 2013-12-24 15:12:09 +0800 | [diff] [blame] | 214 | } |
| 215 | |
Kumar Gala | 55fd766 | 2009-10-16 18:48:40 -0500 | [diff] [blame] | 216 | #ifdef CONFIG_PPC32 |
| 217 | |
| 218 | #if defined(CONFIG_LOWMEM_CAM_NUM_BOOL) && (CONFIG_LOWMEM_CAM_NUM >= NUM_TLBCAMS) |
| 219 | #error "LOWMEM_CAM_NUM must be less than NUM_TLBCAMS" |
| 220 | #endif |
| 221 | |
Stephen Rothwell | ae4cec4 | 2009-12-14 09:04:24 -0700 | [diff] [blame] | 222 | unsigned long __init mmu_mapin_ram(unsigned long top) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 223 | { |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 224 | return tlbcam_addrs[tlbcam_index - 1].limit - PAGE_OFFSET + 1; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | /* |
| 228 | * MMU_init_hw does the chip-specific initialization of the MMU hardware. |
| 229 | */ |
| 230 | void __init MMU_init_hw(void) |
| 231 | { |
| 232 | flush_instruction_cache(); |
| 233 | } |
| 234 | |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 235 | void __init adjust_total_lowmem(void) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 236 | { |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 237 | unsigned long ram; |
Trent Piepho | f88747e | 2008-12-08 19:34:57 -0800 | [diff] [blame] | 238 | int i; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 239 | |
Trent Piepho | f88747e | 2008-12-08 19:34:57 -0800 | [diff] [blame] | 240 | /* adjust lowmem size to __max_low_memory */ |
| 241 | ram = min((phys_addr_t)__max_low_memory, (phys_addr_t)total_lowmem); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 242 | |
Kevin Hao | 78a235e | 2013-12-24 15:12:07 +0800 | [diff] [blame] | 243 | i = switch_to_as1(); |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 244 | __max_low_memory = map_mem_in_cams(ram, CONFIG_LOWMEM_CAM_NUM, false); |
Kevin Hao | 0be7d969b | 2013-12-24 15:12:11 +0800 | [diff] [blame] | 245 | restore_to_as0(i, 0, 0, 1); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 246 | |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 247 | pr_info("Memory CAM mapping: "); |
| 248 | for (i = 0; i < tlbcam_index - 1; i++) |
| 249 | pr_cont("%lu/", tlbcam_sz(i) >> 20); |
| 250 | pr_cont("%lu Mb, residual: %dMb\n", tlbcam_sz(tlbcam_index - 1) >> 20, |
Kumar Gala | 96a8bac | 2009-02-12 09:39:23 -0600 | [diff] [blame] | 251 | (unsigned int)((total_lowmem - __max_low_memory) >> 20)); |
Kumar Gala | 8b27f0b | 2009-10-15 12:49:01 -0500 | [diff] [blame] | 252 | |
Benjamin Herrenschmidt | e63075a | 2010-07-06 15:39:01 -0700 | [diff] [blame] | 253 | memblock_set_current_limit(memstart_addr + __max_low_memory); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 254 | } |
Benjamin Herrenschmidt | cd3db0c | 2010-07-06 15:39:02 -0700 | [diff] [blame] | 255 | |
| 256 | void setup_initial_memory_limit(phys_addr_t first_memblock_base, |
| 257 | phys_addr_t first_memblock_size) |
| 258 | { |
| 259 | phys_addr_t limit = first_memblock_base + first_memblock_size; |
| 260 | |
| 261 | /* 64M mapped initially according to head_fsl_booke.S */ |
| 262 | memblock_set_current_limit(min_t(u64, limit, 0x04000000)); |
| 263 | } |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 264 | |
| 265 | #ifdef CONFIG_RELOCATABLE |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 266 | int __initdata is_second_reloc; |
| 267 | notrace void __init relocate_init(u64 dt_ptr, phys_addr_t start) |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 268 | { |
| 269 | unsigned long base = KERNELBASE; |
| 270 | |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 271 | kernstart_addr = start; |
| 272 | if (is_second_reloc) { |
| 273 | virt_phys_offset = PAGE_OFFSET - memstart_addr; |
| 274 | return; |
| 275 | } |
| 276 | |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 277 | /* |
| 278 | * Relocatable kernel support based on processing of dynamic |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 279 | * relocation entries. Before we get the real memstart_addr, |
| 280 | * We will compute the virt_phys_offset like this: |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 281 | * virt_phys_offset = stext.run - kernstart_addr |
| 282 | * |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 283 | * stext.run = (KERNELBASE & ~0x3ffffff) + |
| 284 | * (kernstart_addr & 0x3ffffff) |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 285 | * When we relocate, we have : |
| 286 | * |
| 287 | * (kernstart_addr & 0x3ffffff) = (stext.run & 0x3ffffff) |
| 288 | * |
| 289 | * hence: |
| 290 | * virt_phys_offset = (KERNELBASE & ~0x3ffffff) - |
| 291 | * (kernstart_addr & ~0x3ffffff) |
| 292 | * |
| 293 | */ |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 294 | start &= ~0x3ffffff; |
| 295 | base &= ~0x3ffffff; |
| 296 | virt_phys_offset = base - start; |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 297 | early_get_first_memblock_info(__va(dt_ptr), NULL); |
| 298 | /* |
| 299 | * We now get the memstart_addr, then we should check if this |
| 300 | * address is the same as what the PAGE_OFFSET map to now. If |
| 301 | * not we have to change the map of PAGE_OFFSET to memstart_addr |
| 302 | * and do a second relocation. |
| 303 | */ |
| 304 | if (start != memstart_addr) { |
| 305 | int n; |
| 306 | long offset = start - memstart_addr; |
| 307 | |
| 308 | is_second_reloc = 1; |
| 309 | n = switch_to_as1(); |
| 310 | /* map a 64M area for the second relocation */ |
| 311 | if (memstart_addr > start) |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 312 | map_mem_in_cams(0x4000000, CONFIG_LOWMEM_CAM_NUM, |
| 313 | false); |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 314 | else |
| 315 | map_mem_in_cams_addr(start, PAGE_OFFSET + offset, |
Scott Wood | eba5de8 | 2015-10-06 22:48:10 -0500 | [diff] [blame] | 316 | 0x4000000, CONFIG_LOWMEM_CAM_NUM, |
| 317 | false); |
Kevin Hao | 0be7d969b | 2013-12-24 15:12:11 +0800 | [diff] [blame] | 318 | restore_to_as0(n, offset, __va(dt_ptr), 1); |
Kevin Hao | 7d2471f | 2013-12-24 15:12:10 +0800 | [diff] [blame] | 319 | /* We should never reach here */ |
| 320 | panic("Relocation error"); |
| 321 | } |
Kevin Hao | dd18969 | 2013-12-24 15:12:06 +0800 | [diff] [blame] | 322 | } |
| 323 | #endif |
Kumar Gala | 55fd766 | 2009-10-16 18:48:40 -0500 | [diff] [blame] | 324 | #endif |