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 * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk). 12 * 13 * Derived from "arch/i386/mm/init.c" 14 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License 18 * as published by the Free Software Foundation; either version 19 * 2 of the License, or (at your option) any later version. 20 * 21 */ 22 23 #include <linux/config.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/types.h> 27 #include <linux/mm.h> 28 #include <linux/vmalloc.h> 29 #include <linux/init.h> 30 #include <linux/highmem.h> 31 32 #include <asm/pgtable.h> 33 #include <asm/pgalloc.h> 34 #include <asm/io.h> 35 36 #include "mmu_decl.h" 37 38 unsigned long ioremap_base; 39 unsigned long ioremap_bot; 40 EXPORT_SYMBOL(ioremap_bot); /* aka VMALLOC_END */ 41 int io_bat_index; 42 43 #if defined(CONFIG_6xx) || defined(CONFIG_POWER3) 44 #define HAVE_BATS 1 45 #endif 46 47 #if defined(CONFIG_FSL_BOOKE) 48 #define HAVE_TLBCAM 1 49 #endif 50 51 extern char etext[], _stext[]; 52 53 #ifdef CONFIG_SMP 54 extern void hash_page_sync(void); 55 #endif 56 57 #ifdef HAVE_BATS 58 extern unsigned long v_mapped_by_bats(unsigned long va); 59 extern unsigned long p_mapped_by_bats(unsigned long pa); 60 void setbat(int index, unsigned long virt, unsigned long phys, 61 unsigned int size, int flags); 62 63 #else /* !HAVE_BATS */ 64 #define v_mapped_by_bats(x) (0UL) 65 #define p_mapped_by_bats(x) (0UL) 66 #endif /* HAVE_BATS */ 67 68 #ifdef HAVE_TLBCAM 69 extern unsigned int tlbcam_index; 70 extern unsigned long v_mapped_by_tlbcam(unsigned long va); 71 extern unsigned long p_mapped_by_tlbcam(unsigned long pa); 72 #else /* !HAVE_TLBCAM */ 73 #define v_mapped_by_tlbcam(x) (0UL) 74 #define p_mapped_by_tlbcam(x) (0UL) 75 #endif /* HAVE_TLBCAM */ 76 77 #ifdef CONFIG_PTE_64BIT 78 /* 44x uses an 8kB pgdir because it has 8-byte Linux PTEs. */ 79 #define PGDIR_ORDER 1 80 #else 81 #define PGDIR_ORDER 0 82 #endif 83 84 pgd_t *pgd_alloc(struct mm_struct *mm) 85 { 86 pgd_t *ret; 87 88 ret = (pgd_t *)__get_free_pages(GFP_KERNEL|__GFP_ZERO, PGDIR_ORDER); 89 return ret; 90 } 91 92 void pgd_free(pgd_t *pgd) 93 { 94 free_pages((unsigned long)pgd, PGDIR_ORDER); 95 } 96 97 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) 98 { 99 pte_t *pte; 100 extern int mem_init_done; 101 extern void *early_get_page(void); 102 103 if (mem_init_done) { 104 pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO); 105 } else { 106 pte = (pte_t *)early_get_page(); 107 if (pte) 108 clear_page(pte); 109 } 110 return pte; 111 } 112 113 struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address) 114 { 115 struct page *ptepage; 116 117 #ifdef CONFIG_HIGHPTE 118 gfp_t flags = GFP_KERNEL | __GFP_HIGHMEM | __GFP_REPEAT; 119 #else 120 gfp_t flags = GFP_KERNEL | __GFP_REPEAT; 121 #endif 122 123 ptepage = alloc_pages(flags, 0); 124 if (ptepage) 125 clear_highpage(ptepage); 126 return ptepage; 127 } 128 129 void pte_free_kernel(pte_t *pte) 130 { 131 #ifdef CONFIG_SMP 132 hash_page_sync(); 133 #endif 134 free_page((unsigned long)pte); 135 } 136 137 void pte_free(struct page *ptepage) 138 { 139 #ifdef CONFIG_SMP 140 hash_page_sync(); 141 #endif 142 __free_page(ptepage); 143 } 144 145 #ifndef CONFIG_PHYS_64BIT 146 void __iomem * 147 ioremap(phys_addr_t addr, unsigned long size) 148 { 149 return __ioremap(addr, size, _PAGE_NO_CACHE); 150 } 151 #else /* CONFIG_PHYS_64BIT */ 152 void __iomem * 153 ioremap64(unsigned long long addr, unsigned long size) 154 { 155 return __ioremap(addr, size, _PAGE_NO_CACHE); 156 } 157 EXPORT_SYMBOL(ioremap64); 158 159 void __iomem * 160 ioremap(phys_addr_t addr, unsigned long size) 161 { 162 phys_addr_t addr64 = fixup_bigphys_addr(addr, size); 163 164 return ioremap64(addr64, size); 165 } 166 #endif /* CONFIG_PHYS_64BIT */ 167 EXPORT_SYMBOL(ioremap); 168 169 void __iomem * 170 __ioremap(phys_addr_t addr, unsigned long size, unsigned long flags) 171 { 172 unsigned long v, i; 173 phys_addr_t p; 174 int err; 175 176 /* 177 * Choose an address to map it to. 178 * Once the vmalloc system is running, we use it. 179 * Before then, we use space going down from ioremap_base 180 * (ioremap_bot records where we're up to). 181 */ 182 p = addr & PAGE_MASK; 183 size = PAGE_ALIGN(addr + size) - p; 184 185 /* 186 * If the address lies within the first 16 MB, assume it's in ISA 187 * memory space 188 */ 189 if (p < 16*1024*1024) 190 p += _ISA_MEM_BASE; 191 192 /* 193 * Don't allow anybody to remap normal RAM that we're using. 194 * mem_init() sets high_memory so only do the check after that. 195 */ 196 if (mem_init_done && (p < virt_to_phys(high_memory))) { 197 printk("__ioremap(): phys addr "PHYS_FMT" is RAM lr %p\n", p, 198 __builtin_return_address(0)); 199 return NULL; 200 } 201 202 if (size == 0) 203 return NULL; 204 205 /* 206 * Is it already mapped? Perhaps overlapped by a previous 207 * BAT mapping. If the whole area is mapped then we're done, 208 * otherwise remap it since we want to keep the virt addrs for 209 * each request contiguous. 210 * 211 * We make the assumption here that if the bottom and top 212 * of the range we want are mapped then it's mapped to the 213 * same virt address (and this is contiguous). 214 * -- Cort 215 */ 216 if ((v = p_mapped_by_bats(p)) /*&& p_mapped_by_bats(p+size-1)*/ ) 217 goto out; 218 219 if ((v = p_mapped_by_tlbcam(p))) 220 goto out; 221 222 if (mem_init_done) { 223 struct vm_struct *area; 224 area = get_vm_area(size, VM_IOREMAP); 225 if (area == 0) 226 return NULL; 227 v = (unsigned long) area->addr; 228 } else { 229 v = (ioremap_bot -= size); 230 } 231 232 if ((flags & _PAGE_PRESENT) == 0) 233 flags |= _PAGE_KERNEL; 234 if (flags & _PAGE_NO_CACHE) 235 flags |= _PAGE_GUARDED; 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 void __iomem *ioport_map(unsigned long port, unsigned int len) 269 { 270 return (void __iomem *) (port + _IO_BASE); 271 } 272 273 void ioport_unmap(void __iomem *addr) 274 { 275 /* Nothing to do */ 276 } 277 EXPORT_SYMBOL(ioport_map); 278 EXPORT_SYMBOL(ioport_unmap); 279 280 int 281 map_page(unsigned long va, phys_addr_t pa, int flags) 282 { 283 pmd_t *pd; 284 pte_t *pg; 285 int err = -ENOMEM; 286 287 /* Use upper 10 bits of VA to index the first level map */ 288 pd = pmd_offset(pgd_offset_k(va), va); 289 /* Use middle 10 bits of VA to index the second-level map */ 290 pg = pte_alloc_kernel(pd, va); 291 if (pg != 0) { 292 err = 0; 293 set_pte_at(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT, __pgprot(flags))); 294 if (mem_init_done) 295 flush_HPTE(0, va, pmd_val(*pd)); 296 } 297 return err; 298 } 299 300 /* 301 * Map in all of physical memory starting at KERNELBASE. 302 */ 303 void __init mapin_ram(void) 304 { 305 unsigned long v, p, s, f; 306 307 s = mmu_mapin_ram(); 308 v = KERNELBASE + s; 309 p = PPC_MEMSTART + s; 310 for (; s < total_lowmem; s += PAGE_SIZE) { 311 if ((char *) v >= _stext && (char *) v < etext) 312 f = _PAGE_RAM_TEXT; 313 else 314 f = _PAGE_RAM; 315 map_page(v, p, f); 316 v += PAGE_SIZE; 317 p += PAGE_SIZE; 318 } 319 } 320 321 /* is x a power of 2? */ 322 #define is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0)) 323 324 /* is x a power of 4? */ 325 #define is_power_of_4(x) ((x) != 0 && (((x) & (x-1)) == 0) && (ffs(x) & 1)) 326 327 /* 328 * Set up a mapping for a block of I/O. 329 * virt, phys, size must all be page-aligned. 330 * This should only be called before ioremap is called. 331 */ 332 void __init io_block_mapping(unsigned long virt, phys_addr_t phys, 333 unsigned int size, int flags) 334 { 335 int i; 336 337 if (virt > KERNELBASE && virt < ioremap_bot) 338 ioremap_bot = ioremap_base = virt; 339 340 #ifdef HAVE_BATS 341 /* 342 * Use a BAT for this if possible... 343 */ 344 if (io_bat_index < 2 && is_power_of_2(size) 345 && (virt & (size - 1)) == 0 && (phys & (size - 1)) == 0) { 346 setbat(io_bat_index, virt, phys, size, flags); 347 ++io_bat_index; 348 return; 349 } 350 #endif /* HAVE_BATS */ 351 352 #ifdef HAVE_TLBCAM 353 /* 354 * Use a CAM for this if possible... 355 */ 356 if (tlbcam_index < num_tlbcam_entries && is_power_of_4(size) 357 && (virt & (size - 1)) == 0 && (phys & (size - 1)) == 0) { 358 settlbcam(tlbcam_index, virt, phys, size, flags, 0); 359 ++tlbcam_index; 360 return; 361 } 362 #endif /* HAVE_TLBCAM */ 363 364 /* No BATs available, put it in the page tables. */ 365 for (i = 0; i < size; i += PAGE_SIZE) 366 map_page(virt + i, phys + i, flags); 367 } 368 369 /* Scan the real Linux page tables and return a PTE pointer for 370 * a virtual address in a context. 371 * Returns true (1) if PTE was found, zero otherwise. The pointer to 372 * the PTE pointer is unmodified if PTE is not found. 373 */ 374 int 375 get_pteptr(struct mm_struct *mm, unsigned long addr, pte_t **ptep, pmd_t **pmdp) 376 { 377 pgd_t *pgd; 378 pmd_t *pmd; 379 pte_t *pte; 380 int retval = 0; 381 382 pgd = pgd_offset(mm, addr & PAGE_MASK); 383 if (pgd) { 384 pmd = pmd_offset(pgd, addr & PAGE_MASK); 385 if (pmd_present(*pmd)) { 386 pte = pte_offset_map(pmd, addr & PAGE_MASK); 387 if (pte) { 388 retval = 1; 389 *ptep = pte; 390 if (pmdp) 391 *pmdp = pmd; 392 /* XXX caller needs to do pte_unmap, yuck */ 393 } 394 } 395 } 396 return(retval); 397 } 398 399 /* Find physical address for this virtual address. Normally used by 400 * I/O functions, but anyone can call it. 401 */ 402 unsigned long iopa(unsigned long addr) 403 { 404 unsigned long pa; 405 406 /* I don't know why this won't work on PMacs or CHRP. It 407 * appears there is some bug, or there is some implicit 408 * mapping done not properly represented by BATs or in page 409 * tables.......I am actively working on resolving this, but 410 * can't hold up other stuff. -- Dan 411 */ 412 pte_t *pte; 413 struct mm_struct *mm; 414 415 /* Check the BATs */ 416 pa = v_mapped_by_bats(addr); 417 if (pa) 418 return pa; 419 420 /* Allow mapping of user addresses (within the thread) 421 * for DMA if necessary. 422 */ 423 if (addr < TASK_SIZE) 424 mm = current->mm; 425 else 426 mm = &init_mm; 427 428 pa = 0; 429 if (get_pteptr(mm, addr, &pte, NULL)) { 430 pa = (pte_val(*pte) & PAGE_MASK) | (addr & ~PAGE_MASK); 431 pte_unmap(pte); 432 } 433 434 return(pa); 435 } 436 437 /* This is will find the virtual address for a physical one.... 438 * Swiped from APUS, could be dangerous :-). 439 * This is only a placeholder until I really find a way to make this 440 * work. -- Dan 441 */ 442 unsigned long 443 mm_ptov (unsigned long paddr) 444 { 445 unsigned long ret; 446 #if 0 447 if (paddr < 16*1024*1024) 448 ret = ZTWO_VADDR(paddr); 449 else { 450 int i; 451 452 for (i = 0; i < kmap_chunk_count;){ 453 unsigned long phys = kmap_chunks[i++]; 454 unsigned long size = kmap_chunks[i++]; 455 unsigned long virt = kmap_chunks[i++]; 456 if (paddr >= phys 457 && paddr < (phys + size)){ 458 ret = virt + paddr - phys; 459 goto exit; 460 } 461 } 462 463 ret = (unsigned long) __va(paddr); 464 } 465 exit: 466 #ifdef DEBUGPV 467 printk ("PTOV(%lx)=%lx\n", paddr, ret); 468 #endif 469 #else 470 ret = (unsigned long)paddr + KERNELBASE; 471 #endif 472 return ret; 473 } 474 475