Replaced memsizes.c with smaller memmap.c, taking advantage of __data16,
[people/xl0/gpxe.git] / src / arch / i386 / firmware / pcbios / memmap.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <errno.h>
21 #include <realmode.h>
22 #include <bios.h>
23 #include <memmap.h>
24
25 /**
26  * @file
27  *
28  * Memory mapping
29  *
30  */
31
32 /** Magic value for INT 15,e820 calls */
33 #define SMAP ( 0x534d4150 )
34
35 /** An INT 15,e820 memory map entry */
36 struct e820_entry {
37         /** Start of region */
38         uint64_t start;
39         /** Length of region */
40         uint64_t len;
41         /** Type of region */
42         uint32_t type;
43 } __attribute__ (( packed ));
44
45 #define E820_TYPE_RAM           1 /**< Normal memory */
46 #define E820_TYPE_RESERVED      2 /**< Reserved and unavailable */
47 #define E820_TYPE_ACPI          3 /**< ACPI reclaim memory */
48 #define E820_TYPE_NVS           4 /**< ACPI NVS memory */
49
50 /** Buffer for INT 15,e820 calls */
51 static struct e820_entry __data16 ( e820buf );
52 #define e820buf __use_data16 ( e820buf )
53
54 /**
55  * Get size of base memory from BIOS free base memory counter
56  *
57  * @ret basemem         Base memory size, in kB
58  */
59 static unsigned int basememsize ( void ) {
60         uint16_t basemem;
61
62         get_real ( basemem, BDA_SEG, 0x0013 );
63         DBG ( "Base memory size %dkB\n", basemem );
64         return basemem;
65 }
66
67 /**
68  * Get size of extended memory via INT 15,e801
69  *
70  * @ret extmem          Extended memory size, in kB, or 0
71  */
72 static unsigned int extmemsize_e801 ( void ) {
73         uint16_t extmem_1m_to_16m_k, extmem_16m_plus_64k;
74         uint16_t confmem_1m_to_16m_k, confmem_16m_plus_64k;
75         unsigned int flags;
76         unsigned int extmem;
77
78         REAL_EXEC ( rm_mem_e801,
79                     "int $0x15\n\t"
80                     "pushfw\n\t"
81                     "popw %w0\n\t",
82                     5,
83                     OUT_CONSTRAINTS ( "=r" ( flags ),
84                                       "=a" ( extmem_1m_to_16m_k ),
85                                       "=b" ( extmem_16m_plus_64k ),
86                                       "=c" ( confmem_1m_to_16m_k ),
87                                       "=d" ( confmem_16m_plus_64k ) ),
88                     IN_CONSTRAINTS ( "a" ( 0xe801 ) ),
89                     CLOBBER ( "cc" ) );
90
91         if ( flags & CF )
92                 return 0;
93
94         if ( ! ( extmem_1m_to_16m_k | extmem_16m_plus_64k ) ) {
95                 extmem_1m_to_16m_k = confmem_1m_to_16m_k;
96                 extmem_16m_plus_64k = confmem_16m_plus_64k;
97         }
98
99         extmem = ( extmem_1m_to_16m_k + ( extmem_16m_plus_64k * 64 ) );
100         DBG ( "Extended memory size %d+64*%d=%d kB\n",
101               extmem_1m_to_16m_k, extmem_16m_plus_64k, extmem );
102         return extmem;
103 }
104
105 /**
106  * Get size of extended memory via INT 15,88
107  *
108  * @ret extmem          Extended memory size, in kB
109  */
110 static unsigned int extmemsize_88 ( void ) {
111         uint16_t extmem;
112
113         REAL_EXEC ( rm_mem_88,
114                     "int $0x15\n\t"
115                     "jnc 1f\n\t"
116                     "xorw %%ax, %%ax\n\t"
117                     "\n1:\n\t",
118                     1,
119                     OUT_CONSTRAINTS ( "=a" ( extmem ) ),
120                     IN_CONSTRAINTS ( "a" ( 0x8800 ) ),
121                     CLOBBER ( "cc" ) );
122
123         DBG ( "Extended memory size %d kB\n", extmem );
124         return extmem;
125 }
126
127 /**
128  * Get size of extended memory
129  *
130  * @ret extmem          Extended memory size, in kB
131  */
132 static unsigned int extmemsize ( void ) {
133         unsigned int extmem;
134
135         /* Try INT 15,e801 first, then fall back to INT 15,88 */
136         extmem = extmemsize_e801();
137         if ( ! extmem )
138                 extmem = extmemsize_88();
139         return extmem;
140 }
141
142 /**
143  * Get e820 memory map
144  *
145  * @v memmap            Memory map to fill in
146  * @v entries           Maximum number of entries in memory map
147  * @ret rc              Return status code
148  */
149 static int meme820 ( struct memory_region *memmap, unsigned int entries ) {
150         unsigned int index = 0;
151         uint32_t next = 0;
152         uint32_t smap;
153         unsigned int flags;
154         unsigned int discard_c, discard_d, discard_D;
155
156         do {
157                 REAL_EXEC ( rm_mem_e820,
158                             "int $0x15\n\t"
159                             "pushfw\n\t"
160                             "popw %w0\n\t",
161                             6,
162                             OUT_CONSTRAINTS ( "=r" ( flags ),
163                                               "=a" ( smap ),
164                                               "=b" ( next ),
165                                               "=D" ( discard_D ),
166                                               "=c" ( discard_c ),
167                                               "=d" ( discard_d ) ),
168                             IN_CONSTRAINTS ( "a" ( 0xe820 ),
169                                              "b" ( next ),
170                                              "D" ( &__from_data16 ( e820buf )),
171                                              "c" ( sizeof ( e820buf ) ),
172                                              "d" ( SMAP ) ),
173                             CLOBBER ( "memory" ) );
174                 if ( smap != SMAP )
175                         return -ENOTSUP;
176                 if ( flags & CF )
177                         break;
178                 DBG ( "E820 region [%llx,%llx) type %d\n", e820buf.start,
179                       ( e820buf.start + e820buf.len ), ( int ) e820buf.type );
180                 if ( e820buf.type != E820_TYPE_RAM )
181                         continue;
182                 memmap[index].start = e820buf.start;
183                 memmap[index].end = e820buf.start + e820buf.len;
184                 index++;
185         } while ( ( index < entries ) && ( next != 0 ) );
186         return 0;
187 }
188
189 /**
190  * Get memory map
191  *
192  * @v memmap            Memory map to fill in
193  * @v entries           Maximum number of entries in memory map (minimum 2)
194  */
195 void get_memmap ( struct memory_region *memmap, unsigned int entries ) {
196         unsigned int basemem, extmem;
197         int rc;
198
199         /* Clear memory map */
200         memset ( memmap, 0, ( entries * sizeof ( *memmap ) ) );
201
202         /* Get base and extended memory sizes */
203         basemem = basememsize();
204         extmem = extmemsize();
205         
206         /* Try INT 15,e820 first */
207         if ( ( rc = meme820 ( memmap, entries ) ) == 0 )
208                 return;
209
210         /* Fall back to constructing a map from basemem and extmem sizes */
211         memmap[0].end = ( basemem * 1024 );
212         memmap[1].start = 0x100000;
213         memmap[1].end = 0x100000 + ( extmem * 1024 );
214 }