freebsd/sys/dev/coreboot/coreboot.h

/*
 * Copyright (c) 2026 Abdelkader Boudih <[email protected]>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/*
 * coreboot(4) driver for FreeBSD
 *
 * Structures and constants derived from the coreboot table specification.
 */

#ifndef _DEV_COREBOOT_COREBOOT_H_
#define _DEV_COREBOOT_COREBOOT_H_

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/sysctl.h>
#include <sys/bus.h>

#include <dev/coreboot/corebootio.h>

#define CB_HEADER_SIGNATURE	"LBIO"
#define CB_HEADER_SIG_LEN	4

/*
 * Memory scan range for coreboot table discovery.
 * Low memory (0x0–0x1000) contains a forward pointer to the real table.
 */
#define CB_SCAN_LOW_START	0x00000000
#define CB_SCAN_LOW_END		0x00001000
#define CB_SCAN_LOW_STEP	16

/*
 * Defensive limits for parsing untrusted firmware-provided lengths.
 */
#define CB_TABLE_ALIGN		4
#define CB_MAX_HEADER_BYTES	4096
#define CB_MAX_TABLE_BYTES	(1024 * 1024)
#define CB_MAX_TABLE_MAP_BYTES	(CB_MAX_HEADER_BYTES + CB_MAX_TABLE_BYTES)
#define CB_MAX_CONSOLE_BYTES	(1024 * 1024)

/*
 * Coreboot table record tags - only tags we actually parse.
 * Full enum preserved for forward compatibility (unknown tags are skipped).
 */
enum cb_tag {
	CB_TAG_UNUSED			= 0x0000,
	CB_TAG_MAINBOARD		= 0x0003,
	CB_TAG_VERSION			= 0x0004,
	CB_TAG_EXTRA_VERSION		= 0x0005,
	CB_TAG_BUILD			= 0x0006,
	CB_TAG_COMPILE_TIME		= 0x0007,
	CB_TAG_COMPILER			= 0x000b,
	CB_TAG_SERIAL			= 0x000f,
	CB_TAG_CONSOLE			= 0x0010,
	CB_TAG_FORWARD			= 0x0011,
	CB_TAG_FRAMEBUFFER		= 0x0012,
	CB_TAG_GPIO			= 0x0013,
	CB_TAG_TIMESTAMPS		= 0x0016,
	CB_TAG_CBMEM_CONSOLE		= 0x0017,
	CB_TAG_ACPI_GNVS		= 0x0024,
	CB_TAG_VERSION_TIMESTAMP	= 0x0026,
	CB_TAG_WIFI_CALIBRATION		= 0x0027,
	CB_TAG_SPI_FLASH		= 0x0029,
	CB_TAG_SERIALNO			= 0x002a,
	CB_TAG_VPD			= 0x002c,
	CB_TAG_BOOT_MEDIA_PARAMS	= 0x0030,
	CB_TAG_CBMEM_ENTRY		= 0x0031,
	CB_TAG_TSC_INFO			= 0x0032,
	CB_TAG_MAC_ADDRS		= 0x0033,
	CB_TAG_VBOOT_WORKBUF		= 0x0034,
	CB_TAG_MMC_INFO			= 0x0035,
	CB_TAG_TPM_CB_LOG		= 0x0036,
	CB_TAG_FMAP			= 0x0037,
	CB_TAG_PLATFORM_BLOB_VERSION	= 0x0038,
	CB_TAG_SMMSTOREV2		= 0x0039,
	CB_TAG_TPM_PPI_HANDOFF		= 0x003a,
	CB_TAG_BOARD_CONFIG		= 0x0040,
	CB_TAG_ACPI_CNVS		= 0x0041,
	CB_TAG_TYPE_C_INFO		= 0x0042,
	CB_TAG_ACPI_RSDP		= 0x0043,
	CB_TAG_PCIE			= 0x0044,
	CB_TAG_ROOT_BRIDGE_INFO		= 0x0048,
};

/*
 * Coreboot table header - located at a physical address found by scanning
 * low memory for the "LBIO" signature.
 */
