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