path: root/protocol.c

// SPDX-License-Identifier: Apache-2.0
// Copyright (C) 2018 IBM Corp.
#include "config.h"

#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>

#include "backend.h"
#include "common.h"
#include "lpc.h"
#include "mboxd.h"
#include "protocol.h"
#include "windows.h"


#define BLOCK_SIZE_SHIFT_V1		12 /* 4K */

static inline uint8_t protocol_get_bmc_event_mask(struct mbox_context *context)
{
	if (context->version == API_VERSION_1) {
		return BMC_EVENT_V1_MASK;
	}

	return BMC_EVENT_V2_MASK;
}

/*
 * protocol_events_put() - Push the full set/cleared state of BMC events on the
 * 			   provided transport
 * @context:    The mbox context pointer
 * @ops:	The operations struct for the transport of interest
 *
 * Return:      0 on success otherwise negative error code
 */
int protocol_events_put(struct mbox_context *context,
			const struct transport_ops *ops)
{
	const uint8_t mask = protocol_get_bmc_event_mask(context);

	return ops->put_events(context, mask);
}

/*
 * protocol_events_set() - Update the set BMC events on the active transport
 * @context:	The mbox context pointer
 * @bmc_event:	The bits to set
 *
 * Return:	0 on success otherwise negative error code
 */
int protocol_events_set(struct mbox_context *context, uint8_t bmc_event)
{
	const uint8_t mask = protocol_get_bmc_event_mask(context);

	/*
	 * Store the raw value, as we may up- or down- grade the protocol
	 * version and subsequently need to flush the appropriate set. Instead
	 * we pass the masked value through to the transport
	 */
	context->bmc_events |= bmc_event;

	return context->transport->set_events(context, bmc_event, mask);
}

/*
 * protocol_events_clear() - Update the cleared BMC events on the active
 *                           transport
 * @context:	The mbox context pointer
 * @bmc_event:	The bits to clear
 *
 * Return:	0 on success otherwise negative error code
 */
int protocol_events_clear(struct mbox_context *context, uint8_t bmc_event)
{
	const uint8_t mask = protocol_get_bmc_event_mask(context);

	context->bmc_events &= ~bmc_event;

	return context->transport->clear_events(context, bmc_event, mask);
}

static int protocol_negotiate_version(struct mbox_context *context,
				      uint8_t requested);

static int protocol_v1_reset(struct mbox_context *context)
{
	return __protocol_reset(context);
}

static int protocol_negotiate_version(struct mbox_context *context,
				      uint8_t requested);

static int protocol_v1_get_info(struct mbox_context *context,
				struct protocol_get_info *io)
{
	uint8_t old_version = context->version;
	int rc;

	/* Bootstrap protocol version. This may involve {up,down}grading */
	rc = protocol_negotiate_version(context, io->req.api_version);
	if (rc < 0)
		return rc;

	/* Do the {up,down}grade if necessary*/
	if (rc != old_version) {
		/* Doing version negotiation, don't alert host to reset */
		windows_reset_all(context);
		return context->protocol->get_info(context, io);
	}

	/* Record the negotiated version for the response */
	io->resp.api_version = rc;

	/* Now do all required intialisation for v1 */
	context->backend.block_size_shift = BLOCK_SIZE_SHIFT_V1;
	MSG_INFO("Block Size: 0x%.8x (shift: %u)\n",
		 1 << context->backend.block_size_shift, context->backend.block_size_shift);

	/* Knowing blocksize we can allocate the window dirty_bytemap */
	windows_alloc_dirty_bytemap(context);

	io->resp.v1.read_window_size =
		context->windows.default_size >> context->backend.block_size_shift;
	io->resp.v1.write_window_size =
		context->windows.default_size >> context->backend.block_size_shift;

	return lpc_map_memory(context);
}

static int protocol_v1_get_flash_info(struct mbox_context *context,
				      struct protocol_get_flash_info *io)
{
	io->resp.v1.flash_size = context->backend.flash_size;
	io->resp.v1.erase_size = 1 << context->backend.erase_size_shift;

	return 0;
}

/*
 * get_lpc_addr_shifted() - Get lpc address of the current window
 * @context:		The mbox context pointer
 *
 * Return:	The lpc address to access that offset shifted by block size
 */
static inline uint16_t get_lpc_addr_shifted(struct mbox_context *context)
{
	uint32_t lpc_addr, mem_offset;

	/* Offset of the current window in the reserved memory region */
	mem_offset = context->current->mem - context->mem;
	/* Total LPC Address */
	lpc_addr = context->lpc_base + mem_offset;

	MSG_DBG("LPC address of current window: 0x%.8x\n", lpc_addr);

	return lpc_addr >> context->backend.block_size_shift;
}

