Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 5b67954e804465a4658dd4da8d52b87a8d1ea00c

Authored by Paul Mundt
1 parent f36af73304
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

sh: Fixup pte_mkhuge() build failure. 

When hugetlbpage support isn't enabled, this can be bogus.
Wrap it back in _PAGE_FLAGS_HARD to avoid changes to the
base PTE when not aiming for larger sizes.

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

Showing 1 changed file with 8 additions and 0 deletions Inline Diff

include/asm-sh/pgtable.h
Diff comments   View file @ 5b67954
1 /* 1 /*
2 * This file contains the functions and defines necessary to modify and 2 * This file contains the functions and defines necessary to modify and
3 * use the SuperH page table tree. 3 * use the SuperH page table tree.
4 * 4 *
5 * Copyright (C) 1999 Niibe Yutaka 5 * Copyright (C) 1999 Niibe Yutaka
6 * Copyright (C) 2002 - 2005 Paul Mundt 6 * Copyright (C) 2002 - 2005 Paul Mundt
7 * 7 *
8 * This file is subject to the terms and conditions of the GNU General 8 * This file is subject to the terms and conditions of the GNU General
9 * Public License. See the file "COPYING" in the main directory of this 9 * Public License. See the file "COPYING" in the main directory of this
10 * archive for more details. 10 * archive for more details.
11 */ 11 */
12 #ifndef __ASM_SH_PGTABLE_H 12 #ifndef __ASM_SH_PGTABLE_H
13 #define __ASM_SH_PGTABLE_H 13 #define __ASM_SH_PGTABLE_H
14 14
15 #include <asm-generic/pgtable-nopmd.h> 15 #include <asm-generic/pgtable-nopmd.h>
16 #include <asm/page.h> 16 #include <asm/page.h>
17 17
18 #ifndef __ASSEMBLY__ 18 #ifndef __ASSEMBLY__
19 #include <asm/addrspace.h> 19 #include <asm/addrspace.h>
20 #include <asm/fixmap.h> 20 #include <asm/fixmap.h>
21 21
22 /* 22 /*
23 * ZERO_PAGE is a global shared page that is always zero: used 23 * ZERO_PAGE is a global shared page that is always zero: used
24 * for zero-mapped memory areas etc.. 24 * for zero-mapped memory areas etc..
25 */ 25 */
26 extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]; 26 extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
27 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page)) 27 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
28 28
29 #endif /* !__ASSEMBLY__ */ 29 #endif /* !__ASSEMBLY__ */
30 30
31 /* 31 /*
32 * traditional two-level paging structure 32 * traditional two-level paging structure
33 */ 33 */
34 /* PTE bits */ 34 /* PTE bits */
35 #ifdef CONFIG_X2TLB 35 #ifdef CONFIG_X2TLB
36 # define PTE_MAGNITUDE 3 /* 64-bit PTEs on extended mode SH-X2 TLB */ 36 # define PTE_MAGNITUDE 3 /* 64-bit PTEs on extended mode SH-X2 TLB */
37 #else 37 #else
38 # define PTE_MAGNITUDE 2 /* 32-bit PTEs */ 38 # define PTE_MAGNITUDE 2 /* 32-bit PTEs */
39 #endif 39 #endif
40 #define PTE_SHIFT PAGE_SHIFT 40 #define PTE_SHIFT PAGE_SHIFT
41 #define PTE_BITS (PTE_SHIFT - PTE_MAGNITUDE) 41 #define PTE_BITS (PTE_SHIFT - PTE_MAGNITUDE)
42 42
43 /* PGD bits */ 43 /* PGD bits */
44 #define PGDIR_SHIFT (PTE_SHIFT + PTE_BITS) 44 #define PGDIR_SHIFT (PTE_SHIFT + PTE_BITS)
45 #define PGDIR_BITS (32 - PGDIR_SHIFT) 45 #define PGDIR_BITS (32 - PGDIR_SHIFT)
46 #define PGDIR_SIZE (1 << PGDIR_SHIFT) 46 #define PGDIR_SIZE (1 << PGDIR_SHIFT)
47 #define PGDIR_MASK (~(PGDIR_SIZE-1)) 47 #define PGDIR_MASK (~(PGDIR_SIZE-1))
48 48
49 /* Entries per level */ 49 /* Entries per level */
50 #define PTRS_PER_PTE (PAGE_SIZE / 4) 50 #define PTRS_PER_PTE (PAGE_SIZE / 4)
51 #define PTRS_PER_PGD (PAGE_SIZE / 4) 51 #define PTRS_PER_PGD (PAGE_SIZE / 4)
52 52
53 #define USER_PTRS_PER_PGD (TASK_SIZE/PGDIR_SIZE) 53 #define USER_PTRS_PER_PGD (TASK_SIZE/PGDIR_SIZE)
54 #define FIRST_USER_ADDRESS 0 54 #define FIRST_USER_ADDRESS 0
55 55
56 #define PTE_PHYS_MASK 0x1ffff000 56 #define PTE_PHYS_MASK 0x1ffff000
57 57
58 /* 58 /*
59 * First 1MB map is used by fixed purpose. 59 * First 1MB map is used by fixed purpose.
60 * Currently only 4-entry (16kB) is used (see arch/sh/mm/cache.c) 60 * Currently only 4-entry (16kB) is used (see arch/sh/mm/cache.c)
61 */ 61 */
62 #define VMALLOC_START (P3SEG+0x00100000) 62 #define VMALLOC_START (P3SEG+0x00100000)
63 #define VMALLOC_END (FIXADDR_START-2*PAGE_SIZE) 63 #define VMALLOC_END (FIXADDR_START-2*PAGE_SIZE)
64 64
65 /* 65 /*
66 * Linux PTEL encoding. 66 * Linux PTEL encoding.
67 * 67 *
68 * Hardware and software bit definitions for the PTEL value (see below for 68 * Hardware and software bit definitions for the PTEL value (see below for
69 * notes on SH-X2 MMUs and 64-bit PTEs): 69 * notes on SH-X2 MMUs and 64-bit PTEs):
70 * 70 *
71 * - Bits 0 and 7 are reserved on SH-3 (_PAGE_WT and _PAGE_SZ1 on SH-4). 71 * - Bits 0 and 7 are reserved on SH-3 (_PAGE_WT and _PAGE_SZ1 on SH-4).
72 * 72 *
73 * - Bit 1 is the SH-bit, but is unused on SH-3 due to an MMU bug (the 73 * - Bit 1 is the SH-bit, but is unused on SH-3 due to an MMU bug (the
74 * hardware PTEL value can't have the SH-bit set when MMUCR.IX is set, 74 * hardware PTEL value can't have the SH-bit set when MMUCR.IX is set,
75 * which is the default in cpu-sh3/mmu_context.h:MMU_CONTROL_INIT). 75 * which is the default in cpu-sh3/mmu_context.h:MMU_CONTROL_INIT).
76 * 76 *
77 * In order to keep this relatively clean, do not use these for defining 77 * In order to keep this relatively clean, do not use these for defining
78 * SH-3 specific flags until all of the other unused bits have been 78 * SH-3 specific flags until all of the other unused bits have been
79 * exhausted. 79 * exhausted.
80 * 80 *
81 * - Bit 9 is reserved by everyone and used by _PAGE_PROTNONE. 81 * - Bit 9 is reserved by everyone and used by _PAGE_PROTNONE.
82 * 82 *
83 * - Bits 10 and 11 are low bits of the PPN that are reserved on >= 4K pages. 83 * - Bits 10 and 11 are low bits of the PPN that are reserved on >= 4K pages.
84 * Bit 10 is used for _PAGE_ACCESSED, bit 11 remains unused. 84 * Bit 10 is used for _PAGE_ACCESSED, bit 11 remains unused.
85 * 85 *
86 * - Bits 31, 30, and 29 remain unused by everyone and can be used for future 86 * - Bits 31, 30, and 29 remain unused by everyone and can be used for future
87 * software flags, although care must be taken to update _PAGE_CLEAR_FLAGS. 87 * software flags, although care must be taken to update _PAGE_CLEAR_FLAGS.
88 * 88 *
89 * XXX: Leave the _PAGE_FILE and _PAGE_WT overhaul for a rainy day. 89 * XXX: Leave the _PAGE_FILE and _PAGE_WT overhaul for a rainy day.
90 * 90 *
91 * SH-X2 MMUs and extended PTEs 91 * SH-X2 MMUs and extended PTEs
92 * 92 *
93 * SH-X2 supports an extended mode TLB with split data arrays due to the 93 * SH-X2 supports an extended mode TLB with split data arrays due to the
94 * number of bits needed for PR and SZ (now EPR and ESZ) encodings. The PR and 94 * number of bits needed for PR and SZ (now EPR and ESZ) encodings. The PR and
95 * SZ bit placeholders still exist in data array 1, but are implemented as 95 * SZ bit placeholders still exist in data array 1, but are implemented as
96 * reserved bits, with the real logic existing in data array 2. 96 * reserved bits, with the real logic existing in data array 2.
97 * 97 *
98 * The downside to this is that we can no longer fit everything in to a 32-bit 98 * The downside to this is that we can no longer fit everything in to a 32-bit
99 * PTE encoding, so a 64-bit pte_t is necessary for these parts. On the plus 99 * PTE encoding, so a 64-bit pte_t is necessary for these parts. On the plus
100 * side, this gives us quite a few spare bits to play with for future usage. 100 * side, this gives us quite a few spare bits to play with for future usage.
101 */ 101 */
102 /* Legacy and compat mode bits */ 102 /* Legacy and compat mode bits */
103 #define _PAGE_WT 0x001 /* WT-bit on SH-4, 0 on SH-3 */ 103 #define _PAGE_WT 0x001 /* WT-bit on SH-4, 0 on SH-3 */
104 #define _PAGE_HW_SHARED 0x002 /* SH-bit : shared among processes */ 104 #define _PAGE_HW_SHARED 0x002 /* SH-bit : shared among processes */
105 #define _PAGE_DIRTY 0x004 /* D-bit : page changed */ 105 #define _PAGE_DIRTY 0x004 /* D-bit : page changed */
106 #define _PAGE_CACHABLE 0x008 /* C-bit : cachable */ 106 #define _PAGE_CACHABLE 0x008 /* C-bit : cachable */
107 #ifndef CONFIG_X2TLB 107 #ifndef CONFIG_X2TLB
108 # define _PAGE_SZ0 0x010 /* SZ0-bit : Size of page */ 108 # define _PAGE_SZ0 0x010 /* SZ0-bit : Size of page */
109 # define _PAGE_RW 0x020 /* PR0-bit : write access allowed */ 109 # define _PAGE_RW 0x020 /* PR0-bit : write access allowed */
110 # define _PAGE_USER 0x040 /* PR1-bit : user space access allowed*/ 110 # define _PAGE_USER 0x040 /* PR1-bit : user space access allowed*/
111 # define _PAGE_SZ1 0x080 /* SZ1-bit : Size of page (on SH-4) */ 111 # define _PAGE_SZ1 0x080 /* SZ1-bit : Size of page (on SH-4) */
112 #endif 112 #endif
113 #define _PAGE_PRESENT 0x100 /* V-bit : page is valid */ 113 #define _PAGE_PRESENT 0x100 /* V-bit : page is valid */
114 #define _PAGE_PROTNONE 0x200 /* software: if not present */ 114 #define _PAGE_PROTNONE 0x200 /* software: if not present */
115 #define _PAGE_ACCESSED 0x400 /* software: page referenced */ 115 #define _PAGE_ACCESSED 0x400 /* software: page referenced */
116 #define _PAGE_FILE _PAGE_WT /* software: pagecache or swap? */ 116 #define _PAGE_FILE _PAGE_WT /* software: pagecache or swap? */
117 117
118 /* Extended mode bits */ 118 /* Extended mode bits */
119 #define _PAGE_EXT_ESZ0 0x0010 /* ESZ0-bit: Size of page */ 119 #define _PAGE_EXT_ESZ0 0x0010 /* ESZ0-bit: Size of page */
120 #define _PAGE_EXT_ESZ1 0x0020 /* ESZ1-bit: Size of page */ 120 #define _PAGE_EXT_ESZ1 0x0020 /* ESZ1-bit: Size of page */
121 #define _PAGE_EXT_ESZ2 0x0040 /* ESZ2-bit: Size of page */ 121 #define _PAGE_EXT_ESZ2 0x0040 /* ESZ2-bit: Size of page */
122 #define _PAGE_EXT_ESZ3 0x0080 /* ESZ3-bit: Size of page */ 122 #define _PAGE_EXT_ESZ3 0x0080 /* ESZ3-bit: Size of page */
123 123
124 #define _PAGE_EXT_USER_EXEC 0x0100 /* EPR0-bit: User space executable */ 124 #define _PAGE_EXT_USER_EXEC 0x0100 /* EPR0-bit: User space executable */
125 #define _PAGE_EXT_USER_WRITE 0x0200 /* EPR1-bit: User space writable */ 125 #define _PAGE_EXT_USER_WRITE 0x0200 /* EPR1-bit: User space writable */
126 #define _PAGE_EXT_USER_READ 0x0400 /* EPR2-bit: User space readable */ 126 #define _PAGE_EXT_USER_READ 0x0400 /* EPR2-bit: User space readable */
127 127
128 #define _PAGE_EXT_KERN_EXEC 0x0800 /* EPR3-bit: Kernel space executable */ 128 #define _PAGE_EXT_KERN_EXEC 0x0800 /* EPR3-bit: Kernel space executable */
129 #define _PAGE_EXT_KERN_WRITE 0x1000 /* EPR4-bit: Kernel space writable */ 129 #define _PAGE_EXT_KERN_WRITE 0x1000 /* EPR4-bit: Kernel space writable */
130 #define _PAGE_EXT_KERN_READ 0x2000 /* EPR5-bit: Kernel space readable */ 130 #define _PAGE_EXT_KERN_READ 0x2000 /* EPR5-bit: Kernel space readable */
131 131
132 /* Wrapper for extended mode pgprot twiddling */ 132 /* Wrapper for extended mode pgprot twiddling */
133 #ifdef CONFIG_X2TLB 133 #ifdef CONFIG_X2TLB
134 # define _PAGE_EXT(x) ((unsigned long long)(x) << 32) 134 # define _PAGE_EXT(x) ((unsigned long long)(x) << 32)
135 #else 135 #else
136 # define _PAGE_EXT(x) (0) 136 # define _PAGE_EXT(x) (0)
137 #endif 137 #endif
138 138
139 /* software: moves to PTEA.TC (Timing Control) */ 139 /* software: moves to PTEA.TC (Timing Control) */
140 #define _PAGE_PCC_AREA5 0x00000000 /* use BSC registers for area5 */ 140 #define _PAGE_PCC_AREA5 0x00000000 /* use BSC registers for area5 */
141 #define _PAGE_PCC_AREA6 0x80000000 /* use BSC registers for area6 */ 141 #define _PAGE_PCC_AREA6 0x80000000 /* use BSC registers for area6 */
142 142
143 /* software: moves to PTEA.SA[2:0] (Space Attributes) */ 143 /* software: moves to PTEA.SA[2:0] (Space Attributes) */
144 #define _PAGE_PCC_IODYN 0x00000001 /* IO space, dynamically sized bus */ 144 #define _PAGE_PCC_IODYN 0x00000001 /* IO space, dynamically sized bus */
145 #define _PAGE_PCC_IO8 0x20000000 /* IO space, 8 bit bus */ 145 #define _PAGE_PCC_IO8 0x20000000 /* IO space, 8 bit bus */
146 #define _PAGE_PCC_IO16 0x20000001 /* IO space, 16 bit bus */ 146 #define _PAGE_PCC_IO16 0x20000001 /* IO space, 16 bit bus */
147 #define _PAGE_PCC_COM8 0x40000000 /* Common Memory space, 8 bit bus */ 147 #define _PAGE_PCC_COM8 0x40000000 /* Common Memory space, 8 bit bus */
148 #define _PAGE_PCC_COM16 0x40000001 /* Common Memory space, 16 bit bus */ 148 #define _PAGE_PCC_COM16 0x40000001 /* Common Memory space, 16 bit bus */
149 #define _PAGE_PCC_ATR8 0x60000000 /* Attribute Memory space, 8 bit bus */ 149 #define _PAGE_PCC_ATR8 0x60000000 /* Attribute Memory space, 8 bit bus */
150 #define _PAGE_PCC_ATR16 0x60000001 /* Attribute Memory space, 6 bit bus */ 150 #define _PAGE_PCC_ATR16 0x60000001 /* Attribute Memory space, 6 bit bus */
151 151
152 /* Mask which drops unused bits from the PTEL value */ 152 /* Mask which drops unused bits from the PTEL value */
153 #ifdef CONFIG_CPU_SH3 153 #ifdef CONFIG_CPU_SH3
154 #define _PAGE_CLEAR_FLAGS (_PAGE_PROTNONE | _PAGE_ACCESSED| \ 154 #define _PAGE_CLEAR_FLAGS (_PAGE_PROTNONE | _PAGE_ACCESSED| \
155 _PAGE_FILE | _PAGE_SZ1 | \ 155 _PAGE_FILE | _PAGE_SZ1 | \
156 _PAGE_HW_SHARED) 156 _PAGE_HW_SHARED)
157 #else 157 #else
158 #define _PAGE_CLEAR_FLAGS (_PAGE_PROTNONE | _PAGE_ACCESSED | _PAGE_FILE) 158 #define _PAGE_CLEAR_FLAGS (_PAGE_PROTNONE | _PAGE_ACCESSED | _PAGE_FILE)
159 #endif 159 #endif
160 160
161 #define _PAGE_FLAGS_HARDWARE_MASK (0x1fffffff & ~(_PAGE_CLEAR_FLAGS)) 161 #define _PAGE_FLAGS_HARDWARE_MASK (0x1fffffff & ~(_PAGE_CLEAR_FLAGS))
162 162
163 /* Hardware flags, page size encoding */ 163 /* Hardware flags, page size encoding */
164 #if defined(CONFIG_X2TLB) 164 #if defined(CONFIG_X2TLB)
165 # if defined(CONFIG_PAGE_SIZE_4KB) 165 # if defined(CONFIG_PAGE_SIZE_4KB)
166 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ0) 166 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ0)
167 # elif defined(CONFIG_PAGE_SIZE_8KB) 167 # elif defined(CONFIG_PAGE_SIZE_8KB)
168 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ1) 168 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ1)
169 # elif defined(CONFIG_PAGE_SIZE_64KB) 169 # elif defined(CONFIG_PAGE_SIZE_64KB)
170 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ2) 170 # define _PAGE_FLAGS_HARD _PAGE_EXT(_PAGE_EXT_ESZ2)
171 # endif 171 # endif
172 #else 172 #else
173 # if defined(CONFIG_PAGE_SIZE_4KB) 173 # if defined(CONFIG_PAGE_SIZE_4KB)
174 # define _PAGE_FLAGS_HARD _PAGE_SZ0 174 # define _PAGE_FLAGS_HARD _PAGE_SZ0
175 # elif defined(CONFIG_PAGE_SIZE_64KB) 175 # elif defined(CONFIG_PAGE_SIZE_64KB)
176 # define _PAGE_FLAGS_HARD _PAGE_SZ1 176 # define _PAGE_FLAGS_HARD _PAGE_SZ1
177 # endif 177 # endif
178 #endif 178 #endif
179 179
180 #if defined(CONFIG_X2TLB) 180 #if defined(CONFIG_X2TLB)
181 # if defined(CONFIG_HUGETLB_PAGE_SIZE_64K) 181 # if defined(CONFIG_HUGETLB_PAGE_SIZE_64K)
182 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ2) 182 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ2)
183 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_256K) 183 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_256K)
184 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ0 | _PAGE_EXT_ESZ2) 184 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ0 | _PAGE_EXT_ESZ2)
185 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB) 185 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB)
186 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ0 | _PAGE_EXT_ESZ1 | _PAGE_EXT_ESZ2) 186 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ0 | _PAGE_EXT_ESZ1 | _PAGE_EXT_ESZ2)
187 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_4MB) 187 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_4MB)
188 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ3) 188 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ3)
189 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_64MB) 189 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_64MB)
190 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ2 | _PAGE_EXT_ESZ3) 190 # define _PAGE_SZHUGE (_PAGE_EXT_ESZ2 | _PAGE_EXT_ESZ3)
191 # endif 191 # endif
192 #else 192 #else
193 # if defined(CONFIG_HUGETLB_PAGE_SIZE_64K) 193 # if defined(CONFIG_HUGETLB_PAGE_SIZE_64K)
194 # define _PAGE_SZHUGE (_PAGE_SZ1) 194 # define _PAGE_SZHUGE (_PAGE_SZ1)
195 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB) 195 # elif defined(CONFIG_HUGETLB_PAGE_SIZE_1MB)
196 # define _PAGE_SZHUGE (_PAGE_SZ0 | _PAGE_SZ1) 196 # define _PAGE_SZHUGE (_PAGE_SZ0 | _PAGE_SZ1)
197 # endif 197 # endif
198 #endif 198 #endif
199 199
200 /*
201 * Stub out _PAGE_SZHUGE if we don't have a good definition for it,
202 * to make pte_mkhuge() happy.
203 */
204 #ifndef _PAGE_SZHUGE
205 # define _PAGE_SZHUGE (_PAGE_FLAGS_HARD)
206 #endif
207
200 #define _PAGE_CHG_MASK \ 208 #define _PAGE_CHG_MASK \
201 (PTE_MASK | _PAGE_ACCESSED | _PAGE_CACHABLE | _PAGE_DIRTY) 209 (PTE_MASK | _PAGE_ACCESSED | _PAGE_CACHABLE | _PAGE_DIRTY)
202 210
203 #ifndef __ASSEMBLY__ 211 #ifndef __ASSEMBLY__
204 212
205 #if defined(CONFIG_X2TLB) /* SH-X2 TLB */ 213 #if defined(CONFIG_X2TLB) /* SH-X2 TLB */
206 #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_CACHABLE | \ 214 #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_CACHABLE | \
207 _PAGE_ACCESSED | _PAGE_FLAGS_HARD) 215 _PAGE_ACCESSED | _PAGE_FLAGS_HARD)
208 216
209 #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \ 217 #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \
210 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \ 218 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \
211 _PAGE_EXT(_PAGE_EXT_USER_READ | \ 219 _PAGE_EXT(_PAGE_EXT_USER_READ | \
212 _PAGE_EXT_USER_WRITE)) 220 _PAGE_EXT_USER_WRITE))
213 221
214 #define PAGE_EXECREAD __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \ 222 #define PAGE_EXECREAD __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \
215 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \ 223 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \
216 _PAGE_EXT(_PAGE_EXT_USER_EXEC | \ 224 _PAGE_EXT(_PAGE_EXT_USER_EXEC | \
217 _PAGE_EXT_USER_READ)) 225 _PAGE_EXT_USER_READ))
218 226
219 #define PAGE_COPY PAGE_EXECREAD 227 #define PAGE_COPY PAGE_EXECREAD
220 228
221 #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \ 229 #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \
222 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \ 230 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \
223 _PAGE_EXT(_PAGE_EXT_USER_READ)) 231 _PAGE_EXT(_PAGE_EXT_USER_READ))
224 232
225 #define PAGE_WRITEONLY __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \ 233 #define PAGE_WRITEONLY __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \
226 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \ 234 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \
227 _PAGE_EXT(_PAGE_EXT_USER_WRITE)) 235 _PAGE_EXT(_PAGE_EXT_USER_WRITE))
228 236
229 #define PAGE_RWX __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \ 237 #define PAGE_RWX __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | \
230 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \ 238 _PAGE_CACHABLE | _PAGE_FLAGS_HARD | \
231 _PAGE_EXT(_PAGE_EXT_USER_WRITE | \ 239 _PAGE_EXT(_PAGE_EXT_USER_WRITE | \
232 _PAGE_EXT_USER_READ | \ 240 _PAGE_EXT_USER_READ | \
233 _PAGE_EXT_USER_EXEC)) 241 _PAGE_EXT_USER_EXEC))
234 242
235 #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \ 243 #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \
236 _PAGE_DIRTY | _PAGE_ACCESSED | \ 244 _PAGE_DIRTY | _PAGE_ACCESSED | \
237 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD | \ 245 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD | \
238 _PAGE_EXT(_PAGE_EXT_KERN_READ | \ 246 _PAGE_EXT(_PAGE_EXT_KERN_READ | \
239 _PAGE_EXT_KERN_WRITE | \ 247 _PAGE_EXT_KERN_WRITE | \
240 _PAGE_EXT_KERN_EXEC)) 248 _PAGE_EXT_KERN_EXEC))
241 249
242 #define PAGE_KERNEL_NOCACHE \ 250 #define PAGE_KERNEL_NOCACHE \
243 __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | \ 251 __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | \
244 _PAGE_ACCESSED | _PAGE_HW_SHARED | \ 252 _PAGE_ACCESSED | _PAGE_HW_SHARED | \
245 _PAGE_FLAGS_HARD | \ 253 _PAGE_FLAGS_HARD | \
246 _PAGE_EXT(_PAGE_EXT_KERN_READ | \ 254 _PAGE_EXT(_PAGE_EXT_KERN_READ | \
247 _PAGE_EXT_KERN_WRITE | \ 255 _PAGE_EXT_KERN_WRITE | \
248 _PAGE_EXT_KERN_EXEC)) 256 _PAGE_EXT_KERN_EXEC))
249 257
250 #define PAGE_KERNEL_RO __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \ 258 #define PAGE_KERNEL_RO __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \
251 _PAGE_DIRTY | _PAGE_ACCESSED | \ 259 _PAGE_DIRTY | _PAGE_ACCESSED | \
252 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD | \ 260 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD | \
253 _PAGE_EXT(_PAGE_EXT_KERN_READ | \ 261 _PAGE_EXT(_PAGE_EXT_KERN_READ | \
254 _PAGE_EXT_KERN_EXEC)) 262 _PAGE_EXT_KERN_EXEC))
255 263
256 #define PAGE_KERNEL_PCC(slot, type) \ 264 #define PAGE_KERNEL_PCC(slot, type) \
257 __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | \ 265 __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | \
258 _PAGE_ACCESSED | _PAGE_FLAGS_HARD | \ 266 _PAGE_ACCESSED | _PAGE_FLAGS_HARD | \
259 _PAGE_EXT(_PAGE_EXT_KERN_READ | \ 267 _PAGE_EXT(_PAGE_EXT_KERN_READ | \
260 _PAGE_EXT_KERN_WRITE | \ 268 _PAGE_EXT_KERN_WRITE | \
261 _PAGE_EXT_KERN_EXEC) \ 269 _PAGE_EXT_KERN_EXEC) \
262 (slot ? _PAGE_PCC_AREA5 : _PAGE_PCC_AREA6) | \ 270 (slot ? _PAGE_PCC_AREA5 : _PAGE_PCC_AREA6) | \
263 (type)) 271 (type))
264 272
265 #elif defined(CONFIG_MMU) /* SH-X TLB */ 273 #elif defined(CONFIG_MMU) /* SH-X TLB */
266 #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_CACHABLE | \ 274 #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_CACHABLE | \
267 _PAGE_ACCESSED | _PAGE_FLAGS_HARD) 275 _PAGE_ACCESSED | _PAGE_FLAGS_HARD)
268 276
269 #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | \ 277 #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | \
270 _PAGE_CACHABLE | _PAGE_ACCESSED | \ 278 _PAGE_CACHABLE | _PAGE_ACCESSED | \
271 _PAGE_FLAGS_HARD) 279 _PAGE_FLAGS_HARD)
272 280
273 #define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_CACHABLE | \ 281 #define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_CACHABLE | \
274 _PAGE_ACCESSED | _PAGE_FLAGS_HARD) 282 _PAGE_ACCESSED | _PAGE_FLAGS_HARD)
275 283
276 #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_CACHABLE | \ 284 #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_CACHABLE | \
277 _PAGE_ACCESSED | _PAGE_FLAGS_HARD) 285 _PAGE_ACCESSED | _PAGE_FLAGS_HARD)
278 286
279 #define PAGE_EXECREAD PAGE_READONLY 287 #define PAGE_EXECREAD PAGE_READONLY
280 #define PAGE_RWX PAGE_SHARED 288 #define PAGE_RWX PAGE_SHARED
281 #define PAGE_WRITEONLY PAGE_SHARED 289 #define PAGE_WRITEONLY PAGE_SHARED
282 290
283 #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_CACHABLE | \ 291 #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_CACHABLE | \
284 _PAGE_DIRTY | _PAGE_ACCESSED | \ 292 _PAGE_DIRTY | _PAGE_ACCESSED | \
285 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD) 293 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD)
286 294
287 #define PAGE_KERNEL_NOCACHE \ 295 #define PAGE_KERNEL_NOCACHE \
288 __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | \ 296 __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | \
289 _PAGE_ACCESSED | _PAGE_HW_SHARED | \ 297 _PAGE_ACCESSED | _PAGE_HW_SHARED | \
290 _PAGE_FLAGS_HARD) 298 _PAGE_FLAGS_HARD)
291 299
292 #define PAGE_KERNEL_RO __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \ 300 #define PAGE_KERNEL_RO __pgprot(_PAGE_PRESENT | _PAGE_CACHABLE | \
293 _PAGE_DIRTY | _PAGE_ACCESSED | \ 301 _PAGE_DIRTY | _PAGE_ACCESSED | \
294 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD) 302 _PAGE_HW_SHARED | _PAGE_FLAGS_HARD)
295 303
296 #define PAGE_KERNEL_PCC(slot, type) \ 304 #define PAGE_KERNEL_PCC(slot, type) \
297 __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | \ 305 __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | \
298 _PAGE_ACCESSED | _PAGE_FLAGS_HARD | \ 306 _PAGE_ACCESSED | _PAGE_FLAGS_HARD | \
299 (slot ? _PAGE_PCC_AREA5 : _PAGE_PCC_AREA6) | \ 307 (slot ? _PAGE_PCC_AREA5 : _PAGE_PCC_AREA6) | \
300 (type)) 308 (type))
301 #else /* no mmu */ 309 #else /* no mmu */
302 #define PAGE_NONE __pgprot(0) 310 #define PAGE_NONE __pgprot(0)
303 #define PAGE_SHARED __pgprot(0) 311 #define PAGE_SHARED __pgprot(0)
304 #define PAGE_COPY __pgprot(0) 312 #define PAGE_COPY __pgprot(0)
305 #define PAGE_EXECREAD __pgprot(0) 313 #define PAGE_EXECREAD __pgprot(0)
306 #define PAGE_RWX __pgprot(0) 314 #define PAGE_RWX __pgprot(0)
307 #define PAGE_READONLY __pgprot(0) 315 #define PAGE_READONLY __pgprot(0)
308 #define PAGE_WRITEONLY __pgprot(0) 316 #define PAGE_WRITEONLY __pgprot(0)
309 #define PAGE_KERNEL __pgprot(0) 317 #define PAGE_KERNEL __pgprot(0)
310 #define PAGE_KERNEL_NOCACHE __pgprot(0) 318 #define PAGE_KERNEL_NOCACHE __pgprot(0)
311 #define PAGE_KERNEL_RO __pgprot(0) 319 #define PAGE_KERNEL_RO __pgprot(0)
312 #define PAGE_KERNEL_PCC __pgprot(0) 320 #define PAGE_KERNEL_PCC __pgprot(0)
313 #endif 321 #endif
314 322
315 #endif /* __ASSEMBLY__ */ 323 #endif /* __ASSEMBLY__ */
316 324
317 /* 325 /*
318 * SH-X and lower (legacy) SuperH parts (SH-3, SH-4, some SH-4A) can't do page 326 * SH-X and lower (legacy) SuperH parts (SH-3, SH-4, some SH-4A) can't do page
319 * protection for execute, and considers it the same as a read. Also, write 327 * protection for execute, and considers it the same as a read. Also, write
320 * permission implies read permission. This is the closest we can get.. 328 * permission implies read permission. This is the closest we can get..
321 * 329 *
322 * SH-X2 (SH7785) and later parts take this to the opposite end of the extreme, 330 * SH-X2 (SH7785) and later parts take this to the opposite end of the extreme,
323 * not only supporting separate execute, read, and write bits, but having 331 * not only supporting separate execute, read, and write bits, but having
324 * completely separate permission bits for user and kernel space. 332 * completely separate permission bits for user and kernel space.
325 */ 333 */
326 /*xwr*/ 334 /*xwr*/
327 #define __P000 PAGE_NONE 335 #define __P000 PAGE_NONE
328 #define __P001 PAGE_READONLY 336 #define __P001 PAGE_READONLY
329 #define __P010 PAGE_COPY 337 #define __P010 PAGE_COPY
330 #define __P011 PAGE_COPY 338 #define __P011 PAGE_COPY
331 #define __P100 PAGE_EXECREAD 339 #define __P100 PAGE_EXECREAD
332 #define __P101 PAGE_EXECREAD 340 #define __P101 PAGE_EXECREAD
333 #define __P110 PAGE_COPY 341 #define __P110 PAGE_COPY
334 #define __P111 PAGE_COPY 342 #define __P111 PAGE_COPY
335 343
336 #define __S000 PAGE_NONE 344 #define __S000 PAGE_NONE
337 #define __S001 PAGE_READONLY 345 #define __S001 PAGE_READONLY
338 #define __S010 PAGE_WRITEONLY 346 #define __S010 PAGE_WRITEONLY
339 #define __S011 PAGE_SHARED 347 #define __S011 PAGE_SHARED
340 #define __S100 PAGE_EXECREAD 348 #define __S100 PAGE_EXECREAD
341 #define __S101 PAGE_EXECREAD 349 #define __S101 PAGE_EXECREAD
342 #define __S110 PAGE_RWX 350 #define __S110 PAGE_RWX
343 #define __S111 PAGE_RWX 351 #define __S111 PAGE_RWX
344 352
345 #ifndef __ASSEMBLY__ 353 #ifndef __ASSEMBLY__
346 354
347 /* 355 /*
348 * Certain architectures need to do special things when PTEs 356 * Certain architectures need to do special things when PTEs
349 * within a page table are directly modified. Thus, the following 357 * within a page table are directly modified. Thus, the following
350 * hook is made available. 358 * hook is made available.
351 */ 359 */
352 #ifdef CONFIG_X2TLB 360 #ifdef CONFIG_X2TLB
353 static inline void set_pte(pte_t *ptep, pte_t pte) 361 static inline void set_pte(pte_t *ptep, pte_t pte)
354 { 362 {
355 ptep->pte_high = pte.pte_high; 363 ptep->pte_high = pte.pte_high;
356 smp_wmb(); 364 smp_wmb();
357 ptep->pte_low = pte.pte_low; 365 ptep->pte_low = pte.pte_low;
358 } 366 }
359 #else 367 #else
360 #define set_pte(pteptr, pteval) (*(pteptr) = pteval) 368 #define set_pte(pteptr, pteval) (*(pteptr) = pteval)
361 #endif 369 #endif
362 370
363 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval) 371 #define set_pte_at(mm,addr,ptep,pteval) set_pte(ptep,pteval)
364 372
365 /* 373 /*
366 * (pmds are folded into pgds so this doesn't get actually called, 374 * (pmds are folded into pgds so this doesn't get actually called,
367 * but the define is needed for a generic inline function.) 375 * but the define is needed for a generic inline function.)
368 */ 376 */
369 #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval) 377 #define set_pmd(pmdptr, pmdval) (*(pmdptr) = pmdval)
370 378
371 #define pte_pfn(x) ((unsigned long)(((x).pte_low >> PAGE_SHIFT))) 379 #define pte_pfn(x) ((unsigned long)(((x).pte_low >> PAGE_SHIFT)))
372 #define pfn_pte(pfn, prot) __pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot)) 380 #define pfn_pte(pfn, prot) __pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
373 #define pfn_pmd(pfn, prot) __pmd(((pfn) << PAGE_SHIFT) | pgprot_val(prot)) 381 #define pfn_pmd(pfn, prot) __pmd(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
374 382
375 #define pte_none(x) (!pte_val(x)) 383 #define pte_none(x) (!pte_val(x))
376 #define pte_present(x) (pte_val(x) & (_PAGE_PRESENT | _PAGE_PROTNONE)) 384 #define pte_present(x) (pte_val(x) & (_PAGE_PRESENT | _PAGE_PROTNONE))
377 #define pte_clear(mm,addr,xp) do { set_pte_at(mm, addr, xp, __pte(0)); } while (0) 385 #define pte_clear(mm,addr,xp) do { set_pte_at(mm, addr, xp, __pte(0)); } while (0)
378 386
379 #define pmd_none(x) (!pmd_val(x)) 387 #define pmd_none(x) (!pmd_val(x))
380 #define pmd_present(x) (pmd_val(x)) 388 #define pmd_present(x) (pmd_val(x))
381 #define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0) 389 #define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0)
382 #define pmd_bad(x) (pmd_val(x) & ~PAGE_MASK) 390 #define pmd_bad(x) (pmd_val(x) & ~PAGE_MASK)
383 391
384 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT)) 392 #define pages_to_mb(x) ((x) >> (20-PAGE_SHIFT))
385 #define pte_page(x) phys_to_page(pte_val(x)&PTE_PHYS_MASK) 393 #define pte_page(x) phys_to_page(pte_val(x)&PTE_PHYS_MASK)
386 394
387 /* 395 /*
388 * The following only work if pte_present() is true. 396 * The following only work if pte_present() is true.
389 * Undefined behaviour if not.. 397 * Undefined behaviour if not..
390 */ 398 */
391 #define pte_not_present(pte) (!(pte_val(pte) & _PAGE_PRESENT)) 399 #define pte_not_present(pte) (!(pte_val(pte) & _PAGE_PRESENT))
392 #define pte_dirty(pte) (pte_val(pte) & _PAGE_DIRTY) 400 #define pte_dirty(pte) (pte_val(pte) & _PAGE_DIRTY)
393 #define pte_young(pte) (pte_val(pte) & _PAGE_ACCESSED) 401 #define pte_young(pte) (pte_val(pte) & _PAGE_ACCESSED)
394 #define pte_file(pte) (pte_val(pte) & _PAGE_FILE) 402 #define pte_file(pte) (pte_val(pte) & _PAGE_FILE)
395 403
396 #ifdef CONFIG_X2TLB 404 #ifdef CONFIG_X2TLB
397 #define pte_read(pte) ((pte).pte_high & _PAGE_EXT_USER_READ) 405 #define pte_read(pte) ((pte).pte_high & _PAGE_EXT_USER_READ)
398 #define pte_exec(pte) ((pte).pte_high & _PAGE_EXT_USER_EXEC) 406 #define pte_exec(pte) ((pte).pte_high & _PAGE_EXT_USER_EXEC)
399 #define pte_write(pte) ((pte).pte_high & _PAGE_EXT_USER_WRITE) 407 #define pte_write(pte) ((pte).pte_high & _PAGE_EXT_USER_WRITE)
400 #else 408 #else
401 #define pte_read(pte) (pte_val(pte) & _PAGE_USER) 409 #define pte_read(pte) (pte_val(pte) & _PAGE_USER)
402 #define pte_exec(pte) (pte_val(pte) & _PAGE_USER) 410 #define pte_exec(pte) (pte_val(pte) & _PAGE_USER)
403 #define pte_write(pte) (pte_val(pte) & _PAGE_RW) 411 #define pte_write(pte) (pte_val(pte) & _PAGE_RW)
404 #endif 412 #endif
405 413
406 #define PTE_BIT_FUNC(h,fn,op) \ 414 #define PTE_BIT_FUNC(h,fn,op) \
407 static inline pte_t pte_##fn(pte_t pte) { pte.pte_##h op; return pte; } 415 static inline pte_t pte_##fn(pte_t pte) { pte.pte_##h op; return pte; }
408 416
409 #ifdef CONFIG_X2TLB 417 #ifdef CONFIG_X2TLB
410 /* 418 /*
411 * We cheat a bit in the SH-X2 TLB case. As the permission bits are 419 * We cheat a bit in the SH-X2 TLB case. As the permission bits are
412 * individually toggled (and user permissions are entirely decoupled from 420 * individually toggled (and user permissions are entirely decoupled from
413 * kernel permissions), we attempt to couple them a bit more sanely here. 421 * kernel permissions), we attempt to couple them a bit more sanely here.
414 */ 422 */
415 PTE_BIT_FUNC(high, rdprotect, &= ~_PAGE_EXT_USER_READ); 423 PTE_BIT_FUNC(high, rdprotect, &= ~_PAGE_EXT_USER_READ);
416 PTE_BIT_FUNC(high, mkread, |= _PAGE_EXT_USER_READ | _PAGE_EXT_KERN_READ); 424 PTE_BIT_FUNC(high, mkread, |= _PAGE_EXT_USER_READ | _PAGE_EXT_KERN_READ);
417 PTE_BIT_FUNC(high, wrprotect, &= ~_PAGE_EXT_USER_WRITE); 425 PTE_BIT_FUNC(high, wrprotect, &= ~_PAGE_EXT_USER_WRITE);
418 PTE_BIT_FUNC(high, mkwrite, |= _PAGE_EXT_USER_WRITE | _PAGE_EXT_KERN_WRITE); 426 PTE_BIT_FUNC(high, mkwrite, |= _PAGE_EXT_USER_WRITE | _PAGE_EXT_KERN_WRITE);
419 PTE_BIT_FUNC(high, exprotect, &= ~_PAGE_EXT_USER_EXEC); 427 PTE_BIT_FUNC(high, exprotect, &= ~_PAGE_EXT_USER_EXEC);
420 PTE_BIT_FUNC(high, mkexec, |= _PAGE_EXT_USER_EXEC | _PAGE_EXT_KERN_EXEC); 428 PTE_BIT_FUNC(high, mkexec, |= _PAGE_EXT_USER_EXEC | _PAGE_EXT_KERN_EXEC);
421 PTE_BIT_FUNC(high, mkhuge, |= _PAGE_SZHUGE); 429 PTE_BIT_FUNC(high, mkhuge, |= _PAGE_SZHUGE);
422 #else 430 #else
423 PTE_BIT_FUNC(low, rdprotect, &= ~_PAGE_USER); 431 PTE_BIT_FUNC(low, rdprotect, &= ~_PAGE_USER);
424 PTE_BIT_FUNC(low, mkread, |= _PAGE_USER); 432 PTE_BIT_FUNC(low, mkread, |= _PAGE_USER);
425 PTE_BIT_FUNC(low, wrprotect, &= ~_PAGE_RW); 433 PTE_BIT_FUNC(low, wrprotect, &= ~_PAGE_RW);
426 PTE_BIT_FUNC(low, mkwrite, |= _PAGE_RW); 434 PTE_BIT_FUNC(low, mkwrite, |= _PAGE_RW);
427 PTE_BIT_FUNC(low, exprotect, &= ~_PAGE_USER); 435 PTE_BIT_FUNC(low, exprotect, &= ~_PAGE_USER);
428 PTE_BIT_FUNC(low, mkexec, |= _PAGE_USER); 436 PTE_BIT_FUNC(low, mkexec, |= _PAGE_USER);
429 PTE_BIT_FUNC(low, mkhuge, |= _PAGE_SZHUGE); 437 PTE_BIT_FUNC(low, mkhuge, |= _PAGE_SZHUGE);
430 #endif 438 #endif
431 439
432 PTE_BIT_FUNC(low, mkclean, &= ~_PAGE_DIRTY); 440 PTE_BIT_FUNC(low, mkclean, &= ~_PAGE_DIRTY);
433 PTE_BIT_FUNC(low, mkdirty, |= _PAGE_DIRTY); 441 PTE_BIT_FUNC(low, mkdirty, |= _PAGE_DIRTY);
434 PTE_BIT_FUNC(low, mkold, &= ~_PAGE_ACCESSED); 442 PTE_BIT_FUNC(low, mkold, &= ~_PAGE_ACCESSED);
435 PTE_BIT_FUNC(low, mkyoung, |= _PAGE_ACCESSED); 443 PTE_BIT_FUNC(low, mkyoung, |= _PAGE_ACCESSED);
436 444
437 /* 445 /*
438 * Macro and implementation to make a page protection as uncachable. 446 * Macro and implementation to make a page protection as uncachable.
439 */ 447 */
440 #define pgprot_noncached pgprot_noncached 448 #define pgprot_noncached pgprot_noncached
441 449
442 static inline pgprot_t pgprot_noncached(pgprot_t _prot) 450 static inline pgprot_t pgprot_noncached(pgprot_t _prot)
443 { 451 {
444 unsigned long prot = pgprot_val(_prot); 452 unsigned long prot = pgprot_val(_prot);
445 453
446 prot &= ~_PAGE_CACHABLE; 454 prot &= ~_PAGE_CACHABLE;
447 return __pgprot(prot); 455 return __pgprot(prot);
448 } 456 }
449 457
450 #define pgprot_writecombine(prot) __pgprot(pgprot_val(prot) & ~_PAGE_CACHABLE) 458 #define pgprot_writecombine(prot) __pgprot(pgprot_val(prot) & ~_PAGE_CACHABLE)
451 459
452 /* 460 /*
453 * Conversion functions: convert a page and protection to a page entry, 461 * Conversion functions: convert a page and protection to a page entry,
454 * and a page entry and page directory to the page they refer to. 462 * and a page entry and page directory to the page they refer to.
455 * 463 *
456 * extern pte_t mk_pte(struct page *page, pgprot_t pgprot) 464 * extern pte_t mk_pte(struct page *page, pgprot_t pgprot)
457 */ 465 */
458 #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot)) 466 #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot))
459 467
460 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) 468 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
461 { 469 {
462 set_pte(&pte, __pte((pte_val(pte) & _PAGE_CHG_MASK) | 470 set_pte(&pte, __pte((pte_val(pte) & _PAGE_CHG_MASK) |
463 pgprot_val(newprot))); 471 pgprot_val(newprot)));
464 return pte; 472 return pte;
465 } 473 }
466 474
467 #define pmd_page_vaddr(pmd) pmd_val(pmd) 475 #define pmd_page_vaddr(pmd) pmd_val(pmd)
468 #define pmd_page(pmd) (virt_to_page(pmd_val(pmd))) 476 #define pmd_page(pmd) (virt_to_page(pmd_val(pmd)))
469 477
470 /* to find an entry in a page-table-directory. */ 478 /* to find an entry in a page-table-directory. */
471 #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1)) 479 #define pgd_index(address) (((address) >> PGDIR_SHIFT) & (PTRS_PER_PGD-1))
472 #define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address)) 480 #define pgd_offset(mm, address) ((mm)->pgd+pgd_index(address))
473 481
474 /* to find an entry in a kernel page-table-directory */ 482 /* to find an entry in a kernel page-table-directory */
475 #define pgd_offset_k(address) pgd_offset(&init_mm, address) 483 #define pgd_offset_k(address) pgd_offset(&init_mm, address)
476 484
477 /* Find an entry in the third-level page table.. */ 485 /* Find an entry in the third-level page table.. */
478 #define pte_index(address) \ 486 #define pte_index(address) \
479 ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)) 487 ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
480 #define pte_offset_kernel(dir, address) \ 488 #define pte_offset_kernel(dir, address) \
481 ((pte_t *) pmd_page_vaddr(*(dir)) + pte_index(address)) 489 ((pte_t *) pmd_page_vaddr(*(dir)) + pte_index(address))
482 #define pte_offset_map(dir, address) pte_offset_kernel(dir, address) 490 #define pte_offset_map(dir, address) pte_offset_kernel(dir, address)
483 #define pte_offset_map_nested(dir, address) pte_offset_kernel(dir, address) 491 #define pte_offset_map_nested(dir, address) pte_offset_kernel(dir, address)
484 #define pte_unmap(pte) do { } while (0) 492 #define pte_unmap(pte) do { } while (0)
485 #define pte_unmap_nested(pte) do { } while (0) 493 #define pte_unmap_nested(pte) do { } while (0)
486 494
487 #ifdef CONFIG_X2TLB 495 #ifdef CONFIG_X2TLB
488 #define pte_ERROR(e) \ 496 #define pte_ERROR(e) \
489 printk("%s:%d: bad pte %p(%08lx%08lx).\n", __FILE__, __LINE__, \ 497 printk("%s:%d: bad pte %p(%08lx%08lx).\n", __FILE__, __LINE__, \
490 &(e), (e).pte_high, (e).pte_low) 498 &(e), (e).pte_high, (e).pte_low)
491 #else 499 #else
492 #define pte_ERROR(e) \ 500 #define pte_ERROR(e) \
493 printk("%s:%d: bad pte %08lx.\n", __FILE__, __LINE__, pte_val(e)) 501 printk("%s:%d: bad pte %08lx.\n", __FILE__, __LINE__, pte_val(e))
494 #endif 502 #endif
495 503
496 #define pgd_ERROR(e) \ 504 #define pgd_ERROR(e) \
497 printk("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e)) 505 printk("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
498 506
499 struct vm_area_struct; 507 struct vm_area_struct;
500 extern void update_mmu_cache(struct vm_area_struct * vma, 508 extern void update_mmu_cache(struct vm_area_struct * vma,
501 unsigned long address, pte_t pte); 509 unsigned long address, pte_t pte);
502 510
503 /* Encode and de-code a swap entry */ 511 /* Encode and de-code a swap entry */
504 /* 512 /*
505 * NOTE: We should set ZEROs at the position of _PAGE_PRESENT 513 * NOTE: We should set ZEROs at the position of _PAGE_PRESENT
506 * and _PAGE_PROTNONE bits 514 * and _PAGE_PROTNONE bits
507 */ 515 */
508 #define __swp_type(x) ((x).val & 0xff) 516 #define __swp_type(x) ((x).val & 0xff)
509 #define __swp_offset(x) ((x).val >> 10) 517 #define __swp_offset(x) ((x).val >> 10)
510 #define __swp_entry(type, offset) ((swp_entry_t) { (type) | ((offset) << 10) }) 518 #define __swp_entry(type, offset) ((swp_entry_t) { (type) | ((offset) << 10) })
511 #define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) >> 1 }) 519 #define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) >> 1 })
512 #define __swp_entry_to_pte(x) ((pte_t) { (x).val << 1 }) 520 #define __swp_entry_to_pte(x) ((pte_t) { (x).val << 1 })
513 521
514 /* 522 /*
515 * Encode and decode a nonlinear file mapping entry 523 * Encode and decode a nonlinear file mapping entry
516 */ 524 */
517 #define PTE_FILE_MAX_BITS 29 525 #define PTE_FILE_MAX_BITS 29
518 #define pte_to_pgoff(pte) (pte_val(pte) >> 1) 526 #define pte_to_pgoff(pte) (pte_val(pte) >> 1)
519 #define pgoff_to_pte(off) ((pte_t) { ((off) << 1) | _PAGE_FILE }) 527 #define pgoff_to_pte(off) ((pte_t) { ((off) << 1) | _PAGE_FILE })
520 528
521 typedef pte_t *pte_addr_t; 529 typedef pte_t *pte_addr_t;
522 530
523 #define kern_addr_valid(addr) (1) 531 #define kern_addr_valid(addr) (1)
524 532
525 #define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \ 533 #define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \
526 remap_pfn_range(vma, vaddr, pfn, size, prot) 534 remap_pfn_range(vma, vaddr, pfn, size, prot)
527 535
528 #define MK_IOSPACE_PFN(space, pfn) (pfn) 536 #define MK_IOSPACE_PFN(space, pfn) (pfn)
529 #define GET_IOSPACE(pfn) 0 537 #define GET_IOSPACE(pfn) 0
530 #define GET_PFN(pfn) (pfn) 538 #define GET_PFN(pfn) (pfn)
531 539
532 struct mm_struct; 540 struct mm_struct;
533 541
534 /* 542 /*
535 * No page table caches to initialise 543 * No page table caches to initialise
536 */ 544 */
537 #define pgtable_cache_init() do { } while (0) 545 #define pgtable_cache_init() do { } while (0)
538 546
539 #ifndef CONFIG_MMU 547 #ifndef CONFIG_MMU
540 extern unsigned int kobjsize(const void *objp); 548 extern unsigned int kobjsize(const void *objp);
541 #endif /* !CONFIG_MMU */ 549 #endif /* !CONFIG_MMU */
542 550
543 #if defined(CONFIG_CPU_SH4) || defined(CONFIG_SH7705_CACHE_32KB) 551 #if defined(CONFIG_CPU_SH4) || defined(CONFIG_SH7705_CACHE_32KB)
544 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR 552 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
545 extern pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep); 553 extern pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
546 #endif 554 #endif
547 555
548 extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; 556 extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
549 extern void paging_init(void); 557 extern void paging_init(void);
550 558
551 #include <asm-generic/pgtable.h> 559 #include <asm-generic/pgtable.h>
552 560
553 #endif /* !__ASSEMBLY__ */ 561 #endif /* !__ASSEMBLY__ */
554 #endif /* __ASM_SH_PAGE_H */ 562 #endif /* __ASM_SH_PAGE_H */
555 563