[PATCH] m68knommu: remove FP conditionals in ucontext struct
[linux-2.6.git] / arch / sparc / prom / memory.c
1 /* $Id: memory.c,v 1.15 2000/01/29 01:09:12 anton 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 Michael A. Griffith (grif@acm.org)
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/init.h>
11
12 #include <asm/openprom.h>
13 #include <asm/sun4prom.h>
14 #include <asm/oplib.h>
15
16 /* This routine, for consistency, returns the ram parameters in the
17  * V0 prom memory descriptor format.  I choose this format because I
18  * think it was the easiest to work with.  I feel the religious
19  * arguments now... ;)  Also, I return the linked lists sorted to
20  * prevent paging_init() upset stomach as I have not yet written
21  * the pepto-bismol kernel module yet.
22  */
23
24 struct linux_prom_registers prom_reg_memlist[64];
25 struct linux_prom_registers prom_reg_tmp[64];
26
27 struct linux_mlist_v0 prom_phys_total[64];
28 struct linux_mlist_v0 prom_prom_taken[64];
29 struct linux_mlist_v0 prom_phys_avail[64];
30
31 struct linux_mlist_v0 *prom_ptot_ptr = prom_phys_total;
32 struct linux_mlist_v0 *prom_ptak_ptr = prom_prom_taken;
33 struct linux_mlist_v0 *prom_pavl_ptr = prom_phys_avail;
34
35 struct linux_mem_v0 prom_memlist;
36
37
38 /* Internal Prom library routine to sort a linux_mlist_v0 memory
39  * list.  Used below in initialization.
40  */
41 static void __init
42 prom_sortmemlist(struct linux_mlist_v0 *thislist)
43 {
44         int swapi = 0;
45         int i, mitr, tmpsize;
46         char *tmpaddr;
47         char *lowest;
48
49         for(i=0; thislist[i].theres_more; i++) {
50                 lowest = thislist[i].start_adr;
51                 for(mitr = i+1; thislist[mitr-1].theres_more; mitr++)
52                         if(thislist[mitr].start_adr < lowest) {
53                                 lowest = thislist[mitr].start_adr;
54                                 swapi = mitr;
55                         }
56                 if(lowest == thislist[i].start_adr) continue;
57                 tmpaddr = thislist[swapi].start_adr;
58                 tmpsize = thislist[swapi].num_bytes;
59                 for(mitr = swapi; mitr > i; mitr--) {
60                         thislist[mitr].start_adr = thislist[mitr-1].start_adr;
61                         thislist[mitr].num_bytes = thislist[mitr-1].num_bytes;
62                 }
63                 thislist[i].start_adr = tmpaddr;
64                 thislist[i].num_bytes = tmpsize;
65         }
66
67         return;
68 }
69
70 /* Initialize the memory lists based upon the prom version. */
71 void __init prom_meminit(void)
72 {
73         int node = 0;
74         unsigned int iter, num_regs;
75         struct linux_mlist_v0 *mptr;  /* ptr for traversal */
76
77         switch(prom_vers) {
78         case PROM_V0:
79                 /* Nice, kind of easier to do in this case. */
80                 /* First, the total physical descriptors. */
81                 for(mptr = (*(romvec->pv_v0mem.v0_totphys)), iter=0;
82                     mptr; mptr=mptr->theres_more, iter++) {
83                         prom_phys_total[iter].start_adr = mptr->start_adr;
84                         prom_phys_total[iter].num_bytes = mptr->num_bytes;
85                         prom_phys_total[iter].theres_more = &prom_phys_total[iter+1];
86                 }
87                 prom_phys_total[iter-1].theres_more = NULL;
88                 /* Second, the total prom taken descriptors. */
89                 for(mptr = (*(romvec->pv_v0mem.v0_prommap)), iter=0;
90                     mptr; mptr=mptr->theres_more, iter++) {
91                         prom_prom_taken[iter].start_adr = mptr->start_adr;
92                         prom_prom_taken[iter].num_bytes = mptr->num_bytes;
93                         prom_prom_taken[iter].theres_more = &prom_prom_taken[iter+1];
94                 }
95                 prom_prom_taken[iter-1].theres_more = NULL;
96                 /* Last, the available physical descriptors. */
97                 for(mptr = (*(romvec->pv_v0mem.v0_available)), iter=0;
98                     mptr; mptr=mptr->theres_more, iter++) {
99                         prom_phys_avail[iter].start_adr = mptr->start_adr;
100                         prom_phys_avail[iter].num_bytes = mptr->num_bytes;
101                         prom_phys_avail[iter].theres_more = &prom_phys_avail[iter+1];
102                 }
103                 prom_phys_avail[iter-1].theres_more = NULL;
104                 /* Sort all the lists. */
105                 prom_sortmemlist(prom_phys_total);
106                 prom_sortmemlist(prom_prom_taken);
107                 prom_sortmemlist(prom_phys_avail);
108                 break;
109         case PROM_V2:
110         case PROM_V3:
111                 /* Grrr, have to traverse the prom device tree ;( */
112                 node = prom_getchild(prom_root_node);
113                 node = prom_searchsiblings(node, "memory");
114                 num_regs = prom_getproperty(node, "available",
115                                             (char *) prom_reg_memlist,
116                                             sizeof(prom_reg_memlist));
117                 num_regs = (num_regs/sizeof(struct linux_prom_registers));
118                 for(iter=0; iter<num_regs; iter++) {
119                         prom_phys_avail[iter].start_adr =
120                                 (char *) prom_reg_memlist[iter].phys_addr;
121                         prom_phys_avail[iter].num_bytes =
122                                 (unsigned long) prom_reg_memlist[iter].reg_size;
123                         prom_phys_avail[iter].theres_more =
124                                 &prom_phys_avail[iter+1];
125                 }
126                 prom_phys_avail[iter-1].theres_more = NULL;
127
128                 num_regs = prom_getproperty(node, "reg",
129                                             (char *) prom_reg_memlist,
130                                             sizeof(prom_reg_memlist));
131                 num_regs = (num_regs/sizeof(struct linux_prom_registers));
132                 for(iter=0; iter<num_regs; iter++) {
133                         prom_phys_total[iter].start_adr =
134                                 (char *) prom_reg_memlist[iter].phys_addr;
135                         prom_phys_total[iter].num_bytes =
136                                 (unsigned long) prom_reg_memlist[iter].reg_size;
137                         prom_phys_total[iter].theres_more =
138                                 &prom_phys_total[iter+1];
139                 }
140                 prom_phys_total[iter-1].theres_more = NULL;
141
142                 node = prom_getchild(prom_root_node);
143                 node = prom_searchsiblings(node, "virtual-memory");
144                 num_regs = prom_getproperty(node, "available",
145                                             (char *) prom_reg_memlist,
146                                             sizeof(prom_reg_memlist));
147                 num_regs = (num_regs/sizeof(struct linux_prom_registers));
148
149                 /* Convert available virtual areas to taken virtual
150                  * areas.  First sort, then convert.
151                  */
152                 for(iter=0; iter<num_regs; iter++) {
153                         prom_prom_taken[iter].start_adr =
154                                 (char *) prom_reg_memlist[iter].phys_addr;
155                         prom_prom_taken[iter].num_bytes =
156                                 (unsigned long) prom_reg_memlist[iter].reg_size;
157                         prom_prom_taken[iter].theres_more =
158                                 &prom_prom_taken[iter+1];
159                 }
160                 prom_prom_taken[iter-1].theres_more = NULL;
161
162                 prom_sortmemlist(prom_prom_taken);
163
164                 /* Finally, convert. */
165                 for(iter=0; iter<num_regs; iter++) {
166                         prom_prom_taken[iter].start_adr =
167                                 prom_prom_taken[iter].start_adr +
168                                         prom_prom_taken[iter].num_bytes;
169                         prom_prom_taken[iter].num_bytes =
170                                 prom_prom_taken[iter+1].start_adr -
171                                         prom_prom_taken[iter].start_adr;
172                 }
173                 prom_prom_taken[iter-1].num_bytes =
174                         0xffffffff - (unsigned long) prom_prom_taken[iter-1].start_adr;
175
176                 /* Sort the other two lists. */
177                 prom_sortmemlist(prom_phys_total);
178                 prom_sortmemlist(prom_phys_avail);
179                 break;
180
181         case PROM_SUN4:
182 #ifdef CONFIG_SUN4      
183                 /* how simple :) */
184                 prom_phys_total[0].start_adr = NULL;
185                 prom_phys_total[0].num_bytes = *(sun4_romvec->memorysize);
186                 prom_phys_total[0].theres_more = NULL;
187                 prom_prom_taken[0].start_adr = NULL; 
188                 prom_prom_taken[0].num_bytes = 0x0;
189                 prom_prom_taken[0].theres_more = NULL;
190                 prom_phys_avail[0].start_adr = NULL;
191                 prom_phys_avail[0].num_bytes = *(sun4_romvec->memoryavail);
192                 prom_phys_avail[0].theres_more = NULL;
193 #endif
194                 break;
195
196         default:
197                 break;
198         };
199
200         /* Link all the lists into the top-level descriptor. */
201         prom_memlist.v0_totphys=&prom_ptot_ptr;
202         prom_memlist.v0_prommap=&prom_ptak_ptr;
203         prom_memlist.v0_available=&prom_pavl_ptr;
204
205         return;
206 }
207
208 /* This returns a pointer to our libraries internal v0 format
209  * memory descriptor.
210  */
211 struct linux_mem_v0 *
212 prom_meminfo(void)
213 {
214         return &prom_memlist;
215 }