static inline int64_t blktrace_gettime(void)
{
	struct timespec ts;
	int64_t n;

	clock_gettime(CLOCK_REALTIME, &ts);
	n = (int64_t)(ts.tv_sec) * (int64_t)1000000000 + (int64_t)(ts.tv_nsec);

	return n;
}

static void blktrace_flush_start(struct mbox_context *context)
{
	struct blk_io_trace *trace = &context->trace;
	struct timespec now;

	if (!context->blktracefd)
		return;

	if (!context->blktrace_start) {
		clock_gettime(CLOCK_REALTIME, &now);
		context->blktrace_start = blktrace_gettime();
	}

	trace->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;
	trace->sequence++;
	trace->time = blktrace_gettime() - context->blktrace_start;
	trace->sector = context->current->flash_offset / 512;
	trace->bytes = context->current->size;
	if (context->current_is_write)
		trace->action = BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_WRITE);
	else
		trace->action = BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_READ);
	trace->pid = 0;
	trace->device = 0;
	trace->cpu = 0;
	trace->error = 0;
	trace->pdu_len = 0;
	write(context->blktracefd, trace, sizeof(*trace));
	trace->sequence++;
	trace->time = blktrace_gettime() - context->blktrace_start;
	trace->action &= ~BLK_TA_QUEUE;
	trace->action |= BLK_TA_ISSUE;
	write(context->blktracefd, trace, sizeof(*trace));
}

static void blktrace_flush_done(struct mbox_context *context)
{
	struct blk_io_trace *trace = &context->trace;

	if (!context->blktracefd)
		return;

	trace->sequence++;
	trace->time = blktrace_gettime() - context->blktrace_start;
	trace->action &= ~BLK_TA_ISSUE;
	trace->action |= BLK_TA_COMPLETE;
	write(context->blktracefd, trace, sizeof(*trace));
}

static void blktrace_window_start(struct mbox_context *context)
{
	struct blk_io_trace *trace = &context->trace;

	if (!context->blktracefd)
		return;

	if (!context->blktrace_start)
		context->blktrace_start = blktrace_gettime();

	trace->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;
	trace->sequence++;
	trace->time = blktrace_gettime() - context->blktrace_start;
	trace->action = BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_READ);
	trace->pid = 0;
	trace->device = 0;
	trace->cpu = 0;
	trace->error = 0;
	trace->pdu_len = 0;
}

static void blktrace_window_done(struct mbox_context *context)
{
	struct blk_io_trace *trace = &context->trace;

	if (!context->blktracefd)
		return;

	trace->sector = context->current->flash_offset / 512;
	trace->bytes = context->current->size;
	write(context->blktracefd, trace, sizeof(*trace));
	trace->sequence++;
	trace->action &= ~BLK_TA_QUEUE;
	trace->action |= BLK_TA_ISSUE;
	write(context->blktracefd, trace, sizeof(*trace));

	trace->sequence++;
	trace->time = blktrace_gettime() - context->blktrace_start;
	trace->action &= ~BLK_TA_ISSUE;
	trace->action |= BLK_TA_COMPLETE;
	write(context->blktracefd, trace, sizeof(*trace));
}

static int protocol_v1_create_window(struct mbox_context *context,
				     struct protocol_create_window *io)
{
	struct backend *backend = &context->backend;
	uint32_t offset;
	uint32_t size;
	int rc;

	offset = io->req.offset << backend->block_size_shift;
	size = io->req.size << backend->block_size_shift;
	rc = backend_validate(backend, offset, size, io->req.ro);
	if (rc < 0) {
		/* Backend does not allow window to be created. */
		return rc;
	}

	/* Close the current window if there is one */
	if (context->current) {
		/* There is an implicit flush if it was a write window
		 *
		 * protocol_v2_create_window() calls
		 * protocol_v1_create_window(), so use indirect call to
		 * write_flush() to make sure we pick the right one.
		 */
		if (context->current_is_write) {
			blktrace_flush_start(context);
			rc = context->protocol->flush(context, NULL);
			blktrace_flush_done(context);
			if (rc < 0) {
				MSG_ERR("Couldn't Flush Write Window\n");
				return rc;
			}
		}
		windows_close_current(context, FLAGS_NONE);
	}

