1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
4 *
5 * Adapted from coreboot src/arch/x86/smbios.c
6 */
7
8 #include <common.h>
9 #include <mapmem.h>
10 #include <smbios.h>
11 #include <tables_csum.h>
12 #include <version.h>
13 #ifdef CONFIG_CPU
14 #include <cpu.h>
15 #include <dm.h>
16 #include <dm/uclass-internal.h>
17 #endif
18
19 /**
20 * smbios_add_string() - add a string to the string area
21 *
22 * This adds a string to the string area which is appended directly after
23 * the formatted portion of an SMBIOS structure.
24 *
25 * @start: string area start address
26 * @str: string to add
27 * @return: string number in the string area
28 */
smbios_add_string(char * start,const char * str)29 static int smbios_add_string(char *start, const char *str)
30 {
31 int i = 1;
32 char *p = start;
33
34 for (;;) {
35 if (!*p) {
36 strcpy(p, str);
37 p += strlen(str);
38 *p++ = '\0';
39 *p++ = '\0';
40
41 return i;
42 }
43
44 if (!strcmp(p, str))
45 return i;
46
47 p += strlen(p) + 1;
48 i++;
49 }
50 }
51
52 /**
53 * smbios_string_table_len() - compute the string area size
54 *
55 * This computes the size of the string area including the string terminator.
56 *
57 * @start: string area start address
58 * @return: string area size
59 */
smbios_string_table_len(char * start)60 static int smbios_string_table_len(char *start)
61 {
62 char *p = start;
63 int i, len = 0;
64
65 while (*p) {
66 i = strlen(p) + 1;
67 p += i;
68 len += i;
69 }
70
71 return len + 1;
72 }
73
smbios_write_type0(ulong * current,int handle)74 static int smbios_write_type0(ulong *current, int handle)
75 {
76 struct smbios_type0 *t;
77 int len = sizeof(struct smbios_type0);
78
79 t = map_sysmem(*current, len);
80 memset(t, 0, sizeof(struct smbios_type0));
81 fill_smbios_header(t, SMBIOS_BIOS_INFORMATION, len, handle);
82 t->vendor = smbios_add_string(t->eos, "U-Boot");
83 t->bios_ver = smbios_add_string(t->eos, PLAIN_VERSION);
84 t->bios_release_date = smbios_add_string(t->eos, U_BOOT_DMI_DATE);
85 #ifdef CONFIG_ROM_SIZE
86 t->bios_rom_size = (CONFIG_ROM_SIZE / 65536) - 1;
87 #endif
88 t->bios_characteristics = BIOS_CHARACTERISTICS_PCI_SUPPORTED |
89 BIOS_CHARACTERISTICS_SELECTABLE_BOOT |
90 BIOS_CHARACTERISTICS_UPGRADEABLE;
91 #ifdef CONFIG_GENERATE_ACPI_TABLE
92 t->bios_characteristics_ext1 = BIOS_CHARACTERISTICS_EXT1_ACPI;
93 #endif
94 #ifdef CONFIG_EFI_LOADER
95 t->bios_characteristics_ext1 |= BIOS_CHARACTERISTICS_EXT1_UEFI;
96 #endif
97 t->bios_characteristics_ext2 = BIOS_CHARACTERISTICS_EXT2_TARGET;
98
99 t->bios_major_release = 0xff;
100 t->bios_minor_release = 0xff;
101 t->ec_major_release = 0xff;
102 t->ec_minor_release = 0xff;
103
104 len = t->length + smbios_string_table_len(t->eos);
105 *current += len;
106 unmap_sysmem(t);
107
108 return len;
109 }
110
smbios_write_type1(ulong * current,int handle)111 static int smbios_write_type1(ulong *current, int handle)
112 {
113 struct smbios_type1 *t;
114 int len = sizeof(struct smbios_type1);
115 char *serial_str = env_get("serial#");
116
117 t = map_sysmem(*current, len);
118 memset(t, 0, sizeof(struct smbios_type1));
119 fill_smbios_header(t, SMBIOS_SYSTEM_INFORMATION, len, handle);
120 t->manufacturer = smbios_add_string(t->eos, CONFIG_SMBIOS_MANUFACTURER);
121 t->product_name = smbios_add_string(t->eos, CONFIG_SMBIOS_PRODUCT_NAME);
122 if (serial_str) {
123 strncpy((char *)t->uuid, serial_str, sizeof(t->uuid));
124 t->serial_number = smbios_add_string(t->eos, serial_str);
125 }
126
127 len = t->length + smbios_string_table_len(t->eos);
128 *current += len;
129 unmap_sysmem(t);
130
131 return len;
132 }
133
smbios_write_type2(ulong * current,int handle)134 static int smbios_write_type2(ulong *current, int handle)
135 {
136 struct smbios_type2 *t;
137 int len = sizeof(struct smbios_type2);
138
139 t = map_sysmem(*current, len);
140 memset(t, 0, sizeof(struct smbios_type2));
141 fill_smbios_header(t, SMBIOS_BOARD_INFORMATION, len, handle);
142 t->manufacturer = smbios_add_string(t->eos, CONFIG_SMBIOS_MANUFACTURER);
143 t->product_name = smbios_add_string(t->eos, CONFIG_SMBIOS_PRODUCT_NAME);
144 t->feature_flags = SMBIOS_BOARD_FEATURE_HOSTING;
145 t->board_type = SMBIOS_BOARD_MOTHERBOARD;
146
147 len = t->length + smbios_string_table_len(t->eos);
148 *current += len;
149 unmap_sysmem(t);
150
151 return len;
152 }
153
smbios_write_type3(ulong * current,int handle)154 static int smbios_write_type3(ulong *current, int handle)
155 {
156 struct smbios_type3 *t;
157 int len = sizeof(struct smbios_type3);
158
159 t = map_sysmem(*current, len);
160 memset(t, 0, sizeof(struct smbios_type3));
161 fill_smbios_header(t, SMBIOS_SYSTEM_ENCLOSURE, len, handle);
162 t->manufacturer = smbios_add_string(t->eos, CONFIG_SMBIOS_MANUFACTURER);
163 t->chassis_type = SMBIOS_ENCLOSURE_DESKTOP;
164 t->bootup_state = SMBIOS_STATE_SAFE;
165 t->power_supply_state = SMBIOS_STATE_SAFE;
166 t->thermal_state = SMBIOS_STATE_SAFE;
167 t->security_status = SMBIOS_SECURITY_NONE;
168
169 len = t->length + smbios_string_table_len(t->eos);
170 *current += len;
171 unmap_sysmem(t);
172
173 return len;
174 }
175
smbios_write_type4_dm(struct smbios_type4 * t)176 static void smbios_write_type4_dm(struct smbios_type4 *t)
177 {
178 u16 processor_family = SMBIOS_PROCESSOR_FAMILY_UNKNOWN;
179 const char *vendor = "Unknown";
180 const char *name = "Unknown";
181
182 #ifdef CONFIG_CPU
183 char processor_name[49];
184 char vendor_name[49];
185 struct udevice *dev = NULL;
186
187 uclass_find_first_device(UCLASS_CPU, &dev);
188 if (dev) {
189 struct cpu_platdata *plat = dev_get_parent_platdata(dev);
190
191 if (plat->family)
192 processor_family = plat->family;
193 t->processor_id[0] = plat->id[0];
194 t->processor_id[1] = plat->id[1];
195
196 if (!cpu_get_vendor(dev, vendor_name, sizeof(vendor_name)))
197 vendor = vendor_name;
198 if (!cpu_get_desc(dev, processor_name, sizeof(processor_name)))
199 name = processor_name;
200 }
201 #endif
202
203 t->processor_family = processor_family;
204 t->processor_manufacturer = smbios_add_string(t->eos, vendor);
205 t->processor_version = smbios_add_string(t->eos, name);
206 }
207
smbios_write_type4(ulong * current,int handle)208 static int smbios_write_type4(ulong *current, int handle)
209 {
210 struct smbios_type4 *t;
211 int len = sizeof(struct smbios_type4);
212
213 t = map_sysmem(*current, len);
214 memset(t, 0, sizeof(struct smbios_type4));
215 fill_smbios_header(t, SMBIOS_PROCESSOR_INFORMATION, len, handle);
216 t->processor_type = SMBIOS_PROCESSOR_TYPE_CENTRAL;
217 smbios_write_type4_dm(t);
218 t->status = SMBIOS_PROCESSOR_STATUS_ENABLED;
219 t->processor_upgrade = SMBIOS_PROCESSOR_UPGRADE_NONE;
220 t->l1_cache_handle = 0xffff;
221 t->l2_cache_handle = 0xffff;
222 t->l3_cache_handle = 0xffff;
223 t->processor_family2 = t->processor_family;
224
225 len = t->length + smbios_string_table_len(t->eos);
226 *current += len;
227 unmap_sysmem(t);
228
229 return len;
230 }
231
smbios_write_type32(ulong * current,int handle)232 static int smbios_write_type32(ulong *current, int handle)
233 {
234 struct smbios_type32 *t;
235 int len = sizeof(struct smbios_type32);
236
237 t = map_sysmem(*current, len);
238 memset(t, 0, sizeof(struct smbios_type32));
239 fill_smbios_header(t, SMBIOS_SYSTEM_BOOT_INFORMATION, len, handle);
240
241 *current += len;
242 unmap_sysmem(t);
243
244 return len;
245 }
246
smbios_write_type127(ulong * current,int handle)247 static int smbios_write_type127(ulong *current, int handle)
248 {
249 struct smbios_type127 *t;
250 int len = sizeof(struct smbios_type127);
251
252 t = map_sysmem(*current, len);
253 memset(t, 0, sizeof(struct smbios_type127));
254 fill_smbios_header(t, SMBIOS_END_OF_TABLE, len, handle);
255
256 *current += len;
257 unmap_sysmem(t);
258
259 return len;
260 }
261
262 static smbios_write_type smbios_write_funcs[] = {
263 smbios_write_type0,
264 smbios_write_type1,
265 smbios_write_type2,
266 smbios_write_type3,
267 smbios_write_type4,
268 smbios_write_type32,
269 smbios_write_type127
270 };
271
write_smbios_table(ulong addr)272 ulong write_smbios_table(ulong addr)
273 {
274 struct smbios_entry *se;
275 ulong table_addr;
276 ulong tables;
277 int len = 0;
278 int max_struct_size = 0;
279 int handle = 0;
280 char *istart;
281 int isize;
282 int i;
283
284 /* 16 byte align the table address */
285 addr = ALIGN(addr, 16);
286
287 se = map_sysmem(addr, sizeof(struct smbios_entry));
288 memset(se, 0, sizeof(struct smbios_entry));
289
290 addr += sizeof(struct smbios_entry);
291 addr = ALIGN(addr, 16);
292 tables = addr;
293
294 /* populate minimum required tables */
295 for (i = 0; i < ARRAY_SIZE(smbios_write_funcs); i++) {
296 int tmp = smbios_write_funcs[i]((ulong *)&addr, handle++);
297
298 max_struct_size = max(max_struct_size, tmp);
299 len += tmp;
300 }
301
302 memcpy(se->anchor, "_SM_", 4);
303 se->length = sizeof(struct smbios_entry);
304 se->major_ver = SMBIOS_MAJOR_VER;
305 se->minor_ver = SMBIOS_MINOR_VER;
306 se->max_struct_size = max_struct_size;
307 memcpy(se->intermediate_anchor, "_DMI_", 5);
308 se->struct_table_length = len;
309
310 /*
311 * We must use a pointer here so things work correctly on sandbox. The
312 * user of this table is not aware of the mapping of addresses to
313 * sandbox's DRAM buffer.
314 */
315 table_addr = (ulong)map_sysmem(tables, 0);
316 if (sizeof(table_addr) > sizeof(u32) && table_addr > (ulong)UINT_MAX) {
317 /*
318 * We need to put this >32-bit pointer into the table but the
319 * field is only 32 bits wide.
320 */
321 printf("WARNING: SMBIOS table_address overflow %llx\n",
322 (unsigned long long)table_addr);
323 table_addr = 0;
324 }
325 se->struct_table_address = table_addr;
326
327 se->struct_count = handle;
328
329 /* calculate checksums */
330 istart = (char *)se + SMBIOS_INTERMEDIATE_OFFSET;
331 isize = sizeof(struct smbios_entry) - SMBIOS_INTERMEDIATE_OFFSET;
332 se->intermediate_checksum = table_compute_checksum(istart, isize);
333 se->checksum = table_compute_checksum(se, sizeof(struct smbios_entry));
334 unmap_sysmem(se);
335
336 return addr;
337 }
338