blob: d9d52bd58d756d723a3d4b0c81d2ec3be93012aa [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Bin Meng721e9922015-10-12 05:23:41 -07002/*
3 * Copyright (C) 2015, Bin Meng <bmeng.cn@gmail.com>
4 *
5 * Adapted from coreboot src/arch/x86/smbios.c
Bin Meng721e9922015-10-12 05:23:41 -07006 */
7
Simon Glass78227d42020-11-05 06:32:07 -07008#include <dm.h>
Simon Glass7b51b572019-08-01 09:46:52 -06009#include <env.h>
Pali Rohár11275e42021-04-22 18:09:57 +020010#include <linux/stringify.h>
Ilias Apalodimas738b3462023-12-07 11:18:50 +020011#include <linux/string.h>
Simon Glassa2505fc2018-11-22 13:46:37 -070012#include <mapmem.h>
Alexander Graf4b6dddc2016-08-19 01:23:23 +020013#include <smbios.h>
Simon Glass07c9e682021-02-04 21:17:23 -070014#include <sysinfo.h>
Alexander Graf4b6dddc2016-08-19 01:23:23 +020015#include <tables_csum.h>
Bin Meng721e9922015-10-12 05:23:41 -070016#include <version.h>
Ilias Apalodimas738b3462023-12-07 11:18:50 +020017#include <malloc.h>
18#include <dm/ofnode.h>
Alexander Graf96476202016-08-19 01:23:28 +020019#ifdef CONFIG_CPU
20#include <cpu.h>
Alexander Graf96476202016-08-19 01:23:28 +020021#include <dm/uclass-internal.h>
22#endif
Bin Meng721e9922015-10-12 05:23:41 -070023
Pali Rohár11275e42021-04-22 18:09:57 +020024/* Safeguard for checking that U_BOOT_VERSION_NUM macros are compatible with U_BOOT_DMI */
25#if U_BOOT_VERSION_NUM < 2000 || U_BOOT_VERSION_NUM > 2099 || \
26 U_BOOT_VERSION_NUM_PATCH < 1 || U_BOOT_VERSION_NUM_PATCH > 12
27#error U_BOOT_VERSION_NUM macros are not compatible with DMI, fix U_BOOT_DMI macros
28#endif
29
30/*
31 * U_BOOT_DMI_DATE contains BIOS Release Date in format mm/dd/yyyy.
32 * BIOS Release Date is calculated from U-Boot version and fixed day 01.
33 * So for U-Boot version 2021.04 it is calculated as "04/01/2021".
34 * BIOS Release Date should contain date when code was released
35 * and not when it was built or compiled.
36 */
37#if U_BOOT_VERSION_NUM_PATCH < 10
38#define U_BOOT_DMI_MONTH "0" __stringify(U_BOOT_VERSION_NUM_PATCH)
39#else
40#define U_BOOT_DMI_MONTH __stringify(U_BOOT_VERSION_NUM_PATCH)
41#endif
42#define U_BOOT_DMI_DAY "01"
43#define U_BOOT_DMI_YEAR __stringify(U_BOOT_VERSION_NUM)
44#define U_BOOT_DMI_DATE U_BOOT_DMI_MONTH "/" U_BOOT_DMI_DAY "/" U_BOOT_DMI_YEAR
45
Simon Glasse9adaa72021-02-04 21:17:20 -070046DECLARE_GLOBAL_DATA_PTR;
47
Bin Meng721e9922015-10-12 05:23:41 -070048/**
Ilias Apalodimas738b3462023-12-07 11:18:50 +020049 * struct map_sysinfo - Mapping of sysinfo strings to DT
50 *
51 * @sysinfo_str: sysinfo string
52 * @dt_str: DT string
53 * @max: Max index of the tokenized string to pick. Counting starts from 0
54 *
55 */
56struct map_sysinfo {
57 const char *sysinfo_str;
58 const char *dt_str;
59 int max;
60};
61
62static const struct map_sysinfo sysinfo_to_dt[] = {
63 { .sysinfo_str = "product", .dt_str = "model", 2 },
64 { .sysinfo_str = "manufacturer", .dt_str = "compatible", 1 },
65};
66
67/**
Simon Glass1e8989a2021-02-04 21:17:17 -070068 * struct smbios_ctx - context for writing SMBIOS tables
69 *
70 * @node: node containing the information to write (ofnode_null() if none)
71 * @dev: sysinfo device to use (NULL if none)
Simon Glass0c95fff2021-02-04 21:17:18 -070072 * @eos: end-of-string pointer for the table being processed. This is set
73 * up when we start processing a table
Simon Glassfd3b8262021-02-04 21:17:19 -070074 * @next_ptr: pointer to the start of the next string to be added. When the
75 * table is nopt empty, this points to the byte after the \0 of the
76 * previous string.
Simon Glasse9adaa72021-02-04 21:17:20 -070077 * @last_str: points to the last string that was written to the table, or NULL
78 * if none
Simon Glass1e8989a2021-02-04 21:17:17 -070079 */
80struct smbios_ctx {
81 ofnode node;
82 struct udevice *dev;
Simon Glass0c95fff2021-02-04 21:17:18 -070083 char *eos;
Simon Glassfd3b8262021-02-04 21:17:19 -070084 char *next_ptr;
Simon Glasse9adaa72021-02-04 21:17:20 -070085 char *last_str;
Simon Glass1e8989a2021-02-04 21:17:17 -070086};
87
88/**
Simon Glass0e89b852021-02-04 21:17:14 -070089 * Function prototype to write a specific type of SMBIOS structure
90 *
91 * @addr: start address to write the structure
92 * @handle: the structure's handle, a unique 16-bit number
Simon Glass1e8989a2021-02-04 21:17:17 -070093 * @ctx: context for writing the tables
Heinrich Schuchardt8c6532d2021-06-10 12:13:52 +020094 * Return: size of the structure
Simon Glass0e89b852021-02-04 21:17:14 -070095 */
Simon Glass1e8989a2021-02-04 21:17:17 -070096typedef int (*smbios_write_type)(ulong *addr, int handle,
97 struct smbios_ctx *ctx);
Simon Glass0e89b852021-02-04 21:17:14 -070098
99/**
Simon Glass44ffb6f2020-11-05 06:32:08 -0700100 * struct smbios_write_method - Information about a table-writing function
101 *
102 * @write: Function to call
103 * @subnode_name: Name of subnode which has the information for this function,
104 * NULL if none
105 */
106struct smbios_write_method {
107 smbios_write_type write;
108 const char *subnode_name;
109};
110
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200111static const struct map_sysinfo *convert_sysinfo_to_dt(const char *sysinfo_str)
112{
113 int i;
114
115 for (i = 0; i < ARRAY_SIZE(sysinfo_to_dt); i++) {
116 if (!strcmp(sysinfo_str, sysinfo_to_dt[i].sysinfo_str))
117 return &sysinfo_to_dt[i];
118 }
119
120 return NULL;
121}
122
Simon Glass44ffb6f2020-11-05 06:32:08 -0700123/**
Bin Meng721e9922015-10-12 05:23:41 -0700124 * smbios_add_string() - add a string to the string area
125 *
126 * This adds a string to the string area which is appended directly after
127 * the formatted portion of an SMBIOS structure.
128 *
Simon Glass0c95fff2021-02-04 21:17:18 -0700129 * @ctx: SMBIOS context
Bin Meng721e9922015-10-12 05:23:41 -0700130 * @str: string to add
Heinrich Schuchardt8c6532d2021-06-10 12:13:52 +0200131 * Return: string number in the string area (1 or more)
Bin Meng721e9922015-10-12 05:23:41 -0700132 */
Simon Glass0c95fff2021-02-04 21:17:18 -0700133static int smbios_add_string(struct smbios_ctx *ctx, const char *str)
Bin Meng721e9922015-10-12 05:23:41 -0700134{
135 int i = 1;
Simon Glass0c95fff2021-02-04 21:17:18 -0700136 char *p = ctx->eos;
137
Bin Meng721e9922015-10-12 05:23:41 -0700138 for (;;) {
139 if (!*p) {
Simon Glasse9adaa72021-02-04 21:17:20 -0700140 ctx->last_str = p;
Bin Meng721e9922015-10-12 05:23:41 -0700141 strcpy(p, str);
142 p += strlen(str);
143 *p++ = '\0';
Simon Glassfd3b8262021-02-04 21:17:19 -0700144 ctx->next_ptr = p;
Bin Meng721e9922015-10-12 05:23:41 -0700145 *p++ = '\0';
146
147 return i;
148 }
149
Simon Glasse9adaa72021-02-04 21:17:20 -0700150 if (!strcmp(p, str)) {
151 ctx->last_str = p;
Bin Meng721e9922015-10-12 05:23:41 -0700152 return i;
Simon Glasse9adaa72021-02-04 21:17:20 -0700153 }
Bin Meng721e9922015-10-12 05:23:41 -0700154
155 p += strlen(p) + 1;
156 i++;
157 }
158}
159
160/**
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200161 * get_str_from_dt - Get a substring from a DT property.
162 * After finding the property in the DT, the function
163 * will parse comma-separated values and return the value.
164 * If nprop->max exceeds the number of comma-separated
165 * elements, the last non NULL value will be returned.
166 * Counting starts from zero.
167 *
168 * @nprop: sysinfo property to use
169 * @str: pointer to fill with data
170 * @size: str buffer length
171 */
172static
173void get_str_from_dt(const struct map_sysinfo *nprop, char *str, size_t size)
174{
175 const char *dt_str;
176 int cnt = 0;
177 char *token;
178
179 memset(str, 0, size);
180 if (!nprop || !nprop->max)
181 return;
182
183 dt_str = ofnode_read_string(ofnode_root(), nprop->dt_str);
184 if (!dt_str)
185 return;
186
187 memcpy(str, dt_str, size);
188 token = strtok(str, ",");
189 while (token && cnt < nprop->max) {
190 strlcpy(str, token, strlen(token) + 1);
191 token = strtok(NULL, ",");
192 cnt++;
193 }
194}
195
196/**
Simon Glass07c9e682021-02-04 21:17:23 -0700197 * smbios_add_prop_si() - Add a property from the devicetree or sysinfo
198 *
199 * Sysinfo is used if available, with a fallback to devicetree
Simon Glass44ffb6f2020-11-05 06:32:08 -0700200 *
Simon Glass1e8989a2021-02-04 21:17:17 -0700201 * @ctx: context for writing the tables
Simon Glass44ffb6f2020-11-05 06:32:08 -0700202 * @prop: property to write
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200203 * @dval: Default value to use if the string is not found or is empty
Heinrich Schuchardt8c6532d2021-06-10 12:13:52 +0200204 * Return: 0 if not found, else SMBIOS string number (1 or more)
Simon Glass44ffb6f2020-11-05 06:32:08 -0700205 */
Simon Glass07c9e682021-02-04 21:17:23 -0700206static int smbios_add_prop_si(struct smbios_ctx *ctx, const char *prop,
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200207 int sysinfo_id, const char *dval)
Simon Glass44ffb6f2020-11-05 06:32:08 -0700208{
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200209 int ret;
210
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200211 if (!dval || !*dval)
212 dval = "Unknown";
213
214 if (!prop)
215 return smbios_add_string(ctx, dval);
216
Simon Glass07c9e682021-02-04 21:17:23 -0700217 if (sysinfo_id && ctx->dev) {
218 char val[SMBIOS_STR_MAX];
Simon Glass07c9e682021-02-04 21:17:23 -0700219
220 ret = sysinfo_get_str(ctx->dev, sysinfo_id, sizeof(val), val);
221 if (!ret)
222 return smbios_add_string(ctx, val);
223 }
Simon Glasse4f8e542020-11-05 06:32:18 -0700224 if (IS_ENABLED(CONFIG_OF_CONTROL)) {
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200225 const char *str = NULL;
226 char str_dt[128] = { 0 };
227 /*
228 * If the node is not valid fallback and try the entire DT
229 * so we can at least fill in manufacturer and board type
230 */
231 if (ofnode_valid(ctx->node)) {
232 str = ofnode_read_string(ctx->node, prop);
233 } else {
234 const struct map_sysinfo *nprop;
Simon Glasse4f8e542020-11-05 06:32:18 -0700235
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200236 nprop = convert_sysinfo_to_dt(prop);
237 get_str_from_dt(nprop, str_dt, sizeof(str_dt));
238 str = (const char *)str_dt;
239 }
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200240
Ilias Apalodimas738b3462023-12-07 11:18:50 +0200241 ret = smbios_add_string(ctx, str && *str ? str : dval);
242 return ret;
Simon Glasse4f8e542020-11-05 06:32:18 -0700243 }
244
245 return 0;
Simon Glass44ffb6f2020-11-05 06:32:08 -0700246}
247
Simon Glass07c9e682021-02-04 21:17:23 -0700248/**
249 * smbios_add_prop() - Add a property from the devicetree
250 *
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200251 * @prop: property to write. The default string will be written if
252 * prop is NULL
253 * @dval: Default value to use if the string is not found or is empty
Heinrich Schuchardt8c6532d2021-06-10 12:13:52 +0200254 * Return: 0 if not found, else SMBIOS string number (1 or more)
Simon Glass07c9e682021-02-04 21:17:23 -0700255 */
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200256static int smbios_add_prop(struct smbios_ctx *ctx, const char *prop,
257 const char *dval)
Simon Glass07c9e682021-02-04 21:17:23 -0700258{
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200259 return smbios_add_prop_si(ctx, prop, SYSINFO_ID_NONE, dval);
Simon Glass07c9e682021-02-04 21:17:23 -0700260}
261
Simon Glass0c95fff2021-02-04 21:17:18 -0700262static void smbios_set_eos(struct smbios_ctx *ctx, char *eos)
263{
264 ctx->eos = eos;
Simon Glassfd3b8262021-02-04 21:17:19 -0700265 ctx->next_ptr = eos;
Simon Glasse9adaa72021-02-04 21:17:20 -0700266 ctx->last_str = NULL;
267}
268
269int smbios_update_version(const char *version)
270{
271 char *ptr = gd->smbios_version;
272 uint old_len, len;
273
274 if (!ptr)
275 return log_ret(-ENOENT);
276
277 /*
278 * This string is supposed to have at least enough bytes and is
279 * padded with spaces. Update it, taking care not to move the
280 * \0 terminator, so that other strings in the string table
281 * are not disturbed. See smbios_add_string()
282 */
283 old_len = strnlen(ptr, SMBIOS_STR_MAX);
284 len = strnlen(version, SMBIOS_STR_MAX);
285 if (len > old_len)
286 return log_ret(-ENOSPC);
287
288 log_debug("Replacing SMBIOS type 0 version string '%s'\n", ptr);
289 memcpy(ptr, version, len);
290#ifdef LOG_DEBUG
291 print_buffer((ulong)ptr, ptr, 1, old_len + 1, 0);
292#endif
293
294 return 0;
Simon Glass0c95fff2021-02-04 21:17:18 -0700295}
296
Simon Glass44ffb6f2020-11-05 06:32:08 -0700297/**
Bin Meng721e9922015-10-12 05:23:41 -0700298 * smbios_string_table_len() - compute the string area size
299 *
300 * This computes the size of the string area including the string terminator.
301 *
Simon Glassfd3b8262021-02-04 21:17:19 -0700302 * @ctx: SMBIOS context
Heinrich Schuchardt8c6532d2021-06-10 12:13:52 +0200303 * Return: string area size
Bin Meng721e9922015-10-12 05:23:41 -0700304 */
Simon Glassfd3b8262021-02-04 21:17:19 -0700305static int smbios_string_table_len(const struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700306{
Simon Glassfd3b8262021-02-04 21:17:19 -0700307 /* Allow for the final \0 after all strings */
308 return (ctx->next_ptr + 1) - ctx->eos;
Bin Meng721e9922015-10-12 05:23:41 -0700309}
310
Simon Glass1e8989a2021-02-04 21:17:17 -0700311static int smbios_write_type0(ulong *current, int handle,
312 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700313{
Simon Glassa2505fc2018-11-22 13:46:37 -0700314 struct smbios_type0 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700315 int len = sizeof(struct smbios_type0);
316
Simon Glassa2505fc2018-11-22 13:46:37 -0700317 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700318 memset(t, 0, sizeof(struct smbios_type0));
319 fill_smbios_header(t, SMBIOS_BIOS_INFORMATION, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700320 smbios_set_eos(ctx, t->eos);
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200321 t->vendor = smbios_add_prop(ctx, NULL, "U-Boot");
Simon Glasse9adaa72021-02-04 21:17:20 -0700322
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200323 t->bios_ver = smbios_add_prop(ctx, "version", PLAIN_VERSION);
Simon Glasse9adaa72021-02-04 21:17:20 -0700324 if (t->bios_ver)
325 gd->smbios_version = ctx->last_str;
326 log_debug("smbios_version = %p: '%s'\n", gd->smbios_version,
327 gd->smbios_version);
328#ifdef LOG_DEBUG
329 print_buffer((ulong)gd->smbios_version, gd->smbios_version,
330 1, strlen(gd->smbios_version) + 1, 0);
331#endif
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200332 t->bios_release_date = smbios_add_prop(ctx, NULL, U_BOOT_DMI_DATE);
Alexander Grafe663b352016-08-19 01:23:29 +0200333#ifdef CONFIG_ROM_SIZE
Bin Meng721e9922015-10-12 05:23:41 -0700334 t->bios_rom_size = (CONFIG_ROM_SIZE / 65536) - 1;
Alexander Grafe663b352016-08-19 01:23:29 +0200335#endif
Bin Meng721e9922015-10-12 05:23:41 -0700336 t->bios_characteristics = BIOS_CHARACTERISTICS_PCI_SUPPORTED |
337 BIOS_CHARACTERISTICS_SELECTABLE_BOOT |
338 BIOS_CHARACTERISTICS_UPGRADEABLE;
339#ifdef CONFIG_GENERATE_ACPI_TABLE
340 t->bios_characteristics_ext1 = BIOS_CHARACTERISTICS_EXT1_ACPI;
341#endif
Alexander Grafe663b352016-08-19 01:23:29 +0200342#ifdef CONFIG_EFI_LOADER
Ilias Apalodimasff192302021-06-09 18:14:47 +0300343 t->bios_characteristics_ext2 |= BIOS_CHARACTERISTICS_EXT2_UEFI;
Alexander Grafe663b352016-08-19 01:23:29 +0200344#endif
Ilias Apalodimasff192302021-06-09 18:14:47 +0300345 t->bios_characteristics_ext2 |= BIOS_CHARACTERISTICS_EXT2_TARGET;
Alexander Grafe663b352016-08-19 01:23:29 +0200346
Simon Glass7617f992021-02-04 21:17:16 -0700347 /* bios_major_release has only one byte, so drop century */
348 t->bios_major_release = U_BOOT_VERSION_NUM % 100;
349 t->bios_minor_release = U_BOOT_VERSION_NUM_PATCH;
Bin Meng721e9922015-10-12 05:23:41 -0700350 t->ec_major_release = 0xff;
351 t->ec_minor_release = 0xff;
352
Simon Glassfd3b8262021-02-04 21:17:19 -0700353 len = t->length + smbios_string_table_len(ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700354 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700355 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700356
357 return len;
358}
359
Simon Glass1e8989a2021-02-04 21:17:17 -0700360static int smbios_write_type1(ulong *current, int handle,
361 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700362{
Simon Glassa2505fc2018-11-22 13:46:37 -0700363 struct smbios_type1 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700364 int len = sizeof(struct smbios_type1);
Simon Glass00caae62017-08-03 12:22:12 -0600365 char *serial_str = env_get("serial#");
Bin Meng721e9922015-10-12 05:23:41 -0700366
Simon Glassa2505fc2018-11-22 13:46:37 -0700367 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700368 memset(t, 0, sizeof(struct smbios_type1));
369 fill_smbios_header(t, SMBIOS_SYSTEM_INFORMATION, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700370 smbios_set_eos(ctx, t->eos);
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200371 t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
372 t->product_name = smbios_add_prop(ctx, "product", "Unknown");
Simon Glass07c9e682021-02-04 21:17:23 -0700373 t->version = smbios_add_prop_si(ctx, "version",
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200374 SYSINFO_ID_SMBIOS_SYSTEM_VERSION,
375 "Unknown");
Alexander Graf6fb580d2016-08-19 01:23:31 +0200376 if (serial_str) {
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200377 t->serial_number = smbios_add_prop(ctx, NULL, serial_str);
Simon Glass44ffb6f2020-11-05 06:32:08 -0700378 strncpy((char *)t->uuid, serial_str, sizeof(t->uuid));
379 } else {
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200380 t->serial_number = smbios_add_prop(ctx, "serial", "Unknown");
Alexander Graf6fb580d2016-08-19 01:23:31 +0200381 }
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200382 t->sku_number = smbios_add_prop(ctx, "sku", "Unknown");
383 t->family = smbios_add_prop(ctx, "family", "Unknown");
Bin Meng721e9922015-10-12 05:23:41 -0700384
Simon Glassfd3b8262021-02-04 21:17:19 -0700385 len = t->length + smbios_string_table_len(ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700386 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700387 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700388
389 return len;
390}
391
Simon Glass1e8989a2021-02-04 21:17:17 -0700392static int smbios_write_type2(ulong *current, int handle,
393 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700394{
Simon Glassa2505fc2018-11-22 13:46:37 -0700395 struct smbios_type2 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700396 int len = sizeof(struct smbios_type2);
397
Simon Glassa2505fc2018-11-22 13:46:37 -0700398 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700399 memset(t, 0, sizeof(struct smbios_type2));
400 fill_smbios_header(t, SMBIOS_BOARD_INFORMATION, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700401 smbios_set_eos(ctx, t->eos);
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200402 t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
403 t->product_name = smbios_add_prop(ctx, "product", "Unknown");
Simon Glass07c9e682021-02-04 21:17:23 -0700404 t->version = smbios_add_prop_si(ctx, "version",
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200405 SYSINFO_ID_SMBIOS_BASEBOARD_VERSION,
406 "Unknown");
407 t->asset_tag_number = smbios_add_prop(ctx, "asset-tag", "Unknown");
Bin Meng721e9922015-10-12 05:23:41 -0700408 t->feature_flags = SMBIOS_BOARD_FEATURE_HOSTING;
409 t->board_type = SMBIOS_BOARD_MOTHERBOARD;
410
Simon Glassfd3b8262021-02-04 21:17:19 -0700411 len = t->length + smbios_string_table_len(ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700412 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700413 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700414
415 return len;
416}
417
Simon Glass1e8989a2021-02-04 21:17:17 -0700418static int smbios_write_type3(ulong *current, int handle,
419 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700420{
Simon Glassa2505fc2018-11-22 13:46:37 -0700421 struct smbios_type3 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700422 int len = sizeof(struct smbios_type3);
423
Simon Glassa2505fc2018-11-22 13:46:37 -0700424 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700425 memset(t, 0, sizeof(struct smbios_type3));
426 fill_smbios_header(t, SMBIOS_SYSTEM_ENCLOSURE, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700427 smbios_set_eos(ctx, t->eos);
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200428 t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
Bin Meng721e9922015-10-12 05:23:41 -0700429 t->chassis_type = SMBIOS_ENCLOSURE_DESKTOP;
430 t->bootup_state = SMBIOS_STATE_SAFE;
431 t->power_supply_state = SMBIOS_STATE_SAFE;
432 t->thermal_state = SMBIOS_STATE_SAFE;
433 t->security_status = SMBIOS_SECURITY_NONE;
434
Simon Glassfd3b8262021-02-04 21:17:19 -0700435 len = t->length + smbios_string_table_len(ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700436 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700437 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700438
439 return len;
440}
441
Simon Glass1e8989a2021-02-04 21:17:17 -0700442static void smbios_write_type4_dm(struct smbios_type4 *t,
443 struct smbios_ctx *ctx)
Alexander Graf96476202016-08-19 01:23:28 +0200444{
445 u16 processor_family = SMBIOS_PROCESSOR_FAMILY_UNKNOWN;
446 const char *vendor = "Unknown";
447 const char *name = "Unknown";
448
449#ifdef CONFIG_CPU
450 char processor_name[49];
451 char vendor_name[49];
Simon Glass78227d42020-11-05 06:32:07 -0700452 struct udevice *cpu = NULL;
Alexander Graf96476202016-08-19 01:23:28 +0200453
Simon Glass78227d42020-11-05 06:32:07 -0700454 uclass_find_first_device(UCLASS_CPU, &cpu);
455 if (cpu) {
Simon Glass8a8d24b2020-12-03 16:55:23 -0700456 struct cpu_plat *plat = dev_get_parent_plat(cpu);
Alexander Graf96476202016-08-19 01:23:28 +0200457
458 if (plat->family)
459 processor_family = plat->family;
460 t->processor_id[0] = plat->id[0];
461 t->processor_id[1] = plat->id[1];
462
Simon Glass78227d42020-11-05 06:32:07 -0700463 if (!cpu_get_vendor(cpu, vendor_name, sizeof(vendor_name)))
Alexander Graf96476202016-08-19 01:23:28 +0200464 vendor = vendor_name;
Simon Glass78227d42020-11-05 06:32:07 -0700465 if (!cpu_get_desc(cpu, processor_name, sizeof(processor_name)))
Alexander Graf96476202016-08-19 01:23:28 +0200466 name = processor_name;
467 }
468#endif
469
470 t->processor_family = processor_family;
Ilias Apalodimasa986cce2023-12-07 11:18:49 +0200471 t->processor_manufacturer = smbios_add_prop(ctx, NULL, vendor);
472 t->processor_version = smbios_add_prop(ctx, NULL, name);
Alexander Graf96476202016-08-19 01:23:28 +0200473}
474
Simon Glass1e8989a2021-02-04 21:17:17 -0700475static int smbios_write_type4(ulong *current, int handle,
476 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700477{
Simon Glassa2505fc2018-11-22 13:46:37 -0700478 struct smbios_type4 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700479 int len = sizeof(struct smbios_type4);
Bin Meng721e9922015-10-12 05:23:41 -0700480
Simon Glassa2505fc2018-11-22 13:46:37 -0700481 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700482 memset(t, 0, sizeof(struct smbios_type4));
483 fill_smbios_header(t, SMBIOS_PROCESSOR_INFORMATION, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700484 smbios_set_eos(ctx, t->eos);
Bin Meng721e9922015-10-12 05:23:41 -0700485 t->processor_type = SMBIOS_PROCESSOR_TYPE_CENTRAL;
Simon Glass1e8989a2021-02-04 21:17:17 -0700486 smbios_write_type4_dm(t, ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700487 t->status = SMBIOS_PROCESSOR_STATUS_ENABLED;
488 t->processor_upgrade = SMBIOS_PROCESSOR_UPGRADE_NONE;
489 t->l1_cache_handle = 0xffff;
490 t->l2_cache_handle = 0xffff;
491 t->l3_cache_handle = 0xffff;
492 t->processor_family2 = t->processor_family;
493
Simon Glassfd3b8262021-02-04 21:17:19 -0700494 len = t->length + smbios_string_table_len(ctx);
Bin Meng721e9922015-10-12 05:23:41 -0700495 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700496 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700497
498 return len;
499}
500
Simon Glass1e8989a2021-02-04 21:17:17 -0700501static int smbios_write_type32(ulong *current, int handle,
502 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700503{
Simon Glassa2505fc2018-11-22 13:46:37 -0700504 struct smbios_type32 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700505 int len = sizeof(struct smbios_type32);
506
Simon Glassa2505fc2018-11-22 13:46:37 -0700507 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700508 memset(t, 0, sizeof(struct smbios_type32));
509 fill_smbios_header(t, SMBIOS_SYSTEM_BOOT_INFORMATION, len, handle);
Simon Glass0c95fff2021-02-04 21:17:18 -0700510 smbios_set_eos(ctx, t->eos);
Bin Meng721e9922015-10-12 05:23:41 -0700511
512 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700513 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700514
515 return len;
516}
517
Simon Glass1e8989a2021-02-04 21:17:17 -0700518static int smbios_write_type127(ulong *current, int handle,
519 struct smbios_ctx *ctx)
Bin Meng721e9922015-10-12 05:23:41 -0700520{
Simon Glassa2505fc2018-11-22 13:46:37 -0700521 struct smbios_type127 *t;
Bin Meng721e9922015-10-12 05:23:41 -0700522 int len = sizeof(struct smbios_type127);
523
Simon Glassa2505fc2018-11-22 13:46:37 -0700524 t = map_sysmem(*current, len);
Bin Meng721e9922015-10-12 05:23:41 -0700525 memset(t, 0, sizeof(struct smbios_type127));
526 fill_smbios_header(t, SMBIOS_END_OF_TABLE, len, handle);
527
528 *current += len;
Simon Glassa2505fc2018-11-22 13:46:37 -0700529 unmap_sysmem(t);
Bin Meng721e9922015-10-12 05:23:41 -0700530
531 return len;
532}
533
Simon Glass44ffb6f2020-11-05 06:32:08 -0700534static struct smbios_write_method smbios_write_funcs[] = {
Simon Glasse9adaa72021-02-04 21:17:20 -0700535 { smbios_write_type0, "bios", },
Simon Glass44ffb6f2020-11-05 06:32:08 -0700536 { smbios_write_type1, "system", },
537 { smbios_write_type2, "baseboard", },
538 { smbios_write_type3, "chassis", },
539 { smbios_write_type4, },
540 { smbios_write_type32, },
541 { smbios_write_type127 },
Bin Meng721e9922015-10-12 05:23:41 -0700542};
543
Simon Glass42fd8c12017-01-16 07:03:35 -0700544ulong write_smbios_table(ulong addr)
Bin Meng721e9922015-10-12 05:23:41 -0700545{
Simon Glass44ffb6f2020-11-05 06:32:08 -0700546 ofnode parent_node = ofnode_null();
Simon Glassf19cf8d2023-12-31 08:25:45 -0700547 ulong table_addr, start_addr;
Simon Glass1c5f6fa2023-12-31 08:25:51 -0700548 struct smbios3_entry *se;
Simon Glass1e8989a2021-02-04 21:17:17 -0700549 struct smbios_ctx ctx;
Simon Glass42fd8c12017-01-16 07:03:35 -0700550 ulong tables;
Bin Meng721e9922015-10-12 05:23:41 -0700551 int len = 0;
552 int max_struct_size = 0;
553 int handle = 0;
Bin Meng721e9922015-10-12 05:23:41 -0700554 int i;
555
Simon Glass1e8989a2021-02-04 21:17:17 -0700556 ctx.node = ofnode_null();
Simon Glass78227d42020-11-05 06:32:07 -0700557 if (IS_ENABLED(CONFIG_OF_CONTROL)) {
Simon Glass1e8989a2021-02-04 21:17:17 -0700558 uclass_first_device(UCLASS_SYSINFO, &ctx.dev);
559 if (ctx.dev)
560 parent_node = dev_read_subnode(ctx.dev, "smbios");
561 } else {
562 ctx.dev = NULL;
Simon Glass78227d42020-11-05 06:32:07 -0700563 }
564
Simon Glassf19cf8d2023-12-31 08:25:45 -0700565 start_addr = addr;
Bin Meng721e9922015-10-12 05:23:41 -0700566
Simon Glass1c5f6fa2023-12-31 08:25:51 -0700567 /* move past the (so-far-unwritten) header to start writing structs */
568 addr = ALIGN(addr + sizeof(struct smbios3_entry), 16);
Bin Meng721e9922015-10-12 05:23:41 -0700569 tables = addr;
570
571 /* populate minimum required tables */
572 for (i = 0; i < ARRAY_SIZE(smbios_write_funcs); i++) {
Simon Glass44ffb6f2020-11-05 06:32:08 -0700573 const struct smbios_write_method *method;
Simon Glass44ffb6f2020-11-05 06:32:08 -0700574 int tmp;
575
576 method = &smbios_write_funcs[i];
577 if (IS_ENABLED(CONFIG_OF_CONTROL) && method->subnode_name)
Simon Glass1e8989a2021-02-04 21:17:17 -0700578 ctx.node = ofnode_find_subnode(parent_node,
579 method->subnode_name);
580 tmp = method->write((ulong *)&addr, handle++, &ctx);
Christian Gmeiner60a4df32018-07-30 13:22:07 +0200581
Bin Meng721e9922015-10-12 05:23:41 -0700582 max_struct_size = max(max_struct_size, tmp);
583 len += tmp;
584 }
585
Simon Glassa2505fc2018-11-22 13:46:37 -0700586 /*
587 * We must use a pointer here so things work correctly on sandbox. The
588 * user of this table is not aware of the mapping of addresses to
589 * sandbox's DRAM buffer.
590 */
591 table_addr = (ulong)map_sysmem(tables, 0);
Simon Glassf19cf8d2023-12-31 08:25:45 -0700592
Simon Glass1c5f6fa2023-12-31 08:25:51 -0700593 /* now go back and write the SMBIOS3 header */
594 se = map_sysmem(start_addr, sizeof(struct smbios_entry));
595 memset(se, '\0', sizeof(struct smbios_entry));
596 memcpy(se->anchor, "_SM3_", 5);
597 se->length = sizeof(struct smbios3_entry);
598 se->major_ver = SMBIOS_MAJOR_VER;
599 se->minor_ver = SMBIOS_MINOR_VER;
600 se->doc_rev = 0;
601 se->entry_point_rev = 1;
602 se->max_struct_size = len;
603 se->struct_table_address = table_addr;
604 se->checksum = table_compute_checksum(se, sizeof(struct smbios3_entry));
605 unmap_sysmem(se);
Bin Meng721e9922015-10-12 05:23:41 -0700606
607 return addr;
608}