LXR linux/arch/mips/fw/arc/memory.c

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