[PATCH] ACPI build fix
[linux-3.10.git] / arch / sparc64 / prom / memory.c
1 /* $Id: memory.c,v 1.5 1999/08/31 06:55:04 davem Exp $
2  * memory.c: Prom routine for acquiring various bits of information
3  *           about RAM on the machine, both virtual and physical.
4  *
5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6  * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/init.h>
11
12 #include <asm/openprom.h>
13 #include <asm/oplib.h>
14
15 /* This routine, for consistency, returns the ram parameters in the
16  * V0 prom memory descriptor format.  I choose this format because I
17  * think it was the easiest to work with.  I feel the religious
18  * arguments now... ;)  Also, I return the linked lists sorted to
19  * prevent paging_init() upset stomach as I have not yet written
20  * the pepto-bismol kernel module yet.
21  */
22
23 struct linux_prom64_registers prom_reg_memlist[64];
24 struct linux_prom64_registers prom_reg_tmp[64];
25
26 struct linux_mlist_p1275 prom_phys_total[64];
27 struct linux_mlist_p1275 prom_prom_taken[64];
28 struct linux_mlist_p1275 prom_phys_avail[64];
29
30 struct linux_mlist_p1275 *prom_ptot_ptr = prom_phys_total;
31 struct linux_mlist_p1275 *prom_ptak_ptr = prom_prom_taken;
32 struct linux_mlist_p1275 *prom_pavl_ptr = prom_phys_avail;
33
34 struct linux_mem_p1275 prom_memlist;
35
36
37 /* Internal Prom library routine to sort a linux_mlist_p1275 memory
38  * list.  Used below in initialization.
39  */
40 static void __init
41 prom_sortmemlist(struct linux_mlist_p1275 *thislist)
42 {
43         int swapi = 0;
44         int i, mitr;
45         unsigned long tmpaddr, tmpsize;
46         unsigned long lowest;
47
48         for(i=0; thislist[i].theres_more; i++) {
49                 lowest = thislist[i].start_adr;
50                 for(mitr = i+1; thislist[mitr-1].theres_more; mitr++)
51                         if(thislist[mitr].start_adr < lowest) {
52                                 lowest = thislist[mitr].start_adr;
53                                 swapi = mitr;
54                         }
55                 if(lowest == thislist[i].start_adr) continue;
56                 tmpaddr = thislist[swapi].start_adr;
57                 tmpsize = thislist[swapi].num_bytes;
58                 for(mitr = swapi; mitr > i; mitr--) {
59                         thislist[mitr].start_adr = thislist[mitr-1].start_adr;
60                         thislist[mitr].num_bytes = thislist[mitr-1].num_bytes;
61                 }
62                 thislist[i].start_adr = tmpaddr;
63                 thislist[i].num_bytes = tmpsize;
64         }
65 }
66
67 /* Initialize the memory lists based upon the prom version. */
68 void __init prom_meminit(void)
69 {
70         int node = 0;
71         unsigned int iter, num_regs;
72
73         node = prom_finddevice("/memory");
74         num_regs = prom_getproperty(node, "available",
75                                     (char *) prom_reg_memlist,
76                                     sizeof(prom_reg_memlist));
77         num_regs = (num_regs/sizeof(struct linux_prom64_registers));
78         for(iter=0; iter<num_regs; iter++) {
79                 prom_phys_avail[iter].start_adr =
80                         prom_reg_memlist[iter].phys_addr;
81                 prom_phys_avail[iter].num_bytes =
82                         prom_reg_memlist[iter].reg_size;
83                 prom_phys_avail[iter].theres_more =
84                         &prom_phys_avail[iter+1];
85         }
86         prom_phys_avail[iter-1].theres_more = NULL;
87
88         num_regs = prom_getproperty(node, "reg",
89                                     (char *) prom_reg_memlist,
90                                     sizeof(prom_reg_memlist));
91         num_regs = (num_regs/sizeof(struct linux_prom64_registers));
92         for(iter=0; iter<num_regs; iter++) {
93                 prom_phys_total[iter].start_adr =
94                         prom_reg_memlist[iter].phys_addr;
95                 prom_phys_total[iter].num_bytes =
96                         prom_reg_memlist[iter].reg_size;
97                 prom_phys_total[iter].theres_more =
98                         &prom_phys_total[iter+1];
99         }
100         prom_phys_total[iter-1].theres_more = NULL;
101
102         node = prom_finddevice("/virtual-memory");
103         num_regs = prom_getproperty(node, "available",
104                                     (char *) prom_reg_memlist,
105                                     sizeof(prom_reg_memlist));
106         num_regs = (num_regs/sizeof(struct linux_prom64_registers));
107
108         /* Convert available virtual areas to taken virtual
109          * areas.  First sort, then convert.
110          */
111         for(iter=0; iter<num_regs; iter++) {
112                 prom_prom_taken[iter].start_adr =
113                         prom_reg_memlist[iter].phys_addr;
114                 prom_prom_taken[iter].num_bytes =
115                         prom_reg_memlist[iter].reg_size;
116                 prom_prom_taken[iter].theres_more =
117                         &prom_prom_taken[iter+1];
118         }
119         prom_prom_taken[iter-1].theres_more = NULL;
120
121         prom_sortmemlist(prom_prom_taken);
122
123         /* Finally, convert. */
124         for(iter=0; iter<num_regs; iter++) {
125                 prom_prom_taken[iter].start_adr =
126                         prom_prom_taken[iter].start_adr +
127                         prom_prom_taken[iter].num_bytes;
128                 prom_prom_taken[iter].num_bytes =
129                         prom_prom_taken[iter+1].start_adr -
130                         prom_prom_taken[iter].start_adr;
131         }
132         prom_prom_taken[iter-1].num_bytes =
133                 -1UL - prom_prom_taken[iter-1].start_adr;
134
135         /* Sort the other two lists. */
136         prom_sortmemlist(prom_phys_total);
137         prom_sortmemlist(prom_phys_avail);
138
139         /* Link all the lists into the top-level descriptor. */
140         prom_memlist.p1275_totphys=&prom_ptot_ptr;
141         prom_memlist.p1275_prommap=&prom_ptak_ptr;
142         prom_memlist.p1275_available=&prom_pavl_ptr;
143 }
144
145 /* This returns a pointer to our libraries internal p1275 format
146  * memory descriptor.
147  */
148 struct linux_mem_p1275 *
149 prom_meminfo(void)
150 {
151         return &prom_memlist;
152 }