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 meassuring 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 } 193