arch/metag/mm/mmu-meta1.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 2005,2006,2007,2008,2009 Imagination Technologies
   4  *
   5  * Meta 1 MMU handling code.
   6  *
   7  */
   8
   9 #include <linux/sched.h>
  10 #include <linux/mm.h>
  11 #include <linux/io.h>
  12
  13 #include <asm/mmu.h>
  14
  15 #define DM3_BASE (LINSYSDIRECT_BASE + (MMCU_DIRECTMAPn_ADDR_SCALE * 3))
  16
  17 /*
  18  * This contains the physical address of the top level 2k pgd table.
  19  */
  20 static unsigned long mmu_base_phys;
  21
  22 /*
  23  * Given a physical address, return a mapped virtual address that can be used
  24  * to access that location.
  25  * In practice, we use the DirectMap region to make this happen.
  26  */
  27 static unsigned long map_addr(unsigned long phys)
  28 {
  29         static unsigned long dm_base = 0xFFFFFFFF;
  30         int offset;
  31
  32         offset = phys - dm_base;
  33
  34         /* Are we in the current map range ? */
  35         if ((offset < 0) || (offset >= MMCU_DIRECTMAPn_ADDR_SCALE)) {
  36                 /* Calculate new DM area */
  37                 dm_base = phys & ~(MMCU_DIRECTMAPn_ADDR_SCALE - 1);
  38
  39                 /* Actually map it in! */
  40                 metag_out32(dm_base, MMCU_DIRECTMAP3_ADDR);
  41
  42                 /* And calculate how far into that area our reference is */
  43                 offset = phys - dm_base;
  44         }
  45
  46         return DM3_BASE + offset;
  47 }
  48
  49 /*
  50  * Return the physical address of the base of our pgd table.
  51  */
  52 static inline unsigned long __get_mmu_base(void)
  53 {
  54         unsigned long base_phys;
  55         unsigned int stride;
  56
  57         if (is_global_space(PAGE_OFFSET))
  58                 stride = 4;
  59         else
  60                 stride = hard_processor_id();   /* [0..3] */
  61
  62         base_phys = metag_in32(MMCU_TABLE_PHYS_ADDR);
  63         base_phys += (0x800 * stride);
  64
  65         return base_phys;
  66 }
  67
  68 /* Given a virtual address, return the virtual address of the relevant pgd */
  69 static unsigned long pgd_entry_addr(unsigned long virt)
  70 {
  71         unsigned long pgd_phys;
  72         unsigned long pgd_virt;
  73
  74         if (!mmu_base_phys)
  75                 mmu_base_phys = __get_mmu_base();
  76
  77         /*
  78          * Are we trying to map a global address.  If so, then index
  79          * the global pgd table instead of our local one.
  80          */
  81         if (is_global_space(virt)) {
  82                 /* Scale into 2gig map */
  83                 virt &= ~0x80000000;
  84         }
  85
  86         /* Base of the pgd table plus our 4Meg entry, 4bytes each */
  87         pgd_phys = mmu_base_phys + ((virt >> PGDIR_SHIFT) * 4);
  88
  89         pgd_virt = map_addr(pgd_phys);
  90
  91         return pgd_virt;
  92 }
  93
  94 /* Given a virtual address, return the virtual address of the relevant pte */
  95 static unsigned long pgtable_entry_addr(unsigned long virt)
  96 {
  97         unsigned long pgtable_phys;
  98         unsigned long pgtable_virt, pte_virt;
  99
 100         /* Find the physical address of the 4MB page table*/
 101         pgtable_phys = metag_in32(pgd_entry_addr(virt)) & MMCU_ENTRY_ADDR_BITS;
 102
 103         /* Map it to a virtual address */
 104         pgtable_virt = map_addr(pgtable_phys);
 105
 106         /* And index into it for our pte */
 107         pte_virt = pgtable_virt + ((virt >> PAGE_SHIFT) & 0x3FF) * 4;
 108
 109         return pte_virt;
 110 }
 111
 112 unsigned long mmu_read_first_level_page(unsigned long vaddr)
 113 {
 114         return metag_in32(pgd_entry_addr(vaddr));
 115 }
 116
 117 unsigned long mmu_read_second_level_page(unsigned long vaddr)
 118 {
 119         return metag_in32(pgtable_entry_addr(vaddr));
 120 }
 121
 122 unsigned long mmu_get_base(void)
 123 {
 124         static unsigned long __base;
 125
 126         /* Find the base of our MMU pgd table */
 127         if (!__base)
 128                 __base = pgd_entry_addr(0);
 129
 130         return __base;
 131 }
 132
 133 void __init mmu_init(unsigned long mem_end)
 134 {
 135         unsigned long entry, addr;
 136         pgd_t *p_swapper_pg_dir;
 137
 138         /*
 139          * Now copy over any MMU pgd entries already in the mmu page tables
 140          * over to our root init process (swapper_pg_dir) map.  This map is
 141          * then inherited by all other processes, which means all processes
 142          * inherit a map of the kernel space.
 143          */
 144         addr = PAGE_OFFSET;
 145         entry = pgd_index(PAGE_OFFSET);
 146         p_swapper_pg_dir = pgd_offset_k(0) + entry;
 147
 148         while (addr <= META_MEMORY_LIMIT) {
 149                 unsigned long pgd_entry;
 150                 /* copy over the current MMU value */
 151                 pgd_entry = mmu_read_first_level_page(addr);
 152                 pgd_val(*p_swapper_pg_dir) = pgd_entry;
 153
 154                 p_swapper_pg_dir++;
 155                 addr += PGDIR_SIZE;
 156         }
 157 }