lib/smbios.c

   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  */
  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  */
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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 }