arch/mips/fw/arc/memory.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * memory.c: PROM library functions for acquiring/using memory descriptors
   4  *           given to us from the ARCS firmware.
   5  *
   6  * Copyright (C) 1996 by David S. Miller
   7  * Copyright (C) 1999, 2000, 2001 by Ralf Baechle
   8  * Copyright (C) 1999, 2000 by Silicon Graphics, Inc.
   9  *
  10  * PROM library functions for acquiring/using memory descriptors given to us
  11  * from the ARCS firmware.  This is only used when CONFIG_ARC_MEMORY is set
  12  * because on some machines like SGI IP27 the ARC memory configuration data
  13  * completely bogus and alternate easier to use mechanisms are available.
  14  */
  15 #include <linux/init.h>
  16 #include <linux/kernel.h>
  17 #include <linux/types.h>
  18 #include <linux/sched.h>
  19 #include <linux/mm.h>
  20 #include <linux/memblock.h>
  21 #include <linux/swap.h>
  22
  23 #include <asm/sgialib.h>
  24 #include <asm/page.h>
  25 #include <asm/bootinfo.h>
  26
  27 #undef DEBUG
  28
  29 #define MAX_PROM_MEM 5
  30 static phys_addr_t prom_mem_base[MAX_PROM_MEM] __initdata;
  31 static phys_addr_t prom_mem_size[MAX_PROM_MEM] __initdata;
  32 static unsigned int nr_prom_mem __initdata;
  33
  34 /*
  35  * For ARC firmware memory functions the unit of measuring memory is always
  36  * a 4k page of memory
  37  */
  38 #define ARC_PAGE_SHIFT  12
  39
  40 struct linux_mdesc * __init ArcGetMemoryDescriptor(struct linux_mdesc *Current)
  41 {
  42         return (struct linux_mdesc *) ARC_CALL1(get_mdesc, Current);
  43 }
  44
  45 #ifdef DEBUG /* convenient for debugging */
  46 static char *arcs_mtypes[8] = {
  47         "Exception Block",
  48         "ARCS Romvec Page",
  49         "Free/Contig RAM",
  50         "Generic Free RAM",
  51         "Bad Memory",
  52         "Standalone Program Pages",
  53         "ARCS Temp Storage Area",
  54         "ARCS Permanent Storage Area"
  55 };
  56
  57 static char *arc_mtypes[8] = {
  58         "Exception Block",
  59         "SystemParameterBlock",
  60         "FreeMemory",
  61         "Bad Memory",
  62         "LoadedProgram",
  63         "FirmwareTemporary",
  64         "FirmwarePermanent",
  65         "FreeContiguous"
  66 };
  67 #define mtypes(a) (prom_flags & PROM_FLAG_ARCS) ? arcs_mtypes[a.arcs] \
  68                                                 : arc_mtypes[a.arc]
  69 #endif
  70
  71 enum {
  72         mem_free, mem_prom_used, mem_reserved
  73 };
  74
  75 static inline int memtype_classify_arcs(union linux_memtypes type)
  76 {
  77         switch (type.arcs) {
  78         case arcs_fcontig:
  79         case arcs_free:
  80                 return mem_free;
  81         case arcs_atmp:
  82                 return mem_prom_used;
  83         case arcs_eblock:
  84         case arcs_rvpage:
  85         case arcs_bmem:
  86         case arcs_prog:
  87         case arcs_aperm:
  88                 return mem_reserved;
  89         default:
  90                 BUG();
  91         }
  92         while(1);                               /* Nuke warning.  */
  93 }
  94
  95 static inline int memtype_classify_arc(union linux_memtypes type)
  96 {
  97         switch (type.arc) {
  98         case arc_free:
  99         case arc_fcontig:
 100                 return mem_free;
 101         case arc_atmp:
 102                 return mem_prom_used;
 103         case arc_eblock:
 104         case arc_rvpage:
 105         case arc_bmem:
 106         case arc_prog:
 107         case arc_aperm:
 108                 return mem_reserved;
 109         default:
 110                 BUG();
 111         }
 112         while(1);                               /* Nuke warning.  */
 113 }
 114
 115 static int __init prom_memtype_classify(union linux_memtypes type)
 116 {
 117         if (prom_flags & PROM_FLAG_ARCS)        /* SGI is ``different'' ... */
 118                 return memtype_classify_arcs(type);
 119
 120         return memtype_classify_arc(type);
 121 }
 122
 123 void __weak __init prom_meminit(void)
 124 {
 125         struct linux_mdesc *p;
 126
 127 #ifdef DEBUG
 128         int i = 0;
 129
 130         printk("ARCS MEMORY DESCRIPTOR dump:\n");
 131         p = ArcGetMemoryDescriptor(PROM_NULL_MDESC);
 132         while(p) {
 133                 printk("[%d,%p]: base<%08lx> pages<%08lx> type<%s>\n",
 134                        i, p, p->base, p->pages, mtypes(p->type));
 135                 p = ArcGetMemoryDescriptor(p);
 136                 i++;
 137         }
 138 #endif
 139
 140         nr_prom_mem = 0;
 141         p = PROM_NULL_MDESC;
 142         while ((p = ArcGetMemoryDescriptor(p))) {
 143                 unsigned long base, size;
 144                 long type;
 145
 146                 base = p->base << ARC_PAGE_SHIFT;
 147                 size = p->pages << ARC_PAGE_SHIFT;
 148                 type = prom_memtype_classify(p->type);
 149
 150                 /* ignore mirrored RAM on IP28/IP30 */
 151                 if (base < PHYS_OFFSET)
 152                         continue;
 153
 154                 memblock_add(base, size);
 155
 156                 if (type == mem_reserved)
 157                         memblock_reserve(base, size);
 158
 159                 if (type == mem_prom_used) {
 160                         memblock_reserve(base, size);
 161                         if (nr_prom_mem >= 5) {
 162                                 pr_err("Too many ROM DATA regions");
 163                                 continue;
 164                         }
 165                         prom_mem_base[nr_prom_mem] = base;
 166                         prom_mem_size[nr_prom_mem] = size;
 167                         nr_prom_mem++;
 168                 }
 169         }
 170 }
 171
 172 void __weak __init prom_cleanup(void)
 173 {
 174 }
 175
 176 void __init prom_free_prom_memory(void)
 177 {
 178         int i;
 179
 180         if (prom_flags & PROM_FLAG_DONT_FREE_TEMP)
 181                 return;
 182
 183         for (i = 0; i < nr_prom_mem; i++) {
 184                 free_init_pages("prom memory",
 185                         prom_mem_base[i], prom_mem_base[i] + prom_mem_size[i]);
 186         }
 187         /*
 188          * at this point it isn't safe to call PROM functions
 189          * give platforms a way to do PROM cleanups
 190          */
 191         prom_cleanup();
 192 }