drivers/elog/elog.c

/* SPDX-License-Identifier: GPL-2.0-only */

#include <acpi/acpi.h>
#include <boot_device.h>
#include <bootstate.h>
#include <cbmem.h>
#include <commonlib/bsd/bcd.h>
#include <commonlib/bsd/elog.h>
#include <commonlib/region.h>
#include <console/console.h>
#include <elog.h>
#include <fmap.h>
#include <lib.h>
#include <post.h>
#include <rtc.h>
#include <smbios.h>
#include <stdint.h>
#include <string.h>
#include <timestamp.h>

#define ELOG_MIN_AVAILABLE_ENTRIES	2  /* Shrink when this many can't fit */
#define ELOG_SHRINK_PERCENTAGE		25 /* Percent of total area to remove */

#if CONFIG(ELOG_DEBUG)
#define elog_debug(STR...) printk(BIOS_DEBUG, STR)
#else
#define elog_debug(STR...)
#endif

#define NV_NEEDS_ERASE (~(size_t)0)
enum elog_init_state {
	ELOG_UNINITIALIZED = 0,
	ELOG_INITIALIZED,
	ELOG_BROKEN,
};

struct elog_state {
	u16 full_threshold;
	u16 shrink_size;

	/*
	 * The non-volatile storage chases the mirrored copy. When nv_last_write
	 * is less than the mirrored last write the non-volatile storage needs
	 * to be updated.
	 */
	size_t mirror_last_write;
	size_t nv_last_write;

	struct region_device nv_dev;
	/* Device that mirrors the eventlog in memory. */
	struct region_device mirror_dev;

	enum elog_init_state elog_initialized;
};

static struct elog_state elog_state;

#define ELOG_SIZE (4 * KiB)
static uint8_t elog_mirror_buf[ELOG_SIZE];

static inline struct region_device *mirror_dev_get(void)
{
	return &elog_state.mirror_dev;
}

static size_t elog_events_start(void)
{
	/* Events are added directly after the header. */
	return sizeof(struct elog_header);
}

static size_t elog_events_total_space(void)
{
	return region_device_sz(&elog_state.nv_dev) - elog_events_start();
}

static struct event_header *elog_get_event_buffer(size_t offset, size_t size)
{
	return rdev_mmap(mirror_dev_get(), offset, size);
}

static struct event_header *elog_get_next_event_buffer(size_t size)
{
	elog_debug("ELOG: new event at offset 0x%zx\n",
		   elog_state.mirror_last_write);
	return elog_get_event_buffer(elog_state.mirror_last_write, size);
}

static void elog_put_event_buffer(struct event_header *event)
{
	rdev_munmap(mirror_dev_get(), event);
}

static size_t elog_mirror_reset_last_write(void)
{
	/* Return previous write value. */
	size_t prev = elog_state.mirror_last_write;

	elog_state.mirror_last_write = 0;
	return prev;
}

static void elog_mirror_increment_last_write(size_t size)
{
	elog_state.mirror_last_write += size;
}

static void elog_nv_reset_last_write(void)
{
	elog_state.nv_last_write = 0;
}

static void elog_nv_increment_last_write(size_t size)
{
	elog_state.nv_last_write += size;
}

static void elog_nv_needs_possible_erase(void)
{
	/* If last write is 0 it means it is already erased. */
	if (elog_state.nv_last_write != 0)
		elog_state.nv_last_write = NV_NEEDS_ERASE;
}

static bool elog_should_shrink(void)
{
	return elog_state.mirror_last_write >= elog_state.full_threshold;
}

static bool elog_nv_needs_erase(void)
{
	return elog_state.nv_last_write == NV_NEEDS_ERASE;
}

static bool elog_nv_needs_update(void)
{
	return elog_state.nv_last_write != elog_state.mirror_last_write;
}

static size_t elog_nv_region_to_update(size_t *offset)
{
	*offset = elog_state.nv_last_write;
	return elog_state.mirror_last_write - elog_state.nv_last_write;
}

/*
 * When parsing state from the NV one needs to adjust both the NV and mirror
 * write state. Therefore, provide helper functions which adjust both
 * at the same time.
 */
static void elog_tandem_reset_last_write(void)
{
	elog_mirror_reset_last_write();
	elog_nv_reset_last_write();
}

static void elog_tandem_increment_last_write(size_t size)
{
	elog_mirror_increment_last_write(size);
	elog_nv_increment_last_write(size);
}

