blob: 6c1eb88424be054c56d26b90da72f3e637acc2c0 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassf1a0baf2015-08-04 12:33:59 -06002/*
3 * (C) Copyright 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
Simon Glassf1a0baf2015-08-04 12:33:59 -06005 */
6
7#include <common.h>
8#include <command.h>
9#include <efi.h>
10#include <errno.h>
11#include <malloc.h>
12
13static const char *const type_name[] = {
14 "reserved",
15 "loader_code",
16 "loader_data",
17 "bs_code",
18 "bs_data",
19 "rt_code",
20 "rt_data",
21 "conv",
22 "unusable",
23 "acpi_reclaim",
24 "acpi_nvs",
25 "io",
26 "io_port",
27 "pal_code",
28};
29
30static struct attr_info {
31 int shift;
32 const char *name;
33} mem_attr[] = {
34 { EFI_MEMORY_UC_SHIFT, "uncached" },
35 { EFI_MEMORY_WC_SHIFT, "write-coalescing" },
36 { EFI_MEMORY_WT_SHIFT, "write-through" },
37 { EFI_MEMORY_WB_SHIFT, "write-back" },
38 { EFI_MEMORY_UCE_SHIFT, "uncached & exported" },
39 { EFI_MEMORY_WP_SHIFT, "write-protect" },
40 { EFI_MEMORY_RP_SHIFT, "read-protect" },
41 { EFI_MEMORY_XP_SHIFT, "execute-protect" },
42 { EFI_MEMORY_RUNTIME_SHIFT, "needs runtime mapping" }
43};
44
45/* Maximum different attribute values we can track */
46#define ATTR_SEEN_MAX 30
47
48static inline bool is_boot_services(int type)
49{
50 return type == EFI_LOADER_CODE || type == EFI_LOADER_DATA ||
51 type == EFI_BOOT_SERVICES_CODE ||
52 type == EFI_BOOT_SERVICES_DATA;
53}
54
55static int h_cmp_entry(const void *v1, const void *v2)
56{
57 const struct efi_mem_desc *desc1 = v1;
58 const struct efi_mem_desc *desc2 = v2;
59 int64_t diff = desc1->physical_start - desc2->physical_start;
60
61 /*
62 * Manually calculate the difference to avoid sign loss in the 64-bit
63 * to 32-bit conversion
64 */
65 return diff < 0 ? -1 : diff > 0 ? 1 : 0;
66}
67
68void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs)
69{
70 struct efi_mem_desc *desc, *end, *base, *dest, *prev;
71 int count;
72 u64 addr;
73
74 base = malloc(size + sizeof(*desc));
75 if (!base) {
76 debug("%s: Cannot allocate %#x bytes\n", __func__, size);
77 return NULL;
78 }
79 end = (struct efi_mem_desc *)((ulong)map + size);
80 count = ((ulong)end - (ulong)map->desc) / map->desc_size;
81 memcpy(base, map->desc, (ulong)end - (ulong)map->desc);
82 qsort(base, count, map->desc_size, h_cmp_entry);
83 prev = NULL;
84 addr = 0;
85 dest = base;
Bin Mengdd099ec2018-06-22 01:38:31 -070086 end = (struct efi_mem_desc *)((ulong)base + count * map->desc_size);
Simon Glassf1a0baf2015-08-04 12:33:59 -060087 for (desc = base; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
88 bool merge = true;
89 int type = desc->type;
90
91 if (skip_bs && is_boot_services(desc->type))
92 type = EFI_CONVENTIONAL_MEMORY;
93
94 memcpy(dest, desc, map->desc_size);
95 dest->type = type;
96 if (!skip_bs || !prev)
97 merge = false;
98 else if (desc->physical_start != addr)
99 merge = false;
100 else if (type != EFI_CONVENTIONAL_MEMORY)
101 merge = false;
102 else if (prev->type != EFI_CONVENTIONAL_MEMORY)
103 merge = false;
104
105 if (merge) {
106 prev->num_pages += desc->num_pages;
107 } else {
108 prev = dest;
109 dest = efi_get_next_mem_desc(map, dest);
110 }
111 addr = desc->physical_start + (desc->num_pages <<
112 EFI_PAGE_SHIFT);
113 }
114
115 /* Mark the end */
116 dest->type = EFI_TABLE_END;
117
118 return base;
119}
120
121static void efi_print_mem_table(struct efi_entry_memmap *map,
122 struct efi_mem_desc *desc, bool skip_bs)
123{
124 u64 attr_seen[ATTR_SEEN_MAX];
125 int attr_seen_count;
126 int upto, i;
127 u64 addr;
128
129 printf(" # %-14s %10s %10s %10s %s\n", "Type", "Physical",
130 "Virtual", "Size", "Attributes");
131
132 /* Keep track of all the different attributes we have seen */
133 attr_seen_count = 0;
134 addr = 0;
135 for (upto = 0; desc->type != EFI_TABLE_END;
136 upto++, desc = efi_get_next_mem_desc(map, desc)) {
137 const char *name;
138 u64 size;
139
140 if (skip_bs && is_boot_services(desc->type))
141 continue;
142 if (desc->physical_start != addr) {
143 printf(" %-14s %010llx %10s %010llx\n", "<gap>",
144 addr, "", desc->physical_start - addr);
145 }
146 size = desc->num_pages << EFI_PAGE_SHIFT;
147
148 name = desc->type < ARRAY_SIZE(type_name) ?
149 type_name[desc->type] : "<invalid>";
150 printf("%2d %x:%-12s %010llx %010llx %010llx ", upto,
151 desc->type, name, desc->physical_start,
152 desc->virtual_start, size);
153 if (desc->attribute & EFI_MEMORY_RUNTIME)
154 putc('r');
155 printf("%llx", desc->attribute & ~EFI_MEMORY_RUNTIME);
156 putc('\n');
157
158 for (i = 0; i < attr_seen_count; i++) {
159 if (attr_seen[i] == desc->attribute)
160 break;
161 }
162 if (i == attr_seen_count && i < ATTR_SEEN_MAX)
163 attr_seen[attr_seen_count++] = desc->attribute;
164 addr = desc->physical_start + size;
165 }
166
167 printf("\nAttributes key:\n");
168 for (i = 0; i < attr_seen_count; i++) {
169 u64 attr = attr_seen[i];
170 bool first;
171 int j;
172
173 printf("%c%llx: ", attr & EFI_MEMORY_RUNTIME ? 'r' : ' ',
174 attr & ~EFI_MEMORY_RUNTIME);
175 for (j = 0, first = true; j < ARRAY_SIZE(mem_attr); j++) {
176 if (attr & (1ULL << mem_attr[j].shift)) {
177 if (first)
178 first = false;
179 else
180 printf(", ");
181 printf("%s", mem_attr[j].name);
182 }
183 }
184 putc('\n');
185 }
186 if (skip_bs)
187 printf("*Some areas are merged (use 'all' to see)\n");
188}
189
190static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
191{
192 struct efi_mem_desc *desc;
193 struct efi_entry_memmap *map;
194 int size, ret;
195 bool skip_bs;
196
197 skip_bs = !argc || *argv[0] != 'a';
198 ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
199 switch (ret) {
200 case -ENOENT:
201 printf("No EFI table available\n");
202 goto done;
203 case -EPROTONOSUPPORT:
204 printf("Incorrect EFI table version\n");
205 goto done;
206 }
207 printf("EFI table at %lx, memory map %p, size %x, version %x, descr. size %#x\n",
208 gd->arch.table, map, size, map->version, map->desc_size);
209 if (map->version != EFI_MEM_DESC_VERSION) {
210 printf("Incorrect memory map version\n");
211 ret = -EPROTONOSUPPORT;
212 goto done;
213 }
214
215 desc = efi_build_mem_table(map, size, skip_bs);
216 if (!desc) {
217 ret = -ENOMEM;
218 goto done;
219 }
220
221 efi_print_mem_table(map, desc, skip_bs);
222 free(desc);
223done:
224 if (ret)
225 printf("Error: %d\n", ret);
226
227 return ret ? CMD_RET_FAILURE : 0;
228}
229
230static cmd_tbl_t efi_commands[] = {
231 U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
232};
233
234static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
235{
236 cmd_tbl_t *efi_cmd;
237 int ret;
238
239 if (argc < 2)
240 return CMD_RET_USAGE;
241 efi_cmd = find_cmd_tbl(argv[1], efi_commands, ARRAY_SIZE(efi_commands));
242 argc -= 2;
243 argv += 2;
244 if (!efi_cmd || argc > efi_cmd->maxargs)
245 return CMD_RET_USAGE;
246
247 ret = efi_cmd->cmd(efi_cmd, flag, argc, argv);
248
249 return cmd_process_error(efi_cmd, ret);
250}
251
252U_BOOT_CMD(
253 efi, 3, 1, do_efi,
254 "EFI access",
255 "mem [all] Dump memory information [include boot services]"
256);