	/* Offset the host has requested */
	MSG_INFO("Host requested flash @ 0x%.8x\n", offset);
	/* Check if we have an existing window */
	blktrace_window_start(context);
	context->current = windows_search(context, offset,
					  context->version == API_VERSION_1);

	if (!context->current) { /* No existing window */
		MSG_DBG("No existing window which maps that flash offset\n");
		rc = windows_create_map(context, &context->current,
				       offset,
				       context->version == API_VERSION_1);
		if (rc < 0) { /* Unable to map offset */
			MSG_ERR("Couldn't create window mapping for offset 0x%.8x\n",
				offset);
			return rc;
		}
	}
	blktrace_window_done(context);

	context->current_is_write = !io->req.ro;

	MSG_INFO("Window @ %p for size 0x%.8x maps flash offset 0x%.8x\n",
		 context->current->mem, context->current->size,
		 context->current->flash_offset);

	io->resp.lpc_address = get_lpc_addr_shifted(context);

	return 0;
}

static int protocol_v1_mark_dirty(struct mbox_context *context,
				  struct protocol_mark_dirty *io)
{
	uint32_t offset = io->req.v1.offset;
	uint32_t size = io->req.v1.size;
	uint32_t off;

	if (!(context->current && context->current_is_write)) {
		MSG_ERR("Tried to call mark dirty without open write window\n");
		return -EPERM;
	}

	/* For V1 offset given relative to flash - we want the window */
	off = offset - ((context->current->flash_offset) >>
			context->backend.block_size_shift);
	if (off > offset) { /* Underflow - before current window */
		MSG_ERR("Tried to mark dirty before start of window\n");
		MSG_ERR("requested offset: 0x%x window start: 0x%x\n",
				offset << context->backend.block_size_shift,
				context->current->flash_offset);
		return -EINVAL;
	}
	offset = off;
	/*
	 * We only track dirty at the block level.
	 * For protocol V1 we can get away with just marking the whole
	 * block dirty.
	 */
	size = align_up(size, 1 << context->backend.block_size_shift);
	size >>= context->backend.block_size_shift;

	MSG_INFO("Dirty window @ 0x%.8x for 0x%.8x\n",
		 offset << context->backend.block_size_shift,
		 size << context->backend.block_size_shift);

	return window_set_bytemap(context, context->current, offset, size,
				  WINDOW_DIRTY);
}

static int generic_flush(struct mbox_context *context)
{
	int rc, i, offset, count;
	uint8_t prev;

	offset = 0;
	count = 0;
	prev = WINDOW_CLEAN;

	MSG_INFO("Flush window @ %p for size 0x%.8x which maps flash @ 0x%.8x\n",
		 context->current->mem, context->current->size,
		 context->current->flash_offset);

	/*
	 * We look for streaks of the same type and keep a count, when the type
	 * (dirty/erased) changes we perform the required action on the backing
	 * store and update the current streak-type
	 */
	for (i = 0; i < (context->current->size >> context->backend.block_size_shift);
			i++) {
		uint8_t cur = context->current->dirty_bmap[i];
		if (cur != WINDOW_CLEAN) {
			if (cur == prev) { /* Same as previous block, incrmnt */
				count++;
			} else if (prev == WINDOW_CLEAN) { /* Start of run */
				offset = i;
				count++;
			} else { /* Change in streak type */
				rc = window_flush(context, offset, count,
						       prev);
				if (rc < 0) {
					return rc;
				}
				offset = i;
				count = 1;
			}
		} else {
			if (prev != WINDOW_CLEAN) { /* End of a streak */
				rc = window_flush(context, offset, count,
						       prev);
				if (rc < 0) {
					return rc;
				}
				offset = 0;
				count = 0;
			}
		}
		prev = cur;
	}

	if (prev != WINDOW_CLEAN) { /* Still the last streak to write */
		rc = window_flush(context, offset, count, prev);
		if (rc < 0) {
			return rc;
		}
	}

	/* Clear the dirty bytemap since we have written back all changes */
	return window_set_bytemap(context, context->current, 0,
				  context->current->size >>
				  context->backend.block_size_shift,
				  WINDOW_CLEAN);
}

static int protocol_v1_flush(struct mbox_context *context,
			     struct protocol_flush *io)
{
	int rc;

	if (!(context->current && context->current_is_write)) {
		MSG_ERR("Tried to call flush without open write window\n");
		return -EPERM;
	}