static void elog_debug_dump_buffer(const char *msg)
{
	struct region_device *rdev;
	void *buffer;

	if (!CONFIG(ELOG_DEBUG))
		return;

	elog_debug("%s", msg);

	rdev = mirror_dev_get();

	buffer = rdev_mmap_full(rdev);

	if (buffer == NULL)
		return;

	hexdump(buffer, region_device_sz(rdev));

	rdev_munmap(rdev, buffer);
}

/*
 * Check if mirrored buffer is filled with ELOG_TYPE_EOL byte from the
 * provided offset to the end of the mirrored buffer.
 */
static int elog_is_buffer_clear(size_t offset)
{
	size_t i;
	const struct region_device *rdev = mirror_dev_get();
	size_t size = region_device_sz(rdev) - offset;
	uint8_t *buffer = rdev_mmap(rdev, offset, size);
	int ret = 1;

	elog_debug("%s(offset=%zu size=%zu)\n", __func__, offset, size);

	if (buffer == NULL)
		return 0;

	for (i = 0; i < size; i++) {
		if (buffer[i] != ELOG_TYPE_EOL) {
			ret = 0;
			break;
		}
	}
	rdev_munmap(rdev, buffer);
	return ret;
}

/*
 * Verify if the mirrored elog structure is valid.
 * Returns 1 if the header is valid, 0 otherwise
 */
static int elog_is_header_valid(void)
{
	struct elog_header *header;

	elog_debug("%s()\n", __func__);

	header = rdev_mmap(mirror_dev_get(), 0, sizeof(*header));

	if (elog_verify_header(header) != CB_SUCCESS) {
		printk(BIOS_ERR, "ELOG: failed to verify header.\n");
		return 0;
	}
	return 1;
}

/*
 * Validate the event header and data.
 */
static size_t elog_is_event_valid(size_t offset)
{
	uint8_t checksum;
	struct event_header *event;
	uint8_t len;
	const size_t len_offset = offsetof(struct event_header, length);
	const size_t size = sizeof(len);

	/* Read and validate length. */
	if (rdev_readat(mirror_dev_get(), &len, offset + len_offset, size) < 0)
		return 0;

	/* Event length must be at least header size + checksum */
	if (len < (sizeof(*event) + sizeof(checksum)))
		return 0;

	if (len > ELOG_MAX_EVENT_SIZE)
		return 0;

	event = elog_get_event_buffer(offset, len);
	if (!event)
		return 0;

	/* If event checksum is invalid the area is corrupt */
	checksum = elog_checksum_event(event);
	elog_put_event_buffer(event);

	if (checksum != 0)
		return 0;

	/* Event is valid */
	return len;
}

/*
 * Write 'size' bytes of data from provided 'offset' in the mirrored elog to
 * the flash backing store. This will not erase the flash and it assumes the
 * flash area has been erased appropriately.
 */
static void elog_nv_write(size_t offset, size_t size)
{
	void *address;
	const struct region_device *rdev = mirror_dev_get();
	if (!size)
		return;

	address = rdev_mmap(rdev, offset, size);

	elog_debug("%s(address=%p offset=0x%08zx size=%zu)\n", __func__,
		 address, offset, size);

	if (address == NULL)
		return;

	/* Write the data to flash */
	if (rdev_writeat(&elog_state.nv_dev, address, offset, size) != size)
		printk(BIOS_ERR, "ELOG: NV Write failed at 0x%zx, size 0x%zx\n",
			offset, size);

	rdev_munmap(rdev, address);
}

/*
 * Erase the first block specified in the address.
 * Only handles flash area within a single flash block.
 */
static void elog_nv_erase(void)
{
	size_t size = region_device_sz(&elog_state.nv_dev);
	elog_debug("%s()\n", __func__);

	/* Erase the sectors in this region */
	if (rdev_eraseat(&elog_state.nv_dev, 0, size) != size)
		printk(BIOS_ERR, "ELOG: erase failure.\n");
}

/*
 * Scan the event area and validate each entry and update the ELOG state.
 */
