* Copyright 2020, Jérôme Duval, jerome.duval@gmail.com.
* Distributed under the terms of the MIT license.
*/
#include "smbios.h"
#include <device_manager.h>
#include <KernelExport.h>
#include <module.h>
#include <stdlib.h>
#include <string.h>
#include <boot_item.h>
#include <vm/vm.h>
#define TRACE_SMBIOS
#ifdef TRACE_SMBIOS
# define TRACE(x...) dprintf (x)
#else
# define TRACE(x...) ;
#endif
static device_manager_info* gDeviceManager;
static char* sHardwareVendor = NULL;
static char* sHardwareProduct = NULL;
struct smbios {
uint32 anchor_string;
uint8 entry_point_checksum;
uint8 entry_point_length;
struct {
uint8 major;
uint8 minor;
} version;
uint16 maximum_size;
uint8 entry_point_revision;
uint8 formatted_area[5];
uint8 dmi_anchor_string[5];
uint8 intermediate_checksum;
uint16 structure_table_size;
uint32 structure_table;
uint16 num_structures;
uint8 bcd_revision;
} _PACKED;
struct smbios3 {
uint8 anchor_string[5];
uint8 entry_point_checksum;
uint8 entry_point_length;
struct {
uint8 major;
uint8 minor;
uint8 doc;
} version;
uint8 entry_point_revision;
uint8 reserved;
uint32 structure_table_size;
uint64 structure_table;
} _PACKED;
struct smbios_structure_header {
uint8 type;
uint8 length;
uint16 handle;
} _PACKED;
#define SMBIOS "_SM_"
#define SMBIOS3 "_SM3_"
enum {
SMBIOS_TYPE_BIOS = 0,
SMBIOS_TYPE_SYSTEM,
};
struct smbios_system {
struct smbios_structure_header header;
uint8 manufacturer;
uint8 product_name;
uint8 version;
uint8 serial_number;
uint8 uuid[16];
uint8 wakeup_type;
uint8 sku_number;
uint8 family;
} _PACKED;
static bool
smbios_match_vendor_product(const char* vendor, const char* product)
{
if (vendor == NULL && product == NULL)
return false;
bool match = true;
if (vendor != NULL && sHardwareVendor != NULL)
match = strcmp(vendor, sHardwareVendor) == 0;
if (match && product != NULL && sHardwareProduct != NULL)
match = strcmp(product, sHardwareProduct) == 0;
return match;
}
static const char *
smbios_get_string(struct smbios_structure_header* table, uint8* tableEnd,
uint8 index)
{
uint8* addr = (uint8*)table + table->length;
uint8 i = 1;
for (; addr < tableEnd && i < index && *addr != 0; i++) {
while (*addr != 0 && addr < tableEnd)
addr++;
addr++;
}
if (i == index)
return (const char*)addr;
return NULL;
}
static void
smbios_scan()
{
TRACE("smbios_scan\n");
static bool scanDone = false;
if (scanDone)
return;
addr_t smBiosBase;
phys_addr_t smBiosSearchBase = 0xf0000;
phys_addr_t* smbiosRootPointer = (phys_addr_t*)get_boot_item("SMBIOSv3_ROOT_POINTER", NULL);
if (smbiosRootPointer != NULL) {
smBiosSearchBase = *smbiosRootPointer;
} else {
smbiosRootPointer = (phys_addr_t*)get_boot_item("SMBIOSv2_ROOT_POINTER", NULL);
if (smbiosRootPointer != NULL)
smBiosSearchBase = *smbiosRootPointer;
}
area_id smbiosArea = map_physical_memory("pc bios", smBiosSearchBase, 0x10000,
B_ANY_KERNEL_ADDRESS, B_KERNEL_READ_AREA, (void **)&smBiosBase);
if (smbiosArea < 0)
return;
struct smbios *smbios = NULL;
struct smbios3 *smbios3 = NULL;
for (addr_t offset = 0; offset <= 0xffe0; offset += 0x10) {
void* p = (void*)(smBiosBase + offset);
if (memcmp(p, SMBIOS3, 5) == 0) {
smbios3 = (struct smbios3 *)p;
break;
} else if (memcmp(p, SMBIOS, 4) == 0) {
smbios = (struct smbios *)p;
}
}
phys_addr_t tablePhysAddr = 0;
size_t tablePhysLength = 0;
void* table;
status_t status;
uint8* tableEnd;
if (smbios != NULL) {
tablePhysAddr = smbios->structure_table;
tablePhysLength = smbios->structure_table_size;
} else if (smbios3 != NULL) {
tablePhysAddr = smbios3->structure_table;
tablePhysLength = smbios3->structure_table_size;
}
if (tablePhysAddr == 0)
goto err;
table = malloc(tablePhysLength);
if (table == NULL)
goto err;
status = vm_memcpy_from_physical(table, tablePhysAddr,
tablePhysLength, false);
if (status != B_OK)
goto err;
tableEnd = (uint8*)table + tablePhysLength;
for (uint8* addr = (uint8*)table;
(addr + sizeof(struct smbios_structure_header)) < tableEnd;) {
struct smbios_structure_header* table
= (struct smbios_structure_header*)addr;
if (table->type == SMBIOS_TYPE_SYSTEM) {
struct smbios_system *system = (struct smbios_system*)table;
TRACE("found System Information at %p\n", table);
TRACE("found vendor %u product %u\n", system->manufacturer,
system->product_name);
const char* vendor = smbios_get_string(table, tableEnd,
system->manufacturer);
const char* product = smbios_get_string(table, tableEnd,
system->product_name);
if (vendor != NULL)
sHardwareVendor = strdup(vendor);
if (product != NULL)
sHardwareProduct = strdup(product);
break;
}
addr += table->length;
for (; addr + 1 < tableEnd; addr++) {
if (*addr == 0 && *(addr + 1) == 0)
break;
}
addr += 2;
}
scanDone = true;
TRACE("smbios_scan found vendor %s product %s\n", sHardwareVendor,
sHardwareProduct);
err:
delete_area(smbiosArea);
}
static status_t
std_ops(int32 op, ...)
{
switch (op) {
case B_MODULE_INIT:
smbios_scan();
return B_OK;
case B_MODULE_UNINIT:
free(sHardwareVendor);
free(sHardwareProduct);
return B_OK;
default:
return B_ERROR;
}
}
module_dependency module_dependencies[] = {
{B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&gDeviceManager},
{}
};
static smbios_module_info sSMBIOSModule = {
{
SMBIOS_MODULE_NAME,
B_KEEP_LOADED,
std_ops
},
smbios_match_vendor_product,
};
module_info *modules[] = {
(module_info*)&sSMBIOSModule,
NULL
};
