Add submodule dependency filesHEADmaster

Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec

11 files changed, 1987 insertions, 0 deletions

diff --git a/roms/skiboot/hw/ipmi/Makefile.inc b/roms/skiboot/hw/ipmi/Makefile.inc
new file mode 100644
index 000000000..c6b36a2b3
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/Makefile.inc
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+
+SUBDIRS += hw/ipmi
+
+IPMI_OBJS  = ipmi-rtc.o ipmi-power.o ipmi-fru.o ipmi-sel.o
+IPMI_OBJS += ipmi-watchdog.o ipmi-sensor.o ipmi-attn.o ipmi-info.o
+
+IPMI = hw/ipmi/built-in.a
+$(IPMI): $(IPMI_OBJS:%=hw/ipmi/%)
diff --git a/roms/skiboot/hw/ipmi/ipmi-attn.c b/roms/skiboot/hw/ipmi/ipmi-attn.c
new file mode 100644
index 000000000..280b2525f
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-attn.c
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * When everything is terrible, tell the FSP as much as possible as to why
+ *
+ * Copyright 2013-2019 IBM Corp.
+ */
+
+#include <errorlog.h>
+#include <ipmi.h>
+#include <pel.h>
+#include <platform.h>
+#include <processor.h>
+#include <sbe-p9.h>
+#include <skiboot.h>
+#include <stack.h>
+#include <timebase.h>
+#include <xscom.h>
+
+/* Use same attention SRC for BMC based machine */
+DEFINE_LOG_ENTRY(OPAL_RC_ATTN, OPAL_PLATFORM_ERR_EVT,
+		 OPAL_ATTN, OPAL_PLATFORM_FIRMWARE,
+		 OPAL_ERROR_PANIC, OPAL_ABNORMAL_POWER_OFF);
+
+/* Maximum buffer size to capture backtrace and other useful information */
+#define IPMI_TI_BUFFER_SIZE	(IPMI_MAX_PEL_SIZE - PEL_MIN_SIZE)
+static char ti_buffer[IPMI_TI_BUFFER_SIZE];
+
+#define STACK_BUF_ENTRIES       20
+static struct bt_entry bt_buf[STACK_BUF_ENTRIES];
+
+/* Log eSEL event with OPAL backtrace */
+static void ipmi_log_terminate_event(const char *msg)
+{
+	struct bt_metadata metadata;
+	unsigned int ti_len;
+	unsigned int ti_size;
+	struct errorlog *elog_buf;
+
+	/* Fill OPAL version */
+	ti_len = snprintf(ti_buffer, IPMI_TI_BUFFER_SIZE,
+			  "OPAL version : %s\n", version);
+
+	/* File information */
+	ti_len += snprintf(ti_buffer + ti_len, IPMI_TI_BUFFER_SIZE - ti_len,
+			   "File info : %s\n", msg);
+	ti_size = IPMI_TI_BUFFER_SIZE - ti_len;
+
+	/* Backtrace */
+	backtrace_create(bt_buf, STACK_BUF_ENTRIES, &metadata);
+	metadata.token = OPAL_LAST + 1;
+	backtrace_print(bt_buf, &metadata, ti_buffer + ti_len, &ti_size, true);
+
+	/* Create eSEL event and commit */
+	elog_buf = opal_elog_create(&e_info(OPAL_RC_ATTN), 0);
+	log_append_data(elog_buf, (char *)&ti_buffer, ti_len + ti_size);
+	log_commit(elog_buf);
+}
+
+void __attribute__((noreturn)) ipmi_terminate(const char *msg)
+{
+	/* Log eSEL event */
+	if (ipmi_present())
+		ipmi_log_terminate_event(msg);
+
+	/*
+	 * If mpipl is supported then trigger SBE interrupt
+	 * to initiate mpipl
+	 */
+	p9_sbe_terminate();
+
+	/*
+	 * Trigger software xstop (OPAL TI). It will stop all the CPU threads
+	 * moving them into quiesced state. OCC will collect all FIR data.
+	 * Upon checkstop signal, BMC will then decide whether to reboot/IPL or
+	 * not depending on AutoReboot policy, if any. This helps in cases
+	 * where OPAL is crashing/terminating before host reaches to runtime.
+	 * With OpenBMC AutoReboot policy, in such cases, it will make sure
+	 * that system is moved to Quiesced state after 3 or so attempts to
+	 * IPL.  Without OPAL TI, OpenBMC will never know that OPAL is
+	 * terminating and system would go into never ending IPL'ing loop.
+	 *
+	 * Once the system reaches to runtime, OpenBMC resets the boot counter.
+	 * Hence next time when BMC receieves the OPAL TI, it will IPL the
+	 * system if AutoReboot is enabled. We don't need to worry about self
+	 * rebooting.
+	 */
+
+	xscom_trigger_xstop();
+	/*
+	 * Control will not reach here if software xstop has been supported and
+	 * enabled. If not supported then fallback to cec reboot path below.
+	 */
+
+	/* Reboot call */
+	if (platform.cec_reboot)
+		platform.cec_reboot();
+
+	while (1)
+		time_wait_ms(100);
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-fru.c b/roms/skiboot/hw/ipmi/ipmi-fru.c
new file mode 100644
index 000000000..86c9ca0ce
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-fru.c
@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * Fill out firmware related FRUs (Field Replaceable Units)
+ *
+ * Copyright 2013-2019 IBM Corp.
+ */
+
+#include <skiboot.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ipmi.h>
+#include <lock.h>
+#include <opal.h>
+#include <device.h>
+
+struct product_info {
+	char *manufacturer;
+	char *product;
+	char *part_no;
+	char *version;
+	char *serial_no;
+	char *asset_tag;
+};
+
+struct common_header {
+	u8 version;
+	u8 internal_offset;
+	u8 chassis_offset;
+	u8 board_offset;
+	u8 product_offset;
+	u8 multirecord_offset;
+	u8 pad;
+	u8 checksum;
+} __packed;
+
+/* The maximum amount of FRU data we can store. */
+#define FRU_DATA_SIZE 256
+
+/* We allocate two bytes at these locations in the data array to track
+ * state. */
+#define WRITE_INDEX 256
+#define REMAINING 257
+
+/* The ASCII string encoding used only has 5 bits to encode length
+ * hence the maximum is 31 characters. */
+#define MAX_STR_LEN 31
+
+static u8 fru_dev_id = 0;
+
+static int fru_insert_string(u8 *buf, char *str)
+{
+	int len = strlen(str);
+
+	/* The ASCII type/length format only supports a string length
+	 * between 2 and 31 characters. Zero characters is ok though
+	 * as it indicates no data present. */
+	if (len == 1 || len > MAX_STR_LEN)
+		return OPAL_PARAMETER;
+
+	buf[0] = 0xc0 | len;
+	memcpy(&buf[1], str, len);
+
+	return len + 1;
+}
+
+static u8 fru_checksum(u8 *buf, int len)
+{
+	int i;
+	u8 checksum = 0;
+
+	for(i = 0; i < len; i++) {
+		checksum += buf[i];
+	}
+	checksum = ~checksum + 1;
+	return checksum;
+}
+
+#define FRU_INSERT_STRING(x, y)						\
+	({ rc = fru_insert_string(x, y);				\
+	 { if (rc < 1) return OPAL_PARAMETER; } rc; })
+
+static int fru_fill_product_info(u8 *buf, struct product_info *info, size_t size)
+{
+	size_t total_size = 11;
+	int index = 0;
+	int rc;
+
+	total_size += strlen(info->manufacturer);
+	total_size += strlen(info->product);
+	total_size += strlen(info->part_no);
+	total_size += strlen(info->version);
+	total_size += strlen(info->serial_no);
+	total_size += strlen(info->asset_tag);
+	total_size += (8 - (total_size % 8)) % 8;
+	if (total_size > size)
+		return OPAL_PARAMETER;
+
+	buf[index++] = 0x1;		/* Version */
+	buf[index++] = total_size / 8;	/* Size */
+	buf[index++] = 0;		/* Language code (English) */
+
+	index += FRU_INSERT_STRING(&buf[index], info->manufacturer);
+	index += FRU_INSERT_STRING(&buf[index], info->product);
+	index += FRU_INSERT_STRING(&buf[index], info->part_no);
+	index += FRU_INSERT_STRING(&buf[index], info->version);
+	index += FRU_INSERT_STRING(&buf[index], info->serial_no);
+	index += FRU_INSERT_STRING(&buf[index], info->asset_tag);
+
+	buf[index++] = 0xc1;		/* End of data marker */
+	memset(&buf[index], 0, total_size - index - 1);
+	index += total_size - index - 1;
+	buf[index] = fru_checksum(buf, index);
+	assert(index == total_size - 1);
+
+	return total_size;
+}
+
+static int fru_add(u8 *buf, int size)
+{
+	int len;
+	struct common_header common_hdr;
+	char *short_version;
+	struct product_info info = {
+		.manufacturer = (char *) "IBM",
+		.product = (char *) "skiboot",
+		.part_no = (char *) "",
+		.serial_no = (char *) "",
+		.asset_tag = (char *) "",
+	};
+
+	if (size < sizeof(common_hdr))
+		return OPAL_PARAMETER;
+
+	/* We currently only support adding the version number at the
+	 * product information offset. We choose an offset of 64 bytes
+	 * because that's what the standard recommends. */
+	common_hdr.version = 1;
+	common_hdr.internal_offset = 0;
+	common_hdr.chassis_offset = 0;
+	common_hdr.board_offset = 0;
+	common_hdr.product_offset = 64/8;
+	common_hdr.multirecord_offset = 0;
+	common_hdr.pad = 0;
+	common_hdr.checksum = fru_checksum((u8 *) &common_hdr, sizeof(common_hdr) - 1);
+	memcpy(buf, &common_hdr, sizeof(common_hdr));
+
+	short_version = strdup(version);
+	info.version = short_version;
+	if (!strncmp(version, "skiboot-", 8))
+		info.version = &short_version[8];
+
+	if (strlen(info.version) >= MAX_STR_LEN) {
+		if (info.version[MAX_STR_LEN] != '\0')
+			info.version[MAX_STR_LEN - 1] = '+';
+		info.version[MAX_STR_LEN] = '\0';
+	}
+
+	len = fru_fill_product_info(&buf[64], &info, size - 64);
+	free(short_version);
+	if (len < 0)
+		return OPAL_PARAMETER;
+
+	return len + 64;
+}
+
+static void fru_write_complete(struct ipmi_msg *msg)
+{
+	u8 write_count = msg->data[0];
+	u16 offset;
+
+	msg->data[WRITE_INDEX] += write_count;
+	msg->data[REMAINING] -= write_count;
+	if (msg->data[REMAINING] == 0)
+		goto out;
+
+	offset = msg->data[WRITE_INDEX];
+	ipmi_init_msg(msg, IPMI_DEFAULT_INTERFACE, IPMI_WRITE_FRU,
+		      fru_write_complete, NULL,
+		      MIN(msg->data[REMAINING] + 3, IPMI_MAX_REQ_SIZE), 2);
+
+	memmove(&msg->data[3], &msg->data[offset + 3], msg->req_size - 3);
+
+	msg->data[0] = fru_dev_id;     		/* FRU Device ID */
+	msg->data[1] = offset & 0xff;		/* Offset LSB */
+	msg->data[2] = (offset >> 8) & 0xff;	/* Offset MSB */
+
+	ipmi_queue_msg(msg);
+
+	return;
+
+out:
+	ipmi_free_msg(msg);
+}
+
+static int fru_write(void)
+{
+	struct ipmi_msg *msg;
+	int len;
+
+	/* We allocate FRU_DATA_SIZE + 5 bytes for the message:
+	 * - 3 bytes for the the write FRU command header
+	 * - FRU_DATA_SIZE bytes for FRU data
+	 * - 2 bytes for offset & bytes remaining count
+	 */
+	msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_WRITE_FRU,
+			 fru_write_complete, NULL, NULL, FRU_DATA_SIZE + 5, 2);
+	if (!msg)
+		return OPAL_RESOURCE;
+
+	msg->data[0] = fru_dev_id;	/* FRU Device ID */
+	msg->data[1] = 0x0;		/* Offset LSB (we always write a new common header) */
+	msg->data[2] = 0x0;		/* Offset MSB */
+	len = fru_add(&msg->data[3], FRU_DATA_SIZE);
+
+	if (len < 0)
+		return len;
+
+	/* Three bytes for the actual FRU Data Command */
+	msg->data[WRITE_INDEX] = 0;
+	msg->data[REMAINING] = len;
+	msg->req_size = MIN(len + 3, IPMI_MAX_REQ_SIZE);
+	return ipmi_queue_msg(msg);
+}
+
+void ipmi_fru_init(u8 dev_id)
+{
+	fru_dev_id = dev_id;
+	fru_write();
+
+	return;
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-info.c b/roms/skiboot/hw/ipmi/ipmi-info.c
new file mode 100644
index 000000000..d93b59d7d
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-info.c
@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * Various bits of info retreived over IPMI
+ *
+ * Copyright 2018-2019 IBM Corp.
+ */
+
+#include <device.h>
+#include <skiboot.h>
+#include <stdlib.h>
+#include <ipmi.h>
+#include <mem_region-malloc.h>
+#include <opal.h>
+#include <timebase.h>
+
+/*
+ * Response data from IPMI Get device ID command (As defined in
+ * Section 20.1 Get Device ID Command - IPMI standard spec).
+ */
+struct ipmi_dev_id {
+	uint8_t	dev_id;
+	uint8_t	dev_revision;
+	uint8_t	fw_rev1;
+	uint8_t	fw_rev2;
+	uint8_t	ipmi_ver;
+	uint8_t	add_dev_support;
+	uint8_t	manufactur_id[3];
+	uint8_t	product_id[2];
+	uint8_t	aux_fw_rev[4];
+};
+static struct ipmi_dev_id *ipmi_dev_id;
+
+/*
+ * Response data from IPMI Chassis Get System Boot Option (As defined in
+ * Section 28.13 Get System Boot Options Command - IPMI standard spec).
+ */
+struct ipmi_sys_boot_opt {
+	uint8_t param_version;
+	uint8_t param_valid;
+	/*
+	 * Fields for OEM parameter 0x62. This parameter does not follow
+	 * the normal layout and just has a single byte to signal if it
+	 * is active or not.
+	 */
+	uint8_t flag_set;
+};
+static struct ipmi_sys_boot_opt *ipmi_sys_boot_opt;
+
+/* Got response from BMC? */
+static bool bmc_info_waiting = false;
+static bool bmc_info_valid = false;
+static bool bmc_boot_opt_waiting = false;
+static bool bmc_boot_opt_valid = false;
+
+/* This will free ipmi_dev_id structure */
+void ipmi_dt_add_bmc_info(void)
+{
+	char buf[8];
+	struct dt_node *dt_fw_version;
+
+	while (bmc_info_waiting)
+		time_wait_ms(5);
+
+	if (!bmc_info_valid)
+		return;
+
+	dt_fw_version = dt_find_by_name(dt_root, "ibm,firmware-versions");
+	if (!dt_fw_version) {
+		free(ipmi_dev_id);
+		return;
+	}
+
+	memset(buf, 0, sizeof(buf));
+	snprintf(buf, sizeof(buf), "%x.%02x",
+		 ipmi_dev_id->fw_rev1, ipmi_dev_id->fw_rev2);
+	dt_add_property_string(dt_fw_version, "bmc-firmware-version", buf);
+
+	free(ipmi_dev_id);
+}
+
+static void ipmi_get_bmc_info_resp(struct ipmi_msg *msg)
+{
+	bmc_info_waiting = false;
+
+	if (msg->cc != IPMI_CC_NO_ERROR) {
+		prlog(PR_ERR, "IPMI: IPMI_BMC_GET_DEVICE_ID cmd returned error"
+		      " [rc : 0x%x]\n", msg->data[0]);
+		return;
+	}
+
+	/* ipmi_dev_id has optional fields */
+	if (msg->resp_size <= sizeof(struct ipmi_dev_id)) {
+		bmc_info_valid = true;
+		memcpy(ipmi_dev_id, msg->data, msg->resp_size);
+	} else {
+		prlog(PR_WARNING, "IPMI: IPMI_BMC_GET_DEVICE_ID unexpected response size\n");
+	}
+
+	ipmi_free_msg(msg);
+}
+
+int ipmi_get_bmc_info_request(void)
+{
+	int rc;
+	struct ipmi_msg *msg;
+
+	ipmi_dev_id = zalloc(sizeof(struct ipmi_dev_id));
+	assert(ipmi_dev_id);
+
+	msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_BMC_GET_DEVICE_ID,
+			 ipmi_get_bmc_info_resp, NULL, NULL,
+			 0, sizeof(struct ipmi_dev_id));
+	if (!msg)
+		return OPAL_NO_MEM;
+
+	msg->error = ipmi_get_bmc_info_resp;
+	prlog(PR_INFO, "IPMI: Requesting IPMI_BMC_GET_DEVICE_ID\n");
+	rc = ipmi_queue_msg(msg);
+	if (rc) {
+		prlog(PR_ERR, "IPMI: Failed to queue IPMI_BMC_GET_DEVICE_ID\n");
+		ipmi_free_msg(msg);
+		return rc;
+	}
+
+	bmc_info_waiting = true;
+	return rc;
+}
+
+/* This will free ipmi_sys_boot_opt structure */
+int ipmi_chassis_check_sbe_validation(void)
+{
+	int rc = -1;
+
+	while (bmc_boot_opt_waiting)
+		time_wait_ms(10);
+
+	if (!bmc_boot_opt_valid)
+		goto out;
+
+	if ((ipmi_sys_boot_opt->param_valid & 0x8) != 0)
+		goto out;
+	if (ipmi_sys_boot_opt->param_valid != 0x62)
+		goto out;
+
+	rc = ipmi_sys_boot_opt->flag_set;
+
+out:
+	free(ipmi_sys_boot_opt);
+	return rc;
+}
+
+static void ipmi_get_chassis_boot_opt_resp(struct ipmi_msg *msg)
+{
+	bmc_boot_opt_waiting = false;
+
+	if (msg->cc != IPMI_CC_NO_ERROR) {
+		prlog(PR_INFO, "IPMI: IPMI_CHASSIS_GET_BOOT_OPT cmd returned error"
+		      " [rc : 0x%x]\n", msg->data[0]);
+		ipmi_free_msg(msg);
+		return;
+	}
+
+	if (msg->resp_size == sizeof(struct ipmi_sys_boot_opt)) {
+		bmc_boot_opt_valid = true;
+		memcpy(ipmi_sys_boot_opt, msg->data, msg->resp_size);
+	} else {
+		prlog(PR_WARNING, "IPMI: IPMI_CHASSIS_GET_BOOT_OPT unexpected response size\n");
+	}
+
+	ipmi_free_msg(msg);
+}
+
+int ipmi_get_chassis_boot_opt_request(void)
+{
+	int rc;
+	struct ipmi_msg *msg;
+	uint8_t req[] = {
+		0x62, /* OEM parameter (SBE Validation on astbmc) */
+		0x00, /* no set selector */
+		0x00, /* no block selector */
+	};
+
+	ipmi_sys_boot_opt = zalloc(sizeof(struct ipmi_sys_boot_opt));
+	assert(ipmi_sys_boot_opt);
+
+	msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_CHASSIS_GET_BOOT_OPT,
+			 ipmi_get_chassis_boot_opt_resp, NULL, req,
+			 sizeof(req), sizeof(struct ipmi_sys_boot_opt));
+	if (!msg) {
+		free(ipmi_sys_boot_opt);
+		return OPAL_NO_MEM;
+	}
+
+	msg->error = ipmi_get_chassis_boot_opt_resp;
+	prlog(PR_INFO, "IPMI: Requesting IPMI_CHASSIS_GET_BOOT_OPT\n");
+	rc = ipmi_queue_msg(msg);
+	if (rc) {
+		prlog(PR_ERR, "IPMI: Failed to queue IPMI_CHASSIS_GET_BOOT_OPT\n");
+		free(ipmi_sys_boot_opt);
+		ipmi_free_msg(msg);
+		return rc;
+	}
+
+	bmc_boot_opt_waiting = true;
+	return rc;
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-power.c b/roms/skiboot/hw/ipmi/ipmi-power.c
new file mode 100644
index 000000000..8101a8524
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-power.c
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * Power as in electricity, not POWER as in POWER
+ *
+ * Copyright 2013-2019 IBM Corp.
+ */
+
+#include <skiboot.h>
+#include <stdlib.h>
+#include <ipmi.h>
+#include <opal.h>
+#include <timebase.h>
+
+static void ipmi_chassis_control_complete(struct ipmi_msg *msg)
+{
+	uint8_t request = msg->data[0];
+	uint8_t cc = msg->cc;
+
+	ipmi_free_msg(msg);
+	if (cc == IPMI_CC_NO_ERROR)
+		return;
+
+	prlog(PR_INFO, "IPMI: Chassis control request failed. "
+	      "request=0x%02x, rc=0x%02x\n", request, cc);
+
+	if (ipmi_chassis_control(request)) {
+		prlog(PR_INFO, "IPMI: Failed to resend chassis control "
+		      "request [0x%02x]\n", request);
+	}
+}
+
+int ipmi_chassis_control(uint8_t request)
+{
+	struct ipmi_msg *msg;
+
+	if (!ipmi_present())
+		return OPAL_CLOSED;
+
+	if (request > IPMI_CHASSIS_SOFT_SHUTDOWN)
+		return OPAL_PARAMETER;
+
+	msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_CHASSIS_CONTROL,
+			 ipmi_chassis_control_complete, NULL,
+			 &request, sizeof(request), 0);
+	if (!msg)
+		return OPAL_HARDWARE;
+	/* Set msg->error callback function */
+	msg->error = ipmi_chassis_control_complete;
+
+	prlog(PR_INFO, "IPMI: sending chassis control request 0x%02x\n",
+			request);
+
+	return ipmi_queue_msg(msg);
+}
+
+int ipmi_set_power_state(uint8_t system, uint8_t device)
+{
+	struct ipmi_msg *msg;
+	struct {
+		uint8_t system;
+		uint8_t device;
+	} power_state;
+
+	if (!ipmi_present())
+		return OPAL_CLOSED;
+
+	power_state.system = system;
+	power_state.device = device;
+
+	if (system != IPMI_PWR_NOCHANGE)
+		power_state.system |= 0x80;
+	if (device != IPMI_PWR_NOCHANGE)
+		power_state.device |= 0x80;
+
+	msg = ipmi_mkmsg_simple(IPMI_SET_POWER_STATE, &power_state,
+				sizeof(power_state));
+
+	if (!msg)
+		return OPAL_HARDWARE;
+
+	prlog(PR_INFO, "IPMI: setting power state: sys %02x, dev %02x\n",
+			power_state.system, power_state.device);
+
+	return ipmi_queue_msg(msg);
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-rtc.c b/roms/skiboot/hw/ipmi/ipmi-rtc.c
new file mode 100644
index 000000000..52da2946c
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-rtc.c
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * Talk to a Real Time Clock (RTC) over IPMI
+ *
+ * Copyright 2013-2015 IBM Corp.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <ipmi.h>
+#include <time.h>
+#include <time-utils.h>
+#include <device.h>
+#include <opal.h>
+#include <rtc.h>
+
+static enum {idle, waiting, updated, error} time_status;
+
+static void get_sel_time_error(struct ipmi_msg *msg)
+{
+	time_status = error;
+	ipmi_free_msg(msg);
+}
+
+static void get_sel_time_complete(struct ipmi_msg *msg)
+{
+	struct tm tm;
+	le32 result;
+	time_t time;
+
+	memcpy(&result, msg->data, 4);
+	time = le32_to_cpu(result);
+	gmtime_r(&time, &tm);
+	rtc_cache_update(&tm);
+	time_status = updated;
+	ipmi_free_msg(msg);
+}
+
+static int64_t ipmi_get_sel_time(void)
+{
+	struct ipmi_msg *msg;
+
+	msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_GET_SEL_TIME,
+			 get_sel_time_complete, NULL, NULL, 0, 4);
+	if (!msg)
+		return OPAL_HARDWARE;
+
+	msg->error = get_sel_time_error;
+
+	return ipmi_queue_msg(msg);
+}
+
+static int64_t ipmi_set_sel_time(uint32_t _tv)
+{
+	struct ipmi_msg *msg;
+	const le32 tv = cpu_to_le32(_tv);
+
+	msg = ipmi_mkmsg_simple(IPMI_SET_SEL_TIME, (void*)&tv, sizeof(tv));
+	if (!msg)
+		return OPAL_HARDWARE;
+
+	return ipmi_queue_msg(msg);
+}
+
+static int64_t ipmi_opal_rtc_read(__be32 *__ymd, __be64 *__hmsm)
+{
+	int ret = 0;
+	uint32_t ymd;
+	uint64_t hmsm;
+
+	if (!__ymd || !__hmsm)
+		return OPAL_PARAMETER;
+
+	switch(time_status) {
+	case idle:
+		if (ipmi_get_sel_time() < 0)
+			return OPAL_HARDWARE;
+		time_status = waiting;
+		ret = OPAL_BUSY_EVENT;
+		break;
+
+	case waiting:
+		ret = OPAL_BUSY_EVENT;
+		break;
+
+	case updated:
+		rtc_cache_get_datetime(&ymd, &hmsm);
+		*__ymd = cpu_to_be32(ymd);
+		*__hmsm = cpu_to_be64(hmsm);
+		time_status = idle;
+		ret = OPAL_SUCCESS;
+		break;
+
+	case error:
+		time_status = idle;
+		ret = OPAL_HARDWARE;
+		break;
+	}
+
+	return ret;
+}
+
+static int64_t ipmi_opal_rtc_write(uint32_t year_month_day,
+				  uint64_t hour_minute_second_millisecond)
+{
+	time_t t;
+	struct tm tm;
+
+	datetime_to_tm(year_month_day, hour_minute_second_millisecond, &tm);
+	t = mktime(&tm);
+	if (ipmi_set_sel_time(t))
+		return OPAL_HARDWARE;
+
+	return OPAL_SUCCESS;
+}
+
+void ipmi_rtc_init(void)
+{
+	struct dt_node *np = dt_new(opal_node, "rtc");
+	dt_add_property_strings(np, "compatible", "ibm,opal-rtc");
+
+	opal_register(OPAL_RTC_READ, ipmi_opal_rtc_read, 2);
+	opal_register(OPAL_RTC_WRITE, ipmi_opal_rtc_write, 2);
+
+	/* Initialise the rtc cache */
+	ipmi_get_sel_time();
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-sel.c b/roms/skiboot/hw/ipmi/ipmi-sel.c
new file mode 100644
index 000000000..215b8ba7d
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-sel.c
@@ -0,0 +1,701 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/* Copyright 2013-2018 IBM Corp. */
+
+#define pr_fmt(fmt) "IPMI: " fmt
+#include <ccan/list/list.h>
+#include <ccan/str/str.h>
+#include <compiler.h>
+#include <errno.h>
+#include <skiboot.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ipmi.h>
+#include <device.h>
+#include <opal.h>
+#include <lock.h>
+#include <errorlog.h>
+#include <pel.h>
+#include <opal-msg.h>
+#include <debug_descriptor.h>
+#include <occ.h>
+#include <timebase.h>
+
+/* OEM SEL fields */
+#define SEL_OEM_ID_0		0x55
+#define SEL_OEM_ID_1		0x55
+#define SEL_RECORD_TYPE_OEM	0xC0
+#define SEL_RECORD_TYPE_EVENT	0x02
+
+#define SEL_NETFN_IBM		0x3a
+
+/* OEM SEL Commands */
+/* TODO: Move these to their respective source files */
+#define CMD_AMI_POWER		0x04
+#define CMD_AMI_PNOR_ACCESS	0x07
+#define CMD_AMI_OCC_RESET	0x0e
+#define CMD_HEARTBEAT		0xff
+
+/* XXX: Listed here for completeness, registered in libflash/ipmi-flash.c */
+#define CMD_OP_HIOMAP_EVENT	0x0f
+
+#define SOFT_OFF	        0x00
+#define SOFT_REBOOT	        0x01
+
+#define RELEASE_PNOR		0x00
+#define REQUEST_PNOR		0x01
+
+/* 32.1 SEL Event Records type */
+#define SEL_REC_TYPE_SYS_EVENT	0x02
+#define SEL_REC_TYPE_AMI_ESEL	0xDF
+
+/* OEM SEL generator ID for AMI */
+#define SEL_GENERATOR_ID_AMI	0x0020
+
+/* IPMI SEL version */
+#define SEL_EVM_VER_1		0x03
+#define SEL_EVM_VER_2		0x04
+
+/*
+ * Sensor type for System events
+ *
+ * Sensor information (type, number, etc) is passed to us via
+ * device tree. Currently we are using System Event type to
+ * log OPAL events.
+ */
+#define SENSOR_TYPE_SYS_EVENT	0x12
+
+/*
+ * 42.1 Event/Reading Type Codes
+ *
+ * Note that device hotplug and availability related events
+ * are not defined as we are not using those events type.
+ */
+#define SEL_EVENT_DIR_TYPE_UNSPECIFIED	0x00
+#define SEL_EVENT_DIR_TYPE_THRESHOLD	0x01
+#define SEL_EVENT_DIR_TYPE_STATE	0x03
+#define SEL_EVENT_DIR_TYPE_PREDICTIVE	0x04
+#define SEL_EVENT_DIR_TYPE_LIMIT	0x05
+#define SEL_EVENT_DIR_TYPE_PERFORMANCE	0x06
+#define SEL_EVENT_DIR_TYPE_TRANSITION	0x07
+#define SEL_EVENT_DIR_TYPE_OEM		0x70
+
+/*
+ * 42.1 Event/Reading Type Codes
+ */
+#define SEL_DATA1_AMI			0xAA
+#define SEL_DATA1_DEASSERTED		0x00
+#define SEL_DATA1_ASSERTED		0x01
+#define SEL_DATA1_OK			0x00
+#define SEL_DATA1_NON_CRIT_FROM_OK	0x01
+#define SEL_DATA1_CRIT_FROM_LESS_SEV	0x02
+#define SEL_DATA1_NON_REC_FROM_LESS_SEV	0x03
+#define SEL_DATA1_NON_CRIT		0x04
+#define SEL_DATA1_CRITICAL		0x05
+#define SEL_DATA1_NON_RECOVERABLE	0X06
+#define SEL_DATA1_MONITOR		0x07
+#define SEL_DATA1_INFORMATIONAL		0x08
+
+/* SEL Record Entry */
+struct sel_record {
+	le16		record_id;
+	uint8_t		record_type;
+	le32		timestamp;
+	le16		generator_id;
+	uint8_t		evm_ver;
+	uint8_t		sensor_type;
+	uint8_t		sensor_number;
+	uint8_t		event_dir_type;
+	uint8_t		event_data1;
+	uint8_t		event_data2;
+	uint8_t		event_data3;
+} __packed;
+
+static struct sel_record sel_record;
+
+struct oem_sel {
+	/* SEL header */
+	uint8_t id[2];
+	uint8_t type;
+	uint8_t timestamp[4];
+	uint8_t manuf_id[3];
+	/* OEM SEL data (6 bytes) follows */
+	uint8_t netfun;
+	uint8_t cmd;
+	uint8_t data[4];
+};
+
+#define ESEL_HDR_SIZE 7
+
+/* Used for sending PANIC events like abort() path */
+struct ipmi_sel_panic_msg {
+	bool		busy;
+	struct ipmi_msg	*msg;
+	struct lock	lock;
+};
+static struct ipmi_sel_panic_msg ipmi_sel_panic_msg;
+
+static LIST_HEAD(sel_handlers);
+
+/* Forward declaration */
+static void ipmi_elog_poll(struct ipmi_msg *msg);
+
+/*
+ * Allocate IPMI message:
+ * For normal event, allocate memory using ipmi_mkmsg and for PANIC
+ * event, use pre-allocated buffer.
+ */
+static struct ipmi_msg *ipmi_sel_alloc_msg(struct errorlog *elog_buf)
+{
+	struct ipmi_msg *msg = NULL;
+
+	if (elog_buf->event_severity == OPAL_ERROR_PANIC) {
+		/* Called before initialization completes */
+		if (ipmi_sel_panic_msg.msg == NULL) {
+			ipmi_sel_init();	/* Try to allocate IPMI message */
+			if (ipmi_sel_panic_msg.msg == NULL)
+				return NULL;
+		}
+
+		if (ipmi_sel_panic_msg.busy == true)
+			return NULL;
+
+		lock(&ipmi_sel_panic_msg.lock);
+		msg = ipmi_sel_panic_msg.msg;
+		ipmi_sel_panic_msg.busy = true;
+		unlock(&ipmi_sel_panic_msg.lock);
+
+		ipmi_init_msg(msg, IPMI_DEFAULT_INTERFACE, IPMI_RESERVE_SEL,
+				ipmi_elog_poll, elog_buf, IPMI_MAX_REQ_SIZE, 2);
+	} else {
+		msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_RESERVE_SEL,
+				ipmi_elog_poll, elog_buf, NULL,
+				IPMI_MAX_REQ_SIZE, 2);
+	}
+
+	return msg;
+}
+
+static void ipmi_sel_free_msg(struct ipmi_msg *msg)
+{
+	if (msg == ipmi_sel_panic_msg.msg) {
+		lock(&ipmi_sel_panic_msg.lock);
+		ipmi_sel_panic_msg.busy = false;
+		unlock(&ipmi_sel_panic_msg.lock);
+	} else {
+		ipmi_free_msg(msg);
+	}
+
+	msg = NULL;
+}
+
+/* Initialize eSEL record */
+static void ipmi_init_esel_record(void)
+{
+	memset(&sel_record, 0, sizeof(struct sel_record));
+	sel_record.record_type = SEL_REC_TYPE_AMI_ESEL;
+	sel_record.generator_id = cpu_to_le16(SEL_GENERATOR_ID_AMI);
+	sel_record.evm_ver = SEL_EVM_VER_2;
+	sel_record.sensor_type	= SENSOR_TYPE_SYS_EVENT;
+	sel_record.sensor_number =
+		ipmi_get_sensor_number(SENSOR_TYPE_SYS_EVENT);
+	sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_OEM;
+	sel_record.event_data1 = SEL_DATA1_AMI;
+}
+
+/* Update required fields in SEL record */
+static void ipmi_update_sel_record(uint8_t event_severity, uint16_t esel_record_id)
+{
+	sel_record.record_type = SEL_REC_TYPE_SYS_EVENT;
+	sel_record.event_data2 = (esel_record_id >> 8) & 0xff;
+	sel_record.event_data3 = esel_record_id & 0xff;
+
+	switch (event_severity) {
+	case OPAL_ERROR_PANIC:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_TRANSITION;
+		sel_record.event_data1 = SEL_DATA1_CRITICAL;
+		break;
+	case OPAL_UNRECOVERABLE_ERR_GENERAL:	/* Fall through */
+	case OPAL_UNRECOVERABLE_ERR_DEGRADE_PERF:
+	case OPAL_UNRECOVERABLE_ERR_LOSS_REDUNDANCY:
+	case OPAL_UNRECOVERABLE_ERR_LOSS_REDUNDANCY_PERF:
+	case OPAL_UNRECOVERABLE_ERR_LOSS_OF_FUNCTION:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_TRANSITION;
+		sel_record.event_data1 = SEL_DATA1_NON_RECOVERABLE;
+		break;
+	case OPAL_PREDICTIVE_ERR_GENERAL:	/* Fall through */
+	case OPAL_PREDICTIVE_ERR_DEGRADED_PERF:
+	case OPAL_PREDICTIVE_ERR_FAULT_RECTIFY_REBOOT:
+	case OPAL_PREDICTIVE_ERR_FAULT_RECTIFY_BOOT_DEGRADE_PERF:
+	case OPAL_PREDICTIVE_ERR_LOSS_OF_REDUNDANCY:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_PREDICTIVE;
+		sel_record.event_data1 = SEL_DATA1_NON_CRIT_FROM_OK;
+		break;
+	case OPAL_RECOVERED_ERR_GENERAL:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_TRANSITION;
+		sel_record.event_data1 = SEL_DATA1_OK;
+		break;
+	case OPAL_INFO:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_TRANSITION;
+		sel_record.event_data1 = SEL_DATA1_INFORMATIONAL;
+		break;
+	default:
+		sel_record.event_dir_type = SEL_EVENT_DIR_TYPE_STATE;
+		sel_record.event_data1 = SEL_DATA1_ASSERTED;
+		break;
+	}
+}
+
+static void ipmi_elog_error(struct ipmi_msg *msg)
+{
+	if (msg->cc == IPMI_LOST_ARBITRATION_ERR)
+		/* Retry due to SEL erase */
+		ipmi_queue_msg(msg);
+	else {
+		opal_elog_complete(msg->user_data, false);
+		ipmi_sel_free_msg(msg);
+	}
+}
+
+static void ipmi_log_sel_event_error(struct ipmi_msg *msg)
+{
+	if (msg->cc != IPMI_CC_NO_ERROR)
+		prlog(PR_INFO, "SEL: Failed to log SEL event\n");
+
+	ipmi_sel_free_msg(msg);
+}
+
+static void ipmi_log_sel_event_complete(struct ipmi_msg *msg)
+{
+	prlog(PR_INFO, "SEL: New event logged [ID : %x%x]\n", msg->data[1],
+		msg->data[0]);
+
+	ipmi_sel_free_msg(msg);
+}
+
+/* Log SEL event with eSEL record ID */
+static void ipmi_log_sel_event(struct ipmi_msg *msg, uint8_t event_severity,
+				uint16_t esel_record_id)
+{
+	/* Fill required SEL event fields */
+	ipmi_update_sel_record(event_severity, esel_record_id);
+
+	/* Fill IPMI message */
+	ipmi_init_msg(msg, IPMI_DEFAULT_INTERFACE, IPMI_ADD_SEL_EVENT,
+		      ipmi_log_sel_event_complete, NULL,
+		      sizeof(struct sel_record), 2);
+
+	/* Copy SEL data */
+	memcpy(msg->data, &sel_record, sizeof(struct sel_record));
+
+	msg->error = ipmi_log_sel_event_error;
+	ipmi_queue_msg_head(msg);
+}
+
+/* Goes through the required steps to add a complete eSEL:
+ *
+ *  1. Get a reservation
+ *  2. Add eSEL header
+ *  3. Partially add data to the SEL
+ *
+ * Because a reservation is needed we need to ensure eSEL's are added
+ * as a single transaction as concurrent/interleaved adds would cancel
+ * the reservation. We guarantee this by always adding our messages to
+ * the head of the transmission queue, blocking any other messages
+ * being sent until we have completed sending this message.
+ *
+ * There is still a very small chance that we will accidentally
+ * interleave a message if there is another one waiting at the head of
+ * the ipmi queue and another cpu calls the ipmi poller before we
+ * complete. However this should just cause a resevation cancelled
+ * error which we have to deal with anyway (eg. because there may be a
+ * SEL erase in progress) so it shouldn't cause any problems.
+ */
+static void ipmi_elog_poll(struct ipmi_msg *msg)
+{
+	static bool first = false;
+	static char pel_buf[IPMI_MAX_PEL_SIZE];
+	static size_t pel_size;
+	static size_t esel_size;
+	static int esel_index = 0;
+	int pel_index;
+	static unsigned int reservation_id = 0;
+	static unsigned int record_id = 0;
+	struct errorlog *elog_buf = (struct errorlog *) msg->user_data;
+	size_t req_size;
+
+	if (bmc_platform->sw->ipmi_oem_partial_add_esel == 0) {
+		prlog(PR_WARNING, "Dropped eSEL: BMC code is buggy/missing\n");
+		ipmi_sel_free_msg(msg);
+		return;
+	}
+
+	ipmi_init_esel_record();
+	if (msg->cmd == IPMI_CMD(IPMI_RESERVE_SEL)) {
+		first = true;
+		reservation_id = msg->data[0];
+		reservation_id |= msg->data[1] << 8;
+		if (!reservation_id) {
+			/*
+			 * According to specification we should never
+			 * get here, but just in case we do we cancel
+			 * sending the message.
+			 */
+			prerror("Invalid reservation id");
+			opal_elog_complete(elog_buf, false);
+			ipmi_sel_free_msg(msg);
+			return;
+		}
+
+		pel_size = create_pel_log(elog_buf, pel_buf, IPMI_MAX_PEL_SIZE);
+		esel_size = pel_size + sizeof(struct sel_record);
+		esel_index = 0;
+		record_id = 0;
+	} else {
+		record_id = msg->data[0];
+		record_id |= msg->data[1] << 8;
+	}
+
+	/* Start or continue the IPMI_PARTIAL_ADD_SEL */
+	if (esel_index >= esel_size) {
+		/*
+		 * We're all done. Invalidate the resevation id to
+		 * ensure we get an error if we cut in on another eSEL
+		 * message.
+		 */
+		reservation_id = 0;
+		esel_index = 0;
+
+		/* Log SEL event and free ipmi message */
+		ipmi_log_sel_event(msg, elog_buf->event_severity, record_id);
+
+		opal_elog_complete(elog_buf, true);
+		return;
+	}
+
+	if ((esel_size - esel_index) <= (IPMI_MAX_REQ_SIZE - ESEL_HDR_SIZE)) {
+		/* Last data to send */
+		msg->data[6] = 1;
+		req_size = esel_size - esel_index + ESEL_HDR_SIZE;
+	} else {
+		msg->data[6] = 0;
+		req_size = IPMI_MAX_REQ_SIZE;
+	}
+
+	ipmi_init_msg(msg, IPMI_DEFAULT_INTERFACE,
+		      bmc_platform->sw->ipmi_oem_partial_add_esel,
+		      ipmi_elog_poll, elog_buf, req_size, 2);
+
+	msg->data[0] = reservation_id & 0xff;
+	msg->data[1] = (reservation_id >> 8) & 0xff;
+	msg->data[2] = record_id & 0xff;
+	msg->data[3] = (record_id >> 8) & 0xff;
+	msg->data[4] = esel_index & 0xff;
+	msg->data[5] = (esel_index >> 8) & 0xff;
+
+	if (first) {
+		first = false;
+		memcpy(&msg->data[ESEL_HDR_SIZE], &sel_record,
+			sizeof(struct sel_record));
+		esel_index = sizeof(struct sel_record);
+		msg->req_size = esel_index + ESEL_HDR_SIZE;
+	} else {
+		pel_index = esel_index - sizeof(struct sel_record);
+		memcpy(&msg->data[ESEL_HDR_SIZE], &pel_buf[pel_index],
+			msg->req_size - ESEL_HDR_SIZE);
+		esel_index += msg->req_size - ESEL_HDR_SIZE;
+	}
+
+	ipmi_queue_msg_head(msg);
+	return;
+}
+
+int ipmi_elog_commit(struct errorlog *elog_buf)
+{
+	struct ipmi_msg *msg;
+
+	/* Only log events that needs attention */
+	if (elog_buf->event_severity <
+			OPAL_PREDICTIVE_ERR_FAULT_RECTIFY_REBOOT ||
+			elog_buf->elog_origin != ORG_SAPPHIRE) {
+		prlog(PR_INFO, "dropping non severe PEL event\n");
+		opal_elog_complete(elog_buf, true);
+		return 0;
+	}
+
+	/*
+	 * We pass a large request size in to mkmsg so that we have a
+	 * large enough allocation to reuse the message to pass the
+	 * PEL data via a series of partial add commands.
+	 */
+	msg = ipmi_sel_alloc_msg(elog_buf);
+	if (!msg) {
+		opal_elog_complete(elog_buf, false);
+		return OPAL_RESOURCE;
+	}
+
+	msg->error = ipmi_elog_error;
+	msg->req_size = 0;
+	if (elog_buf->event_severity == OPAL_ERROR_PANIC) {
+		ipmi_queue_msg_sync(msg);
+
+		/*
+		 * eSEL logs are split into multiple smaller chunks and sent
+		 * to BMC. Lets wait until we finish sending all the chunks
+		 * to BMC.
+		 */
+		while (ipmi_sel_panic_msg.busy != false) {
+			if (msg->backend->poll)
+				msg->backend->poll();
+			time_wait_ms(10);
+		}
+	} else {
+		ipmi_queue_msg(msg);
+	}
+
+	return 0;
+}
+
+#define ACCESS_DENIED	0x00
+#define ACCESS_GRANTED	0x01
+
+static void sel_pnor(uint8_t access, void *context __unused)
+{
+	struct ipmi_msg *msg;
+	uint8_t granted = ACCESS_GRANTED;
+
+	switch (access) {
+	case REQUEST_PNOR:
+		prlog(PR_NOTICE, "PNOR access requested\n");
+		if (bmc_platform->sw->ipmi_oem_pnor_access_status == 0) {
+			/**
+			 * @fwts-label PNORAccessYeahButNoBut
+			 * @fwts-advice OPAL doesn't know that the BMC supports
+			 * PNOR access commands. This will be a bug in the OPAL
+			 * support for this BMC.
+			 */
+			prlog(PR_ERR, "PNOR BUG: access requested but BMC doesn't support request\n");
+			break;
+		}
+
+		granted = flash_reserve();
+		if (granted)
+			occ_pnor_set_owner(PNOR_OWNER_EXTERNAL);
+		/* Ack the request */
+		msg = ipmi_mkmsg_simple(bmc_platform->sw->ipmi_oem_pnor_access_status, &granted, 1);
+		ipmi_queue_msg(msg);
+		break;
+	case RELEASE_PNOR:
+		prlog(PR_NOTICE, "PNOR access released\n");
+		flash_release();
+		occ_pnor_set_owner(PNOR_OWNER_HOST);
+		break;
+	default:
+		/**
+		 * @fwts-label InvalidPNORAccessRequest
+		 * @fwts-advice In negotiating PNOR access with BMC, we
+		 * got an odd/invalid request from the BMC. Likely a bug
+		 * in OPAL/BMC interaction.
+		 */
+		prlog(PR_ERR, "invalid PNOR access requested: %02x\n",
+		      access);
+	}
+}
+
+static void sel_power(uint8_t power, void *context __unused)
+{
+	switch (power) {
+	case SOFT_OFF:
+		prlog(PR_NOTICE, "Soft shutdown requested\n");
+		if (opal_booting() && platform.cec_power_down) {
+			prlog(PR_NOTICE, "Host not up, shutting down now\n");
+			platform.cec_power_down(IPMI_CHASSIS_PWR_DOWN);
+		} else {
+			opal_queue_msg(OPAL_MSG_SHUTDOWN, NULL, NULL,
+					cpu_to_be64(SOFT_OFF));
+		}
+
+		break;
+	case SOFT_REBOOT:
+		prlog(PR_NOTICE, "Soft reboot requested\n");
+		if (opal_booting() && platform.cec_reboot) {
+			prlog(PR_NOTICE, "Host not up, rebooting now\n");
+			platform.cec_reboot();
+		} else {
+			opal_queue_msg(OPAL_MSG_SHUTDOWN, NULL, NULL,
+					cpu_to_be64(SOFT_REBOOT));
+		}
+
+		break;
+	default:
+		prlog(PR_WARNING, "requested bad power state: %02x\n",
+		      power);
+	}
+}
+
+static void sel_heartbeat(uint8_t heartbeat, void *context __unused)
+{
+	/* There is only one sub-command so no processing needed */
+	prlog(PR_DEBUG, "BMC issued heartbeat command: %02x\n",
+	      heartbeat);
+}
+
+static uint32_t occ_sensor_id_to_chip(uint8_t sensor, uint32_t *chip)
+{
+	struct dt_node *node, *bmc_node, *sensors_node;
+
+	/* Default chip id */
+	*chip = 0;
+
+	bmc_node = dt_find_by_name(dt_root, "bmc");
+	if (!bmc_node)
+		return 0;
+
+	sensors_node = dt_find_by_name(bmc_node, "sensors");
+	if (!sensors_node)
+		return 0;
+
+	node = dt_find_by_name_addr(sensors_node, "sensor", sensor);
+	if (!node) {
+		prlog(PR_DEBUG, "Could not find OCC sensor node. Id : %d\n",
+		      (u32)sensor);
+		return 0;
+	}
+
+	if (!dt_has_node_property(node, "ibm,chip-id", NULL)) {
+		prlog(PR_DEBUG, "Could not find chip-id for OCC sensor : %d\n",
+		      (u32)sensor);
+		return 0;
+	}
+
+	*chip = dt_get_chip_id(node);
+	return 0;
+}
+
+static void sel_occ_reset(uint8_t sensor, void *context __unused)
+{
+	uint32_t chip;
+	int rc;
+
+	rc = occ_sensor_id_to_chip(sensor, &chip);
+	if (rc) {
+		/**
+		 * @fwts-label: SELUnknownOCCReset
+		 * @fwts-advice: Likely bug in what sent us the OCC reset.
+		 */
+		prlog(PR_ERR, "SEL message to reset an unknown OCC "
+				"(sensor ID 0x%02x)\n", sensor);
+		return;
+	}
+
+	prd_occ_reset(chip);
+}
+
+struct ipmi_sel_handler {
+	uint8_t oem_cmd;
+	void (*fn)(uint8_t data, void *context);
+	void *context;
+	struct list_node node;
+};
+
+int ipmi_sel_register(uint8_t oem_cmd,
+		      void (*fn)(uint8_t data, void *context),
+		      void *context)
+{
+	struct ipmi_sel_handler *handler;
+
+	list_for_each(&sel_handlers, handler, node) {
+		if (handler->oem_cmd == oem_cmd) {
+			prerror("Handler for SEL command 0x%02x already registered\n",
+				oem_cmd);
+			return -EINVAL;
+		}
+	}
+
+	handler = malloc(sizeof(*handler));
+	if (!handler)
+		return -ENOMEM;
+
+	handler->oem_cmd = oem_cmd;
+	handler->fn = fn;
+	handler->context = context;
+
+	list_add(&sel_handlers, &handler->node);
+
+	return 0;
+}
+
+void ipmi_sel_init(void)
+{
+	int rc;
+
+	/* Already done */
+	if (ipmi_sel_panic_msg.msg != NULL)
+		return;
+
+	memset(&ipmi_sel_panic_msg, 0, sizeof(struct ipmi_sel_panic_msg));
+	ipmi_sel_panic_msg.msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE,
+					IPMI_RESERVE_SEL, ipmi_elog_poll,
+					NULL, NULL, IPMI_MAX_REQ_SIZE, 2);
+
+	/* Hackishly register these old-style handlers here for now */
+	/* TODO: Move them to their appropriate source files */
+	rc = ipmi_sel_register(CMD_AMI_POWER, sel_power, NULL);
+	if (rc < 0) {
+		prerror("Failed to register SEL handler for %s",
+			stringify(CMD_AMI_POWER));
+	}
+
+	rc = ipmi_sel_register(CMD_AMI_OCC_RESET, sel_occ_reset, NULL);
+	if (rc < 0) {
+		prerror("Failed to register SEL handler for %s",
+			stringify(CMD_AMI_OCC_RESET));
+	}
+
+	rc = ipmi_sel_register(CMD_AMI_PNOR_ACCESS, sel_pnor, NULL);
+	if (rc < 0) {
+		prerror("Failed to register SEL handler for %s",
+			stringify(CMD_AMI_PNOR_ACCESS));
+	}
+
+	rc = ipmi_sel_register(CMD_HEARTBEAT, sel_heartbeat, NULL);
+	if (rc < 0) {
+		prerror("Failed to register SEL handler for %s",
+			stringify(CMD_HEARTBEAT));
+	}
+}
+
+void ipmi_parse_sel(struct ipmi_msg *msg)
+{
+	struct ipmi_sel_handler *handler;
+	struct oem_sel sel;
+
+	assert(msg->resp_size <= 16);
+
+	memcpy(&sel, msg->data, msg->resp_size);
+
+	/* We do not process system event records */
+	if (sel.type == SEL_RECORD_TYPE_EVENT) {
+		prlog(PR_INFO, "dropping System Event Record SEL\n");
+		return;
+	}
+
+	prlog(PR_DEBUG, "SEL received (%d bytes, netfn %d, cmd %d)\n",
+			msg->resp_size, sel.netfun, sel.cmd);
+
+	/* Only accept OEM SEL messages */
+	if (sel.id[0] != SEL_OEM_ID_0 || sel.id[1] != SEL_OEM_ID_1 ||
+		sel.type != SEL_RECORD_TYPE_OEM) {
+		prlog(PR_WARNING, "unknown SEL %02x%02x (type %02x)\n",
+		      sel.id[0], sel.id[1], sel.type);
+		return;
+	}
+
+	list_for_each(&sel_handlers, handler, node) {
+		if (handler->oem_cmd == sel.cmd) {
+			handler->fn(sel.data[0], handler->context);
+			return;
+		}
+	}
+
+	prlog(PR_WARNING, "unknown OEM SEL command %02x received\n", sel.cmd);
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-sensor.c b/roms/skiboot/hw/ipmi/ipmi-sensor.c
new file mode 100644
index 000000000..857b789e4
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-sensor.c
@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/* Copyright 2013-2017 IBM Corp. */
+
+#include <device.h>
+#include <ipmi.h>
+#include <opal.h>
+#include <skiboot.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define IPMI_WRITE_SENSOR		(1 << 0)
+
+#define FW_PROGRESS_SENSOR_TYPE	0x0F
+#define BOOT_COUNT_SENSOR_TYPE	0xC3
+
+static int16_t sensors[MAX_IPMI_SENSORS];
+
+static bool sensors_present = false;
+
+struct set_sensor_req {
+	u8 sensor_number;
+	u8 operation;
+	u8 sensor_reading;
+	u8 assertion_mask[2];
+	u8 deassertion_mask[2];
+	u8 event_data[3];
+};
+
+static bool ipmi_sensor_type_present(uint8_t sensor_type)
+{
+        const struct dt_property *type_prop;
+        uint8_t type;
+        struct dt_node *node;
+
+        dt_for_each_compatible(dt_root, node, "ibm,ipmi-sensor") {
+                type_prop = dt_find_property(node, "ipmi-sensor-type");
+                if (!type_prop) {
+                        prlog(PR_ERR, "IPMI: sensor doesn't have ipmi-sensor-type\n");
+                        continue;
+                }
+
+                type = (uint8_t)dt_property_get_cell(type_prop, 0);
+                if (type == sensor_type)
+                        return true;
+        }
+        return false;
+}
+
+uint8_t ipmi_get_sensor_number(uint8_t sensor_type)
+{
+	assert(sensor_type < MAX_IPMI_SENSORS);
+	return sensors[sensor_type];
+}
+
+int ipmi_set_boot_count(void)
+{
+	struct set_sensor_req req;
+	struct ipmi_msg *msg;
+	int boot_count_sensor;
+
+	if (!sensors_present)
+		return OPAL_UNSUPPORTED;
+
+	if (!ipmi_present())
+		return OPAL_CLOSED;
+
+        if (!ipmi_sensor_type_present(BOOT_COUNT_SENSOR_TYPE))
+                return OPAL_HARDWARE;
+
+	boot_count_sensor = sensors[BOOT_COUNT_SENSOR_TYPE];
+
+	if (boot_count_sensor < 0) {
+		prlog(PR_DEBUG, "IPMI: boot count set but not present\n");
+		return OPAL_HARDWARE;
+	}
+
+	memset(&req, 0, sizeof(req));
+
+	req.sensor_number = boot_count_sensor;
+	req.operation = IPMI_WRITE_SENSOR;
+	req.sensor_reading = 0x00;
+	req.assertion_mask[0] = 0x02;
+
+	msg = ipmi_mkmsg_simple(IPMI_SET_SENSOR_READING, &req, sizeof(req));
+	if (!msg)
+		return OPAL_HARDWARE;
+
+	printf("IPMI: Resetting boot count on successful boot\n");
+
+	return ipmi_queue_msg(msg);
+}
+
+int ipmi_set_fw_progress_sensor(uint8_t state)
+{
+	struct ipmi_msg *msg;
+	struct set_sensor_req request;
+	int fw_sensor_num;
+
+	if (!sensors_present)
+		return OPAL_UNSUPPORTED;
+
+	if (!ipmi_present())
+		return OPAL_CLOSED;
+
+        if (!ipmi_sensor_type_present(FW_PROGRESS_SENSOR_TYPE))
+                return OPAL_HARDWARE;
+
+	fw_sensor_num = sensors[FW_PROGRESS_SENSOR_TYPE];
+
+	if (fw_sensor_num < 0) {
+		prlog(PR_DEBUG, "IPMI: fw progress set but not present\n");
+		return OPAL_HARDWARE;
+	}
+
+	memset(&request, 0, sizeof(request));
+
+	request.sensor_number = fw_sensor_num;
+	request.operation = 0xa0; /* Set event data bytes, assertion bits */
+	request.assertion_mask[0] = 0x04; /* Firmware progress offset */
+	request.event_data[0] = 0xc2;
+	request.event_data[1] = state;
+
+	prlog(PR_INFO, "IPMI: setting fw progress sensor %02x to %02x\n",
+			request.sensor_number, request.event_data[1]);
+
+	msg = ipmi_mkmsg_simple(IPMI_SET_SENSOR_READING, &request,
+			sizeof(request));
+	if (!msg)
+		return OPAL_HARDWARE;
+
+	return ipmi_queue_msg(msg);
+}
+
+void ipmi_sensor_init(void)
+{
+	const struct dt_property *type_prop, *num_prop;
+	uint8_t num, type;
+	struct dt_node *n;
+
+	memset(sensors, -1, sizeof(sensors));
+
+	dt_for_each_compatible(dt_root, n, "ibm,ipmi-sensor") {
+		type_prop = dt_find_property(n, "ipmi-sensor-type");
+		if (!type_prop) {
+			prerror("IPMI: sensor doesn't have ipmi-sensor-type\n");
+			continue;
+		}
+
+		num_prop = dt_find_property(n, "reg");
+		if (!num_prop) {
+			prerror("IPMI: sensor doesn't have reg property\n");
+			continue;
+		}
+		num = (uint8_t)dt_property_get_cell(num_prop, 0);
+		type = (uint8_t)dt_property_get_cell(type_prop, 0);
+		assert(type < MAX_IPMI_SENSORS);
+		sensors[type] = num;
+	}
+	sensors_present = true;
+}
diff --git a/roms/skiboot/hw/ipmi/ipmi-watchdog.c b/roms/skiboot/hw/ipmi/ipmi-watchdog.c
new file mode 100644
index 000000000..dc0a9e5b4
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/ipmi-watchdog.c
@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+ * Copyright 2013-2018 IBM Corp.
+ * Copyright 2018 Google Corp.
+ */
+
+#include <stdlib.h>
+#include <ipmi.h>
+#include <lock.h>
+#include <opal.h>
+#include <device.h>
+#include <timer.h>
+#include <timebase.h>
+#include <pool.h>
+#include <skiboot.h>
+
+#define TIMER_USE_DONT_LOG	0x80
+#define TIMER_USE_DONT_STOP	0x40
+#define TIMER_USE_POST		0x02
+
+/* WDT expiration actions */
+#define WDT_PRETIMEOUT_SMI	0x10
+#define WDT_RESET_ACTION 	0x01
+#define WDT_NO_ACTION		0x00
+
+/* IPMI defined custom completion codes for the watchdog */
+#define WDT_CC_OK		0x00
+#define WDT_CC_NOT_INITIALIZED	0x80
+
+/* Flags used for IPMI callbacks */
+#define WDT_SET_DO_RESET	0x01
+#define WDT_RESET_NO_REINIT	0x01
+
+/* How long to set the overall watchdog timeout for. In units of
+ * 100ms. If the timer is not reset within this time the watchdog
+ * expiration action will occur. */
+#define WDT_TIMEOUT		600
+
+/* How often to reset the timer using schedule_timer(). Too short and
+we risk accidentally resetting the system due to opal_run_pollers() not
+being called in time, too short and we waste time resetting the wdt
+more frequently than necessary. */
+#define WDT_MARGIN		300
+
+static struct timer wdt_timer;
+static bool wdt_stopped;
+static bool wdt_ticking;
+
+/* Saved values from the last watchdog set action */
+static uint8_t last_action;
+static uint16_t last_count;
+static uint8_t last_pretimeout;
+
+static void reset_wdt(struct timer *t, void *data, uint64_t now);
+
+static void set_wdt_complete(struct ipmi_msg *msg)
+{
+	const uintptr_t flags = (uintptr_t)msg->user_data;
+
+	if (flags & WDT_SET_DO_RESET) {
+		/* Make sure the reset action does not create a loop and
+		 * perform a reset in the case where the BMC send an
+		 * uninitialized error. */
+		reset_wdt(NULL, (void *)WDT_RESET_NO_REINIT, 0);
+	}
+
+	ipmi_free_msg(msg);
+}
+
+static void set_wdt(uint8_t action, uint16_t count, uint8_t pretimeout,
+		bool dont_stop, bool do_reset)
+{
+	struct ipmi_msg *ipmi_msg;
+	uintptr_t completion_flags = 0;
+
+	if (do_reset)
+		completion_flags |= WDT_SET_DO_RESET;
+
+	/* Save the values prior to issuing the set operation so that we can
+	 * re-initialize the watchdog in error cases. */
+	last_action = action;
+	last_count = count;
+	last_pretimeout = pretimeout;
+
+	ipmi_msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_SET_WDT,
+			      set_wdt_complete, NULL, NULL, 6, 0);
+	if (!ipmi_msg) {
+		prerror("Unable to allocate set wdt message\n");
+		return;
+	}
+	ipmi_msg->error = set_wdt_complete;
+	ipmi_msg->user_data = (void *)completion_flags;
+	ipmi_msg->data[0] = TIMER_USE_POST |
+		TIMER_USE_DONT_LOG |
+		(dont_stop ? TIMER_USE_DONT_STOP : 0);
+	ipmi_msg->data[1] = action;			/* Timer Actions */
+	ipmi_msg->data[2] = pretimeout;			/* Pre-timeout Interval */
+	ipmi_msg->data[3] = 0;				/* Timer Use Flags */
+	ipmi_msg->data[4] = count & 0xff;		/* Initial countdown (lsb) */
+	ipmi_msg->data[5] = (count >> 8) & 0xff;	/* Initial countdown (msb) */
+	ipmi_queue_msg(ipmi_msg);
+}
+
+static void reset_wdt_complete(struct ipmi_msg *msg)
+{
+	const uintptr_t flags = (uintptr_t)msg->user_data;
+	uint64_t reset_delay_ms = (WDT_TIMEOUT - WDT_MARGIN) * 100;
+
+	if (msg->cc == WDT_CC_NOT_INITIALIZED &&
+			!(flags & WDT_RESET_NO_REINIT)) {
+		/* If our timer was not initialized on the BMC side, we should
+		 * perform a single attempt to set it up again. */
+		set_wdt(last_action, last_count, last_pretimeout, true, true);
+	} else if (msg->cc != WDT_CC_OK) {
+		/* Use a short (10s) timeout before performing the next reset
+		 * if we encounter an unknown error. This makes sure that we
+		 * are able to reset and re-initialize the timer since it might
+		 * expire. */
+		reset_delay_ms = 10 * 1000;
+	}
+
+	/* If we are inside of skiboot we need to periodically restart the
+	 * timer. Reschedule a reset so it happens before the timeout. */
+	if (wdt_ticking)
+		schedule_timer(&wdt_timer, msecs_to_tb(reset_delay_ms));
+
+	ipmi_free_msg(msg);
+}
+
+static struct ipmi_msg *wdt_reset_mkmsg(void)
+{
+	struct ipmi_msg *ipmi_msg;
+
+	ipmi_msg = ipmi_mkmsg(IPMI_DEFAULT_INTERFACE, IPMI_RESET_WDT,
+			      reset_wdt_complete, NULL, NULL, 0, 0);
+	if (!ipmi_msg) {
+		prerror("Unable to allocate reset wdt message\n");
+		return NULL;
+	}
+	ipmi_msg->error = reset_wdt_complete;
+
+	return ipmi_msg;
+}
+
+static void sync_reset_wdt(void)
+{
+	struct ipmi_msg *ipmi_msg;
+
+	if ((ipmi_msg = wdt_reset_mkmsg()))
+		ipmi_queue_msg_sync(ipmi_msg);
+}
+
+static void reset_wdt(struct timer *t __unused, void *data,
+		      uint64_t now __unused)
+{
+	struct ipmi_msg *ipmi_msg;
+
+	if ((ipmi_msg = wdt_reset_mkmsg())) {
+		ipmi_msg->user_data = data;
+		ipmi_queue_msg_head(ipmi_msg);
+	}
+}
+
+void ipmi_wdt_stop(void)
+{
+	if (!wdt_stopped) {
+		/* Make sure the background reset timer is disabled before
+		 * stopping the watchdog. If we issue a reset after disabling
+		 * the timer, it will be re-enabled. */
+		wdt_ticking = false;
+		cancel_timer(&wdt_timer);
+
+		/* Configure the watchdog to be disabled and do no action
+		 * in case the underlying implementation is buggy and times
+		 * out anyway. */
+		wdt_stopped = true;
+		set_wdt(WDT_NO_ACTION, 100, 0, false, false);
+	}
+}
+
+void ipmi_wdt_final_reset(void)
+{
+	/* We can safely stop the timer prior to setting up our final
+	 * watchdog timeout since we have enough margin before the
+	 * timeout. */
+	wdt_ticking = false;
+	cancel_timer(&wdt_timer);
+
+	/*
+	 * We're going to wait a little while before requiring
+	 * BOOTKERNEL to have IPMI watchdog support so that people
+	 * can catch up in their development environments.
+	 * If you still read this after 2018, send a patch!
+	 */
+#if 0
+	/* Configure the watchdog and make sure it is still enabled */
+	set_wdt(WDT_RESET_ACTION | WDT_PRETIMEOUT_SMI, WDT_TIMEOUT,
+		WDT_MARGIN/10, true, true);
+	sync_reset_wdt();
+#else
+	set_wdt(WDT_NO_ACTION, 100, 0, false, false);
+#endif
+	ipmi_set_boot_count();
+}
+
+void ipmi_wdt_init(void)
+{
+	init_timer(&wdt_timer, reset_wdt, NULL);
+	set_wdt(WDT_RESET_ACTION, WDT_TIMEOUT, 0, true, false);
+
+	/* Start the WDT. We do it synchronously to make sure it has
+	 * started before skiboot continues booting. Otherwise we
+	 * could crash before the wdt has actually been started. */
+	wdt_ticking = true;
+	sync_reset_wdt();
+
+	return;
+}
diff --git a/roms/skiboot/hw/ipmi/test/Makefile.check b/roms/skiboot/hw/ipmi/test/Makefile.check
new file mode 100644
index 000000000..ceed1ed39
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/test/Makefile.check
@@ -0,0 +1,34 @@
+# -*-Makefile-*-
+IPMI_TEST := hw/ipmi/test/run-fru
+
+LCOV_EXCLUDE += $(IPMI_TEST:%=%.c)
+
+.PHONY : hw-ipmi-check hw-ipmi-coverage
+hw-ipmi-check: $(IPMI_TEST:%=%-check)
+hw-ipmi-coverage: $(IPMI_TEST:%=%-gcov-run)
+
+check: hw-ipmi-check
+coverage: hw-ipmi-coverage
+
+$(IPMI_TEST:%=%-gcov-run) : %-run: %
+	$(call Q, TEST-COVERAGE ,$< , $<)
+
+$(IPMI_TEST:%=%-check) : %-check: %
+	$(call Q, RUN-TEST ,$(VALGRIND) $<, $<)
+
+$(IPMI_TEST) : % : %.c
+	$(call Q, HOSTCC ,$(HOSTCC) $(HOSTCFLAGS) -O0 -g -I include -I . -o $@ $<, $<)
+
+$(IPMI_TEST:%=%-gcov): %-gcov : %.c %
+	$(call Q, HOSTCC ,$(HOSTCC) $(HOSTCFLAGS) $(HOSTGCOVCFLAGS) -I include -I . -I libfdt -lgcov -o $@ $<, $<)
+
+$(IPMI_TEST:%=%-gcov): % : $(%.d:-gcov=)
+
+-include $(wildcard hw/ipmi/test/*.d)
+
+clean: ipmi-test-clean
+
+ipmi-test-clean:
+	$(RM) -f hw/ipmi/test/*.[od] $(IPMI_TEST) $(IPMI_TEST:%=%-gcov)
+	$(RM) -f *.gcda *.gcno skiboot.info
+	$(RM) -rf coverage-report
diff --git a/roms/skiboot/hw/ipmi/test/run-fru.c b/roms/skiboot/hw/ipmi/test/run-fru.c
new file mode 100644
index 000000000..fa79c98a1
--- /dev/null
+++ b/roms/skiboot/hw/ipmi/test/run-fru.c
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/* Copyright 2013-2019 IBM Corp. */
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#define __TEST__
+
+#include "../ipmi-fru.c"
+
+#include <string.h>
+
+int error = 0;
+
+const char version[] = "a-too-long-version-test-string-is-here";
+
+void ipmi_free_msg(struct ipmi_msg __unused *msg)
+{
+}
+
+void ipmi_init_msg(struct ipmi_msg __unused *msg, int __unused interface,
+		   uint32_t __unused code,
+		   void __unused (*complete)(struct ipmi_msg *),
+		   void __unused *user_data, size_t __unused req_size,
+		   size_t __unused resp_size)
+{
+}
+
+struct ipmi_msg *ipmi_mkmsg(int __unused interface, uint32_t __unused code,
+			    void __unused (*complete)(struct ipmi_msg *),
+			    void __unused *user_data, void __unused *req_data, size_t __unused req_size,
+			    size_t __unused resp_size)
+{
+	return NULL;
+}
+
+int ipmi_queue_msg(struct ipmi_msg __unused *msg)
+{
+	return 0;
+}
+
+void _prlog(int __unused log_level, const __unused char* fmt, ...)
+{
+	return;
+}
+
+int main(void)
+{
+	u8 *buf;
+	int len;
+	struct product_info info = {
+		.manufacturer = (char *) "IBM",
+		.product = (char *) "skiboot",
+		.part_no = (char *) "hello",
+		.version = (char *) "12345",
+		.serial_no = (char *) "12345",
+		.asset_tag = (char *) "abcd",
+	};
+	struct product_info invalid_info = {
+		.manufacturer = (char *) "I",
+		.product = (char *) "skiboot",
+		.part_no = (char *) "hello",
+		.version = (char *) "12345",
+		.serial_no = (char *) "12345",
+		.asset_tag = (char *) "abcd",
+	};
+	struct product_info invalid_info2 = {
+		.manufacturer = (char *) "IBM",
+		.product = (char *) "skiboot",
+		.part_no = (char *) "this is a really long string that's more"
+		"than 32 characters, because it turns out that's invalid.",
+		.version = (char *) "12345",
+		.serial_no = (char *) "12345",
+		.asset_tag = (char *) "abcd",
+	};
+
+	buf = malloc(256);
+
+	len = fru_fill_product_info(buf, &info, 40);
+	assert(len == 40);
+	assert(memcmp(buf, "\001\005\000\303IBM\307skiboot\305hello"
+		      "\30512345\30512345\304abcd\301-",len) == 0);
+
+
+	/* Make sure the checksum is right */
+	assert(!fru_checksum(buf, len));
+
+	/* This should fail (not enough space) */
+	assert(fru_fill_product_info(buf, &info, 39) < 0);
+
+	memset(buf, 0, 256);
+	len = fru_fill_product_info(buf, &invalid_info, 40);
+	assert(len == OPAL_PARAMETER);
+
+	memset(buf, 0, 256);
+	len = fru_fill_product_info(buf, &invalid_info2, 256);
+	assert(len == OPAL_PARAMETER);
+
+	memset(buf, 0, 256);
+	assert(fru_add(buf, 256) > 0);
+	assert(0 == memcmp(&buf[64], "\001\a\000\303IBM\307skiboot\300"
+			   "\337a-too-long-version-test-string+\300\300\301"
+			   "\0\0\0",54));
+
+
+	memset(buf, 0, 256);
+	assert(fru_add(buf, 1) == OPAL_PARAMETER);
+
+	memset(buf, 0, 256);
+	assert(fru_add(buf, 65) == OPAL_PARAMETER);
+
+	free(buf);
+
+	return 0;
+}