arch/arm/mm/mm-armo.c

   1 /*
   2  *  linux/arch/arm/mm/mm-armo.c
   3  *
   4  *  Copyright (C) 1998-2000 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  *  Page table sludge for older ARM processor architectures.
  11  */
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/init.h>
  15 #include <linux/bootmem.h>
  16
  17 #include <asm/pgtable.h>
  18 #include <asm/pgalloc.h>
  19 #include <asm/page.h>
  20 #include <asm/arch/memory.h>
  21
  22 #include <asm/mach/map.h>
  23
  24 #define MEMC_TABLE_SIZE (256*sizeof(unsigned long))
  25 #define PGD_TABLE_SIZE  (PTRS_PER_PGD * BYTES_PER_PTR)
  26
  27 int page_nr;
  28
  29 extern unsigned long get_page_2k(int prio);
  30 extern void free_page_2k(unsigned long);
  31 extern pte_t *get_bad_pte_table(void);
  32
  33 /*
  34  * Allocate a page table.  Note that we place the MEMC
  35  * table before the page directory.  This means we can
  36  * easily get to both tightly-associated data structures
  37  * with a single pointer.
  38  *
  39  * We actually only need 1152 bytes, 896 bytes is wasted.
  40  * We could try to fit 7 PTEs into that slot somehow.
  41  */
  42 static inline void *alloc_pgd_table(int priority)
  43 {
  44         unsigned long pg2k;
  45
  46         pg2k = get_page_2k(priority);
  47         if (pg2k)
  48                 pg2k += MEMC_TABLE_SIZE;
  49
  50         return (void *)pg2k;
  51 }
  52
  53 void free_pgd_slow(pgd_t *pgd)
  54 {
  55         unsigned long tbl = (unsigned long)pgd;
  56
  57         tbl -= MEMC_TABLE_SIZE;
  58         free_page_2k(tbl);
  59 }
  60
  61 /*
  62  * FIXME: the following over-allocates by 1600%
  63  */
  64 static inline void *alloc_pte_table(int size, int prio)
  65 {
  66         if (size != 128)
  67                 printk("invalid table size\n");
  68         return (void *)get_page_2k(prio);
  69 }
  70
  71 void free_pte_slow(pte_t *pte)
  72 {
  73         unsigned long tbl = (unsigned long)pte;
  74         free_page_2k(tbl);
  75 }
  76
  77 pgd_t *get_pgd_slow(void)
  78 {
  79         pgd_t *pgd = (pgd_t *)alloc_pgd_table(GFP_KERNEL);
  80         pmd_t *new_pmd;
  81
  82         if (pgd) {
  83                 pgd_t *init = pgd_offset(&init_mm, 0);
  84
  85                 memzero(pgd, USER_PTRS_PER_PGD * sizeof(pgd_t));
  86                 memcpy(pgd + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
  87                         (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
  88
  89                 /*
  90                  * On ARM, first page must always be allocated
  91                  */
  92                 if (!pmd_alloc(pgd, 0))
  93                         goto nomem;
  94                 else {
  95                         pmd_t *old_pmd = pmd_offset(init, 0);
  96                         new_pmd = pmd_offset(pgd, 0);
  97
  98                         if (!pte_alloc(new_pmd, 0))
  99                                 goto nomem_pmd;
 100                         else {
 101                                 pte_t *new_pte = pte_offset(new_pmd, 0);
 102                                 pte_t *old_pte = pte_offset(old_pmd, 0);
 103
 104                                 set_pte (new_pte, *old_pte);
 105                         }
 106                 }
 107                 /* update MEMC tables */
 108                 cpu_memc_update_all(pgd);
 109         }
 110         return pgd;
 111
 112 nomem_pmd:
 113         pmd_free(new_pmd);
 114 nomem:
 115         free_pgd_slow(pgd);
 116         return NULL;
 117 }
 118
 119 pte_t *get_pte_slow(pmd_t *pmd, unsigned long offset)
 120 {
 121         pte_t *pte;
 122
 123         pte = (pte_t *)alloc_pte_table(PTRS_PER_PTE * sizeof(pte_t), GFP_KERNEL);
 124         if (pmd_none(*pmd)) {
 125                 if (pte) {
 126                         memzero(pte, PTRS_PER_PTE * sizeof(pte_t));
 127                         set_pmd(pmd, mk_user_pmd(pte));
 128                         return pte + offset;
 129                 }
 130                 set_pmd(pmd, mk_user_pmd(get_bad_pte_table()));
 131                 return NULL;
 132         }
 133         free_pte_slow(pte);
 134         if (pmd_bad(*pmd)) {
 135                 __handle_bad_pmd(pmd);
 136                 return NULL;
 137         }
 138         return (pte_t *) pmd_page(*pmd) + offset;
 139 }
 140
 141 /*
 142  * No special code is required here.
 143  */
 144 void setup_mm_for_reboot(char mode)
 145 {
 146 }
 147
 148 /*
 149  * This contains the code to setup the memory map on an ARM2/ARM250/ARM3
 150  * machine. This is both processor & architecture specific, and requires
 151  * some more work to get it to fit into our separate processor and
 152  * architecture structure.
 153  */
 154 void __init memtable_init(struct meminfo *mi)
 155 {
 156         pte_t *pte;
 157         int i;
 158
 159         page_nr = max_low_pfn;
 160
 161         pte = alloc_bootmem_low_pages(PTRS_PER_PTE * sizeof(pte_t));
 162         pte[0] = mk_pte_phys(PAGE_OFFSET + 491520, PAGE_READONLY);
 163         set_pmd(pmd_offset(swapper_pg_dir, 0), mk_kernel_pmd(pte));
 164
 165         for (i = 1; i < PTRS_PER_PGD; i++)
 166                 pgd_val(swapper_pg_dir[i]) = 0;
 167 }
 168
 169 void __init iotable_init(struct map_desc *io_desc)
 170 {
 171         /* nothing to do */
 172 }
 173
 174 /*
 175  * We never have holes in the memmap
 176  */
 177 void __init create_memmap_holes(struct meminfo *mi)
 178 {
 179 }