* Adapted from coreboot src/arch/x86/smbios.c
*/
-#include <common.h>
+#define LOG_CATEGORY LOGC_BOARD
+
#include <dm.h>
#include <env.h>
#include <linux/stringify.h>
#include <cpu.h>
#include <dm/uclass-internal.h>
#endif
+#include <linux/sizes.h>
/* Safeguard for checking that U_BOOT_VERSION_NUM macros are compatible with U_BOOT_DMI */
#if U_BOOT_VERSION_NUM < 2000 || U_BOOT_VERSION_NUM > 2099 || \
/**
* struct map_sysinfo - Mapping of sysinfo strings to DT
*
- * @sysinfo_str: sysinfo string
+ * @si_str: sysinfo string
* @dt_str: DT string
* @max: Max index of the tokenized string to pick. Counting starts from 0
*
*/
struct map_sysinfo {
- const char *sysinfo_str;
+ const char *si_node;
+ const char *si_str;
const char *dt_str;
int max;
};
static const struct map_sysinfo sysinfo_to_dt[] = {
- { .sysinfo_str = "product", .dt_str = "model", 2 },
- { .sysinfo_str = "manufacturer", .dt_str = "compatible", 1 },
+ { .si_node = "system", .si_str = "product", .dt_str = "model", 2 },
+ { .si_node = "system", .si_str = "manufacturer", .dt_str = "compatible", 1 },
+ { .si_node = "baseboard", .si_str = "product", .dt_str = "model", 2 },
+ { .si_node = "baseboard", .si_str = "manufacturer", .dt_str = "compatible", 1 },
};
/**
* struct smbios_ctx - context for writing SMBIOS tables
*
- * @node: node containing the information to write (ofnode_null() if none)
- * @dev: sysinfo device to use (NULL if none)
- * @eos: end-of-string pointer for the table being processed. This is set
- * up when we start processing a table
- * @next_ptr: pointer to the start of the next string to be added. When the
- * table is nopt empty, this points to the byte after the \0 of the
- * previous string.
- * @last_str: points to the last string that was written to the table, or NULL
- * if none
+ * @node: node containing the information to write (ofnode_null()
+ * if none)
+ * @dev: sysinfo device to use (NULL if none)
+ * @subnode_name: sysinfo subnode_name. Used for DT fallback
+ * @eos: end-of-string pointer for the table being processed.
+ * This is set up when we start processing a table
+ * @next_ptr: pointer to the start of the next string to be added.
+ * When the table is not empty, this points to the byte
+ * after the \0 of the previous string.
+ * @last_str: points to the last string that was written to the table,
+ * or NULL if none
*/
struct smbios_ctx {
ofnode node;
struct udevice *dev;
+ const char *subnode_name;
char *eos;
char *next_ptr;
char *last_str;
const char *subnode_name;
};
-static const struct map_sysinfo *convert_sysinfo_to_dt(const char *sysinfo_str)
+static const struct map_sysinfo *convert_sysinfo_to_dt(const char *node, const char *si)
{
int i;
for (i = 0; i < ARRAY_SIZE(sysinfo_to_dt); i++) {
- if (!strcmp(sysinfo_str, sysinfo_to_dt[i].sysinfo_str))
+ if (node && !strcmp(node, sysinfo_to_dt[i].si_node) &&
+ !strcmp(si, sysinfo_to_dt[i].si_str))
return &sysinfo_to_dt[i];
}
*
* @ctx: SMBIOS context
* @str: string to add
- * Return: string number in the string area (1 or more)
+ * Return: string number in the string area. 0 if str is NULL.
*/
static int smbios_add_string(struct smbios_ctx *ctx, const char *str)
{
int i = 1;
char *p = ctx->eos;
+ if (!str)
+ return 0;
+
for (;;) {
if (!*p) {
ctx->last_str = p;
*
* @ctx: context for writing the tables
* @prop: property to write
+ * @sysinfo_id: unique identifier for the string value to be read
* @dval: Default value to use if the string is not found or is empty
* Return: 0 if not found, else SMBIOS string number (1 or more)
*/
int ret;
if (!dval || !*dval)
- dval = "Unknown";
+ dval = NULL;
if (!prop)
return smbios_add_string(ctx, dval);
} else {
const struct map_sysinfo *nprop;
- nprop = convert_sysinfo_to_dt(prop);
+ nprop = convert_sysinfo_to_dt(ctx->subnode_name, prop);
get_str_from_dt(nprop, str_dt, sizeof(str_dt));
str = (const char *)str_dt;
}
*/
static int smbios_string_table_len(const struct smbios_ctx *ctx)
{
+ /* In case no string is defined we have to return two \0 */
+ if (ctx->next_ptr == ctx->eos)
+ return 2;
+
/* Allow for the final \0 after all strings */
return (ctx->next_ptr + 1) - ctx->eos;
}
#endif
t->bios_release_date = smbios_add_prop(ctx, NULL, U_BOOT_DMI_DATE);
#ifdef CONFIG_ROM_SIZE
- t->bios_rom_size = (CONFIG_ROM_SIZE / 65536) - 1;
+ if (CONFIG_ROM_SIZE < SZ_16M) {
+ t->bios_rom_size = (CONFIG_ROM_SIZE / 65536) - 1;
+ } else {
+ /* CONFIG_ROM_SIZE < 8 GiB */
+ t->bios_rom_size = 0xff;
+ t->extended_bios_rom_size = CONFIG_ROM_SIZE >> 20;
+ }
#endif
t->bios_characteristics = BIOS_CHARACTERISTICS_PCI_SUPPORTED |
BIOS_CHARACTERISTICS_SELECTABLE_BOOT |
memset(t, 0, sizeof(struct smbios_type1));
fill_smbios_header(t, SMBIOS_SYSTEM_INFORMATION, len, handle);
smbios_set_eos(ctx, t->eos);
- t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
- t->product_name = smbios_add_prop(ctx, "product", "Unknown");
+ t->manufacturer = smbios_add_prop_si(ctx, "manufacturer",
+ SYSINFO_ID_SMBIOS_SYSTEM_MANUFACTURER,
+ NULL);
+ t->product_name = smbios_add_prop_si(ctx, "product",
+ SYSINFO_ID_SMBIOS_SYSTEM_PRODUCT,
+ NULL);
t->version = smbios_add_prop_si(ctx, "version",
SYSINFO_ID_SMBIOS_SYSTEM_VERSION,
- "Unknown");
+ NULL);
if (serial_str) {
t->serial_number = smbios_add_prop(ctx, NULL, serial_str);
strncpy((char *)t->uuid, serial_str, sizeof(t->uuid));
} else {
- t->serial_number = smbios_add_prop(ctx, "serial", "Unknown");
+ t->serial_number = smbios_add_prop_si(ctx, "serial",
+ SYSINFO_ID_SMBIOS_SYSTEM_SERIAL,
+ NULL);
}
- t->sku_number = smbios_add_prop(ctx, "sku", "Unknown");
- t->family = smbios_add_prop(ctx, "family", "Unknown");
+ t->wakeup_type = SMBIOS_WAKEUP_TYPE_UNKNOWN;
+ t->sku_number = smbios_add_prop_si(ctx, "sku",
+ SYSINFO_ID_SMBIOS_SYSTEM_SKU, NULL);
+ t->family = smbios_add_prop_si(ctx, "family",
+ SYSINFO_ID_SMBIOS_SYSTEM_FAMILY, NULL);
len = t->length + smbios_string_table_len(ctx);
*current += len;
memset(t, 0, sizeof(struct smbios_type2));
fill_smbios_header(t, SMBIOS_BOARD_INFORMATION, len, handle);
smbios_set_eos(ctx, t->eos);
- t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
- t->product_name = smbios_add_prop(ctx, "product", "Unknown");
+ t->manufacturer = smbios_add_prop_si(ctx, "manufacturer",
+ SYSINFO_ID_SMBIOS_BASEBOARD_MANUFACTURER,
+ NULL);
+ t->product_name = smbios_add_prop_si(ctx, "product",
+ SYSINFO_ID_SMBIOS_BASEBOARD_PRODUCT,
+ NULL);
t->version = smbios_add_prop_si(ctx, "version",
SYSINFO_ID_SMBIOS_BASEBOARD_VERSION,
- "Unknown");
- t->asset_tag_number = smbios_add_prop(ctx, "asset-tag", "Unknown");
+ NULL);
+
+ t->serial_number = smbios_add_prop_si(ctx, "serial",
+ SYSINFO_ID_SMBIOS_BASEBOARD_SERIAL,
+ NULL);
+ t->asset_tag_number = smbios_add_prop_si(ctx, "asset-tag",
+ SYSINFO_ID_SMBIOS_BASEBOARD_ASSET_TAG,
+ NULL);
t->feature_flags = SMBIOS_BOARD_FEATURE_HOSTING;
t->board_type = SMBIOS_BOARD_MOTHERBOARD;
+ t->chassis_handle = handle + 1;
len = t->length + smbios_string_table_len(ctx);
*current += len;
memset(t, 0, sizeof(struct smbios_type3));
fill_smbios_header(t, SMBIOS_SYSTEM_ENCLOSURE, len, handle);
smbios_set_eos(ctx, t->eos);
- t->manufacturer = smbios_add_prop(ctx, "manufacturer", "Unknown");
+ t->manufacturer = smbios_add_prop(ctx, "manufacturer", NULL);
t->chassis_type = SMBIOS_ENCLOSURE_DESKTOP;
t->bootup_state = SMBIOS_STATE_SAFE;
t->power_supply_state = SMBIOS_STATE_SAFE;
struct smbios_ctx *ctx)
{
u16 processor_family = SMBIOS_PROCESSOR_FAMILY_UNKNOWN;
- const char *vendor = "Unknown";
- const char *name = "Unknown";
+ const char *vendor = NULL;
+ const char *name = NULL;
#ifdef CONFIG_CPU
char processor_name[49];
}
#endif
- t->processor_family = processor_family;
+ t->processor_family = 0xfe;
+ t->processor_family2 = processor_family;
t->processor_manufacturer = smbios_add_prop(ctx, NULL, vendor);
t->processor_version = smbios_add_prop(ctx, NULL, name);
}
t->l1_cache_handle = 0xffff;
t->l2_cache_handle = 0xffff;
t->l3_cache_handle = 0xffff;
- t->processor_family2 = t->processor_family;
len = t->length + smbios_string_table_len(ctx);
*current += len;
{ smbios_write_type0, "bios", },
{ smbios_write_type1, "system", },
{ smbios_write_type2, "baseboard", },
+ /* Type 3 must immediately follow type 2 due to chassis handle. */
{ smbios_write_type3, "chassis", },
{ smbios_write_type4, },
{ smbios_write_type32, },
ulong write_smbios_table(ulong addr)
{
ofnode parent_node = ofnode_null();
- struct smbios_entry *se;
+ ulong table_addr, start_addr;
+ struct smbios3_entry *se;
struct smbios_ctx ctx;
- ulong table_addr;
ulong tables;
int len = 0;
- int max_struct_size = 0;
int handle = 0;
- char *istart;
- int isize;
int i;
ctx.node = ofnode_null();
- if (IS_ENABLED(CONFIG_OF_CONTROL)) {
+ if (IS_ENABLED(CONFIG_OF_CONTROL) && CONFIG_IS_ENABLED(SYSINFO)) {
uclass_first_device(UCLASS_SYSINFO, &ctx.dev);
- if (ctx.dev)
+ if (ctx.dev) {
+ int ret;
+
parent_node = dev_read_subnode(ctx.dev, "smbios");
+ ret = sysinfo_detect(ctx.dev);
+
+ /*
+ * ignore the error since many boards don't implement
+ * this and we can still use the info in the devicetree
+ */
+ ret = log_msg_ret("sys", ret);
+ }
} else {
ctx.dev = NULL;
}
- /* 16 byte align the table address */
- addr = ALIGN(addr, 16);
-
- se = map_sysmem(addr, sizeof(struct smbios_entry));
- memset(se, 0, sizeof(struct smbios_entry));
+ start_addr = addr;
- addr += sizeof(struct smbios_entry);
- addr = ALIGN(addr, 16);
+ /* move past the (so-far-unwritten) header to start writing structs */
+ addr = ALIGN(addr + sizeof(struct smbios3_entry), 16);
tables = addr;
/* populate minimum required tables */
for (i = 0; i < ARRAY_SIZE(smbios_write_funcs); i++) {
const struct smbios_write_method *method;
- int tmp;
method = &smbios_write_funcs[i];
- if (IS_ENABLED(CONFIG_OF_CONTROL) && method->subnode_name)
- ctx.node = ofnode_find_subnode(parent_node,
- method->subnode_name);
- tmp = method->write((ulong *)&addr, handle++, &ctx);
-
- max_struct_size = max(max_struct_size, tmp);
- len += tmp;
+ ctx.subnode_name = NULL;
+ if (method->subnode_name) {
+ ctx.subnode_name = method->subnode_name;
+ if (IS_ENABLED(CONFIG_OF_CONTROL))
+ ctx.node = ofnode_find_subnode(parent_node,
+ method->subnode_name);
+ }
+ len += method->write((ulong *)&addr, handle++, &ctx);
}
- memcpy(se->anchor, "_SM_", 4);
- se->length = sizeof(struct smbios_entry);
- se->major_ver = SMBIOS_MAJOR_VER;
- se->minor_ver = SMBIOS_MINOR_VER;
- se->max_struct_size = max_struct_size;
- memcpy(se->intermediate_anchor, "_DMI_", 5);
- se->struct_table_length = len;
-
/*
* We must use a pointer here so things work correctly on sandbox. The
* user of this table is not aware of the mapping of addresses to
* sandbox's DRAM buffer.
*/
table_addr = (ulong)map_sysmem(tables, 0);
- if (sizeof(table_addr) > sizeof(u32) && table_addr > (ulong)UINT_MAX) {
- /*
- * We need to put this >32-bit pointer into the table but the
- * field is only 32 bits wide.
- */
- printf("WARNING: SMBIOS table_address overflow %llx\n",
- (unsigned long long)table_addr);
- addr = 0;
- goto out;
- }
- se->struct_table_address = table_addr;
-
- se->struct_count = handle;
- /* calculate checksums */
- istart = (char *)se + SMBIOS_INTERMEDIATE_OFFSET;
- isize = sizeof(struct smbios_entry) - SMBIOS_INTERMEDIATE_OFFSET;
- se->intermediate_checksum = table_compute_checksum(istart, isize);
- se->checksum = table_compute_checksum(se, sizeof(struct smbios_entry));
-out:
+ /* now go back and write the SMBIOS3 header */
+ se = map_sysmem(start_addr, sizeof(struct smbios3_entry));
+ memset(se, '\0', sizeof(struct smbios3_entry));
+ memcpy(se->anchor, "_SM3_", 5);
+ se->length = sizeof(struct smbios3_entry);
+ se->major_ver = SMBIOS_MAJOR_VER;
+ se->minor_ver = SMBIOS_MINOR_VER;
+ se->doc_rev = 0;
+ se->entry_point_rev = 1;
+ se->table_maximum_size = len;
+ se->struct_table_address = table_addr;
+ se->checksum = table_compute_checksum(se, sizeof(struct smbios3_entry));
unmap_sysmem(se);
return addr;
projects / u-boot.git / blobdiff