static int elog_update_event_buffer_state(void)
{
	size_t offset = elog_events_start();

	elog_debug("%s()\n", __func__);

	/* Go through each event and validate it */
	while (1) {
		uint8_t type;
		const size_t type_offset = offsetof(struct event_header, type);
		size_t len;
		const size_t size = sizeof(type);

		if (rdev_readat(mirror_dev_get(), &type,
				offset + type_offset, size) < 0) {
			return -1;
		}

		/* The end of the event marker has been found */
		if (type == ELOG_TYPE_EOL)
			break;

		/* Validate the event */
		len = elog_is_event_valid(offset);

		if (!len) {
			printk(BIOS_ERR, "ELOG: Invalid event @ offset 0x%zx\n",
				offset);
			return -1;
		}

		/* Move to the next event */
		elog_tandem_increment_last_write(len);
		offset += len;
	}

	/* Ensure the remaining buffer is empty */
	if (!elog_is_buffer_clear(offset)) {
		printk(BIOS_ERR, "ELOG: buffer not cleared from 0x%zx\n",
			offset);
		return -1;
	}

	return 0;
}

static int elog_scan_flash(void)
{
	elog_debug("%s()\n", __func__);
	void *mirror_buffer;
	const struct region_device *rdev = mirror_dev_get();

	size_t size = region_device_sz(&elog_state.nv_dev);

	/* Fill memory buffer by reading from SPI */
	mirror_buffer = rdev_mmap_full(rdev);
	if (rdev_readat(&elog_state.nv_dev, mirror_buffer, 0, size) != size) {
		rdev_munmap(rdev, mirror_buffer);
		printk(BIOS_ERR, "ELOG: NV read failure.\n");
		return -1;
	}
	rdev_munmap(rdev, mirror_buffer);

	/* No writes have been done yet. */
	elog_tandem_reset_last_write();

	/* Check if the area is empty or not */
	if (elog_is_buffer_clear(0)) {
		printk(BIOS_ERR, "ELOG: NV Buffer Cleared.\n");
		return -1;
	}

	/* Indicate that header possibly written. */
	elog_tandem_increment_last_write(elog_events_start());

	/* Validate the header */
	if (!elog_is_header_valid()) {
		printk(BIOS_ERR, "ELOG: NV Buffer Invalid.\n");
		return -1;
	}

	return elog_update_event_buffer_state();
}

static void elog_write_header_in_mirror(void)
{
	static const struct elog_header header = {
		.magic = ELOG_SIGNATURE,
		.version = ELOG_VERSION,
		.header_size = sizeof(struct elog_header),
		.reserved = {
			[0] = ELOG_TYPE_EOL,
			[1] = ELOG_TYPE_EOL,
		},
	};

	rdev_writeat(mirror_dev_get(), &header, 0, sizeof(header));
	elog_mirror_increment_last_write(elog_events_start());
}

static void elog_move_events_to_front(size_t offset, size_t size)
{
	void *src;
	void *dest;
	size_t start_offset = elog_events_start();
	const struct region_device *rdev = mirror_dev_get();

	src = rdev_mmap(rdev, offset, size);
	dest = rdev_mmap(rdev, start_offset, size);

	if (src == NULL || dest == NULL) {
		printk(BIOS_ERR, "ELOG: failure moving events!\n");
		rdev_munmap(rdev, dest);
		rdev_munmap(rdev, src);
		return;
	}

	/* Move the events to the front. */
	memmove(dest, src, size);
	rdev_munmap(rdev, dest);
	rdev_munmap(rdev, src);

	/* Mark EOL for previously used buffer until the end. */
	offset = start_offset + size;
	size = region_device_sz(rdev) - offset;
	dest = rdev_mmap(rdev, offset, size);
	if (dest == NULL) {
		printk(BIOS_ERR, "ELOG: failure filling EOL!\n");
		return;
	}
	memset(dest, ELOG_TYPE_EOL, size);
	rdev_munmap(rdev, dest);
}

/* Perform the shrink and move events returning the size of bytes shrunk. */
static size_t elog_do_shrink(size_t requested_size, size_t last_write)
{
	const struct region_device *rdev = mirror_dev_get();
	size_t offset = elog_events_start();
	size_t remaining_size;

	while (1) {
		const size_t type_offset = offsetof(struct event_header, type);
		const size_t len_offset = offsetof(struct event_header, length);
		const size_t size = sizeof(uint8_t);
		uint8_t type;
		uint8_t len;

		/* Next event has exceeded constraints */
		if (offset > requested_size)
			break;

		if (rdev_readat(rdev, &type, offset + type_offset, size) < 0)
			break;

		/* Reached the end of the area */
		if (type == ELOG_TYPE_EOL)
			break;

		if (rdev_readat(rdev, &len, offset + len_offset, size) < 0)
			break;

		offset += len;
	}

	/*
	 * Move the events and update the last write. The last write before
	 * shrinking was captured prior to resetting the counter to determine
	 * actual size we're keeping.
	 */
	remaining_size = last_write - offset;
	elog_debug("ELOG: shrinking offset: 0x%zx remaining_size: 0x%zx\n",
		offset, remaining_size);
	elog_move_events_to_front(offset, remaining_size);
	elog_mirror_increment_last_write(remaining_size);

	/* Return the amount of data removed. */
	return offset - elog_events_start();
}

