1 /* 2 * This file contains the routines setting up the linux page tables. 3 * -- paulus 4 * 5 * Derived from arch/ppc/mm/init.c: 6 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 7 * 8 * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au) 9 * and Cort Dougan (PReP) (cort@cs.nmt.edu) 10 * Copyright (C) 1996 Paul Mackerras 11 * 12 * Derived from "arch/i386/mm/init.c" 13 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 * 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/types.h> 25 #include <linux/mm.h> 26 #include <linux/vmalloc.h> 27 #include <linux/init.h> 28 #include <linux/highmem.h> 29 30 #include <asm/pgtable.h> 31 #include <asm/pgalloc.h> 32 #include <asm/fixmap.h> 33 #include <asm/io.h> 34 35 #include "mmu_decl.h" 36 37 unsigned long ioremap_base; 38 unsigned long ioremap_bot; 39 EXPORT_SYMBOL(ioremap_bot); /* aka VMALLOC_END */ 40 41 #if defined(CONFIG_6xx) || defined(CONFIG_POWER3) 42 #define HAVE_BATS 1 43 #endif 44 45 #if defined(CONFIG_FSL_BOOKE) 46 #define HAVE_TLBCAM 1 47 #endif 48 49 extern char etext[], _stext[]; 50 51 #ifdef CONFIG_SMP 52 extern void hash_page_sync(void); 53 #endif 54 55 #ifdef HAVE_BATS 56 extern phys_addr_t v_mapped_by_bats(unsigned long va); 57 extern unsigned long p_mapped_by_bats(phys_addr_t pa); 58 void setbat(int index, unsigned long virt, phys_addr_t phys, 59 unsigned int size, int flags); 60 61 #else /* !HAVE_BATS */ 62 #define v_mapped_by_bats(x) (0UL) 63 #define p_mapped_by_bats(x) (0UL) 64 #endif /* HAVE_BATS */ 65 66 #ifdef HAVE_TLBCAM 67 extern unsigned int tlbcam_index; 68 extern unsigned long v_mapped_by_tlbcam(unsigned long va); 69 extern unsigned long p_mapped_by_tlbcam(unsigned long pa); 70 #else /* !HAVE_TLBCAM */ 71 #define v_mapped_by_tlbcam(x) (0UL) 72 #define p_mapped_by_tlbcam(x) (0UL) 73 #endif /* HAVE_TLBCAM */ 74 75 #ifdef CONFIG_PTE_64BIT 76 /* 44x uses an 8kB pgdir because it has 8-byte Linux PTEs. */ 77 #define PGDIR_ORDER 1 78 #else 79 #define PGDIR_ORDER 0 80 #endif 81 82 pgd_t *pgd_alloc(struct mm_struct *mm) 83 { 84 pgd_t *ret; 85 86 ret = (pgd_t *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, PGDIR_ORDER); 87 return ret; 88 } 89 90 void pgd_free(struct mm_struct *mm, pgd_t *pgd) 91 { 92 free_pages((unsigned long)pgd, PGDIR_ORDER); 93 } 94 95 __init_refok pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) 96 { 97 pte_t *pte; 98 extern int mem_init_done; 99 extern void *early_get_page(void); 100 101 if (mem_init_done) { 102 pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO); 103 } else { 104 pte = (pte_t *)early_get_page(); 105 if (pte) 106 clear_page(pte); 107 } 108 return pte; 109 } 110 111 pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address) 112 { 113 struct page *ptepage; 114 115 #ifdef CONFIG_HIGHPTE 116 gfp_t flags = GFP_KERNEL | __GFP_HIGHMEM | __GFP_REPEAT | __GFP_ZERO; 117 #else 118 gfp_t flags = GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO; 119 #endif 120 121 ptepage = alloc_pages(flags, 0); 122 if (!ptepage) 123 return NULL; 124 pgtable_page_ctor(ptepage); 125 return ptepage; 126 } 127 128 void pte_free_kernel(struct mm_struct *mm, pte_t *pte) 129 { 130 #ifdef CONFIG_SMP 131 hash_page_sync(); 132 #endif 133 free_page((unsigned long)pte); 134 } 135 136 void pte_free(struct mm_struct *mm, pgtable_t ptepage) 137 { 138 #ifdef CONFIG_SMP 139 hash_page_sync(); 140 #endif 141 pgtable_page_dtor(ptepage); 142 __free_page(ptepage); 143 } 144 145 void __iomem * 146 ioremap(phys_addr_t addr, unsigned long size) 147 { 148 return __ioremap(addr, size, _PAGE_NO_CACHE | _PAGE_GUARDED); 149 } 150 EXPORT_SYMBOL(ioremap); 151 152 void __iomem * 153 ioremap_flags(phys_addr_t addr, unsigned long size, unsigned long flags) 154 { 155 /* writeable implies dirty for kernel addresses */ 156 if (flags & _PAGE_RW) 157 flags |= _PAGE_DIRTY | _PAGE_HWWRITE; 158 159 /* we don't want to let _PAGE_USER and _PAGE_EXEC leak out */ 160 flags &= ~(_PAGE_USER | _PAGE_EXEC | _PAGE_HWEXEC); 161 162 return __ioremap(addr, size, flags); 163 } 164 EXPORT_SYMBOL(ioremap_flags); 165 166 void __iomem * 167 __ioremap(phys_addr_t addr, unsigned long size, unsigned long flags) 168 { 169 unsigned long v, i; 170 phys_addr_t p; 171 int err; 172 173 /* Make sure we have the base flags */ 174 if ((flags & _PAGE_PRESENT) == 0) 175 flags |= _PAGE_KERNEL; 176 177 /* Non-cacheable page cannot be coherent */ 178 if (flags & _PAGE_NO_CACHE) 179 flags &= ~_PAGE_COHERENT; 180 181 /* 182 * Choose an address to map it to. 183 * Once the vmalloc system is running, we use it. 184 * Before then, we use space going down from ioremap_base 185 * (ioremap_bot records where we're up to). 186 */ 187 p = addr & PAGE_MASK; 188 size = PAGE_ALIGN(addr + size) - p; 189 190 /* 191 * If the address lies within the first 16 MB, assume it's in ISA 192 * memory space 193 */ 194 if (p < 16*1024*1024) 195 p += _ISA_MEM_BASE; 196 197 /* 198 * Don't allow anybody to remap normal RAM that we're using. 199 * mem_init() sets high_memory so only do the check after that. 200 */ 201 if (mem_init_done && (p < virt_to_phys(high_memory))) { 202 printk("__ioremap(): phys addr 0x%llx is RAM lr %p\n", 203 (unsigned long long)p, __builtin_return_address(0)); 204 return NULL; 205 } 206 207 if (size == 0) 208 return NULL; 209 210 /* 211 * Is it already mapped? Perhaps overlapped by a previous 212 * BAT mapping. If the whole area is mapped then we're done, 213 * otherwise remap it since we want to keep the virt addrs for 214 * each request contiguous. 215 * 216 * We make the assumption here that if the bottom and top 217 * of the range we want are mapped then it's mapped to the 218 * same virt address (and this is contiguous). 219 * -- Cort 220 */ 221 if ((v = p_mapped_by_bats(p)) /*&& p_mapped_by_bats(p+size-1)*/ ) 222 goto out; 223 224 if ((v = p_mapped_by_tlbcam(p))) 225 goto out; 226 227 if (mem_init_done) { 228 struct vm_struct *area; 229 area = get_vm_area(size, VM_IOREMAP); 230 if (area == 0) 231 return NULL; 232 v = (unsigned long) area->addr; 233 } else { 234 v = (ioremap_bot -= size); 235 } 236 237 /* 238 * Should check if it is a candidate for a BAT mapping 239 */ 240 241 err = 0; 242 for (i = 0; i < size && err == 0; i += PAGE_SIZE) 243 err = map_page(v+i, p+i, flags); 244 if (err) { 245 if (mem_init_done) 246 vunmap((void *)v); 247 return NULL; 248 } 249 250 out: 251 return (void __iomem *) (v + ((unsigned long)addr & ~PAGE_MASK)); 252 } 253 EXPORT_SYMBOL(__ioremap); 254 255 void iounmap(volatile void __iomem *addr) 256 { 257 /* 258 * If mapped by BATs then there is nothing to do. 259 * Calling vfree() generates a benign warning. 260 */ 261 if (v_mapped_by_bats((unsigned long)addr)) return; 262 263 if (addr > high_memory && (unsigned long) addr < ioremap_bot) 264 vunmap((void *) (PAGE_MASK & (unsigned long)addr)); 265 } 266 EXPORT_SYMBOL(iounmap); 267 268 int map_page(unsigned long va, phys_addr_t pa, int flags) 269 { 270 pmd_t *pd; 271 pte_t *pg; 272 int err = -ENOMEM; 273 274 /* Use upper 10 bits of VA to index the first level map */ 275 pd = pmd_offset(pud_offset(pgd_offset_k(va), va), va); 276 /* Use middle 10 bits of VA to index the second-level map */ 277 pg = pte_alloc_kernel(pd, va); 278 if (pg != 0) { 279 err = 0; 280 /* The PTE should never be already set nor present in the 281 * hash table 282 */ 283 BUG_ON(pte_val(*pg) & (_PAGE_PRESENT | _PAGE_HASHPTE)); 284 set_pte_at(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT, 285 __pgprot(flags))); 286 } 287 return err; 288 } 289 290 /* 291 * Map in all of physical memory starting at KERNELBASE. 292 */ 293 void __init mapin_ram(void) 294 { 295 unsigned long v, s, f; 296 phys_addr_t p; 297 int ktext; 298 299 s = mmu_mapin_ram(); 300 v = KERNELBASE + s; 301 p = memstart_addr + s; 302 for (; s < total_lowmem; s += PAGE_SIZE) { 303 ktext = ((char *) v >= _stext && (char *) v < etext); 304 f = ktext ?_PAGE_RAM_TEXT : _PAGE_RAM; 305 map_page(v, p, f); 306 #ifdef CONFIG_PPC_STD_MMU_32 307 if (ktext) 308 hash_preload(&init_mm, v, 0, 0x300); 309 #endif 310 v += PAGE_SIZE; 311 p += PAGE_SIZE; 312 } 313 } 314 315 /* Scan the real Linux page tables and return a PTE pointer for 316 * a virtual address in a context. 317 * Returns true (1) if PTE was found, zero otherwise. The pointer to 318 * the PTE pointer is unmodified if PTE is not found. 319 */ 320 int 321 get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep, pmd_t **pmdp) 322 { 323 pgd_t *pgd; 324 pud_t *pud; 325 pmd_t *pmd; 326 pte_t *pte; 327 int retval = 0; 328 329 pgd = pgd_offset(mm, addr & PAGE_MASK); 330 if (pgd) { 331 pud = pud_offset(pgd, addr & PAGE_MASK); 332 if (pud && pud_present(*pud)) { 333 pmd = pmd_offset(pud, addr & PAGE_MASK); 334 if (pmd_present(*pmd)) { 335 pte = pte_offset_map(pmd, addr & PAGE_MASK); 336 if (pte) { 337 retval = 1; 338 *ptep = pte; 339 if (pmdp) 340 *pmdp = pmd; 341 /* XXX caller needs to do pte_unmap, yuck */ 342 } 343 } 344 } 345 } 346 return(retval); 347 } 348 349 #ifdef CONFIG_DEBUG_PAGEALLOC 350 351 static int __change_page_attr(struct page *page, pgprot_t prot) 352 { 353 pte_t *kpte; 354 pmd_t *kpmd; 355 unsigned long address; 356 357 BUG_ON(PageHighMem(page)); 358 address = (unsigned long)page_address(page); 359 360 if (v_mapped_by_bats(address) || v_mapped_by_tlbcam(address)) 361 return 0; 362 if (!get_pteptr(&init_mm, address, &kpte, &kpmd)) 363 return -EINVAL; 364 set_pte_at(&init_mm, address, kpte, mk_pte(page, prot)); 365 wmb(); 366 flush_HPTE(0, address, pmd_val(*kpmd)); 367 pte_unmap(kpte); 368 369 return 0; 370 } 371 372 /* 373 * Change the page attributes of an page in the linear mapping. 374 * 375 * THIS CONFLICTS WITH BAT MAPPINGS, DEBUG USE ONLY 376 */ 377 static int change_page_attr(struct page *page, int numpages, pgprot_t prot) 378 { 379 int i, err = 0; 380 unsigned long flags; 381 382 local_irq_save(flags); 383 for (i = 0; i < numpages; i++, page++) { 384 err = __change_page_attr(page, prot); 385 if (err) 386 break; 387 } 388 local_irq_restore(flags); 389 return err; 390 } 391 392 393 void kernel_map_pages(struct page *page, int numpages, int enable) 394 { 395 if (PageHighMem(page)) 396 return; 397 398 change_page_attr(page, numpages, enable ? PAGE_KERNEL : __pgprot(0)); 399 } 400 #endif /* CONFIG_DEBUG_PAGEALLOC */ 401 402 static int fixmaps; 403 unsigned long FIXADDR_TOP = 0xfffff000; 404 EXPORT_SYMBOL(FIXADDR_TOP); 405 406 void __set_fixmap (enum fixed_addresses idx, phys_addr_t phys, pgprot_t flags) 407 { 408 unsigned long address = __fix_to_virt(idx); 409 410 if (idx >= __end_of_fixed_addresses) { 411 BUG(); 412 return; 413 } 414 415 map_page(address, phys, pgprot_val(flags)); 416 fixmaps++; 417 } 418 419 void __this_fixmap_does_not_exist(void) 420 { 421 WARN_ON(1); 422 } 423