v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / arch / ppc / mm / init.c
1 /*
2  * BK Id: SCCS/s.init.c 1.30 07/06/01 09:19:29 trini
3  */
4 /*
5  *  PowerPC version 
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/signal.h>
25 #include <linux/sched.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <linux/types.h>
30 #include <linux/ptrace.h>
31 #include <linux/mman.h>
32 #include <linux/mm.h>
33 #include <linux/swap.h>
34 #include <linux/stddef.h>
35 #include <linux/vmalloc.h>
36 #include <linux/init.h>
37 #include <linux/delay.h>
38 #include <linux/bootmem.h>
39 #include <linux/highmem.h>
40 #ifdef CONFIG_BLK_DEV_INITRD
41 #include <linux/blk.h>          /* for initrd_* */
42 #endif
43
44 #include <asm/pgalloc.h>
45 #include <asm/prom.h>
46 #include <asm/io.h>
47 #include <asm/mmu_context.h>
48 #include <asm/pgtable.h>
49 #include <asm/mmu.h>
50 #include <asm/uaccess.h>
51 #ifdef CONFIG_8xx
52 #include <asm/8xx_immap.h>
53 #include <asm/mpc8xx.h>
54 #endif
55 #ifdef CONFIG_8260
56 #include <asm/immap_8260.h>
57 #include <asm/mpc8260.h>
58 #endif
59 #include <asm/smp.h>
60 #include <asm/bootx.h>
61 #include <asm/machdep.h>
62 #include <asm/setup.h>
63 #include <asm/amigahw.h>
64 #include <asm/gemini.h>
65
66 #include "mem_pieces.h"
67
68 #if defined(CONFIG_4xx)
69 #include "4xx_tlb.h"
70 #endif
71
72 #define MAX_LOW_MEM     (512 << 20)
73
74 #define PGTOKB(pages)   (((pages) * PAGE_SIZE) >> 10)
75
76 mm_context_t next_mmu_context;
77 unsigned long context_map[(LAST_CONTEXT+1) / (8*sizeof(unsigned long))];
78 #ifdef FEW_CONTEXTS
79 atomic_t nr_free_contexts;
80 struct mm_struct *context_mm[LAST_CONTEXT+1];
81 void steal_context(void);
82 #endif /* FEW_CONTEXTS */
83
84 int prom_trashed;
85 unsigned long *end_of_DRAM;
86 unsigned long total_memory;
87 unsigned long total_lowmem;
88 unsigned long ram_phys_base;
89 int mem_init_done;
90 int init_bootmem_done;
91 int boot_mapsize;
92 unsigned long totalram_pages;
93 unsigned long totalhigh_pages;
94 extern pgd_t swapper_pg_dir[];
95 extern char _start[], _end[];
96 extern char etext[], _stext[];
97 extern char __init_begin, __init_end;
98 extern char __prep_begin, __prep_end;
99 extern char __chrp_begin, __chrp_end;
100 extern char __pmac_begin, __pmac_end;
101 extern char __openfirmware_begin, __openfirmware_end;
102 unsigned long ioremap_base;
103 unsigned long ioremap_bot;
104 unsigned long avail_start;
105 extern int num_memory;
106 extern struct mem_info memory[];
107 extern boot_infos_t *boot_infos;
108 extern unsigned int rtas_data, rtas_size;
109 #ifndef CONFIG_SMP
110 struct pgtable_cache_struct quicklists;
111 #endif
112 #ifdef CONFIG_HIGHMEM
113 pte_t *kmap_pte;
114 pgprot_t kmap_prot;
115 #endif
116
117 void MMU_init(void);
118 void *early_get_page(void);
119 static void mapin_ram(void);
120 int map_page(unsigned long va, unsigned long pa, int flags);
121 void set_phys_avail(unsigned long total_ram);
122 extern void die_if_kernel(char *,struct pt_regs *,long);
123
124 extern char _start[], _end[];
125 extern char _stext[], etext[];
126 extern struct task_struct *current_set[NR_CPUS];
127
128 char *klimit = _end;
129 struct mem_pieces phys_avail;
130
131 PTE *Hash, *Hash_end;
132 unsigned long Hash_size, Hash_mask;
133 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
134 unsigned long _SDR1;
135 static void hash_init(void);
136
137 union ubat {                    /* BAT register values to be loaded */
138         BAT     bat;
139 #ifdef CONFIG_PPC64BRIDGE
140         u64     word[2];
141 #else
142         u32     word[2];
143 #endif  
144 } BATS[4][2];                   /* 4 pairs of IBAT, DBAT */
145
146 struct batrange {               /* stores address ranges mapped by BATs */
147         unsigned long start;
148         unsigned long limit;
149         unsigned long phys;
150 } bat_addrs[4];
151
152 /*
153  * Return PA for this VA if it is mapped by a BAT, or 0
154  */
155 static inline unsigned long v_mapped_by_bats(unsigned long va)
156 {
157         int b;
158         for (b = 0; b < 4; ++b)
159                 if (va >= bat_addrs[b].start && va < bat_addrs[b].limit)
160                         return bat_addrs[b].phys + (va - bat_addrs[b].start);
161         return 0;
162 }
163
164 /*
165  * Return VA for a given PA or 0 if not mapped
166  */
167 static inline unsigned long p_mapped_by_bats(unsigned long pa)
168 {
169         int b;
170         for (b = 0; b < 4; ++b)
171                 if (pa >= bat_addrs[b].phys
172                     && pa < (bat_addrs[b].limit-bat_addrs[b].start)
173                               +bat_addrs[b].phys)
174                         return bat_addrs[b].start+(pa-bat_addrs[b].phys);
175         return 0;
176 }
177
178 #else /* CONFIG_4xx || CONFIG_8xx */
179 #define v_mapped_by_bats(x)     (0UL)
180 #define p_mapped_by_bats(x)     (0UL)
181 #endif /* !CONFIG_4xx && !CONFIG_8xx */
182
183 /*
184  * this tells the system to map all of ram with the segregs
185  * (i.e. page tables) instead of the bats.
186  * -- Cort
187  */
188 int __map_without_bats;
189
190 /* max amount of RAM to use */
191 unsigned long __max_memory;
192 /* max amount of low RAM to map in */
193 unsigned long __max_low_memory = MAX_LOW_MEM;
194
195 int do_check_pgt_cache(int low, int high)
196 {
197         int freed = 0;
198         if (pgtable_cache_size > high) {
199                 do {
200                         if (pgd_quicklist) {
201                                 free_pgd_slow(get_pgd_fast());
202                                 freed++;
203                         }
204                         if (pte_quicklist) {
205                                 pte_free_slow(pte_alloc_one_fast(NULL, 0));
206                                 freed++;
207                         }
208                 } while (pgtable_cache_size > low);
209         }
210         return freed;
211 }
212
213 void show_mem(void)
214 {
215         int i,free = 0,total = 0,reserved = 0;
216         int shared = 0, cached = 0;
217         struct task_struct *p;
218         int highmem = 0;
219
220         printk("Mem-info:\n");
221         show_free_areas();
222         printk("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
223         i = max_mapnr;
224         while (i-- > 0) {
225                 total++;
226                 if (PageHighMem(mem_map+i))
227                         highmem++;
228                 if (PageReserved(mem_map+i))
229                         reserved++;
230                 else if (PageSwapCache(mem_map+i))
231                         cached++;
232                 else if (!page_count(mem_map+i))
233                         free++;
234                 else
235                         shared += atomic_read(&mem_map[i].count) - 1;
236         }
237         printk("%d pages of RAM\n",total);
238         printk("%d pages of HIGHMEM\n", highmem);
239         printk("%d free pages\n",free);
240         printk("%d reserved pages\n",reserved);
241         printk("%d pages shared\n",shared);
242         printk("%d pages swap cached\n",cached);
243         printk("%d pages in page table cache\n",(int)pgtable_cache_size);
244         show_buffers();
245         printk("%-8s %3s %8s %8s %8s %9s %8s", "Process", "Pid",
246                "Ctx", "Ctx<<4", "Last Sys", "pc", "task");
247 #ifdef CONFIG_SMP
248         printk(" %3s", "CPU");
249 #endif /* CONFIG_SMP */
250         printk("\n");
251         for_each_task(p)
252         {
253                 printk("%-8.8s %3d %8ld %8ld %8ld %c%08lx %08lx ",
254                        p->comm,p->pid,
255                        (p->mm)?p->mm->context:0,
256                        (p->mm)?(p->mm->context<<4):0,
257                        p->thread.last_syscall,
258                        (p->thread.regs)?user_mode(p->thread.regs) ? 'u' : 'k' : '?',
259                        (p->thread.regs)?p->thread.regs->nip:0,
260                        (ulong)p);
261                 {
262                         int iscur = 0;
263 #ifdef CONFIG_SMP
264                         printk("%3d ", p->processor);
265                         if ( (p->processor != NO_PROC_ID) &&
266                              (p == current_set[p->processor]) )
267                         {
268                                 iscur = 1;
269                                 printk("current");
270                         }
271 #else
272                         if ( p == current )
273                         {
274                                 iscur = 1;
275                                 printk("current");
276                         }
277                         
278                         if ( p == last_task_used_math )
279                         {
280                                 if ( iscur )
281                                         printk(",");
282                                 printk("last math");
283                         }                       
284 #endif /* CONFIG_SMP */
285                         printk("\n");
286                 }
287         }
288 }
289
290 void si_meminfo(struct sysinfo *val)
291 {
292         val->totalram = totalram_pages;
293         val->sharedram = 0;
294         val->freeram = nr_free_pages();
295         val->bufferram = atomic_read(&buffermem_pages);
296         val->totalhigh = totalhigh_pages;
297         val->freehigh = nr_free_highpages();
298         val->mem_unit = PAGE_SIZE;
299 }
300
301 void *
302 ioremap(unsigned long addr, unsigned long size)
303 {
304         return __ioremap(addr, size, _PAGE_NO_CACHE);
305 }
306
307 void *
308 __ioremap(unsigned long addr, unsigned long size, unsigned long flags)
309 {
310         unsigned long p, v, i;
311         int err;
312
313         /*
314          * Choose an address to map it to.
315          * Once the vmalloc system is running, we use it.
316          * Before then, we map addresses >= ioremap_base
317          * virt == phys; for addresses below this we use
318          * space going down from ioremap_base (ioremap_bot
319          * records where we're up to).
320          */
321         p = addr & PAGE_MASK;
322         size = PAGE_ALIGN(addr + size) - p;
323
324         /*
325          * If the address lies within the first 16 MB, assume it's in ISA
326          * memory space
327          */
328         if ( p < 16*1024*1024 )
329                 p += _ISA_MEM_BASE;
330
331         /*
332          * Don't allow anybody to remap normal RAM that we're using.
333          * mem_init() sets high_memory so only do the check after that.
334          */
335         if ( mem_init_done && (p < virt_to_phys(high_memory)) )
336         {
337                 printk("__ioremap(): phys addr %0lx is RAM lr %p\n", p,
338                        __builtin_return_address(0));
339                 return NULL;
340         }
341
342         if (size == 0)
343                 return NULL;
344
345         /*
346          * Is it already mapped?  Perhaps overlapped by a previous
347          * BAT mapping.  If the whole area is mapped then we're done,
348          * otherwise remap it since we want to keep the virt addrs for
349          * each request contiguous.
350          *
351          * We make the assumption here that if the bottom and top
352          * of the range we want are mapped then it's mapped to the
353          * same virt address (and this is contiguous).
354          *  -- Cort
355          */
356         if ((v = p_mapped_by_bats(p)) /*&& p_mapped_by_bats(p+size-1)*/ )
357                 goto out;
358         
359         if (mem_init_done) {
360                 struct vm_struct *area;
361                 area = get_vm_area(size, VM_IOREMAP);
362                 if (area == 0)
363                         return NULL;
364                 v = VMALLOC_VMADDR(area->addr);
365         } else {
366 #ifndef CONFIG_HIGHMEM
367                 if (p >= ioremap_base)
368 #else
369                 if (p >= ioremap_base && p < PKMAP_BASE)
370 #endif /* CONFIG_HIGHMEM */
371                         v = p;
372                 else
373                         v = (ioremap_bot -= size);
374         }
375
376         if ((flags & _PAGE_PRESENT) == 0)
377                 flags |= pgprot_val(PAGE_KERNEL);
378         if (flags & (_PAGE_NO_CACHE | _PAGE_WRITETHRU))
379                 flags |= _PAGE_GUARDED;
380
381         /*
382          * Should check if it is a candidate for a BAT mapping
383          */
384
385         err = 0;
386         for (i = 0; i < size && err == 0; i += PAGE_SIZE)
387                 err = map_page(v+i, p+i, flags);
388         if (err) {
389                 if (mem_init_done)
390                         vfree((void *)v);
391                 return NULL;
392         }
393
394 out:
395         return (void *) (v + (addr & ~PAGE_MASK));
396 }
397
398 void iounmap(void *addr)
399 {
400         if (addr > high_memory && (unsigned long) addr < ioremap_bot)
401                 vfree((void *) (PAGE_MASK & (unsigned long) addr));
402 }
403
404 unsigned long iopa(unsigned long addr)
405 {
406         unsigned long pa;
407         pmd_t *pd;
408         pte_t *pg;
409
410         /* Check the BATs */
411         pa = v_mapped_by_bats(addr);
412         if (pa)
413                 return pa;
414
415         /* Do we have a page table? */
416         if (init_mm.pgd == NULL)
417                 return 0;
418
419         /* Use upper 10 bits of addr to index the first level map */
420         pd = (pmd_t *) (init_mm.pgd + (addr >> PGDIR_SHIFT));
421         if (pmd_none(*pd))
422                 return 0;
423
424         /* Use middle 10 bits of addr to index the second-level map */
425         pg = pte_offset(pd, addr);
426         return (pte_val(*pg) & PAGE_MASK) | (addr & ~PAGE_MASK);
427 }
428
429 int
430 map_page(unsigned long va, unsigned long pa, int flags)
431 {
432         pmd_t *pd;
433         pte_t *pg;
434         int err = -ENOMEM;
435
436         spin_lock(&init_mm.page_table_lock);
437         /* Use upper 10 bits of VA to index the first level map */
438         pd = pmd_offset(pgd_offset_k(va), va);
439         /* Use middle 10 bits of VA to index the second-level map */
440         pg = pte_alloc(&init_mm, pd, va);
441         if (pg != 0) {
442                 err = 0;
443                 set_pte(pg, mk_pte_phys(pa & PAGE_MASK, __pgprot(flags)));
444 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
445                 if (mem_init_done && Hash != 0)
446                         flush_hash_page(0, va, pg);
447 #endif /* !4xx && !8xx */
448         }
449         spin_unlock(&init_mm.page_table_lock);
450         return err;
451 }
452
453 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
454 /*
455  * TLB flushing:
456  *
457  *  - flush_tlb_all() flushes all processes TLBs
458  *  - flush_tlb_mm(mm) flushes the specified mm context TLB's
459  *  - flush_tlb_page(vma, vmaddr) flushes one page
460  *  - flush_tlb_range(mm, start, end) flushes a range of pages
461  *
462  * since the hardware hash table functions as an extension of the
463  * tlb as far as the linux tables are concerned, flush it too.
464  *    -- Cort
465  */
466
467 /*
468  * Flush all tlb/hash table entries (except perhaps for those
469  * mapping RAM starting at PAGE_OFFSET, since they never change).
470  */
471 void
472 local_flush_tlb_all(void)
473 {
474         /* aargh!!! */
475         /* just flush the kernel part of the address space, that's
476            all that the current callers of this require.  -- paulus. */
477         local_flush_tlb_range(&init_mm, TASK_SIZE, ~0UL);
478
479 #ifdef CONFIG_SMP
480         smp_send_tlb_invalidate(0);
481 #endif /* CONFIG_SMP */
482 }
483
484 /*
485  * Flush all the (user) entries for the address space described
486  * by mm.  We can't rely on mm->mmap describing all the entries
487  * that might be in the hash table.
488  */
489 void
490 local_flush_tlb_mm(struct mm_struct *mm)
491 {
492         if (Hash == 0) {
493                 _tlbia();
494                 return;
495         }
496
497         if (mm->map_count) {
498                 struct vm_area_struct *mp;
499                 for (mp = mm->mmap; mp != NULL; mp = mp->vm_next)
500                         local_flush_tlb_range(mm, mp->vm_start, mp->vm_end);
501         } else
502                 local_flush_tlb_range(mm, 0, TASK_SIZE);
503
504 #ifdef CONFIG_SMP
505         smp_send_tlb_invalidate(0);
506 #endif  
507 }
508
509 void
510 local_flush_tlb_page(struct vm_area_struct *vma, unsigned long vmaddr)
511 {
512         struct mm_struct *mm;
513         pmd_t *pmd;
514         pte_t *pte;
515
516         if (Hash == 0) {
517                 _tlbie(vmaddr);
518                 return;
519         }
520         mm = (vmaddr < TASK_SIZE)? vma->vm_mm: &init_mm;
521         pmd = pmd_offset(pgd_offset(mm, vmaddr), vmaddr);
522         if (!pmd_none(*pmd)) {
523                 pte = pte_offset(pmd, vmaddr);
524                 if (pte_val(*pte) & _PAGE_HASHPTE)
525                         flush_hash_page(mm->context, vmaddr, pte);
526         }
527 #ifdef CONFIG_SMP
528         smp_send_tlb_invalidate(0);
529 #endif  
530 }
531
532
533 /*
534  * For each address in the range, find the pte for the address
535  * and check _PAGE_HASHPTE bit; if it is set, find and destroy
536  * the corresponding HPTE.
537  */
538 void
539 local_flush_tlb_range(struct mm_struct *mm, unsigned long start, unsigned long end)
540 {
541         pmd_t *pmd;
542         pte_t *pte;
543         unsigned long pmd_end;
544         unsigned int ctx = mm->context;
545
546         if (Hash == 0) {
547                 _tlbia();
548                 return;
549         }
550         start &= PAGE_MASK;
551         if (start >= end)
552                 return;
553         pmd = pmd_offset(pgd_offset(mm, start), start);
554         do {
555                 pmd_end = (start + PGDIR_SIZE) & PGDIR_MASK;
556                 if (!pmd_none(*pmd)) {
557                         if (!pmd_end || pmd_end > end)
558                                 pmd_end = end;
559                         pte = pte_offset(pmd, start);
560                         do {
561                                 if ((pte_val(*pte) & _PAGE_HASHPTE) != 0)
562                                         flush_hash_page(ctx, start, pte);
563                                 start += PAGE_SIZE;
564                                 ++pte;
565                         } while (start && start < pmd_end);
566                 } else {
567                         start = pmd_end;
568                 }
569                 ++pmd;
570         } while (start && start < end);
571
572 #ifdef CONFIG_SMP
573         smp_send_tlb_invalidate(0);
574 #endif  
575 }
576
577 /*
578  * Set up one of the I/D BAT (block address translation) register pairs.
579  * The parameters are not checked; in particular size must be a power
580  * of 2 between 128k and 256M.
581  */
582 void __init setbat(int index, unsigned long virt, unsigned long phys,
583        unsigned int size, int flags)
584 {
585         unsigned int bl;
586         int wimgxpp;
587         union ubat *bat = BATS[index];
588
589         bl = (size >> 17) - 1;
590         if ((_get_PVR() >> 16) != 1) {
591                 /* 603, 604, etc. */
592                 /* Do DBAT first */
593                 wimgxpp = flags & (_PAGE_WRITETHRU | _PAGE_NO_CACHE
594                                    | _PAGE_COHERENT | _PAGE_GUARDED);
595                 wimgxpp |= (flags & _PAGE_RW)? BPP_RW: BPP_RX;
596                 bat[1].word[0] = virt | (bl << 2) | 2; /* Vs=1, Vp=0 */
597                 bat[1].word[1] = phys | wimgxpp;
598 #ifndef CONFIG_KGDB /* want user access for breakpoints */
599                 if (flags & _PAGE_USER)
600 #endif
601                         bat[1].bat.batu.vp = 1;
602                 if (flags & _PAGE_GUARDED) {
603                         /* G bit must be zero in IBATs */
604                         bat[0].word[0] = bat[0].word[1] = 0;
605                 } else {
606                         /* make IBAT same as DBAT */
607                         bat[0] = bat[1];
608                 }
609         } else {
610                 /* 601 cpu */
611                 if (bl > BL_8M)
612                         bl = BL_8M;
613                 wimgxpp = flags & (_PAGE_WRITETHRU | _PAGE_NO_CACHE
614                                    | _PAGE_COHERENT);
615                 wimgxpp |= (flags & _PAGE_RW)?
616                         ((flags & _PAGE_USER)? PP_RWRW: PP_RWXX): PP_RXRX;
617                 bat->word[0] = virt | wimgxpp | 4;      /* Ks=0, Ku=1 */
618                 bat->word[1] = phys | bl | 0x40;        /* V=1 */
619         }
620
621         bat_addrs[index].start = virt;
622         bat_addrs[index].limit = virt + ((bl + 1) << 17) - 1;
623         bat_addrs[index].phys = phys;
624 }
625
626 #define IO_PAGE (_PAGE_NO_CACHE | _PAGE_GUARDED | _PAGE_RW)
627 #ifdef CONFIG_SMP
628 #define RAM_PAGE (_PAGE_RW|_PAGE_COHERENT)
629 #else
630 #define RAM_PAGE (_PAGE_RW)
631 #endif
632 #endif /* CONFIG_8xx */
633
634 /*
635  * Map in all of physical memory starting at KERNELBASE.
636  */
637 static void __init mapin_ram(void)
638 {
639         unsigned long v, p, s, f;
640
641 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx) && !defined(CONFIG_POWER4)
642         if (!__map_without_bats) {
643                 unsigned long tot, bl, done;
644                 unsigned long max_size = (256<<20);
645                 unsigned long align;
646
647                 /* Set up BAT2 and if necessary BAT3 to cover RAM. */
648
649                 /* Make sure we don't map a block larger than the
650                    smallest alignment of the physical address. */
651                 /* alignment of ram_phys_base */
652                 align = ~(ram_phys_base-1) & ram_phys_base;
653                 /* set BAT block size to MIN(max_size, align) */
654                 if (align && align < max_size)
655                         max_size = align;
656
657                 tot = total_lowmem;
658                 for (bl = 128<<10; bl < max_size; bl <<= 1) {
659                         if (bl * 2 > tot)
660                                 break;
661                 }
662
663                 setbat(2, KERNELBASE, ram_phys_base, bl, RAM_PAGE);
664                 done = (unsigned long)bat_addrs[2].limit - KERNELBASE + 1;
665                 if ((done < tot) && !bat_addrs[3].limit) {
666                         /* use BAT3 to cover a bit more */
667                         tot -= done;
668                         for (bl = 128<<10; bl < max_size; bl <<= 1)
669                                 if (bl * 2 > tot)
670                                         break;
671                         setbat(3, KERNELBASE+done, ram_phys_base+done, bl, 
672                                RAM_PAGE);
673                 }
674         }
675 #endif /* !CONFIG_4xx && !CONFIG_8xx && !CONFIG_POWER4 */
676
677         v = KERNELBASE;
678         p = ram_phys_base;
679         for (s = 0; s < total_lowmem; s += PAGE_SIZE) {
680                 /* On the MPC8xx, we want the page shared so we
681                  * don't get ASID compares on kernel space.
682                  */
683                 f = _PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_SHARED;
684 #if defined(CONFIG_KGDB) || defined(CONFIG_XMON)
685                 /* Allows stub to set breakpoints everywhere */
686                 f |= _PAGE_RW | _PAGE_DIRTY;
687 #else
688                 if ((char *) v < _stext || (char *) v >= etext)
689                         f |= _PAGE_RW | _PAGE_DIRTY;
690 #ifndef CONFIG_8xx
691                 else
692                         /* On the powerpc (not 8xx), no user access
693                            forces R/W kernel access */
694                         f |= _PAGE_USER;
695 #endif /* CONFIG_8xx */
696 #endif /* CONFIG_KGDB */
697                 map_page(v, p, f);
698                 v += PAGE_SIZE;
699                 p += PAGE_SIZE;
700         }
701 }
702
703 /* This is only called until mem_init is done. */
704 void __init *early_get_page(void)
705 {
706         void *p;
707
708         if (init_bootmem_done) {
709                 p = alloc_bootmem_pages(PAGE_SIZE);
710         } else {
711                 p = mem_pieces_find(PAGE_SIZE, PAGE_SIZE);
712         }
713         return p;
714 }
715
716 static void free_sec(unsigned long start, unsigned long end, const char *name)
717 {
718         unsigned long cnt = 0;
719
720         while (start < end) {
721                 ClearPageReserved(virt_to_page(start));
722                 set_page_count(virt_to_page(start), 1);
723                 free_page(start);
724                 cnt++;
725                 start += PAGE_SIZE;
726         }
727         if (cnt) {
728                 printk(" %ldk %s", PGTOKB(cnt), name);
729                 totalram_pages += cnt;
730         }
731 }
732
733 void free_initmem(void)
734 {
735 #define FREESEC(TYPE) \
736         free_sec((unsigned long)(&__ ## TYPE ## _begin), \
737                  (unsigned long)(&__ ## TYPE ## _end), \
738                  #TYPE);
739
740         printk ("Freeing unused kernel memory:");
741         FREESEC(init);
742         if (_machine != _MACH_Pmac)
743                 FREESEC(pmac);
744         if (_machine != _MACH_chrp)
745                 FREESEC(chrp);
746         if (_machine != _MACH_prep)
747                 FREESEC(prep);
748         if (!have_of)
749                 FREESEC(openfirmware);
750         printk("\n");
751 #undef FREESEC
752 }
753
754 #ifdef CONFIG_BLK_DEV_INITRD
755 void free_initrd_mem(unsigned long start, unsigned long end)
756 {
757         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
758
759         for (; start < end; start += PAGE_SIZE) {
760                 ClearPageReserved(virt_to_page(start));
761                 set_page_count(virt_to_page(start), 1);
762                 free_page(start);
763                 totalram_pages++;
764         }
765 }
766 #endif
767
768 /*
769  * Initialize the context management stuff.
770  */
771 static void mmu_context_init(void)
772 {
773         context_map[0] = 1;     /* init_mm uses context 0 */
774         next_mmu_context = 1;
775 #ifdef FEW_CONTEXTS
776         atomic_set(&nr_free_contexts, LAST_CONTEXT);
777         context_mm[0] = &init_mm;
778 #endif /* FEW_CONTEXTS */
779 }
780
781 #ifdef FEW_CONTEXTS
782 /*
783  * Steal a context from a task that has one at the moment.
784  * This is only used on 8xx and 4xx and we presently assume that
785  * they don't do SMP.  If they do then this will have to check
786  * whether the MM we steal is in use.
787  * We also assume that this is only used on systems that don't
788  * use an MMU hash table - this is true for 8xx and 4xx.
789  * This isn't an LRU system, it just frees up each context in
790  * turn (sort-of pseudo-random replacement :).  This would be the
791  * place to implement an LRU scheme if anyone was motivated to do it.
792  *  -- paulus
793  */
794 void steal_context(void)
795 {
796         struct mm_struct *mm;
797
798         /* free up context `next_mmu_context' */
799         /* if we shouldn't free context 0, don't... */
800 #ifdef CONFIG_4xx
801         if (next_mmu_context == 0)
802                 next_mmu_context = 1;
803 #endif /* CONFIG_4xx */
804         mm = context_mm[next_mmu_context];
805         flush_tlb_mm(mm);
806         destroy_context(mm);
807 }
808 #endif /* FEW_CONTEXTS */
809
810 extern boot_infos_t *disp_bi;
811
812 /*
813  * Do very early mm setup such as finding the size of memory
814  * and setting up the hash table.
815  * A lot of this is prep/pmac specific but a lot of it could
816  * still be merged.
817  * -- Cort
818  */
819 #if defined(CONFIG_4xx)
820 void __init
821 MMU_init(void)
822 {
823         /*
824          * The Zone Protection Register (ZPR) defines how protection will
825          * be applied to every page which is a member of a given zone. At
826          * present, we utilize only two of the 4xx's zones.
827          * The zone index bits (of ZSEL) in the PTE are used for software
828          * indicators, except the LSB.  For user access, zone 15 is used,
829          * for kernel access, zone 14 is used.  We set all but zone 15
830          * to zero, allowing only kernel access as indicated in the PTE.
831          * For zone 15, we set a 10 binary (I guess a 01 would work too)
832          * to allow user access as indicated in the PTE.  This also allows
833          * kernel access as indicated in the PTE.
834          */
835
836         mtspr(SPRN_ZPR, 0x00000002);
837
838         flush_instruction_cache();
839
840         /*
841          * Find the top of physical memory and map all of it in starting
842          * at KERNELBASE.
843          */
844
845         total_memory = total_lowmem = ppc_md.find_end_of_memory();
846         end_of_DRAM = __va(total_lowmem);
847         set_phys_avail(total_lowmem);
848         mapin_ram();
849
850         /*
851          * Set up the real-mode cache parameters for the exception vector
852          * handlers (which are run in real-mode).
853          */
854
855         mtspr(SPRN_DCWR, 0x00000000);   /* All caching is write-back */
856
857         /*
858          * Cache instruction and data space where the exception
859          * vectors and the kernel live in real-mode.
860          */
861
862         mtspr(SPRN_DCCR, 0x80000000);   /* 128 MB of data space at 0x0. */
863         mtspr(SPRN_ICCR, 0x80000000);   /* 128 MB of instr. space at 0x0. */
864
865         mmu_context_init();
866 }
867
868 #else /* !CONFIG_4xx */
869 void __init MMU_init(void)
870 {
871         if ( ppc_md.progress ) ppc_md.progress("MMU:enter", 0x111);
872
873         total_memory = ppc_md.find_end_of_memory();
874
875         if (__max_memory && total_memory > __max_memory)
876                 total_memory = __max_memory;
877         total_lowmem = total_memory;
878         if (total_lowmem > __max_low_memory) {
879                 total_lowmem = __max_low_memory;
880 #ifndef CONFIG_HIGHMEM
881                 total_memory = total_lowmem;
882 #endif /* CONFIG_HIGHMEM */
883         }
884         end_of_DRAM = __va(total_lowmem);
885         set_phys_avail(total_lowmem);
886
887 #if !defined(CONFIG_8xx)
888         if ( ppc_md.progress ) ppc_md.progress("MMU:hash init", 0x300);
889         hash_init();
890 #ifndef CONFIG_PPC64BRIDGE
891         _SDR1 = __pa(Hash) | (Hash_mask >> 10);
892 #endif
893         
894         ioremap_base = 0xf8000000;
895 #endif /* CONFIG_8xx */
896
897         if ( ppc_md.progress ) ppc_md.progress("MMU:mapin", 0x301);
898         /* Map in all of RAM starting at KERNELBASE */
899         mapin_ram();
900
901 #if defined(CONFIG_8xx)
902         /* Now map in some of the I/O space that is generically needed
903          * or shared with multiple devices.
904          * All of this fits into the same 4Mbyte region, so it only
905          * requires one page table page.
906          */
907         ioremap(IMAP_ADDR, IMAP_SIZE);
908 #ifdef CONFIG_MBX
909         ioremap(NVRAM_ADDR, NVRAM_SIZE);
910         ioremap(MBX_CSR_ADDR, MBX_CSR_SIZE);
911         ioremap(PCI_CSR_ADDR, PCI_CSR_SIZE);
912
913         /* Map some of the PCI/ISA I/O space to get the IDE interface.
914         */
915         ioremap(PCI_ISA_IO_ADDR, 0x4000);
916         ioremap(PCI_IDE_ADDR, 0x4000);
917 #endif
918 #if defined(CONFIG_RPXLITE) || defined(CONFIG_RPXCLASSIC)
919         ioremap(RPX_CSR_ADDR, RPX_CSR_SIZE);
920 #if !defined(CONFIG_PCI)
921         ioremap(_IO_BASE,_IO_BASE_SIZE);
922 #endif
923 #endif
924 #ifdef CONFIG_HTDMSOUND
925         ioremap(HIOX_CSR_ADDR, HIOX_CSR_SIZE);
926 #endif
927 #ifdef CONFIG_FADS
928         ioremap(BCSR_ADDR, BCSR_SIZE);
929 #endif
930 #ifdef CONFIG_PCI
931         ioremap(PCI_CSR_ADDR, PCI_CSR_SIZE);
932 #endif
933 #else /* !CONFIG_8xx */
934         /*
935          * Setup the bat mappings we're going to load that cover
936          * the io areas.  RAM was mapped by mapin_ram().
937          * -- Cort
938          */
939         if ( ppc_md.progress ) ppc_md.progress("MMU:setbat", 0x302);
940         switch (_machine) {
941         case _MACH_prep:
942                 setbat(0, 0x80000000, 0x80000000, 0x10000000, IO_PAGE);
943                 setbat(1, 0xf0000000, 0xc0000000, 0x08000000, IO_PAGE);
944                 ioremap_base = 0xf0000000;
945                 break;
946         case _MACH_chrp:
947                 /*
948                  * The code below tends to get removed, please don't take it out.
949                  * The F50 needs this mapping and it you take it out I'll track you
950                  * down and slap your hands.  If it causes problems please email me.
951                  *  -- Cort <cort@fsmlabs.com>
952                  */
953 #ifndef CONFIG_POWER3
954                 setbat(0, 0x80000000, 0x80000000, 0x10000000, IO_PAGE);
955                 setbat(1, 0x90000000, 0x90000000, 0x10000000, IO_PAGE);
956 #endif
957                 break;
958         case _MACH_Pmac:
959                 ioremap_base = 0xfe000000;
960                 break;
961         case _MACH_apus:
962                 /* Map PPC exception vectors. */
963                 setbat(0, 0xfff00000, 0xfff00000, 0x00020000, RAM_PAGE);
964                 /* Map chip and ZorroII memory */
965                 setbat(1, zTwoBase,   0x00000000, 0x01000000, IO_PAGE);
966                 break;
967         case _MACH_gemini:
968                 setbat(0, 0xf0000000, 0xf0000000, 0x10000000, IO_PAGE);
969                 setbat(1, 0x80000000, 0x80000000, 0x10000000, IO_PAGE);
970                 break;
971         case _MACH_8260:
972                 /* Map the IMMR, plus anything else we can cover
973                  * in that upper space according to the memory controller
974                  * chip select mapping.  Grab another bunch of space
975                  * below that for stuff we can't cover in the upper.
976                  */
977                 setbat(0, 0xf0000000, 0xf0000000, 0x10000000, IO_PAGE);
978                 setbat(1, 0xe0000000, 0xe0000000, 0x10000000, IO_PAGE);
979                 ioremap_base = 0xe0000000;
980                 break;
981         }
982         ioremap_bot = ioremap_base;
983 #endif /* CONFIG_8xx */
984
985         if ( ppc_md.progress ) ppc_md.progress("MMU:exit", 0x211);
986 #ifdef CONFIG_BOOTX_TEXT
987         /* Must be done last, or ppc_md.progress will die */
988         if (_machine == _MACH_Pmac || _machine == _MACH_chrp)
989                 map_bootx_text();
990 #endif
991
992         mmu_context_init();
993 }
994 #endif /* CONFIG_4xx */
995
996 /*
997  * Initialize the bootmem system and give it all the memory we
998  * have available.
999  */
1000 void __init do_init_bootmem(void)
1001 {
1002         unsigned long start, size;
1003         int i;
1004
1005         /*
1006          * Find an area to use for the bootmem bitmap.
1007          * We look for the first area which is at least
1008          * 128kB in length (128kB is enough for a bitmap
1009          * for 4GB of memory, using 4kB pages), plus 1 page
1010          * (in case the address isn't page-aligned).
1011          */
1012         start = 0;
1013         size = 0;
1014         for (i = 0; i < phys_avail.n_regions; ++i) {
1015                 unsigned long a = phys_avail.regions[i].address;
1016                 unsigned long s = phys_avail.regions[i].size;
1017                 if (s <= size)
1018                         continue;
1019                 start = a;
1020                 size = s;
1021                 if (s >= 33 * PAGE_SIZE)
1022                         break;
1023         }
1024         start = PAGE_ALIGN(start);
1025
1026         boot_mapsize = init_bootmem(start >> PAGE_SHIFT,
1027                                     total_lowmem >> PAGE_SHIFT);
1028
1029         /* remove the bootmem bitmap from the available memory */
1030         mem_pieces_remove(&phys_avail, start, boot_mapsize, 1);
1031
1032         /* add everything in phys_avail into the bootmem map */
1033         for (i = 0; i < phys_avail.n_regions; ++i)
1034                 free_bootmem(phys_avail.regions[i].address,
1035                              phys_avail.regions[i].size);
1036
1037         init_bootmem_done = 1;
1038 }
1039
1040 /*
1041  * paging_init() sets up the page tables - in fact we've already done this.
1042  */
1043 void __init paging_init(void)
1044 {
1045         unsigned long zones_size[MAX_NR_ZONES], i;
1046
1047 #ifdef CONFIG_HIGHMEM
1048         map_page(PKMAP_BASE, 0, 0);     /* XXX gross */
1049         pkmap_page_table = pte_offset(pmd_offset(pgd_offset_k(PKMAP_BASE), PKMAP_BASE), PKMAP_BASE);
1050         map_page(KMAP_FIX_BEGIN, 0, 0); /* XXX gross */
1051         kmap_pte = pte_offset(pmd_offset(pgd_offset_k(KMAP_FIX_BEGIN), KMAP_FIX_BEGIN), KMAP_FIX_BEGIN);
1052         kmap_prot = PAGE_KERNEL;
1053 #endif /* CONFIG_HIGHMEM */
1054
1055         /*
1056          * All pages are DMA-able so we put them all in the DMA zone.
1057          */
1058         zones_size[ZONE_DMA] = total_lowmem >> PAGE_SHIFT;
1059         for (i = 1; i < MAX_NR_ZONES; i++)
1060                 zones_size[i] = 0;
1061
1062 #ifdef CONFIG_HIGHMEM
1063         zones_size[ZONE_HIGHMEM] = (total_memory - total_lowmem) >> PAGE_SHIFT;
1064 #endif /* CONFIG_HIGHMEM */
1065
1066         free_area_init(zones_size);
1067 }
1068
1069 void __init mem_init(void)
1070 {
1071         extern char *sysmap; 
1072         extern unsigned long sysmap_size;
1073         unsigned long addr;
1074         int codepages = 0;
1075         int datapages = 0;
1076         int initpages = 0;
1077 #ifdef CONFIG_HIGHMEM
1078         unsigned long highmem_mapnr;
1079
1080         highmem_mapnr = total_lowmem >> PAGE_SHIFT;
1081         highmem_start_page = mem_map + highmem_mapnr;
1082         max_mapnr = total_memory >> PAGE_SHIFT;
1083 #else
1084         max_mapnr = max_low_pfn;
1085 #endif /* CONFIG_HIGHMEM */
1086
1087         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
1088         num_physpages = max_mapnr;      /* RAM is assumed contiguous */
1089
1090         totalram_pages += free_all_bootmem();
1091
1092 #ifdef CONFIG_BLK_DEV_INITRD
1093         /* if we are booted from BootX with an initial ramdisk,
1094            make sure the ramdisk pages aren't reserved. */
1095         if (initrd_start) {
1096                 for (addr = initrd_start; addr < initrd_end; addr += PAGE_SIZE)
1097                         clear_bit(PG_reserved, &virt_to_page(addr)->flags);
1098         }
1099 #endif /* CONFIG_BLK_DEV_INITRD */
1100
1101 #if defined(CONFIG_ALL_PPC)     
1102         /* mark the RTAS pages as reserved */
1103         if ( rtas_data )
1104                 for (addr = (ulong)__va(rtas_data);
1105                      addr < PAGE_ALIGN((ulong)__va(rtas_data)+rtas_size) ;
1106                      addr += PAGE_SIZE)
1107                         SetPageReserved(virt_to_page(addr));
1108 #endif /* defined(CONFIG_ALL_PPC) */
1109         if ( sysmap_size )
1110                 for (addr = (unsigned long)sysmap;
1111                      addr < PAGE_ALIGN((unsigned long)sysmap+sysmap_size) ;
1112                      addr += PAGE_SIZE)
1113                         SetPageReserved(virt_to_page(addr));
1114         
1115         for (addr = PAGE_OFFSET; addr < (unsigned long)end_of_DRAM;
1116              addr += PAGE_SIZE) {
1117                 if (!PageReserved(virt_to_page(addr)))
1118                         continue;
1119                 if (addr < (ulong) etext)
1120                         codepages++;
1121                 else if (addr >= (unsigned long)&__init_begin
1122                          && addr < (unsigned long)&__init_end)
1123                         initpages++;
1124                 else if (addr < (ulong) klimit)
1125                         datapages++;
1126         }
1127
1128 #ifdef CONFIG_HIGHMEM
1129         {
1130                 unsigned long pfn;
1131
1132                 for (pfn = highmem_mapnr; pfn < max_mapnr; ++pfn) {
1133                         struct page *page = mem_map + pfn;
1134
1135                         ClearPageReserved(page);
1136                         set_bit(PG_highmem, &page->flags);
1137                         atomic_set(&page->count, 1);
1138                         __free_page(page);
1139                         totalhigh_pages++;
1140                 }
1141                 totalram_pages += totalhigh_pages;
1142         }
1143 #endif /* CONFIG_HIGHMEM */
1144
1145         printk("Memory: %luk available (%dk kernel code, %dk data, %dk init, %ldk highmem)\n",
1146                (unsigned long)nr_free_pages()<< (PAGE_SHIFT-10),
1147                codepages<< (PAGE_SHIFT-10), datapages<< (PAGE_SHIFT-10),
1148                initpages<< (PAGE_SHIFT-10),
1149                (unsigned long) (totalhigh_pages << (PAGE_SHIFT-10)));
1150         mem_init_done = 1;
1151 }
1152
1153 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
1154 /*
1155  * Initialize the hash table and patch the instructions in hashtable.S.
1156  */
1157 static void __init hash_init(void)
1158 {
1159         int Hash_bits, mb, mb2;
1160         unsigned int hmask, h;
1161
1162         extern unsigned int hash_page_patch_A[];
1163         extern unsigned int hash_page_patch_B[], hash_page_patch_C[];
1164         extern unsigned int hash_page[];
1165         extern unsigned int flush_hash_patch_A[], flush_hash_patch_B[];
1166
1167 #ifdef CONFIG_PPC64BRIDGE
1168         /* The hash table has already been allocated and initialized
1169            in prom.c */
1170         Hash_mask = (Hash_size >> 7) - 1;
1171         hmask = Hash_mask >> 9;
1172         Hash_bits = __ilog2(Hash_size) - 7;
1173         mb = 25 - Hash_bits;
1174         if (Hash_bits > 16)
1175                 Hash_bits = 16;
1176         mb2 = 25 - Hash_bits;
1177
1178 #else /* CONFIG_PPC64BRIDGE */
1179
1180         if ( ppc_md.progress ) ppc_md.progress("hash:enter", 0x105);
1181         /*
1182          * Allow 64k of hash table for every 16MB of memory,
1183          * up to a maximum of 2MB.
1184          */
1185         for (h = 64<<10; h < total_memory / 256 && h < (2<<20); h *= 2)
1186                 ;
1187         Hash_size = h;
1188         Hash_mask = (h >> 6) - 1;
1189         hmask = Hash_mask >> 10;
1190         Hash_bits = __ilog2(h) - 6;
1191         mb = 26 - Hash_bits;
1192         if (Hash_bits > 16)
1193                 Hash_bits = 16;
1194         mb2 = 26 - Hash_bits;
1195
1196         /* shrink the htab since we don't use it on 603's -- Cort */
1197         switch (_get_PVR()>>16) {
1198         case 3: /* 603 */
1199         case 6: /* 603e */
1200         case 7: /* 603ev */
1201         case 0x0081: /* 82xx */
1202                 Hash_size = 0;
1203                 Hash_mask = 0;
1204                 break;
1205         default:
1206                 /* on 601/4 let things be */
1207                 break;
1208         }
1209         
1210         if ( ppc_md.progress ) ppc_md.progress("hash:find piece", 0x322);
1211         /* Find some memory for the hash table. */
1212         if ( Hash_size ) {
1213                 Hash = mem_pieces_find(Hash_size, Hash_size);
1214                 cacheable_memzero(Hash, Hash_size);
1215                 _SDR1 = __pa(Hash) | (Hash_mask >> 10);
1216         } else
1217                 Hash = 0;
1218 #endif /* CONFIG_PPC64BRIDGE */
1219
1220         printk("Total memory = %ldMB; using %ldkB for hash table (at %p)\n",
1221                total_memory >> 20, Hash_size >> 10, Hash);
1222         if ( Hash_size )
1223         {
1224                 if ( ppc_md.progress ) ppc_md.progress("hash:patch", 0x345);
1225                 Hash_end = (PTE *) ((unsigned long)Hash + Hash_size);
1226
1227                 /*
1228                  * Patch up the instructions in hashtable.S:create_hpte
1229                  */
1230                 hash_page_patch_A[0] = (hash_page_patch_A[0] & ~0xffff)
1231                         | ((unsigned int)(Hash) >> 16);
1232                 hash_page_patch_A[1] = (hash_page_patch_A[1] & ~0x7c0)
1233                         | (mb << 6);
1234                 hash_page_patch_A[2] = (hash_page_patch_A[2] & ~0x7c0)
1235                         | (mb2 << 6);
1236                 hash_page_patch_B[0] = (hash_page_patch_B[0] & ~0xffff)
1237                         | hmask;
1238                 hash_page_patch_C[0] = (hash_page_patch_C[0] & ~0xffff)
1239                         | hmask;
1240                 /*
1241                  * Ensure that the locations we've patched have been written
1242                  * out from the data cache and invalidated in the instruction
1243                  * cache, on those machines with split caches.
1244                  */
1245                 flush_icache_range((unsigned long) &hash_page_patch_A[0],
1246                                    (unsigned long) &hash_page_patch_C[1]);
1247                 /*
1248                  * Patch up the instructions in hashtable.S:flush_hash_page
1249                  */
1250                 flush_hash_patch_A[0] = (flush_hash_patch_A[0] & ~0xffff)
1251                         | ((unsigned int)(Hash) >> 16);
1252                 flush_hash_patch_A[1] = (flush_hash_patch_A[1] & ~0x7c0)
1253                         | (mb << 6);
1254                 flush_hash_patch_A[2] = (flush_hash_patch_A[2] & ~0x7c0)
1255                         | (mb2 << 6);
1256                 flush_hash_patch_B[0] = (flush_hash_patch_B[0] & ~0xffff)
1257                         | hmask;
1258                 flush_icache_range((unsigned long) &flush_hash_patch_A[0],
1259                                    (unsigned long) &flush_hash_patch_B[1]);
1260         }
1261         else {
1262                 Hash_end = 0;
1263                 /*
1264                  * Put a blr (procedure return) instruction at the
1265                  * start of hash_page, since we can still get DSI
1266                  * exceptions on a 603.
1267                  */
1268                 hash_page[0] = 0x4e800020;
1269                 flush_icache_range((unsigned long) &hash_page[0],
1270                                    (unsigned long) &hash_page[1]);
1271         }
1272
1273         if ( ppc_md.progress ) ppc_md.progress("hash:done", 0x205);
1274 }
1275 #endif /* !CONFIG_4xx && !CONFIG_8xx */
1276
1277 /*
1278  * Set phys_avail to the amount of physical memory,
1279  * less the kernel text/data/bss.
1280  */
1281 void __init
1282 set_phys_avail(unsigned long total_memory)
1283 {
1284         unsigned long kstart, ksize;
1285
1286         /*
1287          * Initially, available physical memory is equivalent to all
1288          * physical memory.
1289          */
1290
1291         phys_avail.regions[0].address = 0;
1292         phys_avail.regions[0].size = total_memory;
1293         phys_avail.n_regions = 1;
1294
1295         /*
1296          * Map out the kernel text/data/bss from the available physical
1297          * memory.
1298          */
1299
1300         kstart = __pa(_stext);  /* should be 0 */
1301         ksize = PAGE_ALIGN(klimit - _stext);
1302
1303         mem_pieces_remove(&phys_avail, kstart, ksize, 0);
1304         mem_pieces_remove(&phys_avail, 0, 0x4000, 0);
1305
1306 #if defined(CONFIG_BLK_DEV_INITRD)
1307         /* Remove the init RAM disk from the available memory. */
1308         if (initrd_start) {
1309                 mem_pieces_remove(&phys_avail, __pa(initrd_start),
1310                                   initrd_end - initrd_start, 1);
1311         }
1312 #endif /* CONFIG_BLK_DEV_INITRD */
1313 #ifdef CONFIG_ALL_PPC
1314         /* remove the RTAS pages from the available memory */
1315         if (rtas_data)
1316                 mem_pieces_remove(&phys_avail, rtas_data, rtas_size, 1);
1317 #endif /* CONFIG_ALL_PPC */
1318 #ifdef CONFIG_PPC64BRIDGE
1319         /* Remove the hash table from the available memory */
1320         if (Hash)
1321                 mem_pieces_remove(&phys_avail, __pa(Hash), Hash_size, 1);
1322 #endif /* CONFIG_PPC64BRIDGE */
1323 }
1324
1325 void flush_page_to_ram(struct page *page)
1326 {
1327         unsigned long vaddr = (unsigned long) kmap(page);
1328         __flush_page_to_ram(vaddr);
1329         kunmap(page);
1330 }
1331
1332 #if !defined(CONFIG_4xx) && !defined(CONFIG_8xx)
1333 /*
1334  * This is called at the end of handling a user page fault, when the
1335  * fault has been handled by updating a PTE in the linux page tables.
1336  * We use it to preload an HPTE into the hash table corresponding to
1337  * the updated linux PTE.
1338  */
1339 void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
1340                       pte_t pte)
1341 {
1342         struct mm_struct *mm;
1343         pmd_t *pmd;
1344         pte_t *ptep;
1345         static int nopreload;
1346
1347         if (Hash == 0 || nopreload)
1348                 return;
1349         mm = (address < TASK_SIZE)? vma->vm_mm: &init_mm;
1350         pmd = pmd_offset(pgd_offset(mm, address), address);
1351         if (!pmd_none(*pmd)) {
1352                 ptep = pte_offset(pmd, address);
1353                 add_hash_page(mm->context, address, ptep);
1354         }
1355 }
1356 #endif /* !4xx && !8xx */
1357
1358 /*
1359  * set_pte stores a linux PTE into the linux page table.
1360  * On machines which use an MMU hash table we avoid changing the
1361  * _PAGE_HASHPTE bit.
1362  */
1363 void set_pte(pte_t *ptep, pte_t pte)
1364 {
1365 #if _PAGE_HASHPTE != 0
1366         pte_update(ptep, ~_PAGE_HASHPTE, pte_val(pte) & ~_PAGE_HASHPTE);
1367 #else
1368         *ptep = pte;
1369 #endif
1370 }