forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1066 lines
26 KiB
1066 lines
26 KiB
// 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/kernel.h> |
|
#include <linux/cdev.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> |
|
#include <linux/mm.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_USER_CMD_LEN (0x100000 + PAGE_SIZE) |
|
#define SBEFIFO_RESET_MAGIC 0x52534554 /* "RSET" */ |
|
|
|
struct sbefifo { |
|
uint32_t magic; |
|
#define SBEFIFO_MAGIC 0x53424546 /* "SBEF" */ |
|
struct fsi_device *fsi_dev; |
|
struct device dev; |
|
struct cdev cdev; |
|
struct mutex lock; |
|
bool broken; |
|
bool dead; |
|
bool async_ffdc; |
|
}; |
|
|
|
struct sbefifo_user { |
|
struct sbefifo *sbefifo; |
|
struct mutex file_lock; |
|
void *cmd_page; |
|
void *pending_cmd; |
|
size_t pending_len; |
|
}; |
|
|
|
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; |
|
|
|
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"); |
|
} |
|
} |
|
|
|
static void sbefifo_dump_ffdc(struct device *dev, const __be32 *ffdc, |
|
size_t ffdc_sz, bool internal) |
|
{ |
|
mutex_lock(&sbefifo_ffdc_mutex); |
|
__sbefifo_dump_ffdc(dev, ffdc, ffdc_sz, internal); |
|
mutex_unlock(&sbefifo_ffdc_mutex); |
|
} |
|
|
|
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_DMT: |
|
return -EBUSY; |
|
case SBE_STATE_IPLING: |
|
case SBE_STATE_ISTEP: |
|
case SBE_STATE_MPIPL: |
|
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 status, eot_set; |
|
unsigned long timeout; |
|
bool overflow = false; |
|
__be32 data; |
|
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; |
|
__be32 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, &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 (sbefifo->dead) |
|
return -ENODEV; |
|
|
|
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; |
|
struct iov_iter resp_iter; |
|
struct kvec resp_iov; |
|
size_t rbytes; |
|
int rc; |
|
|
|
if (!dev) |
|
return -ENODEV; |
|
sbefifo = dev_get_drvdata(dev); |
|
if (!sbefifo) |
|
return -ENODEV; |
|
if (WARN_ON_ONCE(sbefifo->magic != SBEFIFO_MAGIC)) |
|
return -ENODEV; |
|
if (!resp_len || !command || !response) |
|
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, &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 void sbefifo_release_command(struct sbefifo_user *user) |
|
{ |
|
if (is_vmalloc_addr(user->pending_cmd)) |
|
vfree(user->pending_cmd); |
|
user->pending_cmd = NULL; |
|
user->pending_len = 0; |
|
} |
|
|
|
static int sbefifo_user_open(struct inode *inode, struct file *file) |
|
{ |
|
struct sbefifo *sbefifo = container_of(inode->i_cdev, struct sbefifo, cdev); |
|
struct sbefifo_user *user; |
|
|
|
user = kzalloc(sizeof(struct sbefifo_user), GFP_KERNEL); |
|
if (!user) |
|
return -ENOMEM; |
|
|
|
file->private_data = user; |
|
user->sbefifo = sbefifo; |
|
user->cmd_page = (void *)__get_free_page(GFP_KERNEL); |
|
if (!user->cmd_page) { |
|
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: |
|
sbefifo_release_command(user); |
|
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_USER_CMD_LEN) |
|
return -EINVAL; |
|
if (len & 3) |
|
return -EINVAL; |
|
|
|
mutex_lock(&user->file_lock); |
|
|
|
/* Can we use the pre-allocate buffer ? If not, allocate */ |
|
if (len <= PAGE_SIZE) |
|
user->pending_cmd = user->cmd_page; |
|
else |
|
user->pending_cmd = vmalloc(len); |
|
if (!user->pending_cmd) { |
|
rc = -ENOMEM; |
|
goto bail; |
|
} |
|
|
|
/* 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: |
|
if (!user->pending_len) |
|
sbefifo_release_command(user); |
|
|
|
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; |
|
|
|
sbefifo_release_command(user); |
|
free_page((unsigned long)user->cmd_page); |
|
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, |
|
}; |
|
|
|
static void sbefifo_free(struct device *dev) |
|
{ |
|
struct sbefifo *sbefifo = container_of(dev, struct sbefifo, dev); |
|
|
|
put_device(&sbefifo->fsi_dev->dev); |
|
kfree(sbefifo); |
|
} |
|
|
|
/* |
|
* 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, didx, child_idx = 0; |
|
|
|
dev_dbg(dev, "Found sbefifo device\n"); |
|
|
|
sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL); |
|
if (!sbefifo) |
|
return -ENOMEM; |
|
|
|
/* Grab a reference to the device (parent of our cdev), we'll drop it later */ |
|
if (!get_device(dev)) { |
|
kfree(sbefifo); |
|
return -ENODEV; |
|
} |
|
|
|
sbefifo->magic = SBEFIFO_MAGIC; |
|
sbefifo->fsi_dev = fsi_dev; |
|
dev_set_drvdata(dev, sbefifo); |
|
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"); |
|
|
|
/* Create chardev for userspace access */ |
|
sbefifo->dev.type = &fsi_cdev_type; |
|
sbefifo->dev.parent = dev; |
|
sbefifo->dev.release = sbefifo_free; |
|
device_initialize(&sbefifo->dev); |
|
|
|
/* Allocate a minor in the FSI space */ |
|
rc = fsi_get_new_minor(fsi_dev, fsi_dev_sbefifo, &sbefifo->dev.devt, &didx); |
|
if (rc) |
|
goto err; |
|
|
|
dev_set_name(&sbefifo->dev, "sbefifo%d", didx); |
|
cdev_init(&sbefifo->cdev, &sbefifo_fops); |
|
rc = cdev_device_add(&sbefifo->cdev, &sbefifo->dev); |
|
if (rc) { |
|
dev_err(dev, "Error %d creating char device %s\n", |
|
rc, dev_name(&sbefifo->dev)); |
|
goto err_free_minor; |
|
} |
|
|
|
/* 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", |
|
dev_name(&sbefifo->dev), 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; |
|
err_free_minor: |
|
fsi_free_minor(sbefifo->dev.devt); |
|
err: |
|
put_device(&sbefifo->dev); |
|
return rc; |
|
} |
|
|
|
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"); |
|
|
|
mutex_lock(&sbefifo->lock); |
|
sbefifo->dead = true; |
|
mutex_unlock(&sbefifo->lock); |
|
|
|
cdev_device_del(&sbefifo->cdev, &sbefifo->dev); |
|
fsi_free_minor(sbefifo->dev.devt); |
|
device_for_each_child(dev, NULL, sbefifo_unregister_child); |
|
put_device(&sbefifo->dev); |
|
|
|
return 0; |
|
} |
|
|
|
static const 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); |
|
} |
|
|
|
module_init(sbefifo_init); |
|
module_exit(sbefifo_exit); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_AUTHOR("Brad Bishop <[email protected]>"); |
|
MODULE_AUTHOR("Eddie James <[email protected]>"); |
|
MODULE_AUTHOR("Andrew Jeffery <[email protected]>"); |
|
MODULE_AUTHOR("Benjamin Herrenschmidt <[email protected]>"); |
|
MODULE_DESCRIPTION("Linux device interface to the POWER Self Boot Engine");
|
|
|