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