struct cb_header {
	uint8_t		signature[CB_HEADER_SIG_LEN];
	uint32_t	header_bytes;
	uint32_t	header_checksum;
	uint32_t	table_bytes;
	uint32_t	table_checksum;
	uint32_t	table_entries;
} __packed;

/*
 * Generic record header - every table entry starts with this.
 */
struct cb_record {
	uint32_t	tag;
	uint32_t	size;
} __packed;

/*
 * CB_TAG_FORWARD - pointer to the real table in high memory.
 */
struct cb_forward {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	forward;
} __packed;

/*
 * CB_TAG_MAINBOARD - board vendor and part number.
 * Strings are packed after the struct, indexed by vendor_idx and part_idx.
 */
struct cb_mainboard {
	uint32_t	tag;
	uint32_t	size;
	uint8_t		vendor_idx;
	uint8_t		part_idx;
	uint8_t		strings[];
} __packed;

/*
 * Variable-length string record - used by VERSION, BUILD, COMPILE_*, etc.
 */
struct cb_string {
	uint32_t	tag;
	uint32_t	size;
	uint8_t		string[];
} __packed;

/*
 * CB_TAG_SERIAL - serial port configuration.
 */
struct cb_serial {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	type;
	uint32_t	baseaddr;
	uint32_t	baud;
	uint32_t	regwidth;
	uint32_t	input_hertz;
} __packed;

/*
 * CB_TAG_CBMEM_CONSOLE - pointer to firmware console ring buffer.
 */
struct cb_cbmem_ref {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	cbmem_addr;
} __packed;

/*
 * CB_TAG_CBMEM_ENTRY - one per CBMEM region.
 */
struct cb_cbmem_entry {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	address;
	uint32_t	entry_size;
	uint32_t	id;
} __packed;

/*
 * CB_TAG_TSC_INFO - TSC frequency.
 */
struct cb_tsc_info {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	freq_khz;
} __packed;

/*
 * CB_TAG_VERSION_TIMESTAMP - build version timestamp.
 * timestamp is Unix time in seconds (seconds since 1970-01-01 UTC).
 */
struct cb_version_timestamp {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	timestamp;
} __packed;

/*
 * CB_TAG_BOARD_CONFIG - board identification and firmware config.
 */
struct cb_board_config {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	fw_config;
	uint32_t	board_id;
	uint32_t	ram_code;
	uint32_t	sku_id;
} __packed;

/*
 * CB_TAG_BOOT_MEDIA_PARAMS - offsets and sizes on boot media.
 */
struct cb_boot_media_params {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	fmap_offset;
	uint64_t	cbfs_offset;
	uint64_t	cbfs_size;
	uint64_t	boot_media_size;
} __packed;

/*
 * CB_TAG_MMC_INFO - early eMMC/MMC status.
 */
struct cb_mmc_info {
	uint32_t	tag;
	uint32_t	size;
	int32_t		early_cmd1_status;
} __packed;

/*
 * CB_TAG_PCIE - PCIe controller base address.
 */
struct cb_pcie {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	ctrl_base;
} __packed;

/*
 * CB_TAG_MAC_ADDRS - factory-provisioned MAC addresses.
 */
struct cb_mac_address {
	uint8_t		mac_addr[6];
	uint8_t		pad[2];
} __packed;

struct cb_macs {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	count;
	struct cb_mac_address entries[];
} __packed;

/*
 * CB_TAG_SPI_FLASH - SPI flash chip parameters.
 */
struct cb_flash_mmap_window {
	uint32_t	flash_base;
	uint32_t	host_base;
	uint32_t	size;
} __packed;

struct cb_spi_flash {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	flash_size;
	uint32_t	sector_size;
	uint8_t		erase_cmd;
	uint8_t		flags;
	uint16_t	reserved;
	uint32_t	mmap_count;
	struct cb_flash_mmap_window mmap_table[];
} __packed;

/*
 * CB_TAG_CONSOLE - firmware console type.
 */
struct cb_console {
	uint32_t	tag;
	uint32_t	size;
	uint16_t	type;
	uint8_t		pad[2];
} __packed;

#define CB_CONSOLE_SERIAL8250		0
#define CB_CONSOLE_VGA			1	/* obsolete */
#define CB_CONSOLE_EHCI			5
#define CB_CONSOLE_SERIAL8250MEM	6