	/*
	 * For V1 the Flush command acts much the same as the dirty command
	 * except with a flush as well. Only do this on an actual flush
	 * command not when we call flush because we've implicitly closed a
	 * window because we might not have the required args in req.
	 */
	if (io) {
		struct protocol_mark_dirty *mdio = (void *)io;
		rc = protocol_v1_mark_dirty(context, mdio);
		if (rc < 0) {
			return rc;
		}
	}

	return generic_flush(context);
}

static int protocol_v1_close(struct mbox_context *context,
			     struct protocol_close *io)
{
	int rc;

	/* Close the current window if there is one */
	if (!context->current) {
		return 0;
	}

	/* There is an implicit flush if it was a write window */
	if (context->current_is_write) {
		rc = protocol_v1_flush(context, NULL);
		if (rc < 0) {
			MSG_ERR("Couldn't Flush Write Window\n");
			return rc;
		}
	}

	/* Host asked for it -> Don't set the BMC Event */
	windows_close_current(context, io->req.flags);

	return 0;
}

static int protocol_v1_ack(struct mbox_context *context,
			   struct protocol_ack *io)
{
	return protocol_events_clear(context,
				     (io->req.flags & BMC_EVENT_ACK_MASK));
}

/*
 * get_suggested_timeout() - get the suggested timeout value in seconds
 * @context:	The mbox context pointer
 *
 * Return:	Suggested timeout in seconds
 */
static uint16_t get_suggested_timeout(struct mbox_context *context)
{
	struct window_context *window = windows_find_largest(context);
	uint32_t max_size_mb = window ? (window->size >> 20) : 0;
	uint16_t ret;

	ret = align_up(max_size_mb * FLASH_ACCESS_MS_PER_MB, 1000) / 1000;

	MSG_DBG("Suggested Timeout: %us, max window size: %uMB, for %dms/MB\n",
		ret, max_size_mb, FLASH_ACCESS_MS_PER_MB);
	return ret;
}

static int protocol_v2_get_info(struct mbox_context *context,
				struct protocol_get_info *io)
{
	uint8_t old_version = context->version;
	int rc;

	/* Bootstrap protocol version. This may involve {up,down}grading */
	rc = protocol_negotiate_version(context, io->req.api_version);
	if (rc < 0)
		return rc;

	/* Do the {up,down}grade if necessary*/
	if (rc != old_version) {
		/* Doing version negotiation, don't alert host to reset */
		windows_reset_all(context);
		return context->protocol->get_info(context, io);
	}

	/* Record the negotiated version for the response */
	io->resp.api_version = rc;

	/* Now do all required intialisation for v2 */

	/* Knowing blocksize we can allocate the window dirty_bytemap */
	windows_alloc_dirty_bytemap(context);

	io->resp.v2.block_size_shift = context->backend.block_size_shift;
	MSG_INFO("Block Size: 0x%.8x (shift: %u)\n",
		 1 << context->backend.block_size_shift, context->backend.block_size_shift);

	io->resp.v2.timeout = get_suggested_timeout(context);

	return lpc_map_memory(context);
}

static int protocol_v2_get_flash_info(struct mbox_context *context,
				      struct protocol_get_flash_info *io)
{
	struct backend *backend = &context->backend;

	io->resp.v2.flash_size =
		backend->flash_size >> backend->block_size_shift;
	io->resp.v2.erase_size =
		((1 << backend->erase_size_shift) >> backend->block_size_shift);

	return 0;
}

static int protocol_v2_create_window(struct mbox_context *context,
				     struct protocol_create_window *io)
{
	int rc;

	rc = protocol_v1_create_window(context, io);
	if (rc < 0)
		return rc;

	io->resp.size = context->current->size >> context->backend.block_size_shift;
	io->resp.offset = context->current->flash_offset >>
					context->backend.block_size_shift;

	return 0;
}

static int protocol_v2_mark_dirty(struct mbox_context *context,
				  struct protocol_mark_dirty *io)
{
	if (!(context->current && context->current_is_write)) {
		MSG_ERR("Tried to call mark dirty without open write window\n");
		return -EPERM;
	}

	MSG_INFO("Dirty window @ 0x%.8x for 0x%.8x\n",
		 io->req.v2.offset << context->backend.block_size_shift,
		 io->req.v2.size << context->backend.block_size_shift);

	return window_set_bytemap(context, context->current, io->req.v2.offset,
				  io->req.v2.size, WINDOW_DIRTY);
}

static int protocol_v2_erase(struct mbox_context *context,
			     struct protocol_erase *io)
{
	size_t start, len;
	int rc;

	if (!(context->current && context->current_is_write)) {
		MSG_ERR("Tried to call erase without open write window\n");
		return -EPERM;
	}