/*
 * Shrink the log, deleting old entries and moving the
 * remaining ones to the front of the log.
 */
static int elog_shrink_by_size(size_t requested_size)
{
	size_t shrunk_size;
	size_t captured_last_write;
	size_t total_event_space = elog_events_total_space();

	elog_debug("%s()\n", __func__);

	/* Indicate possible erase required. */
	elog_nv_needs_possible_erase();

	/* Capture the last write to determine data size in buffer to shrink. */
	captured_last_write = elog_mirror_reset_last_write();

	/* Prepare new header. */
	elog_write_header_in_mirror();

	/* Determine if any actual shrinking is required. */
	if (requested_size >= total_event_space)
		shrunk_size = total_event_space;
	else
		shrunk_size = elog_do_shrink(requested_size,
						captured_last_write);

	/* Add clear event */
	return elog_add_event_word(ELOG_TYPE_LOG_CLEAR, shrunk_size);
}

static int elog_prepare_empty(void)
{
	elog_debug("%s()\n", __func__);
	return elog_shrink_by_size(elog_events_total_space());
}

static int elog_shrink(void)
{
	if (elog_should_shrink())
		return elog_shrink_by_size(elog_state.shrink_size);
	return 0;
}

/*
 * Convert a flash offset into a memory mapped flash address
 */
static inline u8 *elog_flash_offset_to_address(void)
{
	/* Only support memory-mapped devices. */
	if (!CONFIG(BOOT_DEVICE_MEMORY_MAPPED))
		return NULL;

	if (!region_device_sz(&elog_state.nv_dev))
		return NULL;

	/* Get a view into the read-only boot device. */
	return rdev_mmap(boot_device_ro(),
			 region_device_offset(&elog_state.nv_dev),
			 region_device_sz(&elog_state.nv_dev));
}

/*
 * Fill out SMBIOS Type 15 table entry so the
 * event log can be discovered at runtime.
 */
int elog_smbios_write_type15(unsigned long *current, int handle)
{
	uintptr_t log_address;

	size_t elog_size = region_device_sz(&elog_state.nv_dev);

	if (CONFIG(ELOG_CBMEM)) {
		/* Save event log buffer into CBMEM for the OS to read */
		void *cbmem = cbmem_add(CBMEM_ID_ELOG, elog_size);
		if (cbmem)
			rdev_readat(mirror_dev_get(), cbmem, 0, elog_size);
		log_address = (uintptr_t)cbmem;
	} else {
		log_address = (uintptr_t)elog_flash_offset_to_address();
	}

	if (!log_address) {
		printk(BIOS_WARNING, "SMBIOS type 15 log address invalid.\n");
		return 0;
	}

	struct smbios_type15 *t = smbios_carve_table(*current, SMBIOS_EVENT_LOG,
						     sizeof(*t), handle);

	t->area_length = elog_size - 1;
	t->header_offset = 0;
	t->data_offset = sizeof(struct elog_header);
	t->access_method = SMBIOS_EVENTLOG_ACCESS_METHOD_MMIO32;
	t->log_status = SMBIOS_EVENTLOG_STATUS_VALID;
	t->change_token = 0;
	t->address = log_address;
	t->header_format = ELOG_HEADER_TYPE_OEM;
	t->log_type_descriptors = 0;
	t->log_type_descriptor_length = 2;

	const int len = smbios_full_table_len(&t->header, t->eos);
	*current += len;
	return len;
}

/*
 * Clear the entire event log
 */
int elog_clear(void)
{
	elog_debug("%s()\n", __func__);

	/* Make sure ELOG structures are initialized */
	if (elog_init() < 0)
		return -1;

	return elog_prepare_empty();
}

