fsi/sbefifo: Add driver for the SBE FIFO

This driver provides an in-kernel and a user API for accessing
the command FIFO of the SBE (Self Boot Engine) of the POWER9
processor, via the FSI bus.

It provides an in-kernel interface to submit command and receive
responses, along with a helper to locate and analyse the response
status block. It's a simple synchronous submit() type API.

The user interface uses the write/read interface that an earlier
version of this driver already provided, however it has some
specific limitations in order to keep the driver simple and
avoid using up a lot of kernel memory:

 - The user should perform a single write() with the command and
   a single read() to get the response (with a buffer big enough
   to hold the entire response).

 - On a write() the command is simply "stored" into a kernel buffer,
   it is submitted as one operation on the subsequent read(). This
   allows to have the code write directly from the FIFO into the user
   buffer and avoid hogging the SBE between the write() and read()
   syscall as it's critical that the SBE be freed asap to respond
   to the host. An extra write() will simply replace the previously
   written command.

 - A write of a single 4 bytes containing the value 0x52534554
   in big endian will trigger a reset request. No read is necessary,
   the write() call will return when the reset has been acknowledged
   or times out.

 - The command is limited to 4K bytes.

Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Tested-by: Joel Stanley <joel@jms.id.au>
---

4 files changed, 1046 insertions, 0 deletions

diff --git a/drivers/fsi/Kconfig b/drivers/fsi/Kconfig
index a326ed663d3c..24f84a96b8b9 100644
--- a/drivers/fsi/Kconfig
+++ b/drivers/fsi/Kconfig
@@ -32,4 +32,11 @@ config FSI_SCOM
         ---help---
         This option enables an FSI based SCOM device driver.
 
+config FSI_SBEFIFO
+        tristate "SBEFIFO FSI client device driver"
+        ---help---
+        This option enables an FSI based SBEFIFO device driver. The SBEFIFO is
+        a pipe-like FSI device for communicating with the self boot engine
+        (SBE) on POWER processors.
+
 endif
diff --git a/drivers/fsi/Makefile b/drivers/fsi/Makefile
index 65eb99dfafdb..851182e1cd9e 100644
--- a/drivers/fsi/Makefile
+++ b/drivers/fsi/Makefile
@@ -3,3 +3,4 @@ obj-$(CONFIG_FSI) += fsi-core.o
 obj-$(CONFIG_FSI_MASTER_HUB) += fsi-master-hub.o
 obj-$(CONFIG_FSI_MASTER_GPIO) += fsi-master-gpio.o
 obj-$(CONFIG_FSI_SCOM) += fsi-scom.o