/*
 * CB_TAG_FRAMEBUFFER - linear framebuffer info.
 * The orientation, flags, and pad fields were added later.
 * Minimum record size is up to reserved_mask_size (29 bytes).
 */
#define CB_FRAMEBUFFER_MIN_SIZE	29
struct cb_framebuffer {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	physical_address;
	uint32_t	x_resolution;
	uint32_t	y_resolution;
	uint32_t	bytes_per_line;
	uint8_t		bits_per_pixel;
	uint8_t		red_mask_pos;
	uint8_t		red_mask_size;
	uint8_t		green_mask_pos;
	uint8_t		green_mask_size;
	uint8_t		blue_mask_pos;
	uint8_t		blue_mask_size;
	uint8_t		reserved_mask_pos;
	uint8_t		reserved_mask_size;
	uint8_t		orientation;
	uint8_t		flags;
	uint8_t		pad;
} __packed;

/*
 * CB_TAG_GPIO - GPIO pin states.
 */
struct cb_gpio {
	uint32_t	port;
	uint32_t	polarity;
	uint32_t	value;
	uint8_t		name[16];
} __packed;

struct cb_gpios {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	count;
	struct cb_gpio	entries[];
} __packed;

/*
 * CB_TAG_TPM_PPI_HANDOFF - TPM Physical Presence Interface handoff.
 */
struct cb_tpm_ppi {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	ppi_address;
	uint8_t		tpm_version;	/* 1=TPM1.2, 2=TPM2.0 */
	uint8_t		ppi_version;	/* BCD encoded */
	uint8_t		pad[2];
} __packed;

/*
 * CB_TAG_SMMSTOREV2 - SMM-based variable store configuration.
 *
 * The mmap_addr field was added after the initial implementation.
 * Older coreboot emits a shorter record (32 bytes) without it.
 * Consumers must check rec->size to detect whether mmap_addr is present.
 */
#define CB_SMMSTOREV2_BASE_SIZE	32	/* size without mmap_addr */
struct cb_smmstorev2 {
	uint32_t	tag;
	uint32_t	size;
	uint32_t	num_blocks;
	uint32_t	block_size;
	uint32_t	mmap_addr_lo;	/* deprecated 32-bit address */
	uint32_t	com_buffer;
	uint32_t	com_buffer_size;
	uint8_t		apm_cmd;
	uint8_t		unused[3];
	/* Fields below only present if size > CB_SMMSTOREV2_BASE_SIZE */
	uint64_t	mmap_addr;	/* 64-bit address (preferred) */
} __packed;

/*
 * CB_TAG_ACPI_RSDP - ACPI Root System Description Pointer address.
 */
struct cb_acpi_rsdp {
	uint32_t	tag;
	uint32_t	size;
	uint64_t	rsdp_pointer;
} __packed;

/*
 * CBMEM console ring buffer (in-memory structure at cbmem_addr).
 * Bit 31 of cursor indicates overflow (ring has wrapped).
 */
struct cbmem_console {
	uint32_t	size;
	uint32_t	cursor;
	uint8_t		body[];
} __packed;

#define CBMEM_CONSOLE_CURSOR_MASK	((1 << 28) - 1)
#define CBMEM_CONSOLE_OVERFLOW		(1 << 31)

#define CB_MAX_MAC_ADDRS	8
#define CB_MAX_GPIOS		32

/*
 * Driver softc
 */
struct coreboot_softc {
	device_t		dev;

	vm_paddr_t		table_paddr;
	vm_size_t		table_size;
	void			*table_vaddr;

	char			version[64];
	char			build[64];
	char			compile_time[64];
	char			compiler[128];
	char			extra_version[64];
	char			platform_blob_version[64];
	char			serialno[64];
	uint32_t		version_timestamp;
	int			has_version_timestamp;

	char			mb_vendor[64];
	char			mb_part[64];

	uint32_t		serial_baseaddr;
	uint32_t		serial_baud;
	uint32_t		serial_regwidth;
	int			has_serial;

	uint32_t		tsc_freq_khz;
	int			has_tsc_info;

	uint64_t		pcie_ctrl_base;
	int			has_pcie;