static int elog_find_flash(void)
{
	size_t total_size;
	size_t reserved_space = ELOG_MIN_AVAILABLE_ENTRIES * ELOG_MAX_EVENT_SIZE;
	struct region_device *rdev = &elog_state.nv_dev;

	elog_debug("%s()\n", __func__);

	/* Find the ELOG base and size in FMAP */
	if (fmap_locate_area_as_rdev_rw(ELOG_RW_REGION_NAME, rdev) < 0) {
		printk(BIOS_WARNING, "ELOG: Unable to find RW_ELOG in FMAP\n");
		return -1;
	}

	if (region_device_sz(rdev) < ELOG_SIZE) {
		printk(BIOS_WARNING, "ELOG: Needs a minimum size of %dKiB: %zu\n",
			ELOG_SIZE / KiB, region_device_sz(rdev));
		return -1;
	}

	printk(BIOS_INFO, "ELOG: NV offset 0x%zx size 0x%zx\n",
		region_device_offset(rdev), region_device_sz(rdev));

	/* Keep 4KiB max size until large malloc()s have been fixed. */
	total_size = MIN(ELOG_SIZE, region_device_sz(rdev));
	rdev_chain(rdev, rdev, 0, total_size);

	elog_state.full_threshold = total_size - reserved_space;
	elog_state.shrink_size = total_size * ELOG_SHRINK_PERCENTAGE / 100;

	if (reserved_space > elog_state.shrink_size) {
		printk(BIOS_ERR, "ELOG: SHRINK_PERCENTAGE too small\n");
		return -1;
	}

	return 0;
}

static int elog_sync_to_nv(void)
{
	size_t offset;
	size_t size;
	bool erase_needed;
	/* Determine if any updates are required. */
	if (!elog_nv_needs_update())
		return 0;

	erase_needed = elog_nv_needs_erase();

	/* Erase if necessary. */
	if (erase_needed) {
		elog_nv_erase();
		elog_nv_reset_last_write();
	}

	size = elog_nv_region_to_update(&offset);

	elog_nv_write(offset, size);
	elog_nv_increment_last_write(size);

	/*
	 * If erase wasn't performed then don't rescan. Assume the appended
	 * write was successful.
	 */
	if (!erase_needed)
		return 0;

	elog_debug_dump_buffer("ELOG: in-memory mirror:\n");

	/* Mark broken if the scan failed after a sync. */
	if (elog_scan_flash() < 0) {
		printk(BIOS_ERR, "ELOG: Sync back from NV storage failed.\n");
		elog_debug_dump_buffer("ELOG: Buffer from NV:\n");
		elog_state.elog_initialized = ELOG_BROKEN;
		return -1;
	}

	return 0;
}

/*
 * Do not log boot count events in S3 resume or SMM.
 */
static bool elog_do_add_boot_count(void)
{
	if (ENV_SMM)
		return false;

	return !acpi_is_wakeup_s3();
}

/* Check and log POST codes from previous boot */
static void log_last_boot_post(void)
{
#if ENV_X86
	u8 code;
	u32 extra;

	if (!CONFIG(CMOS_POST))
		return;

	if (cmos_post_previous_boot(&code, &extra) == 0)
		return;

	printk(BIOS_WARNING, "POST: Unexpected post code/extra "
	       "in previous boot: 0x%02x/0x%04x\n", code, extra);

	elog_add_event_word(ELOG_TYPE_LAST_POST_CODE, code);
	if (extra)
		elog_add_event_dword(ELOG_TYPE_POST_EXTRA, extra);
#endif
}

static void elog_add_boot_count(void)
{
	if (elog_do_add_boot_count()) {
		elog_add_event_dword(ELOG_TYPE_BOOT, boot_count_read());

		log_last_boot_post();
	}
}

/*
 * Event log main entry point
 */
