[efi] Include installed protocol list in unknown handle names
[ipxe.git] / src / core / memmap_settings.c
1 /*
2 * Copyright (C) 2013 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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 #include <string.h>
27 #include <errno.h>
28 #include <byteswap.h>
29 #include <ipxe/init.h>
30 #include <ipxe/settings.h>
31 #include <ipxe/io.h>
32
33 /** @file
34 *
35 * Memory map settings
36 *
37 * Memory map settings are numerically encoded as:
38 *
39 * Bits 31-24 Number of regions, minus one
40 * Bits 23-16 Starting region
41 * Bits 15-11 Unused
42 * Bit 10 Ignore non-existent regions (rather than generating an error)
43 * Bit 9 Include length
44 * Bit 8 Include start address
45 * Bits 7-6 Unused
46 * Bits 5-0 Scale factor (i.e. right shift count)
47 */
48
49 /**
50 * Construct memory map setting tag
51 *
52 * @v start Starting region
53 * @v count Number of regions
54 * @v include_start Include start address
55 * @v include_length Include length
56 * @v ignore Ignore non-existent regions
57 * @v scale Scale factor
58 * @ret tag Setting tag
59 */
60 #define MEMMAP_TAG( start, count, include_start, include_length, \
61 ignore, scale ) \
62 ( ( (start) << 16 ) | ( ( (count) - 1 ) << 24 ) | \
63 ( (ignore) << 10 ) | ( (include_length) << 9 ) | \
64 ( (include_start) << 8 ) | (scale) )
65
66 /**
67 * Extract number of regions from setting tag
68 *
69 * @v tag Setting tag
70 * @ret count Number of regions
71 */
72 #define MEMMAP_COUNT( tag ) ( ( ( (tag) >> 24 ) & 0xff ) + 1 )
73
74 /**
75 * Extract starting region from setting tag
76 *
77 * @v tag Setting tag
78 * @ret start Starting region
79 */
80 #define MEMMAP_START( tag ) ( ( (tag) >> 16 ) & 0xff )
81
82 /**
83 * Extract ignore flag from setting tag
84 *
85 * @v tag Setting tag
86 * @ret ignore Ignore non-existent regions
87 */
88 #define MEMMAP_IGNORE_NONEXISTENT( tag ) ( (tag) & 0x00000400UL )
89
90 /**
91 * Extract length inclusion flag from setting tag
92 *
93 * @v tag Setting tag
94 * @ret include_length Include length
95 */
96 #define MEMMAP_INCLUDE_LENGTH( tag ) ( (tag) & 0x00000200UL )
97
98 /**
99 * Extract start address inclusion flag from setting tag
100 *
101 * @v tag Setting tag
102 * @ret include_start Include start address
103 */
104 #define MEMMAP_INCLUDE_START( tag ) ( (tag) & 0x00000100UL )
105
106 /**
107 * Extract scale factor from setting tag
108 *
109 * @v tag Setting tag
110 * @v scale Scale factor
111 */
112 #define MEMMAP_SCALE( tag ) ( (tag) & 0x3f )
113
114 /** Memory map settings scope */
115 static const struct settings_scope memmap_settings_scope;
116
117 /**
118 * Check applicability of memory map setting
119 *
120 * @v settings Settings block
121 * @v setting Setting
122 * @ret applies Setting applies within this settings block
123 */
124 static int memmap_settings_applies ( struct settings *settings __unused,
125 const struct setting *setting ) {
126
127 return ( setting->scope == &memmap_settings_scope );
128 }
129
130 /**
131 * Fetch value of memory map setting
132 *
133 * @v settings Settings block
134 * @v setting Setting to fetch
135 * @v data Buffer to fill with setting data
136 * @v len Length of buffer
137 * @ret len Length of setting data, or negative error
138 */
139 static int memmap_settings_fetch ( struct settings *settings,
140 struct setting *setting,
141 void *data, size_t len ) {
142 struct memory_map memmap;
143 struct memory_region *region;
144 uint64_t result = 0;
145 unsigned int i;
146 unsigned int count;
147
148 DBGC ( settings, "MEMMAP start %d count %d %s%s%s%s scale %d\n",
149 MEMMAP_START ( setting->tag ), MEMMAP_COUNT ( setting->tag ),
150 ( MEMMAP_INCLUDE_START ( setting->tag ) ? "start" : "" ),
151 ( ( MEMMAP_INCLUDE_START ( setting->tag ) &&
152 MEMMAP_INCLUDE_LENGTH ( setting->tag ) ) ? "+" : "" ),
153 ( MEMMAP_INCLUDE_LENGTH ( setting->tag ) ? "length" : "" ),
154 ( MEMMAP_IGNORE_NONEXISTENT ( setting->tag ) ? " ignore" : "" ),
155 MEMMAP_SCALE ( setting->tag ) );
156
157 /* Fetch memory map */
158 get_memmap ( &memmap );
159
160 /* Extract results from memory map */
161 count = MEMMAP_COUNT ( setting->tag );
162 for ( i = MEMMAP_START ( setting->tag ) ; count-- ; i++ ) {
163
164 /* Check that region exists */
165 if ( i >= memmap.count ) {
166 if ( MEMMAP_IGNORE_NONEXISTENT ( setting->tag ) ) {
167 continue;
168 } else {
169 DBGC ( settings, "MEMMAP region %d does not "
170 "exist\n", i );
171 return -ENOENT;
172 }
173 }
174
175 /* Extract results from this region */
176 region = &memmap.regions[i];
177 if ( MEMMAP_INCLUDE_START ( setting->tag ) ) {
178 result += region->start;
179 DBGC ( settings, "MEMMAP %d start %08llx\n",
180 i, region->start );
181 }
182 if ( MEMMAP_INCLUDE_LENGTH ( setting->tag ) ) {
183 result += ( region->end - region->start );
184 DBGC ( settings, "MEMMAP %d length %08llx\n",
185 i, ( region->end - region->start ) );
186 }
187 }
188
189 /* Scale result */
190 result >>= MEMMAP_SCALE ( setting->tag );
191
192 /* Return result */
193 result = cpu_to_be64 ( result );
194 if ( len > sizeof ( result ) )
195 len = sizeof ( result );
196 memcpy ( data, &result, len );
197
198 /* Set type if not already specified */
199 if ( ! setting->type )
200 setting->type = &setting_type_hexraw;
201
202 return sizeof ( result );
203 }
204
205 /** Memory map settings operations */
206 static struct settings_operations memmap_settings_operations = {
207 .applies = memmap_settings_applies,
208 .fetch = memmap_settings_fetch,
209 };
210
211 /** Memory map settings */
212 static struct settings memmap_settings = {
213 .refcnt = NULL,
214 .siblings = LIST_HEAD_INIT ( memmap_settings.siblings ),
215 .children = LIST_HEAD_INIT ( memmap_settings.children ),
216 .op = &memmap_settings_operations,
217 .default_scope = &memmap_settings_scope,
218 };
219
220 /** Initialise memory map settings */
221 static void memmap_settings_init ( void ) {
222 int rc;
223
224 if ( ( rc = register_settings ( &memmap_settings, NULL,
225 "memmap" ) ) != 0 ) {
226 DBG ( "MEMMAP could not register settings: %s\n",
227 strerror ( rc ) );
228 return;
229 }
230 }
231
232 /** Memory map settings initialiser */
233 struct init_fn memmap_settings_init_fn __init_fn ( INIT_NORMAL ) = {
234 .initialise = memmap_settings_init,
235 };
236
237 /** Memory map predefined settings */
238 const struct setting memsize_setting __setting ( SETTING_MISC, memsize ) = {
239 .name = "memsize",
240 .description = "Memory size (in MB)",
241 .tag = MEMMAP_TAG ( 0, 0x100, 0, 1, 1, 20 ),
242 .type = &setting_type_int32,
243 .scope = &memmap_settings_scope,
244 };