	uint64_t		fmap_offset;
	uint64_t		cbfs_offset;
	uint64_t		cbfs_size;
	uint64_t		boot_media_size;
	int			has_boot_media;

	int32_t			mmc_early_cmd1_status;
	int			has_mmc_info;

	vm_paddr_t		console_paddr;
	vm_size_t		console_size;
	uint32_t		console_data_size;
	struct cbmem_console	*console_vaddr;
	int			has_console;
	struct cdev		*console_cdev;

	uint32_t		cbmem_count;
	struct cbmem_entry_info	cbmem_entries[CB_MAX_CBMEM_ENTRIES];
	struct cdev		*cbmem_cdev;

	uint64_t		fw_config;
	uint32_t		board_id;
	uint32_t		ram_code;
	uint32_t		sku_id;
	int			has_board_config;

	uint32_t		mac_count;
	struct cb_mac_address	macs[CB_MAX_MAC_ADDRS];
	char			mac_strs[CB_MAX_MAC_ADDRS][18];

	uint64_t		acpi_rsdp;
	int			has_acpi_rsdp;

	uint32_t		spi_flash_size;
	uint32_t		spi_sector_size;
	uint8_t			spi_erase_cmd;
	uint8_t			spi_flags;
	int			has_spi_flash;

	uint16_t		console_type;
	int			has_console_type;

	uint64_t		fb_addr;
	uint32_t		fb_x_res;
	uint32_t		fb_y_res;
	uint32_t		fb_stride;
	uint8_t			fb_bpp;
	int			has_framebuffer;

	uint32_t		gpio_count;
	struct cb_gpio		gpios[CB_MAX_GPIOS];

	uint32_t		tpm_ppi_addr;
	uint8_t			tpm_version;
	int			has_tpm;

	vm_paddr_t		tpm_log_paddr;
	int			has_tpm_log;

	vm_paddr_t		acpi_gnvs_paddr;
	int			has_acpi_gnvs;
	vm_paddr_t		acpi_cnvs_paddr;
	int			has_acpi_cnvs;
	vm_paddr_t		vpd_paddr;
	int			has_vpd;
	vm_paddr_t		wifi_cal_paddr;
	int			has_wifi_cal;
	vm_paddr_t		fmap_paddr;
	int			has_fmap;
	vm_paddr_t		vboot_workbuf_paddr;
	int			has_vboot_workbuf;
	vm_paddr_t		type_c_info_paddr;
	int			has_type_c_info;
	vm_paddr_t		root_bridge_info_paddr;
	int			has_root_bridge_info;

	uint32_t		smmstore_num_blocks;
	uint32_t		smmstore_block_size;
	uint64_t		smmstore_mmap_addr;
	uint32_t		smmstore_com_buffer;
	uint8_t			smmstore_apm_cmd;
	int			has_smmstore;

	vm_paddr_t		timestamps_paddr;
	int			has_timestamps;

	struct sysctl_ctx_list	sysctl_ctx;
	struct sysctl_oid	*sysctl_tree;
};

/*
 * Generic ID-to-name linear search.
 * The table must be terminated by an entry with name == NULL.
 * Returns fallback if no match is found.
 */
struct cb_id_name {
	uint32_t	id;
	const char	*name;
};

static __inline const char *
cb_id_lookup(const struct cb_id_name *tbl, uint32_t id, const char *fallback)
{
	int i;

	for (i = 0; tbl[i].name != NULL; i++) {
		if (tbl[i].id == id)
			return (tbl[i].name);
	}
	return (fallback);
}

/*
 * CBMEM ID to human-readable name lookup.
 */
