arch/arm/mm/mmu.c

   1 /*
   2  *  linux/arch/arm/mm/mmu.c
   3  *
   4  *  Copyright (C) 1995-2005 Russell King
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/errno.h>
  13 #include <linux/init.h>
  14 #include <linux/bootmem.h>
  15 #include <linux/mman.h>
  16 #include <linux/nodemask.h>
  17
  18 #include <asm/mach-types.h>
  19 #include <asm/setup.h>
  20 #include <asm/sizes.h>
  21 #include <asm/tlb.h>
  22
  23 #include <asm/mach/arch.h>
  24 #include <asm/mach/map.h>
  25
  26 #include "mm.h"
  27
  28 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  29
  30 extern void _stext, _etext, __data_start, _end;
  31 extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
  32
  33 /*
  34  * empty_zero_page is a special page that is used for
  35  * zero-initialized data and COW.
  36  */
  37 struct page *empty_zero_page;
  38
  39 /*
  40  * The pmd table for the upper-most set of pages.
  41  */
  42 pmd_t *top_pmd;
  43
  44 #define CPOLICY_UNCACHED        0
  45 #define CPOLICY_BUFFERED        1
  46 #define CPOLICY_WRITETHROUGH    2
  47 #define CPOLICY_WRITEBACK       3
  48 #define CPOLICY_WRITEALLOC      4
  49
  50 static unsigned int cachepolicy __initdata = CPOLICY_WRITEBACK;
  51 static unsigned int ecc_mask __initdata = 0;
  52 pgprot_t pgprot_kernel;
  53
  54 EXPORT_SYMBOL(pgprot_kernel);
  55
  56 struct cachepolicy {
  57         const char      policy[16];
  58         unsigned int    cr_mask;
  59         unsigned int    pmd;
  60         unsigned int    pte;
  61 };
  62
  63 static struct cachepolicy cache_policies[] __initdata = {
  64         {
  65                 .policy         = "uncached",
  66                 .cr_mask        = CR_W|CR_C,
  67                 .pmd            = PMD_SECT_UNCACHED,
  68                 .pte            = 0,
  69         }, {
  70                 .policy         = "buffered",
  71                 .cr_mask        = CR_C,
  72                 .pmd            = PMD_SECT_BUFFERED,
  73                 .pte            = PTE_BUFFERABLE,
  74         }, {
  75                 .policy         = "writethrough",
  76                 .cr_mask        = 0,
  77                 .pmd            = PMD_SECT_WT,
  78                 .pte            = PTE_CACHEABLE,
  79         }, {
  80                 .policy         = "writeback",
  81                 .cr_mask        = 0,
  82                 .pmd            = PMD_SECT_WB,
  83                 .pte            = PTE_BUFFERABLE|PTE_CACHEABLE,
  84         }, {
  85                 .policy         = "writealloc",
  86                 .cr_mask        = 0,
  87                 .pmd            = PMD_SECT_WBWA,
  88                 .pte            = PTE_BUFFERABLE|PTE_CACHEABLE,
  89         }
  90 };
  91
  92 /*
  93  * These are useful for identifing cache coherency
  94  * problems by allowing the cache or the cache and
  95  * writebuffer to be turned off.  (Note: the write
  96  * buffer should not be on and the cache off).
  97  */
  98 static void __init early_cachepolicy(char **p)
  99 {
 100         int i;
 101
 102         for (i = 0; i < ARRAY_SIZE(cache_policies); i++) {
 103                 int len = strlen(cache_policies[i].policy);
 104
 105                 if (memcmp(*p, cache_policies[i].policy, len) == 0) {
 106                         cachepolicy = i;
 107                         cr_alignment &= ~cache_policies[i].cr_mask;
 108                         cr_no_alignment &= ~cache_policies[i].cr_mask;
 109                         *p += len;
 110                         break;
 111                 }
 112         }
 113         if (i == ARRAY_SIZE(cache_policies))
 114                 printk(KERN_ERR "ERROR: unknown or unsupported cache policy\n");
 115         flush_cache_all();
 116         set_cr(cr_alignment);
 117 }
 118 __early_param("cachepolicy=", early_cachepolicy);
 119
 120 static void __init early_nocache(char **__unused)
 121 {
 122         char *p = "buffered";
 123         printk(KERN_WARNING "nocache is deprecated; use cachepolicy=%s\n", p);
 124         early_cachepolicy(&p);
 125 }
 126 __early_param("nocache", early_nocache);
 127
 128 static void __init early_nowrite(char **__unused)
 129 {
 130         char *p = "uncached";
 131         printk(KERN_WARNING "nowb is deprecated; use cachepolicy=%s\n", p);
 132         early_cachepolicy(&p);
 133 }
 134 __early_param("nowb", early_nowrite);
 135
 136 static void __init early_ecc(char **p)
 137 {
 138         if (memcmp(*p, "on", 2) == 0) {
 139                 ecc_mask = PMD_PROTECTION;
 140                 *p += 2;
 141         } else if (memcmp(*p, "off", 3) == 0) {
 142                 ecc_mask = 0;
 143                 *p += 3;
 144         }
 145 }
 146 __early_param("ecc=", early_ecc);
 147
 148 static int __init noalign_setup(char *__unused)
 149 {
 150         cr_alignment &= ~CR_A;
 151         cr_no_alignment &= ~CR_A;
 152         set_cr(cr_alignment);
 153         return 1;
 154 }
 155 __setup("noalign", noalign_setup);
 156
 157 #ifndef CONFIG_SMP
 158 void adjust_cr(unsigned long mask, unsigned long set)
 159 {
 160         unsigned long flags;
 161
 162         mask &= ~CR_A;
 163
 164         set &= mask;
 165
 166         local_irq_save(flags);
 167
 168         cr_no_alignment = (cr_no_alignment & ~mask) | set;
 169         cr_alignment = (cr_alignment & ~mask) | set;
 170
 171         set_cr((get_cr() & ~mask) | set);
 172
 173         local_irq_restore(flags);
 174 }
 175 #endif
 176
 177 struct mem_types {
 178         unsigned int    prot_pte;
 179         unsigned int    prot_l1;
 180         unsigned int    prot_sect;
 181         unsigned int    domain;
 182 };
 183
 184 static struct mem_types mem_types[] __initdata = {
 185         [MT_DEVICE] = {
 186                 .prot_pte  = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
 187                                 L_PTE_WRITE,
 188                 .prot_l1   = PMD_TYPE_TABLE,
 189                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4 | PMD_SECT_UNCACHED |
 190                                 PMD_SECT_AP_WRITE,
 191                 .domain    = DOMAIN_IO,
 192         },
 193         [MT_CACHECLEAN] = {
 194                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4,
 195                 .domain    = DOMAIN_KERNEL,
 196         },
 197         [MT_MINICLEAN] = {
 198                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4 | PMD_SECT_MINICACHE,
 199                 .domain    = DOMAIN_KERNEL,
 200         },
 201         [MT_LOW_VECTORS] = {
 202                 .prot_pte  = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
 203                                 L_PTE_EXEC,
 204                 .prot_l1   = PMD_TYPE_TABLE,
 205                 .domain    = DOMAIN_USER,
 206         },
 207         [MT_HIGH_VECTORS] = {
 208                 .prot_pte  = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
 209                                 L_PTE_USER | L_PTE_EXEC,
 210                 .prot_l1   = PMD_TYPE_TABLE,
 211                 .domain    = DOMAIN_USER,
 212         },
 213         [MT_MEMORY] = {
 214                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4 | PMD_SECT_AP_WRITE,
 215                 .domain    = DOMAIN_KERNEL,
 216         },
 217         [MT_ROM] = {
 218                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4,
 219                 .domain    = DOMAIN_KERNEL,
 220         },
 221         [MT_IXP2000_DEVICE] = { /* IXP2400 requires XCB=101 for on-chip I/O */
 222                 .prot_pte  = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY |
 223                                 L_PTE_WRITE,
 224                 .prot_l1   = PMD_TYPE_TABLE,
 225                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4 | PMD_SECT_UNCACHED |
 226                                 PMD_SECT_AP_WRITE | PMD_SECT_BUFFERABLE |
 227                                 PMD_SECT_TEX(1),
 228                 .domain    = DOMAIN_IO,
 229         },
 230         [MT_NONSHARED_DEVICE] = {
 231                 .prot_l1   = PMD_TYPE_TABLE,
 232                 .prot_sect = PMD_TYPE_SECT | PMD_BIT4 | PMD_SECT_NONSHARED_DEV |
 233                                 PMD_SECT_AP_WRITE,
 234                 .domain    = DOMAIN_IO,
 235         }
 236 };
 237
 238 /*
 239  * Adjust the PMD section entries according to the CPU in use.
 240  */
 241 static void __init build_mem_type_table(void)
 242 {
 243         struct cachepolicy *cp;
 244         unsigned int cr = get_cr();
 245         unsigned int user_pgprot, kern_pgprot;
 246         int cpu_arch = cpu_architecture();
 247         int i;
 248
 249 #if defined(CONFIG_CPU_DCACHE_DISABLE)
 250         if (cachepolicy > CPOLICY_BUFFERED)
 251                 cachepolicy = CPOLICY_BUFFERED;
 252 #elif defined(CONFIG_CPU_DCACHE_WRITETHROUGH)
 253         if (cachepolicy > CPOLICY_WRITETHROUGH)
 254                 cachepolicy = CPOLICY_WRITETHROUGH;
 255 #endif
 256         if (cpu_arch < CPU_ARCH_ARMv5) {
 257                 if (cachepolicy >= CPOLICY_WRITEALLOC)
 258                         cachepolicy = CPOLICY_WRITEBACK;
 259                 ecc_mask = 0;
 260         }
 261
 262         /*
 263          * Xscale must not have PMD bit 4 set for section mappings.
 264          */
 265         if (cpu_is_xscale())
 266                 for (i = 0; i < ARRAY_SIZE(mem_types); i++)
 267                         mem_types[i].prot_sect &= ~PMD_BIT4;
 268
 269         /*
 270          * ARMv5 and lower, excluding Xscale, bit 4 must be set for
 271          * page tables.
 272          */
 273         if (cpu_arch < CPU_ARCH_ARMv6 && !cpu_is_xscale())
 274                 for (i = 0; i < ARRAY_SIZE(mem_types); i++)
 275                         if (mem_types[i].prot_l1)
 276                                 mem_types[i].prot_l1 |= PMD_BIT4;
 277
 278         cp = &cache_policies[cachepolicy];
 279         kern_pgprot = user_pgprot = cp->pte;
 280
 281         /*
 282          * Enable CPU-specific coherency if supported.
 283          * (Only available on XSC3 at the moment.)
 284          */
 285         if (arch_is_coherent()) {
 286                 if (cpu_is_xsc3()) {
 287                         mem_types[MT_MEMORY].prot_sect |= PMD_SECT_S;
 288                         mem_types[MT_MEMORY].prot_pte |= L_PTE_SHARED;
 289                 }
 290         }
 291
 292         /*
 293          * ARMv6 and above have extended page tables.
 294          */
 295         if (cpu_arch >= CPU_ARCH_ARMv6 && (cr & CR_XP)) {
 296                 /*
 297                  * bit 4 becomes XN which we must clear for the
 298                  * kernel memory mapping.
 299                  */
 300                 mem_types[MT_MEMORY].prot_sect &= ~PMD_SECT_XN;
 301                 mem_types[MT_ROM].prot_sect &= ~PMD_SECT_XN;
 302
 303                 /*
 304                  * Mark cache clean areas and XIP ROM read only
 305                  * from SVC mode and no access from userspace.
 306                  */
 307                 mem_types[MT_ROM].prot_sect |= PMD_SECT_APX|PMD_SECT_AP_WRITE;
 308                 mem_types[MT_MINICLEAN].prot_sect |= PMD_SECT_APX|PMD_SECT_AP_WRITE;
 309                 mem_types[MT_CACHECLEAN].prot_sect |= PMD_SECT_APX|PMD_SECT_AP_WRITE;
 310
 311                 /*
 312                  * Mark the device area as "shared device"
 313                  */
 314                 mem_types[MT_DEVICE].prot_pte |= L_PTE_BUFFERABLE;
 315                 mem_types[MT_DEVICE].prot_sect |= PMD_SECT_BUFFERED;
 316
 317 #ifdef CONFIG_SMP
 318                 /*
 319                  * Mark memory with the "shared" attribute for SMP systems
 320                  */
 321                 user_pgprot |= L_PTE_SHARED;
 322                 kern_pgprot |= L_PTE_SHARED;
 323                 mem_types[MT_MEMORY].prot_sect |= PMD_SECT_S;
 324 #endif
 325         }
 326
 327         for (i = 0; i < 16; i++) {
 328                 unsigned long v = pgprot_val(protection_map[i]);
 329                 v = (v & ~(L_PTE_BUFFERABLE|L_PTE_CACHEABLE)) | user_pgprot;
 330                 protection_map[i] = __pgprot(v);
 331         }
 332
 333         mem_types[MT_LOW_VECTORS].prot_pte |= kern_pgprot;
 334         mem_types[MT_HIGH_VECTORS].prot_pte |= kern_pgprot;
 335
 336         if (cpu_arch >= CPU_ARCH_ARMv5) {
 337 #ifndef CONFIG_SMP
 338                 /*
 339                  * Only use write-through for non-SMP systems
 340                  */
 341                 mem_types[MT_LOW_VECTORS].prot_pte &= ~L_PTE_BUFFERABLE;
 342                 mem_types[MT_HIGH_VECTORS].prot_pte &= ~L_PTE_BUFFERABLE;
 343 #endif
 344         } else {
 345                 mem_types[MT_MINICLEAN].prot_sect &= ~PMD_SECT_TEX(1);
 346         }
 347
 348         pgprot_kernel = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG |
 349                                  L_PTE_DIRTY | L_PTE_WRITE |
 350                                  L_PTE_EXEC | kern_pgprot);
 351
 352         mem_types[MT_LOW_VECTORS].prot_l1 |= ecc_mask;
 353         mem_types[MT_HIGH_VECTORS].prot_l1 |= ecc_mask;
 354         mem_types[MT_MEMORY].prot_sect |= ecc_mask | cp->pmd;
 355         mem_types[MT_ROM].prot_sect |= cp->pmd;
 356
 357         switch (cp->pmd) {
 358         case PMD_SECT_WT:
 359                 mem_types[MT_CACHECLEAN].prot_sect |= PMD_SECT_WT;
 360                 break;
 361         case PMD_SECT_WB:
 362         case PMD_SECT_WBWA:
 363                 mem_types[MT_CACHECLEAN].prot_sect |= PMD_SECT_WB;
 364                 break;
 365         }
 366         printk("Memory policy: ECC %sabled, Data cache %s\n",
 367                 ecc_mask ? "en" : "dis", cp->policy);
 368 }
 369
 370 #define vectors_base()  (vectors_high() ? 0xffff0000 : 0)
 371
 372 /*
 373  * Create a SECTION PGD between VIRT and PHYS in domain
 374  * DOMAIN with protection PROT.  This operates on half-
 375  * pgdir entry increments.
 376  */
 377 static inline void
 378 alloc_init_section(unsigned long virt, unsigned long phys, int prot)
 379 {
 380         pmd_t *pmdp = pmd_off_k(virt);
 381
 382         if (virt & (1 << 20))
 383                 pmdp++;
 384
 385         *pmdp = __pmd(phys | prot);
 386         flush_pmd_entry(pmdp);
 387 }
 388
 389 /*
 390  * Create a SUPER SECTION PGD between VIRT and PHYS with protection PROT
 391  */
 392 static inline void
 393 alloc_init_supersection(unsigned long virt, unsigned long phys, int prot)
 394 {
 395         int i;
 396
 397         for (i = 0; i < 16; i += 1) {
 398                 alloc_init_section(virt, phys, prot | PMD_SECT_SUPER);
 399
 400                 virt += (PGDIR_SIZE / 2);
 401         }
 402 }
 403
 404 /*
 405  * Add a PAGE mapping between VIRT and PHYS in domain
 406  * DOMAIN with protection PROT.  Note that due to the
 407  * way we map the PTEs, we must allocate two PTE_SIZE'd
 408  * blocks - one for the Linux pte table, and one for
 409  * the hardware pte table.
 410  */
 411 static inline void
 412 alloc_init_page(unsigned long virt, unsigned long phys, unsigned int prot_l1, pgprot_t prot)
 413 {
 414         pmd_t *pmdp = pmd_off_k(virt);
 415         pte_t *ptep;
 416
 417         if (pmd_none(*pmdp)) {
 418                 ptep = alloc_bootmem_low_pages(2 * PTRS_PER_PTE *
 419                                                sizeof(pte_t));
 420
 421                 __pmd_populate(pmdp, __pa(ptep) | prot_l1);
 422         }
 423         ptep = pte_offset_kernel(pmdp, virt);
 424
 425         set_pte_ext(ptep, pfn_pte(phys >> PAGE_SHIFT, prot), 0);
 426 }
 427
 428 /*
 429  * Create the page directory entries and any necessary
 430  * page tables for the mapping specified by `md'.  We
 431  * are able to cope here with varying sizes and address
 432  * offsets, and we take full advantage of sections and
 433  * supersections.
 434  */
 435 void __init create_mapping(struct map_desc *md)
 436 {
 437         unsigned long virt, length;
 438         int prot_sect, prot_l1, domain;
 439         pgprot_t prot_pte;
 440         unsigned long off = (u32)__pfn_to_phys(md->pfn);
 441
 442         if (md->virtual != vectors_base() && md->virtual < TASK_SIZE) {
 443                 printk(KERN_WARNING "BUG: not creating mapping for "
 444                        "0x%08llx at 0x%08lx in user region\n",
 445                        __pfn_to_phys((u64)md->pfn), md->virtual);
 446                 return;
 447         }
 448
 449         if ((md->type == MT_DEVICE || md->type == MT_ROM) &&
 450             md->virtual >= PAGE_OFFSET && md->virtual < VMALLOC_END) {
 451                 printk(KERN_WARNING "BUG: mapping for 0x%08llx at 0x%08lx "
 452                        "overlaps vmalloc space\n",
 453                        __pfn_to_phys((u64)md->pfn), md->virtual);
 454         }
 455
 456         domain    = mem_types[md->type].domain;
 457         prot_pte  = __pgprot(mem_types[md->type].prot_pte);
 458         prot_l1   = mem_types[md->type].prot_l1 | PMD_DOMAIN(domain);
 459         prot_sect = mem_types[md->type].prot_sect | PMD_DOMAIN(domain);
 460
 461         /*
 462          * Catch 36-bit addresses
 463          */
 464         if(md->pfn >= 0x100000) {
 465                 if(domain) {
 466                         printk(KERN_ERR "MM: invalid domain in supersection "
 467                                 "mapping for 0x%08llx at 0x%08lx\n",
 468                                 __pfn_to_phys((u64)md->pfn), md->virtual);
 469                         return;
 470                 }
 471                 if((md->virtual | md->length | __pfn_to_phys(md->pfn))
 472                         & ~SUPERSECTION_MASK) {
 473                         printk(KERN_ERR "MM: cannot create mapping for "
 474                                 "0x%08llx at 0x%08lx invalid alignment\n",
 475                                 __pfn_to_phys((u64)md->pfn), md->virtual);
 476                         return;
 477                 }
 478
 479                 /*
 480                  * Shift bits [35:32] of address into bits [23:20] of PMD
 481                  * (See ARMv6 spec).
 482                  */
 483                 off |= (((md->pfn >> (32 - PAGE_SHIFT)) & 0xF) << 20);
 484         }
 485
 486         virt   = md->virtual;
 487         off   -= virt;
 488         length = md->length;
 489
 490         if (mem_types[md->type].prot_l1 == 0 &&
 491             (virt & 0xfffff || (virt + off) & 0xfffff || (virt + length) & 0xfffff)) {
 492                 printk(KERN_WARNING "BUG: map for 0x%08lx at 0x%08lx can not "
 493                        "be mapped using pages, ignoring.\n",
 494                        __pfn_to_phys(md->pfn), md->virtual);
 495                 return;
 496         }
 497
 498         while ((virt & 0xfffff || (virt + off) & 0xfffff) && length >= PAGE_SIZE) {
 499                 alloc_init_page(virt, virt + off, prot_l1, prot_pte);
 500
 501                 virt   += PAGE_SIZE;
 502                 length -= PAGE_SIZE;
 503         }
 504
 505         /* N.B. ARMv6 supersections are only defined to work with domain 0.
 506          *      Since domain assignments can in fact be arbitrary, the
 507          *      'domain == 0' check below is required to insure that ARMv6
 508          *      supersections are only allocated for domain 0 regardless
 509          *      of the actual domain assignments in use.
 510          */
 511         if ((cpu_architecture() >= CPU_ARCH_ARMv6 || cpu_is_xsc3())
 512                 && domain == 0) {
 513                 /*
 514                  * Align to supersection boundary if !high pages.
 515                  * High pages have already been checked for proper
 516                  * alignment above and they will fail the SUPSERSECTION_MASK
 517                  * check because of the way the address is encoded into
 518                  * offset.
 519                  */
 520                 if (md->pfn <= 0x100000) {
 521                         while ((virt & ~SUPERSECTION_MASK ||
 522                                 (virt + off) & ~SUPERSECTION_MASK) &&
 523                                 length >= (PGDIR_SIZE / 2)) {
 524                                 alloc_init_section(virt, virt + off, prot_sect);
 525
 526                                 virt   += (PGDIR_SIZE / 2);
 527                                 length -= (PGDIR_SIZE / 2);
 528                         }
 529                 }
 530
 531                 while (length >= SUPERSECTION_SIZE) {
 532                         alloc_init_supersection(virt, virt + off, prot_sect);
 533
 534                         virt   += SUPERSECTION_SIZE;
 535                         length -= SUPERSECTION_SIZE;
 536                 }
 537         }
 538
 539         /*
 540          * A section mapping covers half a "pgdir" entry.
 541          */
 542         while (length >= (PGDIR_SIZE / 2)) {
 543                 alloc_init_section(virt, virt + off, prot_sect);
 544
 545                 virt   += (PGDIR_SIZE / 2);
 546                 length -= (PGDIR_SIZE / 2);
 547         }
 548
 549         while (length >= PAGE_SIZE) {
 550                 alloc_init_page(virt, virt + off, prot_l1, prot_pte);
 551
 552                 virt   += PAGE_SIZE;
 553                 length -= PAGE_SIZE;
 554         }
 555 }
 556
 557 /*
 558  * Create the architecture specific mappings
 559  */
 560 void __init iotable_init(struct map_desc *io_desc, int nr)
 561 {
 562         int i;
 563
 564         for (i = 0; i < nr; i++)
 565                 create_mapping(io_desc + i);
 566 }
 567
 568 static inline void prepare_page_table(struct meminfo *mi)
 569 {
 570         unsigned long addr;
 571
 572         /*
 573          * Clear out all the mappings below the kernel image.
 574          */
 575         for (addr = 0; addr < MODULE_START; addr += PGDIR_SIZE)
 576                 pmd_clear(pmd_off_k(addr));
 577
 578 #ifdef CONFIG_XIP_KERNEL
 579         /* The XIP kernel is mapped in the module area -- skip over it */
 580         addr = ((unsigned long)&_etext + PGDIR_SIZE - 1) & PGDIR_MASK;
 581 #endif
 582         for ( ; addr < PAGE_OFFSET; addr += PGDIR_SIZE)
 583                 pmd_clear(pmd_off_k(addr));
 584
 585         /*
 586          * Clear out all the kernel space mappings, except for the first
 587          * memory bank, up to the end of the vmalloc region.
 588          */
 589         for (addr = __phys_to_virt(mi->bank[0].start + mi->bank[0].size);
 590              addr < VMALLOC_END; addr += PGDIR_SIZE)
 591                 pmd_clear(pmd_off_k(addr));
 592 }
 593
 594 /*
 595  * Reserve the various regions of node 0
 596  */
 597 void __init reserve_node_zero(pg_data_t *pgdat)
 598 {
 599         unsigned long res_size = 0;
 600
 601         /*
 602          * Register the kernel text and data with bootmem.
 603          * Note that this can only be in node 0.
 604          */
 605 #ifdef CONFIG_XIP_KERNEL
 606         reserve_bootmem_node(pgdat, __pa(&__data_start), &_end - &__data_start);
 607 #else
 608         reserve_bootmem_node(pgdat, __pa(&_stext), &_end - &_stext);
 609 #endif
 610
 611         /*
 612          * Reserve the page tables.  These are already in use,
 613          * and can only be in node 0.
 614          */
 615         reserve_bootmem_node(pgdat, __pa(swapper_pg_dir),
 616                              PTRS_PER_PGD * sizeof(pgd_t));
 617
 618         /*
 619          * Hmm... This should go elsewhere, but we really really need to
 620          * stop things allocating the low memory; ideally we need a better
 621          * implementation of GFP_DMA which does not assume that DMA-able
 622          * memory starts at zero.
 623          */
 624         if (machine_is_integrator() || machine_is_cintegrator())
 625                 res_size = __pa(swapper_pg_dir) - PHYS_OFFSET;
 626
 627         /*
 628          * These should likewise go elsewhere.  They pre-reserve the
 629          * screen memory region at the start of main system memory.
 630          */
 631         if (machine_is_edb7211())
 632                 res_size = 0x00020000;
 633         if (machine_is_p720t())
 634                 res_size = 0x00014000;
 635
 636         /* H1940 and RX3715 need to reserve this for suspend */
 637
 638         if (machine_is_h1940() || machine_is_rx3715()) {
 639                 reserve_bootmem_node(pgdat, 0x30003000, 0x1000);
 640                 reserve_bootmem_node(pgdat, 0x30081000, 0x1000);
 641         }
 642
 643 #ifdef CONFIG_SA1111
 644         /*
 645          * Because of the SA1111 DMA bug, we want to preserve our
 646          * precious DMA-able memory...
 647          */
 648         res_size = __pa(swapper_pg_dir) - PHYS_OFFSET;
 649 #endif
 650         if (res_size)
 651                 reserve_bootmem_node(pgdat, PHYS_OFFSET, res_size);
 652 }
 653
 654 /*
 655  * Set up device the mappings.  Since we clear out the page tables for all
 656  * mappings above VMALLOC_END, we will remove any debug device mappings.
 657  * This means you have to be careful how you debug this function, or any
 658  * called function.  This means you can't use any function or debugging
 659  * method which may touch any device, otherwise the kernel _will_ crash.
 660  */
 661 static void __init devicemaps_init(struct machine_desc *mdesc)
 662 {
 663         struct map_desc map;
 664         unsigned long addr;
 665         void *vectors;
 666
 667         /*
 668          * Allocate the vector page early.
 669          */
 670         vectors = alloc_bootmem_low_pages(PAGE_SIZE);
 671         BUG_ON(!vectors);
 672
 673         for (addr = VMALLOC_END; addr; addr += PGDIR_SIZE)
 674                 pmd_clear(pmd_off_k(addr));
 675
 676         /*
 677          * Map the kernel if it is XIP.
 678          * It is always first in the modulearea.
 679          */
 680 #ifdef CONFIG_XIP_KERNEL
 681         map.pfn = __phys_to_pfn(CONFIG_XIP_PHYS_ADDR & SECTION_MASK);
 682         map.virtual = MODULE_START;
 683         map.length = ((unsigned long)&_etext - map.virtual + ~SECTION_MASK) & SECTION_MASK;
 684         map.type = MT_ROM;
 685         create_mapping(&map);
 686 #endif
 687
 688         /*
 689          * Map the cache flushing regions.
 690          */
 691 #ifdef FLUSH_BASE
 692         map.pfn = __phys_to_pfn(FLUSH_BASE_PHYS);
 693         map.virtual = FLUSH_BASE;
 694         map.length = SZ_1M;
 695         map.type = MT_CACHECLEAN;
 696         create_mapping(&map);
 697 #endif
 698 #ifdef FLUSH_BASE_MINICACHE
 699         map.pfn = __phys_to_pfn(FLUSH_BASE_PHYS + SZ_1M);
 700         map.virtual = FLUSH_BASE_MINICACHE;
 701         map.length = SZ_1M;
 702         map.type = MT_MINICLEAN;
 703         create_mapping(&map);
 704 #endif
 705
 706         /*
 707          * Create a mapping for the machine vectors at the high-vectors
 708          * location (0xffff0000).  If we aren't using high-vectors, also
 709          * create a mapping at the low-vectors virtual address.
 710          */
 711         map.pfn = __phys_to_pfn(virt_to_phys(vectors));
 712         map.virtual = 0xffff0000;
 713         map.length = PAGE_SIZE;
 714         map.type = MT_HIGH_VECTORS;
 715         create_mapping(&map);
 716
 717         if (!vectors_high()) {
 718                 map.virtual = 0;
 719                 map.type = MT_LOW_VECTORS;
 720                 create_mapping(&map);
 721         }
 722
 723         /*
 724          * Ask the machine support to map in the statically mapped devices.
 725          */
 726         if (mdesc->map_io)
 727                 mdesc->map_io();
 728
 729         /*
 730          * Finally flush the caches and tlb to ensure that we're in a
 731          * consistent state wrt the writebuffer.  This also ensures that
 732          * any write-allocated cache lines in the vector page are written
 733          * back.  After this point, we can start to touch devices again.
 734          */
 735         local_flush_tlb_all();
 736         flush_cache_all();
 737 }
 738
 739 /*
 740  * paging_init() sets up the page tables, initialises the zone memory
 741  * maps, and sets up the zero page, bad page and bad page tables.
 742  */
 743 void __init paging_init(struct meminfo *mi, struct machine_desc *mdesc)
 744 {
 745         void *zero_page;
 746
 747         build_mem_type_table();
 748         prepare_page_table(mi);
 749         bootmem_init(mi);
 750         devicemaps_init(mdesc);
 751
 752         top_pmd = pmd_off_k(0xffff0000);
 753
 754         /*
 755          * allocate the zero page.  Note that we count on this going ok.
 756          */
 757         zero_page = alloc_bootmem_low_pages(PAGE_SIZE);
 758         memzero(zero_page, PAGE_SIZE);
 759         empty_zero_page = virt_to_page(zero_page);
 760         flush_dcache_page(empty_zero_page);
 761 }
 762
 763 /*
 764  * In order to soft-boot, we need to insert a 1:1 mapping in place of
 765  * the user-mode pages.  This will then ensure that we have predictable
 766  * results when turning the mmu off
 767  */
 768 void setup_mm_for_reboot(char mode)
 769 {
 770         unsigned long base_pmdval;
 771         pgd_t *pgd;
 772         int i;
 773
 774         if (current->mm && current->mm->pgd)
 775                 pgd = current->mm->pgd;
 776         else
 777                 pgd = init_mm.pgd;
 778
 779         base_pmdval = PMD_SECT_AP_WRITE | PMD_SECT_AP_READ | PMD_TYPE_SECT;
 780         if (cpu_architecture() <= CPU_ARCH_ARMv5TEJ && !cpu_is_xscale())
 781                 base_pmdval |= PMD_BIT4;
 782
 783         for (i = 0; i < FIRST_USER_PGD_NR + USER_PTRS_PER_PGD; i++, pgd++) {
 784                 unsigned long pmdval = (i << PGDIR_SHIFT) | base_pmdval;
 785                 pmd_t *pmd;
 786
 787                 pmd = pmd_off(pgd, i << PGDIR_SHIFT);
 788                 pmd[0] = __pmd(pmdval);
 789                 pmd[1] = __pmd(pmdval + (1 << (PGDIR_SHIFT - 1)));
 790                 flush_pmd_entry(pmd);
 791         }
 792 }