arch/m68k/mm/motorola.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * linux/arch/m68k/mm/motorola.c
   4  *
   5  * Routines specific to the Motorola MMU, originally from:
   6  * linux/arch/m68k/init.c
   7  * which are Copyright (C) 1995 Hamish Macdonald
   8  *
   9  * Moved 8/20/1999 Sam Creasey
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/signal.h>
  14 #include <linux/sched.h>
  15 #include <linux/mm.h>
  16 #include <linux/swap.h>
  17 #include <linux/kernel.h>
  18 #include <linux/string.h>
  19 #include <linux/types.h>
  20 #include <linux/init.h>
  21 #include <linux/memblock.h>
  22 #include <linux/gfp.h>
  23
  24 #include <asm/setup.h>
  25 #include <linux/uaccess.h>
  26 #include <asm/page.h>
  27 #include <asm/pgalloc.h>
  28 #include <asm/machdep.h>
  29 #include <asm/io.h>
  30 #include <asm/dma.h>
  31 #ifdef CONFIG_ATARI
  32 #include <asm/atari_stram.h>
  33 #endif
  34 #include <asm/sections.h>
  35
  36 #undef DEBUG
  37
  38 #ifndef mm_cachebits
  39 /*
  40  * Bits to add to page descriptors for "normal" caching mode.
  41  * For 68020/030 this is 0.
  42  * For 68040, this is _PAGE_CACHE040 (cachable, copyback)
  43  */
  44 unsigned long mm_cachebits;
  45 EXPORT_SYMBOL(mm_cachebits);
  46 #endif
  47
  48 /* Prior to calling these routines, the page should have been flushed
  49  * from both the cache and ATC, or the CPU might not notice that the
  50  * cache setting for the page has been changed. -jskov
  51  */
  52 static inline void nocache_page(void *vaddr)
  53 {
  54         unsigned long addr = (unsigned long)vaddr;
  55
  56         if (CPU_IS_040_OR_060) {
  57                 pgd_t *dir;
  58                 p4d_t *p4dp;
  59                 pud_t *pudp;
  60                 pmd_t *pmdp;
  61                 pte_t *ptep;
  62
  63                 dir = pgd_offset_k(addr);
  64                 p4dp = p4d_offset(dir, addr);
  65                 pudp = pud_offset(p4dp, addr);
  66                 pmdp = pmd_offset(pudp, addr);
  67                 ptep = pte_offset_kernel(pmdp, addr);
  68                 *ptep = pte_mknocache(*ptep);
  69         }
  70 }
  71
  72 static inline void cache_page(void *vaddr)
  73 {
  74         unsigned long addr = (unsigned long)vaddr;
  75
  76         if (CPU_IS_040_OR_060) {
  77                 pgd_t *dir;
  78                 p4d_t *p4dp;
  79                 pud_t *pudp;
  80                 pmd_t *pmdp;
  81                 pte_t *ptep;
  82
  83                 dir = pgd_offset_k(addr);
  84                 p4dp = p4d_offset(dir, addr);
  85                 pudp = pud_offset(p4dp, addr);
  86                 pmdp = pmd_offset(pudp, addr);
  87                 ptep = pte_offset_kernel(pmdp, addr);
  88                 *ptep = pte_mkcache(*ptep);
  89         }
  90 }
  91
  92 /*
  93  * Motorola 680x0 user's manual recommends using uncached memory for address
  94  * translation tables.
  95  *
  96  * Seeing how the MMU can be external on (some of) these chips, that seems like
  97  * a very important recommendation to follow. Provide some helpers to combat
  98  * 'variation' amongst the users of this.
  99  */
 100
 101 void mmu_page_ctor(void *page)
 102 {
 103         __flush_page_to_ram(page);
 104         flush_tlb_kernel_page(page);
 105         nocache_page(page);
 106 }
 107
 108 void mmu_page_dtor(void *page)
 109 {
 110         cache_page(page);
 111 }
 112
 113 /* ++andreas: {get,free}_pointer_table rewritten to use unused fields from
 114    struct page instead of separately kmalloced struct.  Stolen from
 115    arch/sparc/mm/srmmu.c ... */
 116
 117 typedef struct list_head ptable_desc;
 118
 119 static struct list_head ptable_list[2] = {
 120         LIST_HEAD_INIT(ptable_list[0]),
 121         LIST_HEAD_INIT(ptable_list[1]),
 122 };
 123
 124 #define PD_PTABLE(page) ((ptable_desc *)&(virt_to_page(page)->lru))
 125 #define PD_PAGE(ptable) (list_entry(ptable, struct page, lru))
 126 #define PD_MARKBITS(dp) (*(unsigned int *)&PD_PAGE(dp)->index)
 127
 128 static const int ptable_shift[2] = {
 129         7+2, /* PGD, PMD */
 130         6+2, /* PTE */
 131 };
 132
 133 #define ptable_size(type) (1U << ptable_shift[type])
 134 #define ptable_mask(type) ((1U << (PAGE_SIZE / ptable_size(type))) - 1)
 135
 136 void __init init_pointer_table(void *table, int type)
 137 {
 138         ptable_desc *dp;
 139         unsigned long ptable = (unsigned long)table;
 140         unsigned long page = ptable & PAGE_MASK;
 141         unsigned int mask = 1U << ((ptable - page)/ptable_size(type));
 142
 143         dp = PD_PTABLE(page);
 144         if (!(PD_MARKBITS(dp) & mask)) {
 145                 PD_MARKBITS(dp) = ptable_mask(type);
 146                 list_add(dp, &ptable_list[type]);
 147         }
 148
 149         PD_MARKBITS(dp) &= ~mask;
 150         pr_debug("init_pointer_table: %lx, %x\n", ptable, PD_MARKBITS(dp));
 151
 152         /* unreserve the page so it's possible to free that page */
 153         __ClearPageReserved(PD_PAGE(dp));
 154         init_page_count(PD_PAGE(dp));
 155
 156         return;
 157 }
 158
 159 void *get_pointer_table(int type)
 160 {
 161         ptable_desc *dp = ptable_list[type].next;
 162         unsigned int mask = list_empty(&ptable_list[type]) ? 0 : PD_MARKBITS(dp);
 163         unsigned int tmp, off;
 164
 165         /*
 166          * For a pointer table for a user process address space, a
 167          * table is taken from a page allocated for the purpose.  Each
 168          * page can hold 8 pointer tables.  The page is remapped in
 169          * virtual address space to be noncacheable.
 170          */
 171         if (mask == 0) {
 172                 void *page;
 173                 ptable_desc *new;
 174
 175                 if (!(page = (void *)get_zeroed_page(GFP_KERNEL)))
 176                         return NULL;
 177
 178                 if (type == TABLE_PTE) {
 179                         /*
 180                          * m68k doesn't have SPLIT_PTE_PTLOCKS for not having
 181                          * SMP.
 182                          */
 183                         pgtable_pte_page_ctor(virt_to_page(page));
 184                 }
 185
 186                 mmu_page_ctor(page);
 187
 188                 new = PD_PTABLE(page);
 189                 PD_MARKBITS(new) = ptable_mask(type) - 1;
 190                 list_add_tail(new, dp);
 191
 192                 return (pmd_t *)page;
 193         }
 194
 195         for (tmp = 1, off = 0; (mask & tmp) == 0; tmp <<= 1, off += ptable_size(type))
 196                 ;
 197         PD_MARKBITS(dp) = mask & ~tmp;
 198         if (!PD_MARKBITS(dp)) {
 199                 /* move to end of list */
 200                 list_move_tail(dp, &ptable_list[type]);
 201         }
 202         return page_address(PD_PAGE(dp)) + off;
 203 }
 204
 205 int free_pointer_table(void *table, int type)
 206 {
 207         ptable_desc *dp;
 208         unsigned long ptable = (unsigned long)table;
 209         unsigned long page = ptable & PAGE_MASK;
 210         unsigned int mask = 1U << ((ptable - page)/ptable_size(type));
 211
 212         dp = PD_PTABLE(page);
 213         if (PD_MARKBITS (dp) & mask)
 214                 panic ("table already free!");
 215
 216         PD_MARKBITS (dp) |= mask;
 217
 218         if (PD_MARKBITS(dp) == ptable_mask(type)) {
 219                 /* all tables in page are free, free page */
 220                 list_del(dp);
 221                 mmu_page_dtor((void *)page);
 222                 if (type == TABLE_PTE)
 223                         pgtable_pte_page_dtor(virt_to_page(page));
 224                 free_page (page);
 225                 return 1;
 226         } else if (ptable_list[type].next != dp) {
 227                 /*
 228                  * move this descriptor to the front of the list, since
 229                  * it has one or more free tables.
 230                  */
 231                 list_move(dp, &ptable_list[type]);
 232         }
 233         return 0;
 234 }
 235
 236 /* size of memory already mapped in head.S */
 237 extern __initdata unsigned long m68k_init_mapped_size;
 238
 239 extern unsigned long availmem;
 240
 241 static pte_t *last_pte_table __initdata = NULL;
 242
 243 static pte_t * __init kernel_page_table(void)
 244 {
 245         pte_t *pte_table = last_pte_table;
 246
 247         if (((unsigned long)last_pte_table & ~PAGE_MASK) == 0) {
 248                 pte_table = (pte_t *)memblock_alloc_low(PAGE_SIZE, PAGE_SIZE);
 249                 if (!pte_table) {
 250                         panic("%s: Failed to allocate %lu bytes align=%lx\n",
 251                                         __func__, PAGE_SIZE, PAGE_SIZE);
 252                 }
 253
 254                 clear_page(pte_table);
 255                 mmu_page_ctor(pte_table);
 256
 257                 last_pte_table = pte_table;
 258         }
 259
 260         last_pte_table += PTRS_PER_PTE;
 261
 262         return pte_table;
 263 }
 264
 265 static pmd_t *last_pmd_table __initdata = NULL;
 266
 267 static pmd_t * __init kernel_ptr_table(void)
 268 {
 269         if (!last_pmd_table) {
 270                 unsigned long pmd, last;
 271                 int i;
 272
 273                 /* Find the last ptr table that was used in head.S and
 274                  * reuse the remaining space in that page for further
 275                  * ptr tables.
 276                  */
 277                 last = (unsigned long)kernel_pg_dir;
 278                 for (i = 0; i < PTRS_PER_PGD; i++) {
 279                         pud_t *pud = (pud_t *)(&kernel_pg_dir[i]);
 280
 281                         if (!pud_present(*pud))
 282                                 continue;
 283                         pmd = pgd_page_vaddr(kernel_pg_dir[i]);
 284                         if (pmd > last)
 285                                 last = pmd;
 286                 }
 287
 288                 last_pmd_table = (pmd_t *)last;
 289 #ifdef DEBUG
 290                 printk("kernel_ptr_init: %p\n", last_pmd_table);
 291 #endif
 292         }
 293
 294         last_pmd_table += PTRS_PER_PMD;
 295         if (((unsigned long)last_pmd_table & ~PAGE_MASK) == 0) {
 296                 last_pmd_table = (pmd_t *)memblock_alloc_low(PAGE_SIZE,
 297                                                            PAGE_SIZE);
 298                 if (!last_pmd_table)
 299                         panic("%s: Failed to allocate %lu bytes align=%lx\n",
 300                               __func__, PAGE_SIZE, PAGE_SIZE);
 301
 302                 clear_page(last_pmd_table);
 303                 mmu_page_ctor(last_pmd_table);
 304         }
 305
 306         return last_pmd_table;
 307 }
 308
 309 static void __init map_node(int node)
 310 {
 311         unsigned long physaddr, virtaddr, size;
 312         pgd_t *pgd_dir;
 313         p4d_t *p4d_dir;
 314         pud_t *pud_dir;
 315         pmd_t *pmd_dir;
 316         pte_t *pte_dir;
 317
 318         size = m68k_memory[node].size;
 319         physaddr = m68k_memory[node].addr;
 320         virtaddr = (unsigned long)phys_to_virt(physaddr);
 321         physaddr |= m68k_supervisor_cachemode |
 322                     _PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_DIRTY;
 323         if (CPU_IS_040_OR_060)
 324                 physaddr |= _PAGE_GLOBAL040;
 325
 326         while (size > 0) {
 327 #ifdef DEBUG
 328                 if (!(virtaddr & (PMD_SIZE-1)))
 329                         printk ("\npa=%#lx va=%#lx ", physaddr & PAGE_MASK,
 330                                 virtaddr);
 331 #endif
 332                 pgd_dir = pgd_offset_k(virtaddr);
 333                 if (virtaddr && CPU_IS_020_OR_030) {
 334                         if (!(virtaddr & (PGDIR_SIZE-1)) &&
 335                             size >= PGDIR_SIZE) {
 336 #ifdef DEBUG
 337                                 printk ("[very early term]");
 338 #endif
 339                                 pgd_val(*pgd_dir) = physaddr;
 340                                 size -= PGDIR_SIZE;
 341                                 virtaddr += PGDIR_SIZE;
 342                                 physaddr += PGDIR_SIZE;
 343                                 continue;
 344                         }
 345                 }
 346                 p4d_dir = p4d_offset(pgd_dir, virtaddr);
 347                 pud_dir = pud_offset(p4d_dir, virtaddr);
 348                 if (!pud_present(*pud_dir)) {
 349                         pmd_dir = kernel_ptr_table();
 350 #ifdef DEBUG
 351                         printk ("[new pointer %p]", pmd_dir);
 352 #endif
 353                         pud_set(pud_dir, pmd_dir);
 354                 } else
 355                         pmd_dir = pmd_offset(pud_dir, virtaddr);
 356
 357                 if (CPU_IS_020_OR_030) {
 358                         if (virtaddr) {
 359 #ifdef DEBUG
 360                                 printk ("[early term]");
 361 #endif
 362                                 pmd_val(*pmd_dir) = physaddr;
 363                                 physaddr += PMD_SIZE;
 364                         } else {
 365                                 int i;
 366 #ifdef DEBUG
 367                                 printk ("[zero map]");
 368 #endif
 369                                 pte_dir = kernel_page_table();
 370                                 pmd_set(pmd_dir, pte_dir);
 371
 372                                 pte_val(*pte_dir++) = 0;
 373                                 physaddr += PAGE_SIZE;
 374                                 for (i = 1; i < PTRS_PER_PTE; physaddr += PAGE_SIZE, i++)
 375                                         pte_val(*pte_dir++) = physaddr;
 376                         }
 377                         size -= PMD_SIZE;
 378                         virtaddr += PMD_SIZE;
 379                 } else {
 380                         if (!pmd_present(*pmd_dir)) {
 381 #ifdef DEBUG
 382                                 printk ("[new table]");
 383 #endif
 384                                 pte_dir = kernel_page_table();
 385                                 pmd_set(pmd_dir, pte_dir);
 386                         }
 387                         pte_dir = pte_offset_kernel(pmd_dir, virtaddr);
 388
 389                         if (virtaddr) {
 390                                 if (!pte_present(*pte_dir))
 391                                         pte_val(*pte_dir) = physaddr;
 392                         } else
 393                                 pte_val(*pte_dir) = 0;
 394                         size -= PAGE_SIZE;
 395                         virtaddr += PAGE_SIZE;
 396                         physaddr += PAGE_SIZE;
 397                 }
 398
 399         }
 400 #ifdef DEBUG
 401         printk("\n");
 402 #endif
 403 }
 404
 405 /*
 406  * paging_init() continues the virtual memory environment setup which
 407  * was begun by the code in arch/head.S.
 408  */
 409 void __init paging_init(void)
 410 {
 411         unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0, };
 412         unsigned long min_addr, max_addr;
 413         unsigned long addr;
 414         int i;
 415
 416 #ifdef DEBUG
 417         printk ("start of paging_init (%p, %lx)\n", kernel_pg_dir, availmem);
 418 #endif
 419
 420         /* Fix the cache mode in the page descriptors for the 680[46]0.  */
 421         if (CPU_IS_040_OR_060) {
 422                 int i;
 423 #ifndef mm_cachebits
 424                 mm_cachebits = _PAGE_CACHE040;
 425 #endif
 426                 for (i = 0; i < 16; i++)
 427                         pgprot_val(protection_map[i]) |= _PAGE_CACHE040;
 428         }
 429
 430         min_addr = m68k_memory[0].addr;
 431         max_addr = min_addr + m68k_memory[0].size;
 432         memblock_add_node(m68k_memory[0].addr, m68k_memory[0].size, 0);
 433         for (i = 1; i < m68k_num_memory;) {
 434                 if (m68k_memory[i].addr < min_addr) {
 435                         printk("Ignoring memory chunk at 0x%lx:0x%lx before the first chunk\n",
 436                                 m68k_memory[i].addr, m68k_memory[i].size);
 437                         printk("Fix your bootloader or use a memfile to make use of this area!\n");
 438                         m68k_num_memory--;
 439                         memmove(m68k_memory + i, m68k_memory + i + 1,
 440                                 (m68k_num_memory - i) * sizeof(struct m68k_mem_info));
 441                         continue;
 442                 }
 443                 memblock_add_node(m68k_memory[i].addr, m68k_memory[i].size, i);
 444                 addr = m68k_memory[i].addr + m68k_memory[i].size;
 445                 if (addr > max_addr)
 446                         max_addr = addr;
 447                 i++;
 448         }
 449         m68k_memoffset = min_addr - PAGE_OFFSET;
 450         m68k_virt_to_node_shift = fls(max_addr - min_addr - 1) - 6;
 451
 452         module_fixup(NULL, __start_fixup, __stop_fixup);
 453         flush_icache();
 454
 455         high_memory = phys_to_virt(max_addr);
 456
 457         min_low_pfn = availmem >> PAGE_SHIFT;
 458         max_pfn = max_low_pfn = max_addr >> PAGE_SHIFT;
 459
 460         /* Reserve kernel text/data/bss and the memory allocated in head.S */
 461         memblock_reserve(m68k_memory[0].addr, availmem - m68k_memory[0].addr);
 462
 463         /*
 464          * Map the physical memory available into the kernel virtual
 465          * address space. Make sure memblock will not try to allocate
 466          * pages beyond the memory we already mapped in head.S
 467          */
 468         memblock_set_bottom_up(true);
 469
 470         for (i = 0; i < m68k_num_memory; i++) {
 471                 m68k_setup_node(i);
 472                 map_node(i);
 473         }
 474
 475         flush_tlb_all();
 476
 477         /*
 478          * initialize the bad page table and bad page to point
 479          * to a couple of allocated pages
 480          */
 481         empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
 482         if (!empty_zero_page)
 483                 panic("%s: Failed to allocate %lu bytes align=0x%lx\n",
 484                       __func__, PAGE_SIZE, PAGE_SIZE);
 485
 486         /*
 487          * Set up SFC/DFC registers
 488          */
 489         set_fs(KERNEL_DS);
 490
 491 #ifdef DEBUG
 492         printk ("before free_area_init\n");
 493 #endif
 494         for (i = 0; i < m68k_num_memory; i++)
 495                 if (node_present_pages(i))
 496                         node_set_state(i, N_NORMAL_MEMORY);
 497
 498         max_zone_pfn[ZONE_DMA] = memblock_end_of_DRAM();
 499         free_area_init(max_zone_pfn);
 500 }