+obj-$(CONFIG_FSI_SBEFIFO) += fsi-sbefifo.o
diff --git a/drivers/fsi/fsi-sbefifo.c b/drivers/fsi/fsi-sbefifo.c
new file mode 100644
index 000000000000..9b8b6b346af6
--- /dev/null
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -0,0 +1,1005 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) IBM Corporation 2017
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/fsi.h>
+#include <linux/fsi-sbefifo.h>
+#include <linux/idr.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/delay.h>
+#include <linux/uio.h>
+#include <linux/vmalloc.h>
+
+/*
+ * The SBEFIFO is a pipe-like FSI device for communicating with
+ * the self boot engine on POWER processors.
+ */
+
+#define DEVICE_NAME             "sbefifo"
+#define FSI_ENGID_SBE           0x22
+
+/*
+ * Register layout
+ */
+
+/* Register banks */
+#define SBEFIFO_UP              0x00            /* FSI -> Host */
+#define SBEFIFO_DOWN            0x40            /* Host -> FSI */
+
+/* Per-bank registers */
+#define SBEFIFO_FIFO            0x00            /* The FIFO itself */
+#define SBEFIFO_STS             0x04            /* Status register */
+#define   SBEFIFO_STS_PARITY_ERR        0x20000000
+#define   SBEFIFO_STS_RESET_REQ         0x02000000
+#define   SBEFIFO_STS_GOT_EOT           0x00800000
+#define   SBEFIFO_STS_MAX_XFER_LIMIT    0x00400000
+#define   SBEFIFO_STS_FULL              0x00200000
+#define   SBEFIFO_STS_EMPTY             0x00100000
+#define   SBEFIFO_STS_ECNT_MASK         0x000f0000
+#define   SBEFIFO_STS_ECNT_SHIFT        16
+#define   SBEFIFO_STS_VALID_MASK        0x0000ff00
+#define   SBEFIFO_STS_VALID_SHIFT       8
+#define   SBEFIFO_STS_EOT_MASK          0x000000ff
+#define   SBEFIFO_STS_EOT_SHIFT         0
+#define SBEFIFO_EOT_RAISE       0x08            /* (Up only) Set End Of Transfer */
+#define SBEFIFO_REQ_RESET       0x0C            /* (Up only) Reset Request */
+#define SBEFIFO_PERFORM_RESET   0x10            /* (Down only) Perform Reset */
+#define SBEFIFO_EOT_ACK         0x14            /* (Down only) Acknowledge EOT */
+#define SBEFIFO_DOWN_MAX        0x18            /* (Down only) Max transfer */
+
+/* CFAM GP Mailbox SelfBoot Message register */
+#define CFAM_GP_MBOX_SBM_ADDR   0x2824  /* Converted 0x2809 */
+
+#define CFAM_SBM_SBE_BOOTED             0x80000000
+#define CFAM_SBM_SBE_ASYNC_FFDC         0x40000000
+#define CFAM_SBM_SBE_STATE_MASK         0x00f00000
+#define CFAM_SBM_SBE_STATE_SHIFT        20
+
+enum sbe_state
+{
+        SBE_STATE_UNKNOWN = 0x0, // Unkown, initial state
+        SBE_STATE_IPLING  = 0x1, // IPL'ing - autonomous mode (transient)
+        SBE_STATE_ISTEP   = 0x2, // ISTEP - Running IPL by steps (transient)
+        SBE_STATE_MPIPL   = 0x3, // MPIPL
+        SBE_STATE_RUNTIME = 0x4, // SBE Runtime
+        SBE_STATE_DMT     = 0x5, // Dead Man Timer State (transient)
+        SBE_STATE_DUMP    = 0x6, // Dumping
+        SBE_STATE_FAILURE = 0x7, // Internal SBE failure
+        SBE_STATE_QUIESCE = 0x8, // Final state - needs SBE reset to get out
+};
+
+/* FIFO depth */
+#define SBEFIFO_FIFO_DEPTH              8
+
+/* Helpers */
+#define sbefifo_empty(sts)      ((sts) & SBEFIFO_STS_EMPTY)
+#define sbefifo_full(sts)       ((sts) & SBEFIFO_STS_FULL)
+#define sbefifo_parity_err(sts) ((sts) & SBEFIFO_STS_PARITY_ERR)
+#define sbefifo_populated(sts)  (((sts) & SBEFIFO_STS_ECNT_MASK) >> SBEFIFO_STS_ECNT_SHIFT)
+#define sbefifo_vacant(sts)     (SBEFIFO_FIFO_DEPTH - sbefifo_populated(sts))
+#define sbefifo_eot_set(sts)    (((sts) & SBEFIFO_STS_EOT_MASK) >> SBEFIFO_STS_EOT_SHIFT)
+
+/* Reset request timeout in ms */
+#define SBEFIFO_RESET_TIMEOUT           10000
+
+/* Timeouts for commands in ms */
+#define SBEFIFO_TIMEOUT_START_CMD       10000
+#define SBEFIFO_TIMEOUT_IN_CMD          1000
+#define SBEFIFO_TIMEOUT_START_RSP       10000
+#define SBEFIFO_TIMEOUT_IN_RSP          1000
+
+/* Other constants */
+#define SBEFIFO_MAX_CMD_LEN             PAGE_SIZE
+#define SBEFIFO_RESET_MAGIC             0x52534554 /* "RSET" */
+
+struct sbefifo {
+        uint32_t                magic;
+#define SBEFIFO_MAGIC           0x53424546 /* "SBEF" */
+        struct fsi_device       *fsi_dev;
+        struct miscdevice       mdev;
+        struct mutex            lock;
+        char                    name[32];
+        int                     idx;
+        bool                    broken;
+        bool                    async_ffdc;
+};
+
+struct sbefifo_user {
+        struct sbefifo          *sbefifo;
+        struct mutex            file_lock;
+        void                    *pending_cmd;
+        size_t                  pending_len;
+};
+
+static DEFINE_IDA(sbefifo_ida);
+static DEFINE_MUTEX(sbefifo_ffdc_mutex);
+
+
+static void sbefifo_dump_ffdc(struct device *dev, const __be32 *ffdc,
+                              size_t ffdc_sz, bool internal)
+{
+        int pack = 0;
+#define FFDC_LSIZE      60
+        static char ffdc_line[FFDC_LSIZE];
+        char *p = ffdc_line;
+
+        mutex_lock(&sbefifo_ffdc_mutex);
+        while (ffdc_sz) {
+                u32 w0, w1, w2, i;
+                if (ffdc_sz < 3) {
+                        dev_err(dev, "SBE invalid FFDC package size %zd\n", ffdc_sz);
+                        return;
+                }
+                w0 = be32_to_cpu(*(ffdc++));
+                w1 = be32_to_cpu(*(ffdc++));
+                w2 = be32_to_cpu(*(ffdc++));
+                ffdc_sz -= 3;
+                if ((w0 >> 16) != 0xFFDC) {
+                        dev_err(dev, "SBE invalid FFDC package signature %08x %08x %08x\n",
+                                w0, w1, w2);
+                        break;
+                }
+                w0 &= 0xffff;
+                if (w0 > ffdc_sz) {
+                        dev_err(dev, "SBE FFDC package len %d words but only %zd remaining\n",
+                                w0, ffdc_sz);
+                        w0 = ffdc_sz;
+                        break;
+                }
+                if (internal) {
+                        dev_warn(dev, "+---- SBE FFDC package %d for async err -----+\n",
+                                 pack++);
+                } else {
+                        dev_warn(dev, "+---- SBE FFDC package %d for cmd %02x:%02x -----+\n",
+                                 pack++, (w1 >> 8) & 0xff, w1 & 0xff);
+                }
+                dev_warn(dev, "| Response code: %08x                   |\n", w2);
+                dev_warn(dev, "|-------------------------------------------|\n");
+                for (i = 0; i < w0; i++) {
+                        if ((i & 3) == 0) {
+                                p = ffdc_line;
+                                p += sprintf(p, "| %04x:", i << 4);
+                        }
+                        p += sprintf(p, " %08x", be32_to_cpu(*(ffdc++)));
+                        ffdc_sz--;
+                        if ((i & 3) == 3 || i == (w0 - 1)) {
+                                while ((i & 3) < 3) {
+                                        p += sprintf(p, "         ");
+                                        i++;
+                                }
+                                dev_warn(dev, "%s |\n", ffdc_line);
+                        }
+                }
+                dev_warn(dev, "+-------------------------------------------+\n");
+        }
+}
+
+int sbefifo_parse_status(struct device *dev, u16 cmd, __be32 *response,
+                         size_t resp_len, size_t *data_len)
+{
+        u32 dh, s0, s1;
+        size_t ffdc_sz;
+
+        if (resp_len < 3) {
+                pr_debug("sbefifo: cmd %04x, response too small: %zd\n",
+                         cmd, resp_len);
+                return -ENXIO;
+        }
+        dh = be32_to_cpu(response[resp_len - 1]);
+        if (dh > resp_len || dh < 3) {
+                dev_err(dev, "SBE cmd %02x:%02x status offset out of range: %d/%zd\n",
+                        cmd >> 8, cmd & 0xff, dh, resp_len);
+                return -ENXIO;
+        }
+        s0 = be32_to_cpu(response[resp_len - dh]);
+        s1 = be32_to_cpu(response[resp_len - dh + 1]);
+        if (((s0 >> 16) != 0xC0DE) || ((s0 & 0xffff) != cmd)) {
+                dev_err(dev, "SBE cmd %02x:%02x, status signature invalid: 0x%08x 0x%08x\n",
+                        cmd >> 8, cmd & 0xff, s0, s1);
+                return -ENXIO;
+        }
+        if (s1 != 0) {
+                ffdc_sz = dh - 3;
+                dev_warn(dev, "SBE error cmd %02x:%02x status=%04x:%04x\n",
+                         cmd >> 8, cmd & 0xff, s1 >> 16, s1 & 0xffff);
+                if (ffdc_sz)
+                        sbefifo_dump_ffdc(dev, &response[resp_len - dh + 2],
+                                          ffdc_sz, false);
+        }
+        if (data_len)
+                *data_len = resp_len - dh;
+
+        /*
+         * Primary status don't have the top bit set, so can't be confused with
+         * Linux negative error codes, so return the status word whole.
+         */
+        return s1;
+}
+EXPORT_SYMBOL_GPL(sbefifo_parse_status);
+
+static int sbefifo_regr(struct sbefifo *sbefifo, int reg, u32 *word)
+{
+        __be32 raw_word;
+        int rc;
+
+        rc = fsi_device_read(sbefifo->fsi_dev, reg, &raw_word,
+                             sizeof(raw_word));
+        if (rc)
+                return rc;
+
+        *word = be32_to_cpu(raw_word);
+
+        return 0;
+}
+
+static int sbefifo_regw(struct sbefifo *sbefifo, int reg, u32 word)
+{
+        __be32 raw_word = cpu_to_be32(word);
+
+        return fsi_device_write(sbefifo->fsi_dev, reg, &raw_word,
+                                sizeof(raw_word));
+}
+
+static int sbefifo_check_sbe_state(struct sbefifo *sbefifo)
+{
+        __be32 raw_word;
+        u32 sbm;
+        int rc;
+
+        rc = fsi_slave_read(sbefifo->fsi_dev->slave, CFAM_GP_MBOX_SBM_ADDR,
+                            &raw_word, sizeof(raw_word));
+        if (rc)
+                return rc;
+        sbm = be32_to_cpu(raw_word);
+
+        /* SBE booted at all ? */
+        if (!(sbm & CFAM_SBM_SBE_BOOTED))
+                return -ESHUTDOWN;
+
+        /* Check its state */
+        switch ((sbm & CFAM_SBM_SBE_STATE_MASK) >> CFAM_SBM_SBE_STATE_SHIFT) {
+        case SBE_STATE_UNKNOWN:
+                return -ESHUTDOWN;
+        case SBE_STATE_IPLING:
+        case SBE_STATE_ISTEP:
+        case SBE_STATE_MPIPL:
+        case SBE_STATE_DMT:
+                return -EBUSY;
+        case SBE_STATE_RUNTIME:
+        case SBE_STATE_DUMP: /* Not sure about that one */
+                break;
+        case SBE_STATE_FAILURE:
+        case SBE_STATE_QUIESCE:
+                return -ESHUTDOWN;
+        }
+
+        /* Is there async FFDC available ? Remember it */
+        if (sbm & CFAM_SBM_SBE_ASYNC_FFDC)
+                sbefifo->async_ffdc = true;
+
+        return 0;
+}
+
+/* Don't flip endianness of data to/from FIFO, just pass through. */
+static int sbefifo_down_read(struct sbefifo *sbefifo, __be32 *word)
+{
+        return fsi_device_read(sbefifo->fsi_dev, SBEFIFO_DOWN, word,
+                               sizeof(*word));
+}
+
+static int sbefifo_up_write(struct sbefifo *sbefifo, __be32 word)
+{
+        return fsi_device_write(sbefifo->fsi_dev, SBEFIFO_UP, &word,
+                                sizeof(word));
+}
+
+static int sbefifo_request_reset(struct sbefifo *sbefifo)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        u32 status, timeout;
+        int rc;
+
+        dev_dbg(dev, "Requesting FIFO reset\n");
+
+        /* Mark broken first, will be cleared if reset succeeds */
+        sbefifo->broken = true;
+
+        /* Send reset request */
+        rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_REQ_RESET, 1);
+        if (rc) {
+                dev_err(dev, "Sending reset request failed, rc=%d\n", rc);
+                return rc;
+        }
+
+        /* Wait for it to complete */
+        for (timeout = 0; timeout < SBEFIFO_RESET_TIMEOUT; timeout++) {
+                rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &status);
+                if (rc) {
+                        dev_err(dev, "Failed to read UP fifo status during reset"
+                                " , rc=%d\n", rc);
+                        return rc;
+                }
+
+                if (!(status & SBEFIFO_STS_RESET_REQ)) {
+                        dev_dbg(dev, "FIFO reset done\n");
+                        sbefifo->broken = false;
+                        return 0;
+                }
+
+                msleep(1);
+        }
+        dev_err(dev, "FIFO reset timed out\n");
+
+        return -ETIMEDOUT;
+}
+
+static int sbefifo_cleanup_hw(struct sbefifo *sbefifo)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        u32 up_status, down_status;
+        bool need_reset = false;
+        int rc;
+
+        rc = sbefifo_check_sbe_state(sbefifo);
+        if (rc) {
+                dev_dbg(dev, "SBE state=%d\n", rc);
+                return rc;
+        }
+
+        /* If broken, we don't need to look at status, go straight to reset */
+        if (sbefifo->broken)
+                goto do_reset;
+
+        rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &up_status);
+        if (rc) {
+                dev_err(dev, "Cleanup: Reading UP status failed, rc=%d\n", rc);
+
+                /* Will try reset again on next attempt at using it */
+                sbefifo->broken = true;
+                return rc;
+        }
+
+        rc = sbefifo_regr(sbefifo, SBEFIFO_DOWN | SBEFIFO_STS, &down_status);
+        if (rc) {
+                dev_err(dev, "Cleanup: Reading DOWN status failed, rc=%d\n", rc);
+
+                /* Will try reset again on next attempt at using it */
+                sbefifo->broken = true;
+                return rc;
+        }
+
+        /* The FIFO already contains a reset request from the SBE ? */
+        if (down_status & SBEFIFO_STS_RESET_REQ) {
+                dev_info(dev, "Cleanup: FIFO reset request set, resetting\n");
+                rc = sbefifo_regw(sbefifo, SBEFIFO_UP, SBEFIFO_PERFORM_RESET);
+                if (rc) {
+                        sbefifo->broken = true;
+                        dev_err(dev, "Cleanup: Reset reg write failed, rc=%d\n", rc);
+                        return rc;
+                }
+                sbefifo->broken = false;
+                return 0;
+        }
+
+        /* Parity error on either FIFO ? */
+        if ((up_status | down_status) & SBEFIFO_STS_PARITY_ERR)
+                need_reset = true;
+
+        /* Either FIFO not empty ? */
+        if (!((up_status & down_status) & SBEFIFO_STS_EMPTY))
+                need_reset = true;
+
+        if (!need_reset)
+                return 0;
+
+        dev_info(dev, "Cleanup: FIFO not clean (up=0x%08x down=0x%08x)\n",
+                 up_status, down_status);
+
+ do_reset:
+
+        /* Mark broken, will be cleared if/when reset succeeds */
+        return sbefifo_request_reset(sbefifo);
+}
+
+static int sbefifo_wait(struct sbefifo *sbefifo, bool up,
+                        u32 *status, unsigned long timeout)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        unsigned long end_time;
+        bool ready = false;
+        u32 addr, sts = 0;
+        int rc;
+
+        dev_vdbg(dev, "Wait on %s fifo...\n", up ? "up" : "down");
+
+        addr = (up ? SBEFIFO_UP : SBEFIFO_DOWN) | SBEFIFO_STS;
+
+        end_time = jiffies + timeout;
+        while (!time_after(jiffies, end_time)) {
+                cond_resched();
+                rc = sbefifo_regr(sbefifo, addr, &sts);
+                if (rc < 0) {
+                        dev_err(dev, "FSI error %d reading status register\n", rc);
+                        return rc;
+                }
+                if (!up && sbefifo_parity_err(sts)) {
+                        dev_err(dev, "Parity error in DOWN FIFO\n");
+                        return -ENXIO;
+                }
+                ready = !(up ? sbefifo_full(sts) : sbefifo_empty(sts));
+                if (ready)
+                        break;
+        }
+        if (!ready) {
+                dev_err(dev, "%s FIFO Timeout ! status=%08x\n", up ? "UP" : "DOWN", sts);
+                return -ETIMEDOUT;
+        }
+        dev_vdbg(dev, "End of wait status: %08x\n", sts);
+
+        *status = sts;
+
+        return 0;
+}
+
+static int sbefifo_send_command(struct sbefifo *sbefifo,
+                                const __be32 *command, size_t cmd_len)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        size_t len, chunk, vacant = 0, remaining = cmd_len;
+        unsigned long timeout;
+        u32 status;
+        int rc;
+
+        dev_vdbg(dev, "sending command (%zd words, cmd=%04x)\n",
+                 cmd_len, be32_to_cpu(command[1]));
+
+        /* As long as there's something to send */
+        timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_CMD);
+        while (remaining) {
+                /* Wait for room in the FIFO */
+                rc = sbefifo_wait(sbefifo, true, &status, timeout);
+                if (rc < 0)
+                        return rc;
+                timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_CMD);
+
+                vacant = sbefifo_vacant(status);
+                len = chunk = min(vacant, remaining);
+
+                dev_vdbg(dev, "  status=%08x vacant=%zd chunk=%zd\n",
+                         status, vacant, chunk);
+
+                /* Write as much as we can */
+                while (len--) {
+                        rc = sbefifo_up_write(sbefifo, *(command++));
+                        if (rc) {
+                                dev_err(dev, "FSI error %d writing UP FIFO\n", rc);
+                                return rc;
+                        }
+                }
+                remaining -= chunk;
+                vacant -= chunk;
+        }
+
+        /* If there's no room left, wait for some to write EOT */
+        if (!vacant) {
+                rc = sbefifo_wait(sbefifo, true, &status, timeout);
+                if (rc)
+                        return rc;
+        }
+
+        /* Send an EOT */
+        rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_EOT_RAISE, 0);
+        if (rc)
+                dev_err(dev, "FSI error %d writing EOT\n", rc);
+        return rc;
+}
+
+static int sbefifo_read_response(struct sbefifo *sbefifo, struct iov_iter *response)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        u32 data, status, eot_set;
+        unsigned long timeout;
+        bool overflow = false;
+        size_t len;
+        int rc;
+
+        dev_vdbg(dev, "reading response, buflen = %zd\n", iov_iter_count(response));
+
+        timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_RSP);
+        for (;;) {
+                /* Grab FIFO status (this will handle parity errors) */
+                rc = sbefifo_wait(sbefifo, false, &status, timeout);
+                if (rc < 0)
+                        return rc;
+                timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_RSP);
+
+                /* Decode status */
+                len = sbefifo_populated(status);
+                eot_set = sbefifo_eot_set(status);
+
+                dev_vdbg(dev, "  chunk size %zd eot_set=0x%x\n", len, eot_set);
+
+                /* Go through the chunk */
+                while(len--) {
+                        /* Read the data */
+                        rc = sbefifo_down_read(sbefifo, &data);
+                        if (rc < 0)
+                                return rc;
+
+                        /* Was it an EOT ? */
+                        if (eot_set & 0x80) {
+                                /*
+                                 * There should be nothing else in the FIFO,
+                                 * if there is, mark broken, this will force
+                                 * a reset on next use, but don't fail the
+                                 * command.
+                                 */
+                                if (len) {
+                                        dev_warn(dev, "FIFO read hit"
+                                                 " EOT with still %zd data\n",
+                                                 len);
+                                        sbefifo->broken = true;
+                                }
+
+                                /* We are done */
+                                rc = sbefifo_regw(sbefifo,
+                                                  SBEFIFO_DOWN | SBEFIFO_EOT_ACK, 0);
+
+                                /*
+                                 * If that write fail, still complete the request but mark
+                                 * the fifo as broken for subsequent reset (not much else
+                                 * we can do here).
+                                 */
+                                if (rc) {
+                                        dev_err(dev, "FSI error %d ack'ing EOT\n", rc);
+                                        sbefifo->broken = true;
+                                }
+
+                                /* Tell whether we overflowed */
+                                return overflow ? -EOVERFLOW : 0;
+                        }
+
+                        /* Store it if there is room */
+                        if (iov_iter_count(response) >= sizeof(__be32)) {
+                                if (copy_to_iter(&data, sizeof(__be32), response) < sizeof(__be32))
+                                        return -EFAULT;
+                        } else {
+                                dev_vdbg(dev, "Response overflowed !\n");
+
+                                overflow = true;
+                        }
+
+                        /* Next EOT bit */
+                        eot_set <<= 1;
+                }
+        }
+        /* Shouldn't happen */
+        return -EIO;
+}
+
+static int sbefifo_do_command(struct sbefifo *sbefifo,
+                              const __be32 *command, size_t cmd_len,
+                              struct iov_iter *response)
+{
+        /* Try sending the command */
+        int rc = sbefifo_send_command(sbefifo, command, cmd_len);
+        if (rc)
+                return rc;
+
+        /* Now, get the response */
+        return sbefifo_read_response(sbefifo, response);
+}
+
+static void sbefifo_collect_async_ffdc(struct sbefifo *sbefifo)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        struct iov_iter ffdc_iter;
+        struct kvec ffdc_iov;
+        __be32 *ffdc;
+        size_t ffdc_sz;
+        u32 cmd[2];
+        int rc;
+
+        sbefifo->async_ffdc = false;
+        ffdc = vmalloc(SBEFIFO_MAX_FFDC_SIZE);
+        if (!ffdc) {
+                dev_err(dev, "Failed to allocate SBE FFDC buffer\n");
+                return;
+        }
+        ffdc_iov.iov_base = ffdc;
+        ffdc_iov.iov_len = SBEFIFO_MAX_FFDC_SIZE;;
+        iov_iter_kvec(&ffdc_iter, WRITE | ITER_KVEC, &ffdc_iov, 1, SBEFIFO_MAX_FFDC_SIZE);
+        cmd[0] = cpu_to_be32(2);
+        cmd[1] = cpu_to_be32(SBEFIFO_CMD_GET_SBE_FFDC);
+        rc = sbefifo_do_command(sbefifo, cmd, 2, &ffdc_iter);
+        if (rc != 0) {
+                dev_err(dev, "Error %d retrieving SBE FFDC\n", rc);
+                goto bail;
+        }
+        ffdc_sz = SBEFIFO_MAX_FFDC_SIZE - iov_iter_count(&ffdc_iter);
+        ffdc_sz /= sizeof(__be32);
+        rc = sbefifo_parse_status(dev, SBEFIFO_CMD_GET_SBE_FFDC, ffdc,
+                                  ffdc_sz, &ffdc_sz);
+        if (rc != 0) {
+                dev_err(dev, "Error %d decoding SBE FFDC\n", rc);
+                goto bail;
+        }
+        if (ffdc_sz > 0)
+                sbefifo_dump_ffdc(dev, ffdc, ffdc_sz, true);
+ bail:
+        vfree(ffdc);
+
+}
+
+static int __sbefifo_submit(struct sbefifo *sbefifo,
+                            const __be32 *command, size_t cmd_len,
+                            struct iov_iter *response)
+{
+        struct device *dev = &sbefifo->fsi_dev->dev;
+        int rc;
+
+        if (cmd_len < 2 || be32_to_cpu(command[0]) != cmd_len) {
+                dev_vdbg(dev, "Invalid command len %zd (header: %d)\n",
+                         cmd_len, be32_to_cpu(command[0]));
+                return -EINVAL;
+        }
+
+        /* First ensure the HW is in a clean state */
+        rc = sbefifo_cleanup_hw(sbefifo);
+        if (rc)
+                return rc;
+
+        /* Look for async FFDC first if any */
+        if (sbefifo->async_ffdc)
+                sbefifo_collect_async_ffdc(sbefifo);
+
+        rc = sbefifo_do_command(sbefifo, command, cmd_len, response);
+        if (rc != 0 && rc != -EOVERFLOW)
+                goto fail;
+        return rc;
+ fail:
+        /*
+         * On failure, attempt a reset. Ignore the result, it will mark
+         * the fifo broken if the reset fails
+         */
+        sbefifo_request_reset(sbefifo);
+
+        /* Return original error */
+        return rc;
+}
+
+/**
+ * sbefifo_submit() - Submit and SBE fifo command and receive response
+ * @dev: The sbefifo device
+ * @command: The raw command data
+ * @cmd_len: The command size (in 32-bit words)
+ * @response: The output response buffer
+ * @resp_len: In: Response buffer size, Out: Response size
+ *
+ * This will perform the entire operation. If the reponse buffer
+ * overflows, returns -EOVERFLOW
+ */
+int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
+                   __be32 *response, size_t *resp_len)
+{
+        struct sbefifo *sbefifo = dev_get_drvdata(dev);
+        struct iov_iter resp_iter;
+        struct kvec resp_iov;
+        size_t rbytes;
+        int rc;
+
+        if (!dev || !sbefifo)
+                return -ENODEV;
+        if (WARN_ON_ONCE(sbefifo->magic != SBEFIFO_MAGIC))
+                return -ENODEV;
+        if (!resp_len || !command || !response || cmd_len > SBEFIFO_MAX_CMD_LEN)
+                return -EINVAL;
+
+        /* Prepare iov iterator */
+        rbytes = (*resp_len) * sizeof(__be32);
+        resp_iov.iov_base = response;
+        resp_iov.iov_len = rbytes;
+        iov_iter_kvec(&resp_iter, WRITE | ITER_KVEC, &resp_iov, 1, rbytes);
+
+        /* Perform the command */
+        mutex_lock(&sbefifo->lock);
+        rc = __sbefifo_submit(sbefifo, command, cmd_len, &resp_iter);
+        mutex_unlock(&sbefifo->lock);
+
+        /* Extract the response length */
+        rbytes -= iov_iter_count(&resp_iter);
+        *resp_len = rbytes / sizeof(__be32);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(sbefifo_submit);
+
+/*
+ * Char device interface
+ */
+static int sbefifo_user_open(struct inode *inode, struct file *file)
+{
+        struct sbefifo *sbefifo = container_of(file->private_data,
+                                               struct sbefifo, mdev);
+        struct sbefifo_user *user;
+
+        user = kzalloc(sizeof(struct sbefifo_user), GFP_KERNEL);
+        if (!user)
+                return -ENOMEM;
+
+        file->private_data = user;
+        user->sbefifo = sbefifo;
+        user->pending_cmd = (void *)__get_free_page(GFP_KERNEL);
+        if (!user->pending_cmd) {
+                kfree(user);
+                return -ENOMEM;
+        }
+        mutex_init(&user->file_lock);
+
+        return 0;
+}
+
+static ssize_t sbefifo_user_read(struct file *file, char __user *buf,
+                                 size_t len, loff_t *offset)
+{
+        struct sbefifo_user *user = file->private_data;
+        struct sbefifo *sbefifo;
+        struct iov_iter resp_iter;
+        struct iovec resp_iov;
+        size_t cmd_len;
+        int rc;
+
+        if (!user)
+                return -EINVAL;
+        sbefifo = user->sbefifo;
+        if (len & 3)
+                return -EINVAL;
+
+        mutex_lock(&user->file_lock);
+
+        /* Cronus relies on -EAGAIN after a short read */
+        if (user->pending_len == 0) {
+                rc = -EAGAIN;
+                goto bail;
+        }
+        if (user->pending_len < 8) {
+                rc = -EINVAL;
+                goto bail;
+        }
+        cmd_len = user->pending_len >> 2;
+
+        /* Prepare iov iterator */
+        resp_iov.iov_base = buf;
+        resp_iov.iov_len = len;
+        iov_iter_init(&resp_iter, WRITE, &resp_iov, 1, len);
+
+        /* Perform the command */
+        mutex_lock(&sbefifo->lock);
+        rc = __sbefifo_submit(sbefifo, user->pending_cmd, cmd_len, &resp_iter);
+        mutex_unlock(&sbefifo->lock);
+        if (rc < 0)
+                goto bail;
+
+        /* Extract the response length */
+        rc = len - iov_iter_count(&resp_iter);
+ bail:
+        user->pending_len = 0;
+        mutex_unlock(&user->file_lock);
+        return rc;
+}
+
+static ssize_t sbefifo_user_write(struct file *file, const char __user *buf,
+                                  size_t len, loff_t *offset)
+{
+        struct sbefifo_user *user = file->private_data;
+        struct sbefifo *sbefifo;
+        int rc = len;
+
+        if (!user)
+                return -EINVAL;
+        sbefifo = user->sbefifo;
+        if (len > SBEFIFO_MAX_CMD_LEN)
+                return -EINVAL;
+        if (len & 3)
+                return -EINVAL;
+
+        mutex_lock(&user->file_lock);
+
+        /* Copy the command into the staging buffer */
+        if (copy_from_user(user->pending_cmd, buf, len)) {
+                rc = -EFAULT;
+                goto bail;
+        }
+
+        /* Check for the magic reset command */
+        if (len == 4 && be32_to_cpu(*(__be32 *)user->pending_cmd) ==
+            SBEFIFO_RESET_MAGIC)  {
+
+                /* Clear out any pending command */
+                user->pending_len = 0;
+
+                /* Trigger reset request */
+                mutex_lock(&sbefifo->lock);
+                rc = sbefifo_request_reset(user->sbefifo);
+                mutex_unlock(&sbefifo->lock);
+                if (rc == 0)
+                        rc = 4;
+                goto bail;
+        }
+
+        /* Update the staging buffer size */
+        user->pending_len = len;
+ bail:
+        mutex_unlock(&user->file_lock);
+
+        /* And that's it, we'll issue the command on a read */
+        return rc;
+}
+
+static int sbefifo_user_release(struct inode *inode, struct file *file)
+{
+        struct sbefifo_user *user = file->private_data;
+
+        if (!user)
+                return -EINVAL;
+
+        free_page((unsigned long)user->pending_cmd);
+        kfree(user);
+
+        return 0;
+}
+
+static const struct file_operations sbefifo_fops = {
+        .owner          = THIS_MODULE,
+        .open           = sbefifo_user_open,
+        .read           = sbefifo_user_read,
+        .write          = sbefifo_user_write,
+        .release        = sbefifo_user_release,
+};
+
+/*
+ * Probe/remove
+ */
+
+static int sbefifo_probe(struct device *dev)
+{
+        struct fsi_device *fsi_dev = to_fsi_dev(dev);
+        struct sbefifo *sbefifo;
+        struct device_node *np;
+        struct platform_device *child;
+        char child_name[32];
+        int rc, child_idx = 0;
+
+        dev_dbg(dev, "Found sbefifo device\n");
+
+        sbefifo = devm_kzalloc(dev, sizeof(*sbefifo), GFP_KERNEL);
+        if (!sbefifo)
+                return -ENOMEM;
+        sbefifo->magic = SBEFIFO_MAGIC;
+        sbefifo->fsi_dev = fsi_dev;
+        mutex_init(&sbefifo->lock);
+
+        /*
+         * Try cleaning up the FIFO. If this fails, we still register the
+         * driver and will try cleaning things up again on the next access.
+         */
+        rc = sbefifo_cleanup_hw(sbefifo);
+        if (rc && rc != -ESHUTDOWN)
+                dev_err(dev, "Initial HW cleanup failed, will retry later\n");
+
+        sbefifo->idx = ida_simple_get(&sbefifo_ida, 1, INT_MAX, GFP_KERNEL);
+        snprintf(sbefifo->name, sizeof(sbefifo->name), "sbefifo%d",
+                 sbefifo->idx);
+
+        dev_set_drvdata(dev, sbefifo);
+
+        /* Create misc chardev for userspace access */
+        sbefifo->mdev.minor = MISC_DYNAMIC_MINOR;
+        sbefifo->mdev.fops = &sbefifo_fops;
+        sbefifo->mdev.name = sbefifo->name;
+        sbefifo->mdev.parent = dev;
+        rc = misc_register(&sbefifo->mdev);
+        if (rc) {
+                dev_err(dev, "Failed to register miscdevice: %d\n", rc);
+                ida_simple_remove(&sbefifo_ida, sbefifo->idx);
+                return rc;
+        }
+
+        /* Create platform devs for dts child nodes (occ, etc) */
+        for_each_available_child_of_node(dev->of_node, np) {
+                snprintf(child_name, sizeof(child_name), "%s-dev%d",
+                         sbefifo->name, child_idx++);
+                child = of_platform_device_create(np, child_name, dev);
+                if (!child)
+                        dev_warn(dev, "failed to create child %s dev\n",
+                                 child_name);
+        }
+
+        return 0;
+}
+
+static int sbefifo_unregister_child(struct device *dev, void *data)
+{
+        struct platform_device *child = to_platform_device(dev);
+
+        of_device_unregister(child);
+        if (dev->of_node)
+                of_node_clear_flag(dev->of_node, OF_POPULATED);
+
+        return 0;
+}
+
+static int sbefifo_remove(struct device *dev)
+{
+        struct sbefifo *sbefifo = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "Removing sbefifo device...\n");
+
+        misc_deregister(&sbefifo->mdev);
+        device_for_each_child(dev, NULL, sbefifo_unregister_child);
+
+        ida_simple_remove(&sbefifo_ida, sbefifo->idx);
+
+        return 0;
+}
+
+static struct fsi_device_id sbefifo_ids[] = {
+        {
+                .engine_type = FSI_ENGID_SBE,
+                .version = FSI_VERSION_ANY,
+        },
+        { 0 }
+};
+
+static struct fsi_driver sbefifo_drv = {
+        .id_table = sbefifo_ids,
+        .drv = {
+                .name = DEVICE_NAME,
+                .bus = &fsi_bus_type,
+                .probe = sbefifo_probe,
+                .remove = sbefifo_remove,
+        }
+};
+
+static int sbefifo_init(void)
+{
+        return fsi_driver_register(&sbefifo_drv);
+}
+
+static void sbefifo_exit(void)
+{
+        fsi_driver_unregister(&sbefifo_drv);
+
+        ida_destroy(&sbefifo_ida);
+}
+
+module_init(sbefifo_init);
+module_exit(sbefifo_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Brad Bishop <bradleyb@fuzziesquirrel.com>");
+MODULE_AUTHOR("Eddie James <eajames@linux.vnet.ibm.com>");
+MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
+MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
+MODULE_DESCRIPTION("Linux device interface to the POWER Self Boot Engine");
diff --git a/include/linux/fsi-sbefifo.h b/include/linux/fsi-sbefifo.h
new file mode 100644
index 000000000000..13f9ebeaa25e
--- /dev/null
+++ b/include/linux/fsi-sbefifo.h
@@ -0,0 +1,33 @@
+/*
+ * SBEFIFO FSI Client device driver
+ *
+ * Copyright (C) IBM Corporation 2017
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef LINUX_FSI_SBEFIFO_H
+#define LINUX_FSI_SBEFIFO_H
+
+#define SBEFIFO_CMD_PUT_OCC_SRAM        0xa404
+#define SBEFIFO_CMD_GET_OCC_SRAM        0xa403
+#define SBEFIFO_CMD_GET_SBE_FFDC        0xa801
+
+#define SBEFIFO_MAX_FFDC_SIZE           0x2000
+
+struct device;
+
+int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
+                   __be32 *response, size_t *resp_len);
+
+int sbefifo_parse_status(struct device *dev, u16 cmd, __be32 *response,
+                         size_t resp_len, size_t *data_len);
+
+#endif /* LINUX_FSI_SBEFIFO_H */