int elog_init(void)
{
	void *mirror_buffer;
	size_t elog_size;
	switch (elog_state.elog_initialized) {
	case ELOG_UNINITIALIZED:
		break;
	case ELOG_INITIALIZED:
		return 0;
	case ELOG_BROKEN:
		return -1;
	}
	elog_state.elog_initialized = ELOG_BROKEN;

	if (!ENV_SMM)
		timestamp_add_now(TS_ELOG_INIT_START);

	elog_debug("%s()\n", __func__);

	/* Set up the backing store */
	if (elog_find_flash() < 0)
		return -1;

	elog_size = region_device_sz(&elog_state.nv_dev);
	mirror_buffer = elog_mirror_buf;
	rdev_chain_mem_rw(&elog_state.mirror_dev, mirror_buffer, elog_size);

	/*
	 * Mark as initialized to allow elog_init() to be called and deemed
	 * successful in the prepare/shrink path which adds events.
	 */
	elog_state.elog_initialized = ELOG_INITIALIZED;

	/* Load the log from flash and prepare the flash if necessary. */
	if (elog_scan_flash() < 0 && elog_prepare_empty() < 0) {
		printk(BIOS_ERR, "ELOG: Unable to prepare flash\n");
		return -1;
	}

	printk(BIOS_INFO, "ELOG: area is %zu bytes, full threshold %d,"
	       " shrink size %d\n", region_device_sz(&elog_state.nv_dev),
	       elog_state.full_threshold, elog_state.shrink_size);

	if (ENV_PAYLOAD_LOADER)
		elog_add_boot_count();

	if (!ENV_SMM)
		timestamp_add_now(TS_ELOG_INIT_END);

	return 0;
}

/*
 * Add an event to the log
 */
int elog_add_event_raw(u8 event_type, void *data, u8 data_size)
{
	struct event_header *event;
	struct rtc_time time = { 0 };
	u8 event_size;

	elog_debug("%s(type=%X)\n", __func__, event_type);

	/* Make sure ELOG structures are initialized */
	if (elog_init() < 0)
		return -1;

	/* Header + Data + Checksum */
	event_size = sizeof(*event) + data_size + 1;
	if (event_size > ELOG_MAX_EVENT_SIZE) {
		printk(BIOS_ERR, "ELOG: Event(%X) data size too "
		       "big (%d)\n", event_type, event_size);
		return -1;
	}

	/* Make sure event data can fit */
	event = elog_get_next_event_buffer(event_size);
	if (event == NULL) {
		printk(BIOS_ERR, "ELOG: Event(%X) does not fit\n",
		       event_type);
		return -1;
	}

	/* Fill out event data */
	event->type = event_type;
	event->length = event_size;
	if (CONFIG(RTC))
		rtc_get(&time);

	elog_fill_timestamp(event, time.sec, time.min, time.hour,
			    time.mday, time.mon, time.year);

	if (data_size)
		memcpy(&event[1], data, data_size);

	/* Zero the checksum byte and then compute checksum */
	elog_update_checksum(event, 0);
	elog_update_checksum(event, -(elog_checksum_event(event)));
	elog_put_event_buffer(event);

	elog_mirror_increment_last_write(event_size);

	printk(BIOS_INFO, "ELOG: Event(%X) added with size %d ",
	       event_type, event_size);
	if (event->day != 0) {
		printk(BIOS_INFO, "at 20%02x-%02x-%02x %02x:%02x:%02x UTC\n",
		       event->year, event->month, event->day,
		       event->hour, event->minute, event->second);
	} else {
		printk(BIOS_INFO, "(timestamp unavailable)\n");
	}

	/* Shrink the log if we are getting too full */
	if (elog_shrink() < 0)
		return -1;

	/* Ensure the updates hit the non-volatile storage. */
	return elog_sync_to_nv();
}

int elog_add_event(u8 event_type)
{
	return elog_add_event_raw(event_type, NULL, 0);
}

int elog_add_event_byte(u8 event_type, u8 data)
{
	return elog_add_event_raw(event_type, &data, sizeof(data));
}

int elog_add_event_word(u8 event_type, u16 data)
{
	return elog_add_event_raw(event_type, &data, sizeof(data));
}

int elog_add_event_dword(u8 event_type, u32 data)
{
	return elog_add_event_raw(event_type, &data, sizeof(data));
}

int elog_add_event_wake(u8 source, u32 instance)
{
	struct elog_event_data_wake wake = {
		.source = source,
		.instance = instance
	};
	return elog_add_event_raw(ELOG_TYPE_WAKE_SOURCE, &wake, sizeof(wake));
}

int elog_add_extended_event(u8 type, u32 complement)
{
	struct elog_event_extended_event event = {
		.event_type = type,
		.event_complement = complement
	};
	return elog_add_event_raw(ELOG_TYPE_EXTENDED_EVENT,
				  &event,
				  sizeof(event));
}

/* Make sure elog_init() runs at least once to log System Boot event. */
static void elog_bs_init(void *unused) { elog_init(); }
BOOT_STATE_INIT_ENTRY(BS_POST_DEVICE, BS_ON_ENTRY, elog_bs_init, NULL);