blob: ed870468ef6f12562f7833fc8af56bb24d44cc85 [file] [log] [blame]
Michael Ellerman5cd16ee2005-11-11 14:25:24 +11001#ifndef _ASM_POWERPC_PAGE_H
2#define _ASM_POWERPC_PAGE_H
3
4/*
5 * Copyright (C) 2001,2005 IBM Corporation.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 */
12
Kumar Galaa3ba68f2008-10-20 03:16:55 +000013#ifndef __ASSEMBLY__
14#include <linux/types.h>
Aneesh Kumar K.Vf78f7ed2015-10-08 13:29:28 +053015#include <linux/kernel.h>
Stephen Rothwell463baa82008-10-16 20:29:07 +110016#else
17#include <asm/types.h>
Kumar Galaa3ba68f2008-10-20 03:16:55 +000018#endif
Christophe Leroyec0c4642018-07-05 16:24:57 +000019#include <asm/asm-const.h>
Michael Ellerman5cd16ee2005-11-11 14:25:24 +110020
21/*
Yuri Tikhonove1240122009-01-29 01:40:44 +000022 * On regular PPC32 page size is 4K (but we support 4K/16K/64K/256K pages
Christophe Leroy555f4fd2019-02-21 19:08:46 +000023 * on PPC44x and 4K/16K on 8xx). For PPC64 we support either 4K or 64K software
Michael Ellerman5cd16ee2005-11-11 14:25:24 +110024 * page size. When using 64K pages however, whether we are really supporting
25 * 64K pages in HW or not is irrelevant to those definitions.
26 */
Christophe Leroy555f4fd2019-02-21 19:08:46 +000027#define PAGE_SHIFT CONFIG_PPC_PAGE_SHIFT
Michael Ellerman5cd16ee2005-11-11 14:25:24 +110028#define PAGE_SIZE (ASM_CONST(1) << PAGE_SHIFT)
29
Becky Bruce41151e72011-06-28 09:54:48 +000030#ifndef __ASSEMBLY__
31#ifdef CONFIG_HUGETLB_PAGE
Hari Bathini85975382018-04-10 19:11:31 +053032extern bool hugetlb_disabled;
Becky Bruce41151e72011-06-28 09:54:48 +000033extern unsigned int HPAGE_SHIFT;
34#else
35#define HPAGE_SHIFT PAGE_SHIFT
36#endif
37#define HPAGE_SIZE ((1UL) << HPAGE_SHIFT)
38#define HPAGE_MASK (~(HPAGE_SIZE - 1))
39#define HUGETLB_PAGE_ORDER (HPAGE_SHIFT - PAGE_SHIFT)
40#define HUGE_MAX_HSTATE (MMU_PAGE_COUNT-1)
41#endif
42
Michael Ellerman5cd16ee2005-11-11 14:25:24 +110043/*
44 * Subtle: (1 << PAGE_SHIFT) is an int, not an unsigned long. So if we
45 * assign PAGE_MASK to a larger type it gets extended the way we want
46 * (i.e. with 1s in the high bits)
47 */
48#define PAGE_MASK (~((1 << PAGE_SHIFT) - 1))
49
Michael Ellermanb5666f72005-12-05 10:24:33 -060050/*
51 * KERNELBASE is the virtual address of the start of the kernel, it's often
52 * the same as PAGE_OFFSET, but _might not be_.
53 *
54 * The kdump dump kernel is one example where KERNELBASE != PAGE_OFFSET.
55 *
Kumar Gala37dd2ba2008-04-22 04:22:34 +100056 * PAGE_OFFSET is the virtual address of the start of lowmem.
57 *
58 * PHYSICAL_START is the physical address of the start of the kernel.
59 *
60 * MEMORY_START is the physical address of the start of lowmem.
61 *
62 * KERNELBASE, PAGE_OFFSET, and PHYSICAL_START are all configurable on
63 * ppc32 and based on how they are set we determine MEMORY_START.
64 *
65 * For the linear mapping the following equation should be true:
66 * KERNELBASE - PAGE_OFFSET = PHYSICAL_START - MEMORY_START
67 *
68 * Also, KERNELBASE >= PAGE_OFFSET and PHYSICAL_START >= MEMORY_START
69 *
Vaishnavi Bhatb8394172013-10-27 11:47:19 +053070 * There are two ways to determine a physical address from a virtual one:
Kumar Gala37dd2ba2008-04-22 04:22:34 +100071 * va = pa + PAGE_OFFSET - MEMORY_START
72 * va = pa + KERNELBASE - PHYSICAL_START
Michael Ellermanb5666f72005-12-05 10:24:33 -060073 *
74 * If you want to know something's offset from the start of the kernel you
75 * should subtract KERNELBASE.
76 *
77 * If you want to test if something's a kernel address, use is_kernel_addr().
78 */
Michael Ellerman398ab1f2005-12-04 18:39:23 +110079
Kumar Gala37dd2ba2008-04-22 04:22:34 +100080#define KERNELBASE ASM_CONST(CONFIG_KERNEL_START)
81#define PAGE_OFFSET ASM_CONST(CONFIG_PAGE_OFFSET)
82#define LOAD_OFFSET ASM_CONST((CONFIG_KERNEL_START-CONFIG_PHYSICAL_START))
83
Suzuki Poulose0f890c82011-12-14 22:57:15 +000084#if defined(CONFIG_NONSTATIC_KERNEL)
Kumar Gala37dd2ba2008-04-22 04:22:34 +100085#ifndef __ASSEMBLY__
Kumar Galaa3ba68f2008-10-20 03:16:55 +000086
Kumar Gala37dd2ba2008-04-22 04:22:34 +100087extern phys_addr_t memstart_addr;
88extern phys_addr_t kernstart_addr;
Suzuki Poulose368ff8f2011-12-14 22:58:37 +000089
Kevin Hao27d11492016-07-13 09:14:40 +080090#if defined(CONFIG_RELOCATABLE) && defined(CONFIG_PPC32)
Suzuki Poulose368ff8f2011-12-14 22:58:37 +000091extern long long virt_phys_offset;
Kumar Gala37dd2ba2008-04-22 04:22:34 +100092#endif
Suzuki Poulose368ff8f2011-12-14 22:58:37 +000093
94#endif /* __ASSEMBLY__ */
Kumar Gala37dd2ba2008-04-22 04:22:34 +100095#define PHYSICAL_START kernstart_addr
Suzuki Poulose368ff8f2011-12-14 22:58:37 +000096
97#else /* !CONFIG_NONSTATIC_KERNEL */
Kumar Gala37dd2ba2008-04-22 04:22:34 +100098#define PHYSICAL_START ASM_CONST(CONFIG_PHYSICAL_START)
Paul Mackerras549e8152008-08-30 11:43:47 +100099#endif
100
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000101/* See Description below for VIRT_PHYS_OFFSET */
Scott Woodffda09a2015-10-06 22:48:20 -0500102#if defined(CONFIG_PPC32) && defined(CONFIG_BOOKE)
103#ifdef CONFIG_RELOCATABLE
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000104#define VIRT_PHYS_OFFSET virt_phys_offset
105#else
106#define VIRT_PHYS_OFFSET (KERNELBASE - PHYSICAL_START)
107#endif
Scott Woodffda09a2015-10-06 22:48:20 -0500108#endif
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000109
Paul Mackerras549e8152008-08-30 11:43:47 +1000110#ifdef CONFIG_PPC64
111#define MEMORY_START 0UL
Suzuki Poulose0f890c82011-12-14 22:57:15 +0000112#elif defined(CONFIG_NONSTATIC_KERNEL)
Paul Mackerras549e8152008-08-30 11:43:47 +1000113#define MEMORY_START memstart_addr
114#else
Kumar Gala37dd2ba2008-04-22 04:22:34 +1000115#define MEMORY_START (PHYSICAL_START + PAGE_OFFSET - KERNELBASE)
116#endif
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100117
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100118#ifdef CONFIG_FLATMEM
Scott Wood67eb5492011-03-24 11:51:19 +0000119#define ARCH_PFN_OFFSET ((unsigned long)(MEMORY_START >> PAGE_SHIFT))
Mathieu Malaterre603b8922018-03-07 21:34:35 +0100120#ifndef __ASSEMBLY__
121extern unsigned long max_mapnr;
122static inline bool pfn_valid(unsigned long pfn)
123{
124 unsigned long min_pfn = ARCH_PFN_OFFSET;
125
126 return pfn >= min_pfn && pfn < max_mapnr;
127}
128#endif
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100129#endif
130
Aneesh Kumar K.V65d32232015-09-03 13:20:56 +0530131#define virt_to_pfn(kaddr) (__pa(kaddr) >> PAGE_SHIFT)
132#define virt_to_page(kaddr) pfn_to_page(virt_to_pfn(kaddr))
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100133#define pfn_to_kaddr(pfn) __va((pfn) << PAGE_SHIFT)
Michael Ellermane41e53c2017-05-18 20:37:31 +1000134
135#ifdef CONFIG_PPC_BOOK3S_64
136/*
137 * On hash the vmalloc and other regions alias to the kernel region when passed
138 * through __pa(), which virt_to_pfn() uses. That means virt_addr_valid() can
139 * return true for some vmalloc addresses, which is incorrect. So explicitly
140 * check that the address is in the kernel region.
141 */
142#define virt_addr_valid(kaddr) (REGION_ID(kaddr) == KERNEL_REGION_ID && \
143 pfn_valid(virt_to_pfn(kaddr)))
144#else
Aneesh Kumar K.V65d32232015-09-03 13:20:56 +0530145#define virt_addr_valid(kaddr) pfn_valid(virt_to_pfn(kaddr))
Michael Ellermane41e53c2017-05-18 20:37:31 +1000146#endif
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100147
Kumar Galadbc96322010-04-21 02:12:58 -0500148/*
149 * On Book-E parts we need __va to parse the device tree and we can't
150 * determine MEMORY_START until then. However we can determine PHYSICAL_START
151 * from information at hand (program counter, TLB lookup).
152 *
Kevin Hao27d11492016-07-13 09:14:40 +0800153 * On BookE with RELOCATABLE && PPC32
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000154 *
Kevin Hao27d11492016-07-13 09:14:40 +0800155 * With RELOCATABLE && PPC32, we support loading the kernel at any physical
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000156 * address without any restriction on the page alignment.
157 *
158 * We find the runtime address of _stext and relocate ourselves based on
159 * the following calculation:
160 *
161 * virtual_base = ALIGN_DOWN(KERNELBASE,256M) +
162 * MODULO(_stext.run,256M)
163 * and create the following mapping:
164 *
165 * ALIGN_DOWN(_stext.run,256M) => ALIGN_DOWN(KERNELBASE,256M)
166 *
167 * When we process relocations, we cannot depend on the
168 * existing equation for the __va()/__pa() translations:
169 *
170 * __va(x) = (x) - PHYSICAL_START + KERNELBASE
171 *
172 * Where:
173 * PHYSICAL_START = kernstart_addr = Physical address of _stext
174 * KERNELBASE = Compiled virtual address of _stext.
175 *
176 * This formula holds true iff, kernel load address is TLB page aligned.
177 *
178 * In our case, we need to also account for the shift in the kernel Virtual
179 * address.
180 *
181 * E.g.,
182 *
183 * Let the kernel be loaded at 64MB and KERNELBASE be 0xc0000000 (same as PAGE_OFFSET).
184 * In this case, we would be mapping 0 to 0xc0000000, and kernstart_addr = 64M
185 *
186 * Now __va(1MB) = (0x100000) - (0x4000000) + 0xc0000000
187 * = 0xbc100000 , which is wrong.
188 *
189 * Rather, it should be : 0xc0000000 + 0x100000 = 0xc0100000
190 * according to our mapping.
191 *
192 * Hence we use the following formula to get the translations right:
193 *
194 * __va(x) = (x) - [ PHYSICAL_START - Effective KERNELBASE ]
195 *
196 * Where :
197 * PHYSICAL_START = dynamic load address.(kernstart_addr variable)
198 * Effective KERNELBASE = virtual_base =
199 * = ALIGN_DOWN(KERNELBASE,256M) +
200 * MODULO(PHYSICAL_START,256M)
201 *
202 * To make the cost of __va() / __pa() more light weight, we introduce
203 * a new variable virt_phys_offset, which will hold :
204 *
205 * virt_phys_offset = Effective KERNELBASE - PHYSICAL_START
206 * = ALIGN_DOWN(KERNELBASE,256M) -
207 * ALIGN_DOWN(PHYSICALSTART,256M)
208 *
209 * Hence :
210 *
211 * __va(x) = x - PHYSICAL_START + Effective KERNELBASE
212 * = x + virt_phys_offset
213 *
214 * and
215 * __pa(x) = x + PHYSICAL_START - Effective KERNELBASE
216 * = x - virt_phys_offset
217 *
Kumar Galadbc96322010-04-21 02:12:58 -0500218 * On non-Book-E PPC64 PAGE_OFFSET and MEMORY_START are constants so use
219 * the other definitions for __va & __pa.
220 */
Scott Woodffda09a2015-10-06 22:48:20 -0500221#if defined(CONFIG_PPC32) && defined(CONFIG_BOOKE)
Suzuki Poulose368ff8f2011-12-14 22:58:37 +0000222#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + VIRT_PHYS_OFFSET))
223#define __pa(x) ((unsigned long)(x) - VIRT_PHYS_OFFSET)
Kumar Galadbc96322010-04-21 02:12:58 -0500224#else
Paul Mackerrasbdbc29c2013-08-27 16:07:49 +1000225#ifdef CONFIG_PPC64
226/*
227 * gcc miscompiles (unsigned long)(&static_var) - PAGE_OFFSET
228 * with -mcmodel=medium, so we use & and | instead of - and + on 64-bit.
229 */
230#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) | PAGE_OFFSET))
231#define __pa(x) ((unsigned long)(x) & 0x0fffffffffffffffUL)
232
233#else /* 32-bit, non book E */
Kumar Galadbc96322010-04-21 02:12:58 -0500234#define __va(x) ((void *)(unsigned long)((phys_addr_t)(x) + PAGE_OFFSET - MEMORY_START))
Paul Mackerras549e8152008-08-30 11:43:47 +1000235#define __pa(x) ((unsigned long)(x) - PAGE_OFFSET + MEMORY_START)
Kumar Galadbc96322010-04-21 02:12:58 -0500236#endif
Paul Mackerrasbdbc29c2013-08-27 16:07:49 +1000237#endif
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100238
239/*
240 * Unfortunately the PLT is in the BSS in the PPC32 ELF ABI,
241 * and needs to be executable. This means the whole heap ends
242 * up being executable.
243 */
Denys Vlasenko16e72e92017-02-22 15:45:16 -0800244#define VM_DATA_DEFAULT_FLAGS32 \
245 (((current->personality & READ_IMPLIES_EXEC) ? VM_EXEC : 0) | \
246 VM_READ | VM_WRITE | \
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100247 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
248
249#define VM_DATA_DEFAULT_FLAGS64 (VM_READ | VM_WRITE | \
250 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
251
252#ifdef __powerpc64__
253#include <asm/page_64.h>
254#else
255#include <asm/page_32.h>
256#endif
257
258/* align addr on a size boundary - adjust address up/down if needed */
Aneesh Kumar K.Vf78f7ed2015-10-08 13:29:28 +0530259#define _ALIGN_UP(addr, size) __ALIGN_KERNEL(addr, size)
260#define _ALIGN_DOWN(addr, size) ((addr)&(~((typeof(addr))(size)-1)))
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100261
262/* align addr on a size boundary - adjust address up if needed */
263#define _ALIGN(addr,size) _ALIGN_UP(addr,size)
264
Michael Ellerman51fae6de2005-12-04 18:39:15 +1100265/*
266 * Don't compare things with KERNELBASE or PAGE_OFFSET to test for
267 * "kernelness", use is_kernel_addr() - it should do what you want.
268 */
Benjamin Herrenschmidt57e2a992009-07-28 11:59:34 +1000269#ifdef CONFIG_PPC_BOOK3E_64
270#define is_kernel_addr(x) ((x) >= 0x8000000000000000ul)
271#else
Michael Ellerman51fae6de2005-12-04 18:39:15 +1100272#define is_kernel_addr(x) ((x) >= PAGE_OFFSET)
Benjamin Herrenschmidt57e2a992009-07-28 11:59:34 +1000273#endif
Michael Ellerman51fae6de2005-12-04 18:39:15 +1100274
Aneesh Kumar K.Vcf9427b2013-04-28 09:37:29 +0000275#ifndef CONFIG_PPC_BOOK3S_64
Becky Bruce41151e72011-06-28 09:54:48 +0000276/*
277 * Use the top bit of the higher-level page table entries to indicate whether
278 * the entries we point to contain hugepages. This works because we know that
279 * the page tables live in kernel space. If we ever decide to support having
280 * page tables at arbitrary addresses, this breaks and will have to change.
281 */
282#ifdef CONFIG_PPC64
Daniel Axtensd456f352018-11-07 01:48:03 +1100283#define PD_HUGE 0x8000000000000000UL
Becky Bruce41151e72011-06-28 09:54:48 +0000284#else
285#define PD_HUGE 0x80000000
286#endif
Paul Mackerrasc61a8842016-02-23 13:36:17 +1100287
288#else /* CONFIG_PPC_BOOK3S_64 */
289/*
290 * Book3S 64 stores real addresses in the hugepd entries to
291 * avoid overlaps with _PAGE_PRESENT and _PAGE_PTE.
292 */
293#define HUGEPD_ADDR_MASK (0x0ffffffffffffffful & ~HUGEPD_SHIFT_MASK)
Aneesh Kumar K.Vcf9427b2013-04-28 09:37:29 +0000294#endif /* CONFIG_PPC_BOOK3S_64 */
Becky Bruce41151e72011-06-28 09:54:48 +0000295
296/*
297 * Some number of bits at the level of the page table that points to
298 * a hugepte are used to encode the size. This masks those bits.
299 */
300#define HUGEPD_SHIFT_MASK 0x3f
301
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100302#ifndef __ASSEMBLY__
303
Aneesh Kumar K.V5dc1ef82016-04-29 23:25:28 +1000304#ifdef CONFIG_PPC_BOOK3S_64
305#include <asm/pgtable-be-types.h>
306#else
Aneesh Kumar K.V2bf59912016-03-01 09:45:11 +0530307#include <asm/pgtable-types.h>
Aneesh Kumar K.V5dc1ef82016-04-29 23:25:28 +1000308#endif
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100309
David Gibsona4fe3ce2009-10-26 19:24:31 +0000310
Aneesh Kumar K.V26a344a2015-12-01 09:06:52 +0530311#ifndef CONFIG_HUGETLB_PAGE
312#define is_hugepd(pdep) (0)
313#define pgd_huge(pgd) (0)
David Gibsona4fe3ce2009-10-26 19:24:31 +0000314#endif /* CONFIG_HUGETLB_PAGE */
Aneesh Kumar K.V26a344a2015-12-01 09:06:52 +0530315
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100316struct page;
317extern void clear_user_page(void *page, unsigned long vaddr, struct page *pg);
318extern void copy_user_page(void *to, void *from, unsigned long vaddr,
319 struct page *p);
sukadev@linux.vnet.ibm.com1d54cf22011-08-30 09:19:17 +0000320extern int devmem_is_allowed(unsigned long pfn);
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100321
Robert Jennings14f966e2009-04-15 05:55:32 +0000322#ifdef CONFIG_PPC_SMLPAR
323void arch_free_page(struct page *page, int order);
324#define HAVE_ARCH_FREE_PAGE
325#endif
326
Benjamin Herrenschmidta5bba932006-05-30 13:51:37 +1000327struct vm_area_struct;
Martin Schwidefsky2f569af2008-02-08 04:22:04 -0800328
KAMEZAWA Hiroyuki659e3502006-03-27 01:15:35 -0800329#include <asm-generic/memory_model.h>
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100330#endif /* __ASSEMBLY__ */
Christophe Leroya3286f02018-02-22 15:27:22 +0100331#include <asm/slice.h>
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100332
Christoph Hellwig25078dc2018-12-16 17:53:49 +0100333#define ARCH_ZONE_DMA_BITS 31
334
Michael Ellerman5cd16ee2005-11-11 14:25:24 +1100335#endif /* _ASM_POWERPC_PAGE_H */