	MSG_INFO("Erase window @ 0x%.8x for 0x%.8x\n",
		 io->req.offset << context->backend.block_size_shift,
		 io->req.size << context->backend.block_size_shift);

	rc = window_set_bytemap(context, context->current, io->req.offset,
				io->req.size, WINDOW_ERASED);
	if (rc < 0) {
		return rc;
	}

	/* Write 0xFF to mem -> This ensures consistency between flash & ram */
	start = io->req.offset << context->backend.block_size_shift;
	len = io->req.size << context->backend.block_size_shift;
	memset(context->current->mem + start, 0xFF, len);

	return 0;
}

static int protocol_v2_flush(struct mbox_context *context,
			     struct protocol_flush *io)
{
	if (!(context->current && context->current_is_write)) {
		MSG_ERR("Tried to call flush without open write window\n");
		return -EPERM;
	}

	return generic_flush(context);
}

static int protocol_v2_close(struct mbox_context *context,
			     struct protocol_close *io)
{
	int rc;

	/* Close the current window if there is one */
	if (!context->current) {
		return 0;
	}

	/* There is an implicit flush if it was a write window */
	if (context->current_is_write) {
		rc = protocol_v2_flush(context, NULL);
		if (rc < 0) {
			MSG_ERR("Couldn't Flush Write Window\n");
			return rc;
		}
	}

	/* Host asked for it -> Don't set the BMC Event */
	windows_close_current(context, io->req.flags);

	return 0;
}

static const struct protocol_ops protocol_ops_v1 = {
	.reset = protocol_v1_reset,
	.get_info = protocol_v1_get_info,
	.get_flash_info = protocol_v1_get_flash_info,
	.create_window = protocol_v1_create_window,
	.mark_dirty = protocol_v1_mark_dirty,
	.erase = NULL,
	.flush = protocol_v1_flush,
	.close = protocol_v1_close,
	.ack = protocol_v1_ack,
};

static const struct protocol_ops protocol_ops_v2 = {
	.reset = protocol_v1_reset,
	.get_info = protocol_v2_get_info,
	.get_flash_info = protocol_v2_get_flash_info,
	.create_window = protocol_v2_create_window,
	.mark_dirty = protocol_v2_mark_dirty,
	.erase = protocol_v2_erase,
	.flush = protocol_v2_flush,
	.close = protocol_v2_close,
	.ack = protocol_v1_ack,
};

static const struct protocol_ops *protocol_ops_map[] = {
	[0] = NULL,
	[1] = &protocol_ops_v1,
	[2] = &protocol_ops_v2,
};

static int protocol_negotiate_version(struct mbox_context *context,
				      uint8_t requested)
{
	/* Check we support the version requested */
	if (requested < API_MIN_VERSION)
		return -EINVAL;

	context->version = (requested > API_MAX_VERSION) ?
				API_MAX_VERSION : requested;

	context->protocol = protocol_ops_map[context->version];

	return context->version;
}

int protocol_init(struct mbox_context *context)
{
	protocol_negotiate_version(context, API_MAX_VERSION);

	return 0;
}

void protocol_free(struct mbox_context *context)
{
	return;
}

/* Don't do any state manipulation, just perform the reset */
int __protocol_reset(struct mbox_context *context)
{
	enum backend_reset_mode mode;
	int rc;

	windows_reset_all(context);

	rc = backend_reset(&context->backend, context->mem, context->mem_size);
	if (rc < 0)
		return rc;

	mode = rc;
	if (!(mode == reset_lpc_flash || mode == reset_lpc_memory))
		return -EINVAL;

	if (mode == reset_lpc_flash)
		return lpc_map_flash(context);

	assert(mode == reset_lpc_memory);
	return lpc_map_memory(context);
}

/* Prevent the host from performing actions whilst reset takes place */
int protocol_reset(struct mbox_context *context)
{
	int rc;

	rc = protocol_events_clear(context, BMC_EVENT_DAEMON_READY);
	if (rc < 0) {
		MSG_ERR("Failed to clear daemon ready state, reset failed\n");
		return rc;
	}

	rc = __protocol_reset(context);
	if (rc < 0) {
		MSG_ERR("Failed to reset protocol, daemon remains not ready\n");
		return rc;
	}

	rc = protocol_events_set(context,
			BMC_EVENT_DAEMON_READY | BMC_EVENT_PROTOCOL_RESET);
	if (rc < 0) {
		MSG_ERR("Failed to set daemon ready state, daemon remains not ready\n");
		return rc;
	}

	return 0;
}