static __inline const char *
cbmem_id_to_name(uint32_t id)
{
	static const struct cb_id_name names[] = {
		{ CBMEM_ID_ACPI,		"ACPI" },
		{ CBMEM_ID_ACPI_GNVS,		"ACPI GNVS" },
		{ CBMEM_ID_AFTER_CAR,		"AFTER CAR" },
		{ CBMEM_ID_CBTABLE,		"COREBOOT" },
		{ CBMEM_ID_CBTABLE_FWD,	"COREBOOT FWD" },
		{ CBMEM_ID_CBFS_RO_MCACHE,	"RO MCACHE" },
		{ CBMEM_ID_CBFS_RW_MCACHE,	"RW MCACHE" },
		{ CBMEM_ID_CONSOLE,		"CONSOLE" },
		{ CBMEM_ID_ELOG,		"ELOG" },
		{ CBMEM_ID_FMAP,		"FMAP" },
		{ CBMEM_ID_FREESPACE,		"FREE SPACE" },
		{ CBMEM_ID_FSP_RESERVED_MEMORY, "FSP MEMORY" },
		{ CBMEM_ID_FSP_RUNTIME,	"FSP RUNTIME" },
		{ CBMEM_ID_FSPM_VERSION,	"FSPM VERSION" },
		{ CBMEM_ID_IGD_OPREGION,	"IGD OPREGION" },
		{ CBMEM_ID_IMD_ROOT,		"IMD ROOT" },
		{ CBMEM_ID_IMD_SMALL,		"IMD SMALL" },
		{ CBMEM_ID_MEMINFO,		"MEM INFO" },
		{ CBMEM_ID_MPTABLE,		"SMP TABLE" },
		{ CBMEM_ID_MRCDATA,		"MRC DATA" },
		{ CBMEM_ID_PIRQ,		"IRQ TABLE" },
		{ CBMEM_ID_POWER_STATE,	"POWER STATE" },
		{ CBMEM_ID_RAM_OOPS,		"RAMOOPS" },
		{ CBMEM_ID_RAMSTAGE,		"RAMSTAGE" },
		{ CBMEM_ID_REFCODE,		"REFCODE" },
		{ CBMEM_ID_RESUME,		"ACPI RESUME" },
		{ CBMEM_ID_ROMSTAGE_INFO,	"ROMSTAGE" },
		{ CBMEM_ID_ROMSTAGE_RAM_STACK,	"ROMSTG STACK" },
		{ CBMEM_ID_ROOT,		"CBMEM ROOT" },
		{ CBMEM_ID_SMBIOS,		"SMBIOS" },
		{ CBMEM_ID_SMM_COMBUFFER,	"SMM COMBUF" },
		{ CBMEM_ID_SMM_SAVE_SPACE,	"SMM BACKUP" },
		{ CBMEM_ID_TIMESTAMP,		"TIMESTAMP" },
		{ CBMEM_ID_VBOOT_WORKBUF,	"VBOOT WORK" },
		{ CBMEM_ID_VPD,		"VPD" },
		{ 0, NULL }
	};

	return (cb_id_lookup(names, id, "UNKNOWN"));
}

/*
 * IP-style 16-bit checksum (RFC 1071) over 16-bit words.
 * When computed over data including its checksum field, result is 0.
 */
static __inline uint16_t
cb_checksum(const void *ptr, size_t len)
{
	const uint8_t *p = (const uint8_t *)ptr;
	uint32_t sum = 0;
	size_t i;

	for (i = 0; i + 1 < len; i += 2)
		sum += (uint32_t)p[i] | ((uint32_t)p[i + 1] << 8);

	if (i < len)
		sum += p[i];

	while (sum >> 16)
		sum = (sum & 0xffff) + (sum >> 16);

	return ((uint16_t)~sum);
}

/*
 * Destroy a character device and clear the pointer.
 * Safe to call with a NULL cdev pointer.
 */
static __inline void
coreboot_cdev_destroy(struct cdev **cdevp)
{

	if (*cdevp != NULL) {
		destroy_dev(*cdevp);
		*cdevp = NULL;
	}
}

/* Functions exported from coreboot.c */
struct coreboot_softc *coreboot_get_softc(void);

/* Functions exported from coreboot_console.c */
int	coreboot_console_create(struct coreboot_softc *sc);
void	coreboot_console_destroy(struct coreboot_softc *sc);

/* Functions exported from coreboot_cbmem.c */
int	coreboot_cbmem_create(struct coreboot_softc *sc);
void	coreboot_cbmem_destroy(struct coreboot_softc *sc);

/* Functions exported from coreboot_timestamps.c */
int	coreboot_timestamps_register(struct coreboot_softc *sc,
	    struct sysctl_oid *parent);

#endif /* _DEV_COREBOOT_COREBOOT_H_ */