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 <dm.h> 9#include <env.h> 10#include <linux/stringify.h> 11#include <linux/string.h> 12#include <mapmem.h> 13#include <smbios.h> 14#include <sysinfo.h> 15#include <tables_csum.h> 16#include <version.h> 17#include <malloc.h> 18#include <dm/ofnode.h> 19#ifdef CONFIG_CPU 20#include <cpu.h> 21#include <dm/uclass-internal.h> 22#endif 23 24/* 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 46DECLARE_GLOBAL_DATA_PTR; 47 48/** 49 * struct map_sysinfo - Mapping of sysinfo strings to DT 50 * 51 * @si_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 *si_node; 58 const char *si_str; 59 const char *dt_str; 60 int max; 61}; 62 63static const struct map_sysinfo sysinfo_to_dt[] = { 64 { .si_node = "system", .si_str = "product", .dt_str = "model", 2 }, 65 { .si_node = "system", .si_str = "manufacturer", .dt_str = "compatible", 1 }, 66 { .si_node = "baseboard", .si_str = "product", .dt_str = "model", 2 }, 67 { .si_node = "baseboard", .si_str = "manufacturer", .dt_str = "compatible", 1 }, 68}; 69 70/** 71 * struct smbios_ctx - context for writing SMBIOS tables 72 * 73 * @node: node containing the information to write (ofnode_null() 74 * if none) 75 * @dev: sysinfo device to use (NULL if none) 76 * @subnode_name: sysinfo subnode_name. Used for DT fallback 77 * @eos: end-of-string pointer for the table being processed. 78 * This is set up when we start processing a table 79 * @next_ptr: pointer to the start of the next string to be added. 80 * When the table is not empty, this points to the byte 81 * after the \0 of the previous string. 82 * @last_str: points to the last string that was written to the table, 83 * or NULL if none 84 */ 85struct smbios_ctx { 86 ofnode node; 87 struct udevice *dev; 88 const char *subnode_name; 89 char *eos; 90 char *next_ptr; 91 char *last_str; 92}; 93 94/** 95 * Function prototype to write a specific type of SMBIOS structure 96 * 97 * @addr: start address to write the structure 98 * @handle: the structure's handle, a unique 16-bit number 99 * @ctx: context for writing the tables 100 * Return: size of the structure 101 */ 102typedef int (*smbios_write_type)(ulong *addr, int handle, 103 struct smbios_ctx *ctx); 104 105/** 106 * struct smbios_write_method - Information about a table-writing function 107 * 108 * @write: Function to call 109 * @subnode_name: Name of subnode which has the information for this function, 110 * NULL if none 111 */ 112struct smbios_write_method { 113 smbios_write_type write; 114 const char *subnode_name; 115}; 116 117static const struct map_sysinfo *convert_sysinfo_to_dt(const char *node, const char *si) 118{ 119 int i; 120 121 for (i = 0; i < ARRAY_SIZE(sysinfo_to_dt); i++) { 122 if (node && !strcmp(node, sysinfo_to_dt[i].si_node) && 123 !strcmp(si, sysinfo_to_dt[i].si_str)) 124 return &sysinfo_to_dt[i]; 125 } 126 127 return NULL; 128} 129 130/** 131 * smbios_add_string() - add a string to the string area 132 * 133 * This adds a string to the string area which is appended directly after 134 * the formatted portion of an SMBIOS structure. 135 * 136 * @ctx: SMBIOS context 137 * @str: string to add 138 * Return: string number in the string area. 0 if str is NULL. 139 */ 140static int smbios_add_string(struct smbios_ctx *ctx, const char *str) 141{ 142 int i = 1; 143 char *p = ctx->eos; 144 145 if (!str) 146 return 0; 147 148 for (;;) { 149 if (!*p) { 150 ctx->last_str = p; 151 strcpy(p, str); 152 p += strlen(str); 153 *p++ = '\0'; 154 ctx->next_ptr = p; 155 *p++ = '\0'; 156 157 return i; 158 } 159 160 if (!strcmp(p, str)) { 161 ctx->last_str = p; 162 return i; 163 } 164 165 p += strlen(p) + 1; 166 i++; 167 } 168} 169 170/** 171 * get_str_from_dt - Get a substring from a DT property. 172 * After finding the property in the DT, the function 173 * will parse comma-separated values and return the value. 174 * If nprop->max exceeds the number of comma-separated 175 * elements, the last non NULL value will be returned. 176 * Counting starts from zero. 177 * 178 * @nprop: sysinfo property to use 179 * @str: pointer to fill with data 180 * @size: str buffer length 181 */ 182static 183void get_str_from_dt(const struct map_sysinfo *nprop, char *str, size_t size) 184{ 185 const char *dt_str; 186 int cnt = 0; 187 char *token; 188 189 memset(str, 0, size); 190 if (!nprop || !nprop->max) 191 return; 192 193 dt_str = ofnode_read_string(ofnode_root(), nprop->dt_str); 194 if (!dt_str) 195 return; 196 197 memcpy(str, dt_str, size); 198 token = strtok(str, ","); 199 while (token && cnt < nprop->max) { 200 strlcpy(str, token, strlen(token) + 1); 201 token = strtok(NULL, ","); 202 cnt++; 203 } 204} 205 206/** 207 * smbios_add_prop_si() - Add a property from the devicetree or sysinfo 208 * 209 * Sysinfo is used if available, with a fallback to devicetree 210 * 211 * @ctx: context for writing the tables 212 * @prop: property to write 213 * @sysinfo_id: unique identifier for the string value to be read 214 * @dval: Default value to use if the string is not found or is empty 215 * Return: 0 if not found, else SMBIOS string number (1 or more) 216 */ 217static int smbios_add_prop_si(struct smbios_ctx *ctx, const char *prop, 218 int sysinfo_id, const char *dval) 219{ 220 int ret; 221 222 if (!dval || !*dval) 223 dval = NULL; 224 225 if (!prop) 226 return smbios_add_string(ctx, dval); 227 228 if (sysinfo_id && ctx->dev) { 229 char val[SMBIOS_STR_MAX]; 230 231 ret = sysinfo_get_str(ctx->dev, sysinfo_id, sizeof(val), val); 232 if (!ret) 233 return smbios_add_string(ctx, val); 234 } 235 if (IS_ENABLED(CONFIG_OF_CONTROL)) { 236 const char *str = NULL; 237 char str_dt[128] = { 0 }; 238 /* 239 * If the node is not valid fallback and try the entire DT 240 * so we can at least fill in manufacturer and board type 241 */ 242 if (ofnode_valid(ctx->node)) { 243 str = ofnode_read_string(ctx->node, prop); 244 } else { 245 const struct map_sysinfo *nprop; 246 247 nprop = convert_sysinfo_to_dt(ctx->subnode_name, prop); 248 get_str_from_dt(nprop, str_dt, sizeof(str_dt)); 249 str = (const char *)str_dt; 250 } 251 252 ret = smbios_add_string(ctx, str && *str ? str : dval); 253 return ret; 254 } 255 256 return 0; 257} 258 259/** 260 * smbios_add_prop() - Add a property from the devicetree 261 * 262 * @prop: property to write. The default string will be written if 263 * prop is NULL 264 * @dval: Default value to use if the string is not found or is empty 265 * Return: 0 if not found, else SMBIOS string number (1 or more) 266 */ 267static int smbios_add_prop(struct smbios_ctx *ctx, const char *prop, 268 const char *dval) 269{ 270 return smbios_add_prop_si(ctx, prop, SYSINFO_ID_NONE, dval); 271} 272 273static void smbios_set_eos(struct smbios_ctx *ctx, char *eos) 274{ 275 ctx->eos = eos; 276 ctx->next_ptr = eos; 277 ctx->last_str = NULL; 278} 279 280int smbios_update_version(const char *version) 281{ 282 char *ptr = gd->smbios_version; 283 uint old_len, len; 284 285 if (!ptr) 286 return log_ret(-ENOENT); 287 288 /* 289 * This string is supposed to have at least enough bytes and is 290 * padded with spaces. Update it, taking care not to move the 291 * \0 terminator, so that other strings in the string table 292 * are not disturbed. See smbios_add_string() 293 */ 294 old_len = strnlen(ptr, SMBIOS_STR_MAX); 295 len = strnlen(version, SMBIOS_STR_MAX); 296 if (len > old_len) 297 return log_ret(-ENOSPC); 298 299 log_debug("Replacing SMBIOS type 0 version string '%s'\n", ptr); 300 memcpy(ptr, version, len); 301#ifdef LOG_DEBUG 302 print_buffer((ulong)ptr, ptr, 1, old_len + 1, 0); 303#endif 304 305 return 0; 306} 307 308/** 309 * smbios_string_table_len() - compute the string area size 310 * 311 * This computes the size of the string area including the string terminator. 312 * 313 * @ctx: SMBIOS context 314 * Return: string area size 315 */ 316static int smbios_string_table_len(const struct smbios_ctx *ctx) 317{ 318 /* In case no string is defined we have to return two \0 */ 319 if (ctx->next_ptr == ctx->eos) 320 return 2; 321 322 /* Allow for the final \0 after all strings */ 323 return (ctx->next_ptr + 1) - ctx->eos; 324} 325 326static int smbios_write_type0(ulong *current, int handle, 327 struct smbios_ctx *ctx) 328{ 329 struct smbios_type0 *t; 330 int len = sizeof(struct smbios_type0); 331 332 t = map_sysmem(*current, len); 333 memset(t, 0, sizeof(struct smbios_type0)); 334 fill_smbios_header(t, SMBIOS_BIOS_INFORMATION, len, handle); 335 smbios_set_eos(ctx, t->eos); 336 t->vendor = smbios_add_prop(ctx, NULL, "U-Boot"); 337 338 t->bios_ver = smbios_add_prop(ctx, "version", PLAIN_VERSION); 339 if (t->bios_ver) 340 gd->smbios_version = ctx->last_str; 341 log_debug("smbios_version = %p: '%s'\n", gd->smbios_version, 342 gd->smbios_version); 343#ifdef LOG_DEBUG 344 print_buffer((ulong)gd->smbios_version, gd->smbios_version, 345 1, strlen(gd->smbios_version) + 1, 0); 346#endif 347 t->bios_release_date = smbios_add_prop(ctx, NULL, U_BOOT_DMI_DATE); 348#ifdef CONFIG_ROM_SIZE 349 t->bios_rom_size = (CONFIG_ROM_SIZE / 65536) - 1; 350#endif 351 t->bios_characteristics = BIOS_CHARACTERISTICS_PCI_SUPPORTED | 352 BIOS_CHARACTERISTICS_SELECTABLE_BOOT | 353 BIOS_CHARACTERISTICS_UPGRADEABLE; 354#ifdef CONFIG_GENERATE_ACPI_TABLE 355 t->bios_characteristics_ext1 = BIOS_CHARACTERISTICS_EXT1_ACPI; 356#endif 357#ifdef CONFIG_EFI_LOADER 358 t->bios_characteristics_ext2 |= BIOS_CHARACTERISTICS_EXT2_UEFI; 359#endif 360 t->bios_characteristics_ext2 |= BIOS_CHARACTERISTICS_EXT2_TARGET; 361 362 /* bios_major_release has only one byte, so drop century */ 363 t->bios_major_release = U_BOOT_VERSION_NUM % 100; 364 t->bios_minor_release = U_BOOT_VERSION_NUM_PATCH; 365 t->ec_major_release = 0xff; 366 t->ec_minor_release = 0xff; 367 368 len = t->length + smbios_string_table_len(ctx); 369 *current += len; 370 unmap_sysmem(t); 371 372 return len; 373} 374 375static int smbios_write_type1(ulong *current, int handle, 376 struct smbios_ctx *ctx) 377{ 378 struct smbios_type1 *t; 379 int len = sizeof(struct smbios_type1); 380 char *serial_str = env_get("serial#"); 381 382 t = map_sysmem(*current, len); 383 memset(t, 0, sizeof(struct smbios_type1)); 384 fill_smbios_header(t, SMBIOS_SYSTEM_INFORMATION, len, handle); 385 smbios_set_eos(ctx, t->eos); 386 t->manufacturer = smbios_add_prop(ctx, "manufacturer", NULL); 387 t->product_name = smbios_add_prop(ctx, "product", NULL); 388 t->version = smbios_add_prop_si(ctx, "version", 389 SYSINFO_ID_SMBIOS_SYSTEM_VERSION, 390 NULL); 391 if (serial_str) { 392 t->serial_number = smbios_add_prop(ctx, NULL, serial_str); 393 strncpy((char *)t->uuid, serial_str, sizeof(t->uuid)); 394 } else { 395 t->serial_number = smbios_add_prop(ctx, "serial", NULL); 396 } 397 t->wakeup_type = SMBIOS_WAKEUP_TYPE_UNKNOWN; 398 t->sku_number = smbios_add_prop(ctx, "sku", NULL); 399 t->family = smbios_add_prop(ctx, "family", NULL); 400 401 len = t->length + smbios_string_table_len(ctx); 402 *current += len; 403 unmap_sysmem(t); 404 405 return len; 406} 407 408static int smbios_write_type2(ulong *current, int handle, 409 struct smbios_ctx *ctx) 410{ 411 struct smbios_type2 *t; 412 int len = sizeof(struct smbios_type2); 413 414 t = map_sysmem(*current, len); 415 memset(t, 0, sizeof(struct smbios_type2)); 416 fill_smbios_header(t, SMBIOS_BOARD_INFORMATION, len, handle); 417 smbios_set_eos(ctx, t->eos); 418 t->manufacturer = smbios_add_prop(ctx, "manufacturer", NULL); 419 t->product_name = smbios_add_prop(ctx, "product", NULL); 420 t->version = smbios_add_prop_si(ctx, "version", 421 SYSINFO_ID_SMBIOS_BASEBOARD_VERSION, 422 NULL); 423 t->asset_tag_number = smbios_add_prop(ctx, "asset-tag", NULL); 424 t->feature_flags = SMBIOS_BOARD_FEATURE_HOSTING; 425 t->board_type = SMBIOS_BOARD_MOTHERBOARD; 426 t->chassis_handle = handle + 1; 427 428 len = t->length + smbios_string_table_len(ctx); 429 *current += len; 430 unmap_sysmem(t); 431 432 return len; 433} 434 435static int smbios_write_type3(ulong *current, int handle, 436 struct smbios_ctx *ctx) 437{ 438 struct smbios_type3 *t; 439 int len = sizeof(struct smbios_type3); 440 441 t = map_sysmem(*current, len); 442 memset(t, 0, sizeof(struct smbios_type3)); 443 fill_smbios_header(t, SMBIOS_SYSTEM_ENCLOSURE, len, handle); 444 smbios_set_eos(ctx, t->eos); 445 t->manufacturer = smbios_add_prop(ctx, "manufacturer", NULL); 446 t->chassis_type = SMBIOS_ENCLOSURE_DESKTOP; 447 t->bootup_state = SMBIOS_STATE_SAFE; 448 t->power_supply_state = SMBIOS_STATE_SAFE; 449 t->thermal_state = SMBIOS_STATE_SAFE; 450 t->security_status = SMBIOS_SECURITY_NONE; 451 452 len = t->length + smbios_string_table_len(ctx); 453 *current += len; 454 unmap_sysmem(t); 455 456 return len; 457} 458 459static void smbios_write_type4_dm(struct smbios_type4 *t, 460 struct smbios_ctx *ctx) 461{ 462 u16 processor_family = SMBIOS_PROCESSOR_FAMILY_UNKNOWN; 463 const char *vendor = NULL; 464 const char *name = NULL; 465 466#ifdef CONFIG_CPU 467 char processor_name[49]; 468 char vendor_name[49]; 469 struct udevice *cpu = NULL; 470 471 uclass_find_first_device(UCLASS_CPU, &cpu); 472 if (cpu) { 473 struct cpu_plat *plat = dev_get_parent_plat(cpu); 474 475 if (plat->family) 476 processor_family = plat->family; 477 t->processor_id[0] = plat->id[0]; 478 t->processor_id[1] = plat->id[1]; 479 480 if (!cpu_get_vendor(cpu, vendor_name, sizeof(vendor_name))) 481 vendor = vendor_name; 482 if (!cpu_get_desc(cpu, processor_name, sizeof(processor_name))) 483 name = processor_name; 484 } 485#endif 486 487 t->processor_family = 0xfe; 488 t->processor_family2 = processor_family; 489 t->processor_manufacturer = smbios_add_prop(ctx, NULL, vendor); 490 t->processor_version = smbios_add_prop(ctx, NULL, name); 491} 492 493static int smbios_write_type4(ulong *current, int handle, 494 struct smbios_ctx *ctx) 495{ 496 struct smbios_type4 *t; 497 int len = sizeof(struct smbios_type4); 498 499 t = map_sysmem(*current, len); 500 memset(t, 0, sizeof(struct smbios_type4)); 501 fill_smbios_header(t, SMBIOS_PROCESSOR_INFORMATION, len, handle); 502 smbios_set_eos(ctx, t->eos); 503 t->processor_type = SMBIOS_PROCESSOR_TYPE_CENTRAL; 504 smbios_write_type4_dm(t, ctx); 505 t->status = SMBIOS_PROCESSOR_STATUS_ENABLED; 506 t->processor_upgrade = SMBIOS_PROCESSOR_UPGRADE_NONE; 507 t->l1_cache_handle = 0xffff; 508 t->l2_cache_handle = 0xffff; 509 t->l3_cache_handle = 0xffff; 510 511 len = t->length + smbios_string_table_len(ctx); 512 *current += len; 513 unmap_sysmem(t); 514 515 return len; 516} 517 518static int smbios_write_type32(ulong *current, int handle, 519 struct smbios_ctx *ctx) 520{ 521 struct smbios_type32 *t; 522 int len = sizeof(struct smbios_type32); 523 524 t = map_sysmem(*current, len); 525 memset(t, 0, sizeof(struct smbios_type32)); 526 fill_smbios_header(t, SMBIOS_SYSTEM_BOOT_INFORMATION, len, handle); 527 smbios_set_eos(ctx, t->eos); 528 529 *current += len; 530 unmap_sysmem(t); 531 532 return len; 533} 534 535static int smbios_write_type127(ulong *current, int handle, 536 struct smbios_ctx *ctx) 537{ 538 struct smbios_type127 *t; 539 int len = sizeof(struct smbios_type127); 540 541 t = map_sysmem(*current, len); 542 memset(t, 0, sizeof(struct smbios_type127)); 543 fill_smbios_header(t, SMBIOS_END_OF_TABLE, len, handle); 544 545 *current += len; 546 unmap_sysmem(t); 547 548 return len; 549} 550 551static struct smbios_write_method smbios_write_funcs[] = { 552 { smbios_write_type0, "bios", }, 553 { smbios_write_type1, "system", }, 554 { smbios_write_type2, "baseboard", }, 555 /* Type 3 must immediately follow type 2 due to chassis handle. */ 556 { smbios_write_type3, "chassis", }, 557 { smbios_write_type4, }, 558 { smbios_write_type32, }, 559 { smbios_write_type127 }, 560}; 561 562ulong write_smbios_table(ulong addr) 563{ 564 ofnode parent_node = ofnode_null(); 565 ulong table_addr, start_addr; 566 struct smbios3_entry *se; 567 struct smbios_ctx ctx; 568 ulong tables; 569 int len = 0; 570 int handle = 0; 571 int i; 572 573 ctx.node = ofnode_null(); 574 if (IS_ENABLED(CONFIG_OF_CONTROL)) { 575 uclass_first_device(UCLASS_SYSINFO, &ctx.dev); 576 if (ctx.dev) 577 parent_node = dev_read_subnode(ctx.dev, "smbios"); 578 } else { 579 ctx.dev = NULL; 580 } 581 582 start_addr = addr; 583 584 /* move past the (so-far-unwritten) header to start writing structs */ 585 addr = ALIGN(addr + sizeof(struct smbios3_entry), 16); 586 tables = addr; 587 588 /* populate minimum required tables */ 589 for (i = 0; i < ARRAY_SIZE(smbios_write_funcs); i++) { 590 const struct smbios_write_method *method; 591 592 method = &smbios_write_funcs[i]; 593 ctx.subnode_name = NULL; 594 if (method->subnode_name) { 595 ctx.subnode_name = method->subnode_name; 596 if (IS_ENABLED(CONFIG_OF_CONTROL)) 597 ctx.node = ofnode_find_subnode(parent_node, 598 method->subnode_name); 599 } 600 len += method->write((ulong *)&addr, handle++, &ctx); 601 } 602 603 /* 604 * We must use a pointer here so things work correctly on sandbox. The 605 * user of this table is not aware of the mapping of addresses to 606 * sandbox's DRAM buffer. 607 */ 608 table_addr = (ulong)map_sysmem(tables, 0); 609 610 /* now go back and write the SMBIOS3 header */ 611 se = map_sysmem(start_addr, sizeof(struct smbios3_entry)); 612 memset(se, '\0', sizeof(struct smbios3_entry)); 613 memcpy(se->anchor, "_SM3_", 5); 614 se->length = sizeof(struct smbios3_entry); 615 se->major_ver = SMBIOS_MAJOR_VER; 616 se->minor_ver = SMBIOS_MINOR_VER; 617 se->doc_rev = 0; 618 se->entry_point_rev = 1; 619 se->table_maximum_size = len; 620 se->struct_table_address = table_addr; 621 se->checksum = table_compute_checksum(se, sizeof(struct smbios3_entry)); 622 unmap_sysmem(se); 623 624 return addr; 625} 626