[PATCH linux dev-4.7] drivers/fsi: Add FSI SBEFIFO driver

Eddie James eajames at linux.vnet.ibm.com
Fri Apr 21 02:31:09 AEST 2017



On 04/17/2017 11:14 PM, Brad Bishop wrote:
> IBM POWER9 processors contain some embedded hardware and software bits
> collectively referred to as the self boot engine (SBE).  One role of
> the SBE is to act as a proxy that provides access to the registers of
> the POWER chip from other (embedded) systems.
>
> The POWER9 chip contains a hardware frontend for communicating with
> the SBE from remote systems called the SBEFIFO.  The SBEFIFO logic
> is contained within an FSI CFAM (see Documentation/fsi) and as such
> the driver implements an FSI bus device.
>
> The SBE expects to communicate using a defined wire protocol; however,
> the driver knows nothing of the protocol and only provides raw access
> to the fifo device to userspace applications wishing to communicate with
> the SBE using the wire protocol.
>
> The SBEFIFO consists of two hardware fifos.  The upstream fifo is used by
> the driver to transfer data to the SBE on the POWER chip, from the system
> hosting the driver.  The downstream fifo is used by the driver to transfer
> data from the SBE on the power chip to the system hosting the driver.
>
> Signed-off-by: Brad Bishop <bradleyb at fuzziesquirrel.com>
> ---
>   drivers/fsi/Kconfig       |   6 +
>   drivers/fsi/Makefile      |   1 +
>   drivers/fsi/fsi-sbefifo.c | 811 ++++++++++++++++++++++++++++++++++++++++++++++
>   3 files changed, 818 insertions(+)
>   create mode 100644 drivers/fsi/fsi-sbefifo.c
>
> diff --git a/drivers/fsi/Kconfig b/drivers/fsi/Kconfig
> index c78b9b6e..087f239 100644
> --- a/drivers/fsi/Kconfig
> +++ b/drivers/fsi/Kconfig
> @@ -18,6 +18,12 @@ config FSI_MASTER_GPIO
>   	---help---
>   	This option enables a FSI master driver using GPIO lines.
>
> +config FSI_SBEFIFO
> +	tristate "SBEFIFO FSI client device driver"
> +	depends on FSI
> +	---help---
> +	This option enables an FSI based SBEFIFO device driver.
> +
>   config FSI_SCOM
>   	tristate "SCOM FSI client device driver"
>   	depends on FSI
> diff --git a/drivers/fsi/Makefile b/drivers/fsi/Makefile
> index 3a106ba..edd84b2 100644
> --- a/drivers/fsi/Makefile
> +++ b/drivers/fsi/Makefile
> @@ -1,5 +1,6 @@
>
>   obj-$(CONFIG_FSI) += fsi-core.o
>   obj-$(CONFIG_FSI_MASTER_GPIO) += fsi-master-gpio.o
> +obj-$(CONFIG_FSI_SBEFIFO) += fsi-sbefifo.o
>   obj-$(CONFIG_FSI_SCOM) += fsi-scom.o
>   obj-$(CONFIG_FSI_I2C) += i2c/
> diff --git a/drivers/fsi/fsi-sbefifo.c b/drivers/fsi/fsi-sbefifo.c
> new file mode 100644
> index 0000000..9a13ce3
> --- /dev/null
> +++ b/drivers/fsi/fsi-sbefifo.c
> @@ -0,0 +1,811 @@
> +/*
> + * 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/delay.h>
> +#include <linux/errno.h>
> +#include <linux/idr.h>
> +#include <linux/fsi.h>
> +#include <linux/list.h>
> +#include <linux/miscdevice.h>
> +#include <linux/module.h>
> +#include <linux/poll.h>
> +#include <linux/sched.h>
> +#include <linux/slab.h>
> +#include <linux/timer.h>
> +#include <linux/uaccess.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
> +#define SBEFIFO_BUF_CNT		32
> +
> +#define SBEFIFO_UP		0x00	/* Up register offset */
> +#define SBEFIFO_DWN		0x40	/* Down register offset */
> +
> +#define SBEFIFO_STS		0x04
> +#define   SBEFIFO_EMPTY			BIT(20)
> +#define SBEFIFO_EOT_RAISE	0x08
> +#define   SBEFIFO_EOT_MAGIC		0xffffffff
> +#define SBEFIFO_EOT_ACK		0x14
> +
> +struct sbefifo {
> +	struct timer_list poll_timer;
> +	struct fsi_device *fsi_dev;
> +	struct miscdevice mdev;
> +	wait_queue_head_t wait;
> +	struct list_head link;
> +	struct list_head xfrs;
> +	struct kref kref;
> +	spinlock_t lock;
> +	char name[32];
> +	int idx;
> +	int rc;
> +};
> +
> +struct sbefifo_buf {
> +	u32 buf[SBEFIFO_BUF_CNT];
> +	unsigned long flags;
> +#define SBEFIFO_BUF_FULL		1
> +	u32 *rpos;
> +	u32 *wpos;
> +};
> +
> +struct sbefifo_xfr {
> +	struct sbefifo_buf *rbuf;
> +	struct sbefifo_buf *wbuf;
> +	struct list_head client;
> +	struct list_head xfrs;
> +	unsigned long flags;
> +#define SBEFIFO_XFR_WRITE_DONE		1
> +#define SBEFIFO_XFR_RESP_PENDING	2
> +#define SBEFIFO_XFR_COMPLETE		3
> +#define SBEFIFO_XFR_CANCEL		4
> +};
> +
> +struct sbefifo_client {
> +	struct sbefifo_buf rbuf;
> +	struct sbefifo_buf wbuf;
> +	struct list_head xfrs;
> +	struct sbefifo *dev;
> +	struct kref kref;
> +};
> +
> +static struct list_head sbefifo_fifos;
> +
> +static DEFINE_IDA(sbefifo_ida);
> +
> +static int sbefifo_inw(struct sbefifo *sbefifo, int reg, u32 *word)
> +{
> +	return fsi_device_read(sbefifo->fsi_dev, reg, word, sizeof(*word));
> +}
> +
> +static int sbefifo_outw(struct sbefifo *sbefifo, int reg, u32 word)
> +{
> +	return fsi_device_write(sbefifo->fsi_dev, reg, &word, sizeof(word));
> +}
> +
> +static int sbefifo_readw(struct sbefifo *sbefifo, u32 *word)
> +{
> +	return sbefifo_inw(sbefifo, SBEFIFO_DWN, word);
> +}
> +
> +static int sbefifo_writew(struct sbefifo *sbefifo, u32 word)
> +{
> +	return sbefifo_outw(sbefifo, SBEFIFO_UP, word);
> +}
> +
> +static int sbefifo_ack_eot(struct sbefifo *sbefifo)
> +{
> +	u32 discard;
> +	int ret;
> +
> +	 /* Discard the EOT word. */
> +	ret = sbefifo_readw(sbefifo, &discard);
> +	if (ret)
> +		return ret;
> +
> +	return sbefifo_outw(sbefifo, SBEFIFO_DWN | SBEFIFO_EOT_ACK,
> +			SBEFIFO_EOT_MAGIC);
> +}
> +
> +static size_t sbefifo_dev_nwreadable(u32 sts)
> +{
> +	static const u32 FIFO_NTRY_CNT_MSK = 0x000f0000;
> +	static const unsigned int FIFO_NTRY_CNT_SHIFT = 16;
> +
> +	return (sts & FIFO_NTRY_CNT_MSK) >> FIFO_NTRY_CNT_SHIFT;
> +}
> +
> +static size_t sbefifo_dev_nwwriteable(u32 sts)
> +{
> +	static const size_t FIFO_DEPTH = 8;
> +
> +	return FIFO_DEPTH - sbefifo_dev_nwreadable(sts);
> +}
> +
> +static void sbefifo_buf_init(struct sbefifo_buf *buf)
> +{
> +	WRITE_ONCE(buf->rpos, buf->buf);
> +	WRITE_ONCE(buf->wpos, buf->buf);
> +}
> +
> +static size_t sbefifo_buf_nbreadable(struct sbefifo_buf *buf)
> +{
> +	size_t n;
> +	u32 *rpos = READ_ONCE(buf->rpos);
> +	u32 *wpos = READ_ONCE(buf->wpos);
> +
> +	if (test_bit(SBEFIFO_BUF_FULL, &buf->flags))
> +		n = SBEFIFO_BUF_CNT;
> +	else if (rpos <= wpos)
> +		n = wpos - rpos;
> +	else
> +		n = (buf->buf + SBEFIFO_BUF_CNT) - rpos;
> +
> +	return n << 2;
> +}
> +
> +static size_t sbefifo_buf_nbwriteable(struct sbefifo_buf *buf)
> +{
> +	size_t n;
> +	u32 *rpos = READ_ONCE(buf->rpos);
> +	u32 *wpos = READ_ONCE(buf->wpos);
> +
> +	if (test_bit(SBEFIFO_BUF_FULL, &buf->flags))
> +		n = 0;
> +	else if (wpos < rpos)
> +		n = rpos - wpos;
> +	else
> +		n = (buf->buf + SBEFIFO_BUF_CNT) - wpos;
> +
> +	return n << 2;
> +}
> +
> +/*
> + * Update pointers and flags after doing a buffer read.  Return true if the
> + * buffer is now empty;
> + */
> +static bool sbefifo_buf_readnb(struct sbefifo_buf *buf, size_t n)
> +{
> +	u32 *rpos = READ_ONCE(buf->rpos);
> +	u32 *wpos = READ_ONCE(buf->wpos);
> +
> +	if (n)
> +		clear_bit(SBEFIFO_BUF_FULL, &buf->flags);
> +
> +	rpos += (n >> 2);
> +	if (rpos == buf->buf + SBEFIFO_BUF_CNT)
> +		rpos = buf->buf;
> +
> +	WRITE_ONCE(buf->rpos, rpos);
> +	return rpos == wpos;
> +}
> +
> +/*
> + * Update pointers and flags after doing a buffer write.  Return true if the
> + * buffer is now full.
> + */
> +static bool sbefifo_buf_wrotenb(struct sbefifo_buf *buf, size_t n)
> +{
> +	u32 *rpos = READ_ONCE(buf->rpos);
> +	u32 *wpos = READ_ONCE(buf->wpos);
> +
> +	wpos += (n >> 2);
> +	if (wpos == buf->buf + SBEFIFO_BUF_CNT)
> +		wpos = buf->buf;
> +	if (wpos == rpos)
> +		set_bit(SBEFIFO_BUF_FULL, &buf->flags);
> +
> +	WRITE_ONCE(buf->wpos, wpos);
> +	return rpos == wpos;
> +}
> +
> +static void sbefifo_free(struct kref *kref)
> +{
> +	struct sbefifo *sbefifo;
> +
> +	sbefifo = container_of(kref, struct sbefifo, kref);
> +	kfree(sbefifo);
> +}
> +
> +static void sbefifo_get(struct sbefifo *sbefifo)
> +{
> +	kref_get(&sbefifo->kref);
> +}
> +
> +static void sbefifo_put(struct sbefifo *sbefifo)
> +{
> +	kref_put(&sbefifo->kref, sbefifo_free);
> +}
> +
> +static struct sbefifo_xfr *sbefifo_enq_xfr(struct sbefifo_client *client)
> +{
> +	struct sbefifo *sbefifo = client->dev;
> +	struct sbefifo_xfr *xfr;
> +
> +	xfr = kzalloc(sizeof(*xfr), GFP_KERNEL);
> +	if (!xfr)
> +		return NULL;
> +
> +	xfr->rbuf = &client->rbuf;
> +	xfr->wbuf = &client->wbuf;
> +	list_add_tail(&xfr->xfrs, &sbefifo->xfrs);
> +	list_add_tail(&xfr->client, &client->xfrs);
> +
> +	return xfr;
> +}
> +
> +static struct sbefifo_xfr *sbefifo_client_next_xfr(
> +		struct sbefifo_client *client)
> +{
> +	if (list_empty(&client->xfrs))
> +		return NULL;
> +
> +	return container_of(client->xfrs.next, struct sbefifo_xfr,
> +			client);
> +}
> +
> +static bool sbefifo_xfr_rsp_pending(struct sbefifo_client *client)
> +{
> +	struct sbefifo_xfr *xfr;
> +
> +	xfr = sbefifo_client_next_xfr(client);
> +	if (xfr && test_bit(SBEFIFO_XFR_RESP_PENDING, &xfr->flags))
> +		return true;
> +
> +	return false;
> +}
> +
> +static struct sbefifo_client *sbefifo_new_client(struct sbefifo *sbefifo)
> +{
> +	struct sbefifo_client *client;
> +
> +	client = kzalloc(sizeof(*client), GFP_KERNEL);
> +	if (!client)
> +		return NULL;
> +
> +	kref_init(&client->kref);
> +	client->dev = sbefifo;
> +	sbefifo_buf_init(&client->rbuf);
> +	sbefifo_buf_init(&client->wbuf);
> +	INIT_LIST_HEAD(&client->xfrs);
> +
> +	sbefifo_get(sbefifo);
> +
> +	return client;
> +}
> +
> +static void sbefifo_client_release(struct kref *kref)
> +{
> +	struct sbefifo_client *client;
> +	struct sbefifo_xfr *xfr;
> +
> +	client = container_of(kref, struct sbefifo_client, kref);
> +	list_for_each_entry(xfr, &client->xfrs, client) {
> +		/*
> +		 * The client left with pending or running xfrs.
> +		 * Cancel them.
> +		 */
> +		set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
> +		sbefifo_get(client->dev);
> +		if (mod_timer(&client->dev->poll_timer, jiffies))
> +			sbefifo_put(client->dev);
> +	}
> +
> +	sbefifo_put(client->dev);
> +	kfree(client);
> +}
> +
> +static void sbefifo_get_client(struct sbefifo_client *client)
> +{
> +	kref_get(&client->kref);
> +}
> +
> +static void sbefifo_put_client(struct sbefifo_client *client)
> +{
> +	kref_put(&client->kref, sbefifo_client_release);
> +}
> +
> +static struct sbefifo_xfr *sbefifo_next_xfr(struct sbefifo *sbefifo)
> +{
> +	struct sbefifo_xfr *xfr;
> +
> +	while (!list_empty(&sbefifo->xfrs)) {
> +		xfr = container_of(sbefifo->xfrs.next, struct sbefifo_xfr,
> +				xfrs);
Could you use list_for_each_entry_safe() here?
> +		if (unlikely(test_bit(SBEFIFO_XFR_CANCEL, &xfr->flags))) {
> +			/* Discard cancelled transfers. */
> +			list_del(&xfr->xfrs);
> +			kfree(xfr);
> +			continue;
> +		}
> +		return xfr;
> +	}
> +
> +	return NULL;
> +}
> +
> +static void sbefifo_poll_timer(unsigned long data)
> +{
> +	static const unsigned long EOT_MASK = 0x000000ff;
> +	struct sbefifo *sbefifo = (void *)data;
> +	struct sbefifo_buf *rbuf, *wbuf;
> +	struct sbefifo_xfr *xfr = NULL;
> +	struct sbefifo_buf drain;
> +	size_t devn, bufn;
> +	int eot = 0;
> +	int ret = 0;
> +	u32 sts;
> +	int i;
> +
> +	spin_lock(&sbefifo->lock);
> +	if (!list_empty(&sbefifo->xfrs))
> +		xfr = container_of(sbefifo->xfrs.next, struct sbefifo_xfr,
> +				xfrs);
list_first_entry() might be more convenient.
> +	if (!xfr)
> +		goto out_unlock;
> +
> +	rbuf = xfr->rbuf;
> +	wbuf = xfr->wbuf;
> +
> +	if (unlikely(test_bit(SBEFIFO_XFR_CANCEL, &xfr->flags))) {
> +		/* The client left. */
> +		rbuf = &drain;
> +		wbuf = &drain;
> +		sbefifo_buf_init(&drain);
> +		if (!test_bit(SBEFIFO_XFR_RESP_PENDING, &xfr->flags))
> +			set_bit(SBEFIFO_XFR_WRITE_DONE, &xfr->flags);
> +	}
> +
> +	 /* Drain the write buffer. */
> +	while ((bufn = sbefifo_buf_nbreadable(wbuf))) {
> +		ret = sbefifo_inw(sbefifo, SBEFIFO_UP | SBEFIFO_STS,
> +				&sts);
> +		if (ret)
> +			goto out;
> +
> +		devn = sbefifo_dev_nwwriteable(sts);
> +		if (devn == 0) {
> +			/* No open slot for write.  Reschedule. */
> +			sbefifo->poll_timer.expires += msecs_to_jiffies(500);
expires might be some time in the past, so you may not get the full 
500ms delay, if you want that. Safer to do expires = jiffies + 
msecs_to_jiffies(500). Same for the other reschedule calls below.

Everything else looking good to me.
Eddie
> +			add_timer(&sbefifo->poll_timer);
> +			goto out_unlock;
> +		}
> +
> +		devn = min_t(size_t, devn, bufn >> 2);
> +		for (i = 0; i < devn; i++) {
> +			ret = sbefifo_writew(sbefifo, *wbuf->rpos);
> +			if (ret)
> +				goto out;
> +
> +			sbefifo_buf_readnb(wbuf, 1 << 2);
> +		}
> +	}
> +
> +	 /* Send EOT if the writer is finished. */
> +	if (test_and_clear_bit(SBEFIFO_XFR_WRITE_DONE, &xfr->flags)) {
> +		ret = sbefifo_outw(sbefifo,
> +				SBEFIFO_UP | SBEFIFO_EOT_RAISE,
> +				SBEFIFO_EOT_MAGIC);
> +		if (ret)
> +			goto out;
> +
> +		/* Inform reschedules that the writer is finished. */
> +		set_bit(SBEFIFO_XFR_RESP_PENDING, &xfr->flags);
> +	}
> +
> +	/* Nothing left to do if the writer is not finished. */
> +	if (!test_bit(SBEFIFO_XFR_RESP_PENDING, &xfr->flags))
> +		goto out;
> +
> +	 /* Fill the read buffer. */
> +	while ((bufn = sbefifo_buf_nbwriteable(rbuf))) {
> +		ret = sbefifo_inw(sbefifo, SBEFIFO_DWN | SBEFIFO_STS, &sts);
> +		if (ret)
> +			goto out;
> +
> +		devn = sbefifo_dev_nwreadable(sts);
> +		if (devn == 0) {
> +			/* No data yet.  Reschedule. */
> +			sbefifo->poll_timer.expires += msecs_to_jiffies(500);
> +			add_timer(&sbefifo->poll_timer);
> +			goto out_unlock;
> +		}
> +
> +		/* Fill.  The EOT word is discarded.  */
> +		devn = min_t(size_t, devn, bufn >> 2);
> +		eot = (sts & EOT_MASK) != 0;
> +		if (eot)
> +			devn--;
> +
> +		for (i = 0; i < devn; i++) {
> +			ret = sbefifo_readw(sbefifo, rbuf->wpos);
> +			if (ret)
> +				goto out;
> +
> +			if (likely(!test_bit(SBEFIFO_XFR_CANCEL, &xfr->flags)))
> +				sbefifo_buf_wrotenb(rbuf, 1 << 2);
> +		}
> +
> +		if (eot) {
> +			ret = sbefifo_ack_eot(sbefifo);
> +			if (ret)
> +				goto out;
> +
> +			set_bit(SBEFIFO_XFR_COMPLETE, &xfr->flags);
> +			list_del(&xfr->xfrs);
> +			if (unlikely(test_bit(SBEFIFO_XFR_CANCEL,
> +							&xfr->flags)))
> +				kfree(xfr);
> +			break;
> +		}
> +	}
> +
> +out:
> +	if (unlikely(ret)) {
> +		sbefifo->rc = ret;
> +		dev_err(&sbefifo->fsi_dev->dev,
> +				"Fatal bus access failure: %d\n", ret);
> +		list_for_each_entry(xfr, &sbefifo->xfrs, xfrs)
> +			kfree(xfr);
> +		INIT_LIST_HEAD(&sbefifo->xfrs);
> +
> +	} else if (eot && sbefifo_next_xfr(sbefifo)) {
> +		sbefifo_get(sbefifo);
> +		sbefifo->poll_timer.expires = jiffies;
> +		add_timer(&sbefifo->poll_timer);
> +	}
> +
> +	sbefifo_put(sbefifo);
> +	wake_up(&sbefifo->wait);
> +
> +out_unlock:
> +	spin_unlock(&sbefifo->lock);
> +}
> +
> +static int sbefifo_open(struct inode *inode, struct file *file)
> +{
> +	struct sbefifo *sbefifo = container_of(file->private_data,
> +			struct sbefifo, mdev);
> +	struct sbefifo_client *client;
> +	int ret;
> +
> +	ret = READ_ONCE(sbefifo->rc);
> +	if (ret)
> +		return ret;
> +
> +	client = sbefifo_new_client(sbefifo);
> +	if (!client)
> +		return -ENOMEM;
> +
> +	file->private_data = client;
> +
> +	return 0;
> +}
> +
> +static unsigned int sbefifo_poll(struct file *file, poll_table *wait)
> +{
> +	struct sbefifo_client *client = file->private_data;
> +	struct sbefifo *sbefifo = client->dev;
> +	unsigned int mask = 0;
> +
> +	poll_wait(file, &sbefifo->wait, wait);
> +
> +	if (READ_ONCE(sbefifo->rc))
> +		mask |= POLLERR;
> +
> +	if (sbefifo_buf_nbreadable(&client->rbuf))
> +		mask |= POLLIN;
> +
> +	if (sbefifo_buf_nbwriteable(&client->wbuf))
> +		mask |= POLLOUT;
> +
> +	return mask;
> +}
> +
> +static ssize_t sbefifo_read(struct file *file, char __user *buf,
> +		size_t len, loff_t *offset)
> +{
> +	struct sbefifo_client *client = file->private_data;
> +	struct sbefifo *sbefifo = client->dev;
> +	struct sbefifo_xfr *xfr;
> +	ssize_t ret = 0;
> +	size_t n;
> +
> +	WARN_ON(*offset);
> +
> +	if (!access_ok(VERIFY_WRITE, buf, len))
> +		return -EFAULT;
> +
> +	if ((len >> 2) << 2 != len)
> +		return -EINVAL;
> +
> +	if ((file->f_flags & O_NONBLOCK) && !sbefifo_xfr_rsp_pending(client))
> +		return -EAGAIN;
> +
> +	sbefifo_get_client(client);
> +	if (wait_event_interruptible(sbefifo->wait,
> +				(ret = READ_ONCE(sbefifo->rc)) ||
> +				(n = sbefifo_buf_nbreadable(
> +						&client->rbuf)))) {
> +		sbefifo_put_client(client);
> +		return -ERESTARTSYS;
> +	}
> +	if (ret) {
> +		INIT_LIST_HEAD(&client->xfrs);
> +		sbefifo_put_client(client);
> +		return ret;
> +	}
> +
> +	n = min_t(size_t, n, len);
> +
> +	if (copy_to_user(buf, READ_ONCE(client->rbuf.rpos), n)) {
> +		sbefifo_put_client(client);
> +		return -EFAULT;
> +	}
> +
> +	if (sbefifo_buf_readnb(&client->rbuf, n)) {
> +		xfr = sbefifo_client_next_xfr(client);
> +		if (!test_bit(SBEFIFO_XFR_COMPLETE, &xfr->flags)) {
> +			/*
> +			 * Fill the read buffer back up.
> +			 */
> +			sbefifo_get(sbefifo);
> +			if (mod_timer(&client->dev->poll_timer, jiffies))
> +				sbefifo_put(sbefifo);
> +		} else {
> +			kfree(xfr);
> +			list_del(&xfr->client);
> +			wake_up(&sbefifo->wait);
> +		}
> +	}
> +
> +	sbefifo_put_client(client);
> +
> +	return n;
> +}
> +
> +static ssize_t sbefifo_write(struct file *file, const char __user *buf,
> +		size_t len, loff_t *offset)
> +{
> +	struct sbefifo_client *client = file->private_data;
> +	struct sbefifo *sbefifo = client->dev;
> +	struct sbefifo_xfr *xfr;
> +	ssize_t ret = 0;
> +	size_t n;
> +
> +	WARN_ON(*offset);
> +
> +	if (!access_ok(VERIFY_READ, buf, len))
> +		return -EFAULT;
> +
> +	if ((len >> 2) << 2 != len)
> +		return -EINVAL;
> +
> +	if (!len)
> +		return 0;
> +
> +	n = sbefifo_buf_nbwriteable(&client->wbuf);
> +
> +	spin_lock_irq(&sbefifo->lock);
> +	xfr = sbefifo_next_xfr(sbefifo);
> +
> +	if ((file->f_flags & O_NONBLOCK) && xfr && n < len) {
> +		spin_unlock_irq(&sbefifo->lock);
> +		return -EAGAIN;
> +	}
> +
> +	xfr = sbefifo_enq_xfr(client);
> +	if (!xfr) {
> +		spin_unlock_irq(&sbefifo->lock);
> +		return -ENOMEM;
> +	}
> +	spin_unlock_irq(&sbefifo->lock);
> +
> +	sbefifo_get_client(client);
> +
> +	/*
> +	 * Partial writes are not really allowed in that EOT is sent exactly
> +	 * once per write.
> +	 */
> +	while (len) {
> +		if (wait_event_interruptible(sbefifo->wait,
> +				READ_ONCE(sbefifo->rc) ||
> +					(sbefifo_client_next_xfr(client) == xfr &&
> +					 (n = sbefifo_buf_nbwriteable(
> +							&client->wbuf))))) {
> +			set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
> +			sbefifo_get(sbefifo);
> +			if (mod_timer(&sbefifo->poll_timer, jiffies))
> +				sbefifo_put(sbefifo);
> +
> +			sbefifo_put_client(client);
> +			return -ERESTARTSYS;
> +		}
> +		if (sbefifo->rc) {
> +			INIT_LIST_HEAD(&client->xfrs);
> +			sbefifo_put_client(client);
> +			return sbefifo->rc;
> +		}
> +
> +		n = min_t(size_t, n, len);
> +
> +		if (copy_from_user(READ_ONCE(client->wbuf.wpos), buf, n)) {
> +			set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
> +			sbefifo_get(sbefifo);
> +			if (mod_timer(&sbefifo->poll_timer, jiffies))
> +				sbefifo_put(sbefifo);
> +			sbefifo_put_client(client);
> +			return -EFAULT;
> +		}
> +
> +		sbefifo_buf_wrotenb(&client->wbuf, n);
> +		len -= n;
> +		buf += n;
> +		ret += n;
> +
> +		/*
> +		 * Drain the write buffer.
> +		 */
> +		sbefifo_get(sbefifo);
> +		if (mod_timer(&client->dev->poll_timer, jiffies))
> +			sbefifo_put(sbefifo);
> +	}
> +
> +	set_bit(SBEFIFO_XFR_WRITE_DONE, &xfr->flags);
> +	sbefifo_put_client(client);
> +
> +	return ret;
> +}
> +
> +static int sbefifo_release(struct inode *inode, struct file *file)
> +{
> +	struct sbefifo_client *client = file->private_data;
> +	struct sbefifo *sbefifo = client->dev;
> +
> +	sbefifo_put_client(client);
> +
> +	return READ_ONCE(sbefifo->rc);
> +}
> +
> +static const struct file_operations sbefifo_fops = {
> +	.owner		= THIS_MODULE,
> +	.open		= sbefifo_open,
> +	.read		= sbefifo_read,
> +	.write		= sbefifo_write,
> +	.poll		= sbefifo_poll,
> +	.release	= sbefifo_release,
> +};
> +
> +static int sbefifo_probe(struct device *dev)
> +{
> +	struct fsi_device *fsi_dev = to_fsi_dev(dev);
> +	struct sbefifo *sbefifo;
> +	u32 sts;
> +	int ret;
> +
> +	dev_info(dev, "Found sbefifo device\n");
> +	sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
> +	if (!sbefifo)
> +		return -ENOMEM;
> +
> +	sbefifo->fsi_dev = fsi_dev;
> +
> +	ret = sbefifo_inw(sbefifo,
> +			SBEFIFO_UP | SBEFIFO_STS, &sts);
> +	if (ret)
> +		return ret;
> +	if (!(sts & SBEFIFO_EMPTY)) {
> +		dev_err(&sbefifo->fsi_dev->dev,
> +				"Found data in upstream fifo\n");
> +		return -EIO;
> +	}
> +
> +	ret = sbefifo_inw(sbefifo, SBEFIFO_DWN | SBEFIFO_STS, &sts);
> +	if (ret)
> +		return ret;
> +	if (!(sts & SBEFIFO_EMPTY)) {
> +		dev_err(&sbefifo->fsi_dev->dev,
> +				"Found data in downstream fifo\n");
> +		return -EIO;
> +	}
> +
> +	sbefifo->mdev.minor = MISC_DYNAMIC_MINOR;
> +	sbefifo->mdev.fops = &sbefifo_fops;
> +	sbefifo->mdev.name = sbefifo->name;
> +	sbefifo->mdev.parent = dev;
> +	spin_lock_init(&sbefifo->lock);
> +	kref_init(&sbefifo->kref);
> +
> +	sbefifo->idx = ida_simple_get(&sbefifo_ida, 1, INT_MAX, GFP_KERNEL);
> +	snprintf(sbefifo->name, sizeof(sbefifo->name), "sbefifo%d",
> +			sbefifo->idx);
> +	init_waitqueue_head(&sbefifo->wait);
> +	INIT_LIST_HEAD(&sbefifo->xfrs);
> +
> +	/* This bit of silicon doesn't offer any interrupts... */
> +	setup_timer(&sbefifo->poll_timer, sbefifo_poll_timer,
> +			(unsigned long)sbefifo);
> +
> +	list_add(&sbefifo->link, &sbefifo_fifos);
> +	return misc_register(&sbefifo->mdev);
> +}
> +
> +static int sbefifo_remove(struct device *dev)
> +{
> +	struct fsi_device *fsi_dev = to_fsi_dev(dev);
> +	struct sbefifo *sbefifo, *sbefifo_tmp;
> +	struct sbefifo_xfr *xfr;
> +
> +	list_for_each_entry_safe(sbefifo, sbefifo_tmp, &sbefifo_fifos, link) {
> +		if (sbefifo->fsi_dev != fsi_dev)
> +			continue;
> +		misc_deregister(&sbefifo->mdev);
> +		list_del(&sbefifo->link);
> +		ida_simple_remove(&sbefifo_ida, sbefifo->idx);
> +
> +		if (del_timer_sync(&sbefifo->poll_timer))
> +			sbefifo_put(sbefifo);
> +
> +		spin_lock(&sbefifo->lock);
> +		list_for_each_entry(xfr, &sbefifo->xfrs, xfrs)
> +			kfree(xfr);
> +		spin_unlock(&sbefifo->lock);
> +
> +		WRITE_ONCE(sbefifo->rc, -ENODEV);
> +
> +		wake_up(&sbefifo->wait);
> +		sbefifo_put(sbefifo);
> +	}
> +
> +	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)
> +{
> +	INIT_LIST_HEAD(&sbefifo_fifos);
> +	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 <bradleyb at fuzziesquirrel.com>");
> +MODULE_DESCRIPTION("Linux device interface to the POWER self boot engine");



More information about the openbmc mailing list