* [PATCH linux 1/4] drivers/fsi: Add SBEFIFO FSI client device driver
2017-06-21 19:37 [PATCH linux 0/4] drivers/fsi: Add SBEFIFO and OCC drivers Eddie James
@ 2017-06-21 19:37 ` Eddie James
2017-06-21 19:37 ` [PATCH linux 2/4] drivers/fsi/sbefifo: Add in-kernel API Eddie James
` (2 subsequent siblings)
3 siblings, 0 replies; 9+ messages in thread
From: Eddie James @ 2017-06-21 19:37 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, jk, cbostic,
joel, andrew, eajames, Edward A. James
From: "Edward A. James" <eajames@us.ibm.com>
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 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.
The driver also provides an in-kernel API for SBEFIFO client device
drivers. In this way, applications and client drivers all have safe
access to the hardware.
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
drivers/fsi/Kconfig | 7 +
drivers/fsi/Makefile | 1 +
drivers/fsi/fsi-sbefifo.c | 822 ++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 830 insertions(+)
create mode 100644 drivers/fsi/fsi-sbefifo.c
diff --git a/drivers/fsi/Kconfig b/drivers/fsi/Kconfig
index 6821ed0..8c4d903 100644
--- a/drivers/fsi/Kconfig
+++ b/drivers/fsi/Kconfig
@@ -33,6 +33,13 @@ 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
endmenu
diff --git a/drivers/fsi/Makefile b/drivers/fsi/Makefile
index 65eb99d..851182e 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 0000000..fca277c
--- /dev/null
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -0,0 +1,822 @@
+/*
+ * 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; /* parent fsi device */
+ struct miscdevice mdev; /* /dev/ entry */
+ wait_queue_head_t wait;
+ struct list_head link;
+ struct list_head xfrs;
+ struct kref kref; /* reference counter */
+ 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)
+{
+ int rc;
+ __be32 raw_word;
+
+ 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_outw(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));
+}
+
+/* Don't flip endianness of data to/from FIFO, just pass through. */
+static int sbefifo_readw(struct sbefifo *sbefifo, u32 *word)
+{
+ return fsi_device_read(sbefifo->fsi_dev, SBEFIFO_DWN, word,
+ sizeof(*word));
+}
+
+static int sbefifo_writew(struct sbefifo *sbefifo, u32 word)
+{
+ return fsi_device_write(sbefifo->fsi_dev, SBEFIFO_UP, &word,
+ sizeof(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->flags, 0);
+ 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 = 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_xfr *xfr;
+ struct sbefifo_client *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, *tmp;
+
+ list_for_each_entry_safe(xfr, tmp, &sbefifo->xfrs, xfrs) {
+ 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);
+ xfr = list_first_entry_or_null(&sbefifo->xfrs, struct sbefifo_xfr,
+ xfrs);
+ 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 = jiffies +
+ msecs_to_jiffies(500);
+ 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 = jiffies +
+ 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;
+
+ 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_buf *wbuf = &client->wbuf;
+ struct sbefifo_xfr *xfr;
+ ssize_t ret = 0;
+ size_t n;
+
+ if ((len >> 2) << 2 != len)
+ return -EINVAL;
+
+ if (!len)
+ return 0;
+
+ n = sbefifo_buf_nbwriteable(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(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(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(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;
+
+ 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);
+
+ 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_DESCRIPTION("Linux device interface to the POWER self boot engine");
--
1.8.3.1
^ permalink raw reply related [flat|nested] 9+ messages in thread* [PATCH linux 2/4] drivers/fsi/sbefifo: Add in-kernel API
2017-06-21 19:37 [PATCH linux 0/4] drivers/fsi: Add SBEFIFO and OCC drivers Eddie James
2017-06-21 19:37 ` [PATCH linux 1/4] drivers/fsi: Add SBEFIFO FSI client device driver Eddie James
@ 2017-06-21 19:37 ` Eddie James
2017-06-24 11:17 ` kbuild test robot
2017-06-21 19:38 ` [PATCH linux 3/4] drivers/fsi: Add On-Chip Controller (OCC) driver Eddie James
2017-06-21 19:38 ` [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API Eddie James
3 siblings, 1 reply; 9+ messages in thread
From: Eddie James @ 2017-06-21 19:37 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, jk, cbostic,
joel, andrew, eajames, Edward A. James
From: "Edward A. James" <eajames@us.ibm.com>
Refactor the user interface of the SBEFIFO driver to allow for an
in-kernel read/write API. Add exported functions for other drivers to
call, and add an include file with those functions. Also parse the
device tree for child nodes and create child platform devices
accordingly.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
drivers/fsi/fsi-sbefifo.c | 141 +++++++++++++++++++++++++++++++++++++-------
include/linux/fsi-sbefifo.h | 30 ++++++++++
2 files changed, 150 insertions(+), 21 deletions(-)
create mode 100644 include/linux/fsi-sbefifo.h
diff --git a/drivers/fsi/fsi-sbefifo.c b/drivers/fsi/fsi-sbefifo.c
index fca277c..1038f6c 100644
--- a/drivers/fsi/fsi-sbefifo.c
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -15,9 +15,12 @@
#include <linux/errno.h>
#include <linux/idr.h>
#include <linux/fsi.h>
+#include <linux/fsi-sbefifo.h>
#include <linux/list.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
@@ -82,6 +85,7 @@ struct sbefifo_client {
struct list_head xfrs;
struct sbefifo *dev;
struct kref kref;
+ unsigned long f_flags;
};
static struct list_head sbefifo_fifos;
@@ -509,6 +513,7 @@ static int sbefifo_open(struct inode *inode, struct file *file)
return -ENOMEM;
file->private_data = client;
+ client->f_flags = file->f_flags;
return 0;
}
@@ -533,19 +538,18 @@ static unsigned int sbefifo_poll(struct file *file, poll_table *wait)
return mask;
}
-static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
- loff_t *offset)
+static ssize_t sbefifo_read_common(struct sbefifo_client *client,
+ char __user *ubuf, char *kbuf, size_t len)
{
- struct sbefifo_client *client = file->private_data;
struct sbefifo *sbefifo = client->dev;
struct sbefifo_xfr *xfr;
- ssize_t ret = 0;
size_t n;
+ ssize_t ret = 0;
if ((len >> 2) << 2 != len)
return -EINVAL;
- if ((file->f_flags & O_NONBLOCK) && !sbefifo_xfr_rsp_pending(client))
+ if ((client->f_flags & O_NONBLOCK) && !sbefifo_xfr_rsp_pending(client))
return -EAGAIN;
sbefifo_get_client(client);
@@ -564,10 +568,13 @@ static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
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 (ubuf) {
+ if (copy_to_user(ubuf, READ_ONCE(client->rbuf.rpos), n)) {
+ sbefifo_put_client(client);
+ return -EFAULT;
+ }
+ } else
+ memcpy(kbuf, READ_ONCE(client->rbuf.rpos), n);
if (sbefifo_buf_readnb(&client->rbuf, n)) {
xfr = sbefifo_client_next_xfr(client);
@@ -590,10 +597,18 @@ static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
return n;
}
-static ssize_t sbefifo_write(struct file *file, const char __user *buf,
- size_t len, loff_t *offset)
+static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
+ loff_t *offset)
{
struct sbefifo_client *client = file->private_data;
+
+ return sbefifo_read_common(client, buf, NULL, len);
+}
+
+static ssize_t sbefifo_write_common(struct sbefifo_client *client,
+ const char __user *ubuf, const char *kbuf,
+ size_t len)
+{
struct sbefifo *sbefifo = client->dev;
struct sbefifo_buf *wbuf = &client->wbuf;
struct sbefifo_xfr *xfr;
@@ -611,7 +626,7 @@ static ssize_t sbefifo_write(struct file *file, const char __user *buf,
spin_lock_irq(&sbefifo->lock);
xfr = sbefifo_next_xfr(sbefifo);
- if ((file->f_flags & O_NONBLOCK) && xfr && n < len) {
+ if ((client->f_flags & O_NONBLOCK) && xfr && n < len) {
spin_unlock_irq(&sbefifo->lock);
return -EAGAIN;
}
@@ -650,18 +665,24 @@ static ssize_t sbefifo_write(struct file *file, const char __user *buf,
n = min_t(size_t, n, len);
- if (copy_from_user(READ_ONCE(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;
+ if (ubuf) {
+ if (copy_from_user(READ_ONCE(wbuf->wpos), ubuf, 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;
+ }
+
+ ubuf += n;
+ } else {
+ memcpy(READ_ONCE(wbuf->wpos), kbuf, n);
+ kbuf += n;
}
sbefifo_buf_wrotenb(wbuf, n);
len -= n;
- buf += n;
ret += n;
/*
@@ -678,6 +699,14 @@ static ssize_t sbefifo_write(struct file *file, const char __user *buf,
return ret;
}
+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;
+
+ return sbefifo_write_common(client, buf, NULL, len);
+}
+
static int sbefifo_release(struct inode *inode, struct file *file)
{
struct sbefifo_client *client = file->private_data;
@@ -697,12 +726,68 @@ static int sbefifo_release(struct inode *inode, struct file *file)
.release = sbefifo_release,
};
+struct sbefifo_client *sbefifo_drv_open(struct device *dev,
+ unsigned long flags)
+{
+ struct sbefifo_client *client = NULL;
+ struct sbefifo *sbefifo;
+ struct fsi_device *fsi_dev = to_fsi_dev(dev);
+
+ list_for_each_entry(sbefifo, &sbefifo_fifos, link) {
+ if (sbefifo->fsi_dev != fsi_dev)
+ continue;
+
+ client = sbefifo_new_client(sbefifo);
+ if (client)
+ client->f_flags = flags;
+ }
+
+ return client;
+}
+EXPORT_SYMBOL_GPL(sbefifo_drv_open);
+
+int sbefifo_drv_read(struct sbefifo_client *client, char *buf, size_t len)
+{
+ return sbefifo_read_common(client, NULL, buf, len);
+}
+EXPORT_SYMBOL_GPL(sbefifo_drv_read);
+
+int sbefifo_drv_write(struct sbefifo_client *client, const char *buf,
+ size_t len)
+{
+ return sbefifo_write_common(client, NULL, buf, len);
+}
+EXPORT_SYMBOL_GPL(sbefifo_drv_write);
+
+void sbefifo_drv_release(struct sbefifo_client *client)
+{
+ if (!client)
+ return;
+
+ sbefifo_put_client(client);
+}
+EXPORT_SYMBOL_GPL(sbefifo_drv_release);
+
+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_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];
u32 sts;
- int ret;
+ int ret, child_idx = 0;
sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
if (!sbefifo)
@@ -749,6 +834,18 @@ static int sbefifo_probe(struct device *dev)
list_add(&sbefifo->link, &sbefifo_fifos);
+ if (dev->of_node) {
+ /* create platform devs for dts child nodes (occ, etc) */
+ for_each_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(&sbefifo->fsi_dev->dev,
+ "failed to create child node dev\n");
+ }
+ }
+
return misc_register(&sbefifo->mdev);
}
@@ -762,6 +859,8 @@ static int sbefifo_remove(struct device *dev)
if (sbefifo->fsi_dev != fsi_dev)
continue;
+ device_for_each_child(dev, NULL, sbefifo_unregister_child);
+
misc_deregister(&sbefifo->mdev);
list_del(&sbefifo->link);
ida_simple_remove(&sbefifo_ida, sbefifo->idx);
diff --git a/include/linux/fsi-sbefifo.h b/include/linux/fsi-sbefifo.h
new file mode 100644
index 0000000..8e55891
--- /dev/null
+++ b/include/linux/fsi-sbefifo.h
@@ -0,0 +1,30 @@
+/*
+ * 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
+
+struct device;
+struct sbefifo_client;
+
+extern struct sbefifo_client *sbefifo_drv_open(struct device *dev,
+ unsigned long flags);
+extern int sbefifo_drv_read(struct sbefifo_client *client, char *buf,
+ size_t len);
+extern int sbefifo_drv_write(struct sbefifo_client *client, const char *buf,
+ size_t len);
+extern void sbefifo_drv_release(struct sbefifo_client *client);
+
+#endif /* LINUX_FSI_SBEFIFO_H */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [PATCH linux 2/4] drivers/fsi/sbefifo: Add in-kernel API
2017-06-21 19:37 ` [PATCH linux 2/4] drivers/fsi/sbefifo: Add in-kernel API Eddie James
@ 2017-06-24 11:17 ` kbuild test robot
0 siblings, 0 replies; 9+ messages in thread
From: kbuild test robot @ 2017-06-24 11:17 UTC (permalink / raw)
To: Eddie James
Cc: kbuild-all, linux-kernel, gregkh, devicetree, robh+dt,
mark.rutland, bradleyb, jk, cbostic, joel, andrew, eajames,
Edward A. James
[-- Attachment #1: Type: text/plain, Size: 1484 bytes --]
Hi Edward,
[auto build test ERROR on next-20170619]
[cannot apply to linux/master linus/master robh/for-next v4.12-rc6 v4.12-rc5 v4.12-rc4 v4.12-rc6]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Eddie-James/drivers-fsi-Add-SBEFIFO-and-OCC-drivers/20170623-160949
config: i386-randconfig-n0-06241643 (attached as .config)
compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All errors (new ones prefixed by >>):
drivers//fsi/fsi-sbefifo.c: In function 'sbefifo_unregister_child':
>> drivers//fsi/fsi-sbefifo.c:775:2: error: implicit declaration of function 'of_device_unregister' [-Werror=implicit-function-declaration]
of_device_unregister(child);
^~~~~~~~~~~~~~~~~~~~
cc1: some warnings being treated as errors
vim +/of_device_unregister +775 drivers//fsi/fsi-sbefifo.c
769 EXPORT_SYMBOL_GPL(sbefifo_drv_release);
770
771 static int sbefifo_unregister_child(struct device *dev, void *data)
772 {
773 struct platform_device *child = to_platform_device(dev);
774
> 775 of_device_unregister(child);
776 if (dev->of_node)
777 of_node_clear_flag(dev->of_node, OF_POPULATED);
778
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 28854 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH linux 3/4] drivers/fsi: Add On-Chip Controller (OCC) driver
2017-06-21 19:37 [PATCH linux 0/4] drivers/fsi: Add SBEFIFO and OCC drivers Eddie James
2017-06-21 19:37 ` [PATCH linux 1/4] drivers/fsi: Add SBEFIFO FSI client device driver Eddie James
2017-06-21 19:37 ` [PATCH linux 2/4] drivers/fsi/sbefifo: Add in-kernel API Eddie James
@ 2017-06-21 19:38 ` Eddie James
2017-06-23 9:10 ` kbuild test robot
2017-06-21 19:38 ` [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API Eddie James
3 siblings, 1 reply; 9+ messages in thread
From: Eddie James @ 2017-06-21 19:38 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, jk, cbostic,
joel, andrew, eajames, Edward A. James
From: "Edward A. James" <eajames@us.ibm.com>
The OCC is a device embedded on a POWER processor that collects and
aggregates sensor data from the processor and system. The OCC can
provide the raw sensor data as well as perform thermal and power
management on the system.
This driver provides an atomic communications channel between a service
processor (e.g. a BMC) and the OCC. The driver is dependent on the FSI
SBEFIFO driver to get hardware access through the SBE to the OCC SRAM.
Commands are issued to the SBE to send or fetch data to the SRAM.
The format of communications to the OCC is writing a command to SRAM,
followed by a sending a "doorbell" or attention to the OCC, followed by
reading the response from OCC. All of this takes place atomically so
that multiple users don't collide in the SRAM.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
.../devicetree/bindings/fsi/ibm,p9-occ.txt | 15 +
drivers/fsi/Kconfig | 10 +
drivers/fsi/Makefile | 1 +
drivers/fsi/occ.c | 692 +++++++++++++++++++++
4 files changed, 718 insertions(+)
create mode 100644 Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
create mode 100644 drivers/fsi/occ.c
diff --git a/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
new file mode 100644
index 0000000..88002b9
--- /dev/null
+++ b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
@@ -0,0 +1,15 @@
+Device-tree bindings for FSI-based On-Chip Controller driver
+------------------------------------------------------------
+
+Required properties:
+ - compatible = "ibm,p9-occ";
+
+Optional properties:
+ - reg = <processor index>; : index for the processor this OCC device is on
+
+Examples:
+
+ occ@1 {
+ compatible = "ibm,p9-occ";
+ reg = <1>;
+ };
diff --git a/drivers/fsi/Kconfig b/drivers/fsi/Kconfig
index 8c4d903..9d59276 100644
--- a/drivers/fsi/Kconfig
+++ b/drivers/fsi/Kconfig
@@ -40,6 +40,16 @@ config FSI_SBEFIFO
a pipe-like FSI device for communicating with the self boot engine
(SBE) on POWER processors.
+config OCCFIFO
+ tristate "OCC SBEFIFO client device driver"
+ depends on FSI_SBEFIFO
+ ---help---
+ This option enables an SBEFIFO based On-Chip Controller (OCC) device
+ driver. The OCC is a device embedded on a POWER processor that collects
+ and aggregates sensor data from the processor and system. The OCC can
+ provide the raw sensor data as well as perform thermal and power
+ management on the system.
+
endif
endmenu
diff --git a/drivers/fsi/Makefile b/drivers/fsi/Makefile
index 851182e..7f5ca61 100644
--- a/drivers/fsi/Makefile
+++ b/drivers/fsi/Makefile
@@ -4,3 +4,4 @@ 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
+obj-$(CONFIG_OCCFIFO) += occ.o
diff --git a/drivers/fsi/occ.c b/drivers/fsi/occ.c
new file mode 100644
index 0000000..a1e6e9b
--- /dev/null
+++ b/drivers/fsi/occ.c
@@ -0,0 +1,692 @@
+/*
+ * Copyright 2017 IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <asm/unaligned.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/fsi-sbefifo.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+
+#define OCC_SRAM_BYTES 4096
+#define OCC_CMD_DATA_BYTES 4090
+#define OCC_RESP_DATA_BYTES 4089
+
+struct occ {
+ struct device *sbefifo;
+ char name[32];
+ int idx;
+ struct miscdevice mdev;
+ struct list_head xfrs;
+ spinlock_t list_lock;
+ struct mutex occ_lock;
+ struct work_struct work;
+};
+
+#define to_occ(x) container_of((x), struct occ, mdev)
+
+struct occ_command {
+ u8 seq_no;
+ u8 cmd_type;
+ u16 data_length;
+ u8 data[OCC_CMD_DATA_BYTES];
+ u16 checksum;
+} __packed;
+
+struct occ_response {
+ u8 seq_no;
+ u8 cmd_type;
+ u8 return_status;
+ u16 data_length;
+ u8 data[OCC_RESP_DATA_BYTES];
+ u16 checksum;
+} __packed;
+
+/*
+ * transfer flags are NOT mutually exclusive
+ *
+ * Initial flags are none; transfer is created and queued from write(). All
+ * flags are cleared when the transfer is completed by closing the file or
+ * reading all of the available response data.
+ * XFR_IN_PROGRESS is set when a transfer is started from occ_worker_putsram,
+ * and cleared if the transfer fails or occ_worker_getsram completes.
+ * XFR_COMPLETE is set when a transfer fails or finishes occ_worker_getsram.
+ * XFR_CANCELED is set when the transfer's client is released.
+ * XFR_WAITING is set from read() if the transfer isn't complete and
+ * O_NONBLOCK wasn't specified. Cleared in read() when transfer completes or
+ * fails.
+ */
+enum {
+ XFR_IN_PROGRESS,
+ XFR_COMPLETE,
+ XFR_CANCELED,
+ XFR_WAITING,
+};
+
+struct occ_xfr {
+ struct list_head link;
+ int rc;
+ u8 buf[OCC_SRAM_BYTES];
+ size_t cmd_data_length;
+ size_t resp_data_length;
+ unsigned long flags;
+};
+
+/*
+ * client flags
+ *
+ * CLIENT_NONBLOCKING is set during open() if the file was opened with the
+ * O_NONBLOCK flag.
+ * CLIENT_XFR_PENDING is set during write() and cleared when all data has been
+ * read.
+ */
+enum {
+ CLIENT_NONBLOCKING,
+ CLIENT_XFR_PENDING,
+};
+
+struct occ_client {
+ struct occ *occ;
+ struct occ_xfr xfr;
+ spinlock_t lock;
+ wait_queue_head_t wait;
+ size_t read_offset;
+ unsigned long flags;
+};
+
+#define to_client(x) container_of((x), struct occ_client, xfr)
+
+static struct workqueue_struct *occ_wq;
+
+static DEFINE_IDA(occ_ida);
+
+static void occ_enqueue_xfr(struct occ_xfr *xfr)
+{
+ int empty;
+ struct occ_client *client = to_client(xfr);
+ struct occ *occ = client->occ;
+
+ spin_lock_irq(&occ->list_lock);
+ empty = list_empty(&occ->xfrs);
+ list_add_tail(&xfr->link, &occ->xfrs);
+ spin_unlock(&occ->list_lock);
+
+ if (empty)
+ queue_work(occ_wq, &occ->work);
+}
+
+static int occ_open(struct inode *inode, struct file *file)
+{
+ struct miscdevice *mdev = file->private_data;
+ struct occ *occ = to_occ(mdev);
+ struct occ_client *client = kzalloc(sizeof(*client), GFP_KERNEL);
+
+ if (!client)
+ return -ENOMEM;
+
+ client->occ = occ;
+ spin_lock_init(&client->lock);
+ init_waitqueue_head(&client->wait);
+
+ if (file->f_flags & O_NONBLOCK)
+ set_bit(CLIENT_NONBLOCKING, &client->flags);
+
+ file->private_data = client;
+
+ return 0;
+}
+
+static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
+ loff_t *offset)
+{
+ int rc;
+ size_t bytes;
+ struct occ_client *client = file->private_data;
+ struct occ_xfr *xfr = &client->xfr;
+
+ if (len > OCC_SRAM_BYTES)
+ return -EINVAL;
+
+ spin_lock_irq(&client->lock);
+ if (!test_bit(CLIENT_XFR_PENDING, &client->flags)) {
+ /* we just finished reading all data, return 0 */
+ if (client->read_offset) {
+ rc = 0;
+ client->read_offset = 0;
+ } else
+ rc = -ENOMSG;
+
+ goto done;
+ }
+
+ if (!test_bit(XFR_COMPLETE, &xfr->flags)) {
+ if (test_bit(CLIENT_NONBLOCKING, &client->flags)) {
+ rc = -EAGAIN;
+ goto done;
+ }
+
+ set_bit(XFR_WAITING, &xfr->flags);
+ spin_unlock(&client->lock);
+
+ rc = wait_event_interruptible(client->wait,
+ test_bit(XFR_COMPLETE, &xfr->flags) ||
+ test_bit(XFR_CANCELED, &xfr->flags));
+
+ spin_lock_irq(&client->lock);
+ if (test_bit(XFR_CANCELED, &xfr->flags)) {
+ spin_unlock(&client->lock);
+ kfree(client);
+ return -EBADFD;
+ }
+
+ clear_bit(XFR_WAITING, &xfr->flags);
+ if (!test_bit(XFR_COMPLETE, &xfr->flags)) {
+ rc = -EINTR;
+ goto done;
+ }
+ }
+
+ if (xfr->rc) {
+ rc = xfr->rc;
+ goto done;
+ }
+
+ if (copy_to_user(buf, &xfr->buf[client->read_offset], bytes)) {
+ rc = -EFAULT;
+ goto done;
+ }
+
+ client->read_offset += bytes;
+
+ /* xfr done */
+ if (client->read_offset == xfr->resp_data_length)
+ clear_bit(CLIENT_XFR_PENDING, &client->flags);
+
+ rc = bytes;
+
+done:
+ spin_unlock(&client->lock);
+ return rc;
+}
+
+static ssize_t occ_write(struct file *file, const char __user *buf,
+ size_t len, loff_t *offset)
+{
+ int rc;
+ unsigned int i;
+ u16 data_length, checksum = 0;
+ struct occ_client *client = file->private_data;
+ struct occ_xfr *xfr = &client->xfr;
+
+ if (len > (OCC_CMD_DATA_BYTES + 3) || len < 3)
+ return -EINVAL;
+
+ spin_lock_irq(&client->lock);
+
+ if (test_bit(CLIENT_XFR_PENDING, &client->flags)) {
+ rc = -EBUSY;
+ goto done;
+ }
+
+ memset(xfr, 0, sizeof(*xfr)); /* clear out the transfer */
+ xfr->buf[0] = 1; /* occ sequence number */
+
+ /* Assume user data follows the occ command format.
+ * byte 0: command type
+ * bytes 1-2: data length (msb first)
+ * bytes 3-n: data
+ */
+ if (copy_from_user(&xfr->buf[1], buf, len)) {
+ rc = -EFAULT;
+ goto done;
+ }
+
+ data_length = (xfr->buf[2] << 8) + xfr->buf[3];
+ if (data_length > OCC_CMD_DATA_BYTES) {
+ rc = -EINVAL;
+ goto done;
+ }
+
+ for (i = 0; i < data_length + 4; ++i)
+ checksum += xfr->buf[i];
+
+ xfr->buf[data_length + 4] = checksum >> 8;
+ xfr->buf[data_length + 5] = checksum & 0xFF;
+
+ xfr->cmd_data_length = data_length + 6;
+ client->read_offset = 0;
+ set_bit(CLIENT_XFR_PENDING, &client->flags);
+ occ_enqueue_xfr(xfr);
+
+ rc = len;
+
+done:
+ spin_unlock(&client->lock);
+ return rc;
+}
+
+static int occ_release(struct inode *inode, struct file *file)
+{
+ struct occ_client *client = file->private_data;
+ struct occ_xfr *xfr = &client->xfr;
+ struct occ *occ = client->occ;
+
+ spin_lock_irq(&client->lock);
+ if (!test_bit(CLIENT_XFR_PENDING, &client->flags)) {
+ spin_unlock(&client->lock);
+ kfree(client);
+ return 0;
+ }
+
+ spin_lock_irq(&occ->list_lock);
+ set_bit(XFR_CANCELED, &xfr->flags);
+ if (!test_bit(XFR_IN_PROGRESS, &xfr->flags)) {
+ /* already deleted from list if complete */
+ if (!test_bit(XFR_COMPLETE, &xfr->flags))
+ list_del(&xfr->link);
+
+ spin_unlock(&occ->list_lock);
+
+ if (test_bit(XFR_WAITING, &xfr->flags)) {
+ /* blocking read; let reader clean up */
+ wake_up_interruptible(&client->wait);
+ spin_unlock(&client->lock);
+ return 0;
+ }
+
+ spin_unlock(&client->lock);
+ kfree(client);
+ return 0;
+ }
+
+ /* operation is in progress; let worker clean up*/
+ spin_unlock(&occ->list_lock);
+ spin_unlock(&client->lock);
+ return 0;
+}
+
+static const struct file_operations occ_fops = {
+ .owner = THIS_MODULE,
+ .open = occ_open,
+ .read = occ_read,
+ .write = occ_write,
+ .release = occ_release,
+};
+
+static int occ_write_sbefifo(struct sbefifo_client *client, const char *buf,
+ ssize_t len)
+{
+ int rc;
+ ssize_t total = 0;
+
+ do {
+ rc = sbefifo_drv_write(client, &buf[total], len - total);
+ if (rc < 0)
+ return rc;
+ else if (!rc)
+ break;
+
+ total += rc;
+ } while (total < len);
+
+ return (total == len) ? 0 : -EMSGSIZE;
+}
+
+static int occ_read_sbefifo(struct sbefifo_client *client, char *buf,
+ ssize_t len)
+{
+ int rc;
+ ssize_t total = 0;
+
+ do {
+ rc = sbefifo_drv_read(client, &buf[total], len - total);
+ if (rc < 0)
+ return rc;
+ else if (!rc)
+ break;
+
+ total += rc;
+ } while (total < len);
+
+ return (total == len) ? 0 : -EMSGSIZE;
+}
+
+static int occ_getsram(struct device *sbefifo, u32 address, u8 *data,
+ ssize_t len)
+{
+ int rc;
+ u8 *resp;
+ __be32 buf[5];
+ u32 data_len = ((len + 7) / 8) * 8; /* must be multiples of 8 B */
+ struct sbefifo_client *client;
+
+ /* Magic sequence to do SBE getsram command. SBE will fetch data from
+ * specified SRAM address.
+ */
+ buf[0] = cpu_to_be32(0x5);
+ buf[1] = cpu_to_be32(0xa403);
+ buf[2] = cpu_to_be32(1);
+ buf[3] = cpu_to_be32(address);
+ buf[4] = cpu_to_be32(data_len);
+
+ client = sbefifo_drv_open(sbefifo, 0);
+ if (!client)
+ return -ENODEV;
+
+ rc = occ_write_sbefifo(client, (const char *)buf, sizeof(buf));
+ if (rc)
+ goto done;
+
+ resp = kzalloc(data_len, GFP_KERNEL);
+ if (!resp) {
+ rc = -ENOMEM;
+ goto done;
+ }
+
+ rc = occ_read_sbefifo(client, (char *)resp, data_len);
+ if (rc)
+ goto free;
+
+ /* check for good response */
+ rc = occ_read_sbefifo(client, (char *)buf, 8);
+ if (rc)
+ goto free;
+
+ if ((be32_to_cpu(buf[0]) == data_len) &&
+ (be32_to_cpu(buf[1]) == 0xC0DEA403))
+ memcpy(data, resp, len);
+ else
+ rc = -EFAULT;
+
+free:
+ kfree(resp);
+
+done:
+ sbefifo_drv_release(client);
+ return rc;
+}
+
+static int occ_putsram(struct device *sbefifo, u32 address, u8 *data,
+ ssize_t len)
+{
+ int rc;
+ __be32 *buf;
+ u32 data_len = ((len + 7) / 8) * 8; /* must be multiples of 8 B */
+ size_t cmd_len = data_len + 20;
+ struct sbefifo_client *client;
+
+ buf = kzalloc(cmd_len, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ /* Magic sequence to do SBE putsram command. SBE will transfer
+ * data to specified SRAM address.
+ */
+ buf[0] = cpu_to_be32(0x5 + (data_len / 4));
+ buf[1] = cpu_to_be32(0xa404);
+ buf[2] = cpu_to_be32(1);
+ buf[3] = cpu_to_be32(address);
+ buf[4] = cpu_to_be32(data_len);
+
+ memcpy(&buf[5], data, len);
+
+ client = sbefifo_drv_open(sbefifo, 0);
+ if (!client) {
+ rc = -ENODEV;
+ goto free;
+ }
+
+ rc = occ_write_sbefifo(client, (const char *)buf, cmd_len);
+ if (rc)
+ goto done;
+
+ rc = occ_read_sbefifo(client, (char *)buf, 8);
+ if (rc)
+ goto done;
+
+ /* check for good response */
+ if ((be32_to_cpu(buf[0]) != data_len) ||
+ (be32_to_cpu(buf[1]) != 0xC0DEA404))
+ rc = -EFAULT;
+
+done:
+ sbefifo_drv_release(client);
+free:
+ kfree(buf);
+ return rc;
+}
+
+static int occ_trigger_attn(struct device *sbefifo)
+{
+ int rc;
+ __be32 buf[6];
+ struct sbefifo_client *client;
+
+ /* Magic sequence to do SBE putscom command. SBE will write 8 bytes to
+ * specified SCOM address.
+ */
+ buf[0] = cpu_to_be32(0x6);
+ buf[1] = cpu_to_be32(0xa202);
+ buf[2] = 0;
+ buf[3] = cpu_to_be32(0x6D035);
+ buf[4] = cpu_to_be32(0x20010000); /* trigger occ attention */
+ buf[5] = 0;
+
+ client = sbefifo_drv_open(sbefifo, 0);
+ if (!client)
+ return -ENODEV;
+
+ rc = occ_write_sbefifo(client, (const char *)buf, sizeof(buf));
+ if (rc)
+ goto done;
+
+ rc = occ_read_sbefifo(client, (char *)buf, 8);
+ if (rc)
+ goto done;
+
+ /* check for good response */
+ if ((be32_to_cpu(buf[0]) != 0xC0DEA202) ||
+ (be32_to_cpu(buf[1]) & 0x0FFFFFFF))
+ rc = -EFAULT;
+
+done:
+ sbefifo_drv_release(client);
+
+ return rc;
+}
+
+static void occ_worker(struct work_struct *work)
+{
+ int rc = 0, empty, waiting, canceled;
+ u16 resp_data_length;
+ struct occ_xfr *xfr;
+ struct occ_client *client;
+ struct occ *occ = container_of(work, struct occ, work);
+ struct device *sbefifo = occ->sbefifo;
+
+again:
+ spin_lock_irq(&occ->list_lock);
+ xfr = list_first_entry(&occ->xfrs, struct occ_xfr, link);
+ if (!xfr) {
+ spin_unlock(&occ->list_lock);
+ return;
+ }
+
+ set_bit(XFR_IN_PROGRESS, &xfr->flags);
+
+ spin_unlock(&occ->list_lock);
+ mutex_lock(&occ->occ_lock);
+
+ /* write occ command */
+ rc = occ_putsram(sbefifo, 0xFFFBE000, xfr->buf,
+ xfr->cmd_data_length);
+ if (rc)
+ goto done;
+
+ rc = occ_trigger_attn(sbefifo);
+ if (rc)
+ goto done;
+
+ /* read occ response */
+ rc = occ_getsram(sbefifo, 0xFFFBF000, xfr->buf, 8);
+ if (rc)
+ goto done;
+
+ resp_data_length = (xfr->buf[3] << 8) + xfr->buf[4];
+ if (resp_data_length > OCC_RESP_DATA_BYTES) {
+ rc = -EDOM;
+ goto done;
+ }
+
+ if (resp_data_length > 1) {
+ /* already got 3 bytes resp, also need 2 bytes checksum */
+ rc = occ_getsram(sbefifo, 0xFFFBF008, &xfr->buf[8],
+ resp_data_length - 1);
+ if (rc)
+ goto done;
+ }
+
+ xfr->resp_data_length = resp_data_length + 7;
+
+done:
+ mutex_unlock(&occ->occ_lock);
+
+ xfr->rc = rc;
+ client = to_client(xfr);
+
+ /* lock client to prevent race with read() */
+ spin_lock_irq(&client->lock);
+ set_bit(XFR_COMPLETE, &xfr->flags);
+ waiting = test_bit(XFR_WAITING, &xfr->flags);
+ spin_unlock(&client->lock);
+
+ spin_lock_irq(&occ->list_lock);
+ clear_bit(XFR_IN_PROGRESS, &xfr->flags);
+ list_del(&xfr->link);
+ empty = list_empty(&occ->xfrs);
+ canceled = test_bit(XFR_CANCELED, &xfr->flags);
+ spin_unlock(&occ->list_lock);
+
+ if (waiting)
+ wake_up_interruptible(&client->wait);
+ else if (canceled)
+ kfree(client);
+
+ if (!empty)
+ goto again;
+}
+
+static int occ_probe(struct platform_device *pdev)
+{
+ int rc;
+ u32 reg;
+ struct occ *occ;
+ struct device *dev = &pdev->dev;
+
+ occ = devm_kzalloc(dev, sizeof(*occ), GFP_KERNEL);
+ if (!occ)
+ return -ENOMEM;
+
+ occ->sbefifo = dev->parent;
+ INIT_LIST_HEAD(&occ->xfrs);
+ spin_lock_init(&occ->list_lock);
+ mutex_init(&occ->occ_lock);
+ INIT_WORK(&occ->work, occ_worker);
+
+ if (dev->of_node) {
+ rc = of_property_read_u32(dev->of_node, "reg", ®);
+ if (!rc) {
+ /* make sure we don't have a duplicate from dts */
+ occ->idx = ida_simple_get(&occ_ida, reg, reg + 1,
+ GFP_KERNEL);
+ if (occ->idx < 0)
+ occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX,
+ GFP_KERNEL);
+ } else
+ occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX,
+ GFP_KERNEL);
+ } else
+ occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX, GFP_KERNEL);
+
+ platform_set_drvdata(pdev, occ);
+
+ snprintf(occ->name, sizeof(occ->name), "occ%d", occ->idx);
+ occ->mdev.fops = &occ_fops;
+ occ->mdev.minor = MISC_DYNAMIC_MINOR;
+ occ->mdev.name = occ->name;
+ occ->mdev.parent = dev;
+
+ rc = misc_register(&occ->mdev);
+ if (rc) {
+ dev_err(dev, "failed to register miscdevice\n");
+ return rc;
+ }
+
+ return 0;
+}
+
+static int occ_remove(struct platform_device *pdev)
+{
+ struct occ *occ = platform_get_drvdata(pdev);
+
+ flush_work(&occ->work);
+ misc_deregister(&occ->mdev);
+ ida_simple_remove(&occ_ida, occ->idx);
+
+ return 0;
+}
+
+static const struct of_device_id occ_match[] = {
+ { .compatible = "ibm,p9-occ" },
+ { },
+};
+
+static struct platform_driver occ_driver = {
+ .driver = {
+ .name = "occ",
+ .of_match_table = occ_match,
+ },
+ .probe = occ_probe,
+ .remove = occ_remove,
+};
+
+static int occ_init(void)
+{
+ occ_wq = create_singlethread_workqueue("occ");
+ if (!occ_wq)
+ return -ENOMEM;
+
+ return platform_driver_register(&occ_driver);
+}
+
+static void occ_exit(void)
+{
+ destroy_workqueue(occ_wq);
+
+ platform_driver_unregister(&occ_driver);
+
+ ida_destroy(&occ_ida);
+}
+
+module_init(occ_init);
+module_exit(occ_exit);
+
+MODULE_AUTHOR("Eddie James <eajames@us.ibm.com>");
+MODULE_DESCRIPTION("BMC P9 OCC driver");
+MODULE_LICENSE("GPL");
--
1.8.3.1
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [PATCH linux 3/4] drivers/fsi: Add On-Chip Controller (OCC) driver
2017-06-21 19:38 ` [PATCH linux 3/4] drivers/fsi: Add On-Chip Controller (OCC) driver Eddie James
@ 2017-06-23 9:10 ` kbuild test robot
0 siblings, 0 replies; 9+ messages in thread
From: kbuild test robot @ 2017-06-23 9:10 UTC (permalink / raw)
To: Eddie James
Cc: kbuild-all, linux-kernel, gregkh, devicetree, robh+dt,
mark.rutland, bradleyb, jk, cbostic, joel, andrew, eajames,
Edward A. James
[-- Attachment #1: Type: text/plain, Size: 13957 bytes --]
Hi Edward,
[auto build test ERROR on next-20170619]
[cannot apply to linux/master linus/master robh/for-next v4.12-rc6 v4.12-rc5 v4.12-rc4 v4.12-rc6]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Eddie-James/drivers-fsi-Add-SBEFIFO-and-OCC-drivers/20170623-160949
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gnu-gcc (Debian 6.3.0-18) 6.3.0 20170516
reproduce:
wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
make.cross ARCH=sh
All error/warnings (new ones prefixed by >>):
drivers//fsi/occ.c: In function 'occ_open':
>> drivers//fsi/occ.c:136:32: error: dereferencing pointer to incomplete type 'struct file'
struct miscdevice *mdev = file->private_data;
^~
>> drivers//fsi/occ.c:147:22: error: 'O_NONBLOCK' undeclared (first use in this function)
if (file->f_flags & O_NONBLOCK)
^~~~~~~~~~
drivers//fsi/occ.c:147:22: note: each undeclared identifier is reported only once for each function it appears in
drivers//fsi/occ.c: At top level:
>> drivers//fsi/occ.c:324:21: error: variable 'occ_fops' has initializer but incomplete type
static const struct file_operations occ_fops = {
^~~~~~~~~~~~~~~
>> drivers//fsi/occ.c:325:2: error: unknown field 'owner' specified in initializer
.owner = THIS_MODULE,
^
In file included from include/linux/linkage.h:6:0,
from include/linux/kernel.h:6,
from include/linux/unaligned/packed_struct.h:4,
from include/linux/unaligned/le_struct.h:4,
from include/asm-generic/unaligned.h:17,
from arch/sh/include/asm/unaligned.h:9,
from drivers//fsi/occ.c:10:
include/linux/export.h:35:21: warning: excess elements in struct initializer
#define THIS_MODULE (&__this_module)
^
>> drivers//fsi/occ.c:325:11: note: in expansion of macro 'THIS_MODULE'
.owner = THIS_MODULE,
^~~~~~~~~~~
include/linux/export.h:35:21: note: (near initialization for 'occ_fops')
#define THIS_MODULE (&__this_module)
^
>> drivers//fsi/occ.c:325:11: note: in expansion of macro 'THIS_MODULE'
.owner = THIS_MODULE,
^~~~~~~~~~~
>> drivers//fsi/occ.c:326:2: error: unknown field 'open' specified in initializer
.open = occ_open,
^
>> drivers//fsi/occ.c:326:10: warning: excess elements in struct initializer
.open = occ_open,
^~~~~~~~
drivers//fsi/occ.c:326:10: note: (near initialization for 'occ_fops')
>> drivers//fsi/occ.c:327:2: error: unknown field 'read' specified in initializer
.read = occ_read,
^
drivers//fsi/occ.c:327:10: warning: excess elements in struct initializer
.read = occ_read,
^~~~~~~~
drivers//fsi/occ.c:327:10: note: (near initialization for 'occ_fops')
>> drivers//fsi/occ.c:328:2: error: unknown field 'write' specified in initializer
.write = occ_write,
^
drivers//fsi/occ.c:328:11: warning: excess elements in struct initializer
.write = occ_write,
^~~~~~~~~
drivers//fsi/occ.c:328:11: note: (near initialization for 'occ_fops')
>> drivers//fsi/occ.c:329:2: error: unknown field 'release' specified in initializer
.release = occ_release,
^
drivers//fsi/occ.c:329:13: warning: excess elements in struct initializer
.release = occ_release,
^~~~~~~~~~~
drivers//fsi/occ.c:329:13: note: (near initialization for 'occ_fops')
>> drivers//fsi/occ.c:324:37: error: storage size of 'occ_fops' isn't known
static const struct file_operations occ_fops = {
^~~~~~~~
vim +/O_NONBLOCK +147 drivers//fsi/occ.c
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
> 10 #include <asm/unaligned.h>
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/fsi-sbefifo.h>
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/miscdevice.h>
17 #include <linux/module.h>
18 #include <linux/mutex.h>
19 #include <linux/of.h>
20 #include <linux/of_platform.h>
21 #include <linux/platform_device.h>
22 #include <linux/slab.h>
23 #include <linux/uaccess.h>
24 #include <linux/wait.h>
25 #include <linux/workqueue.h>
26
27 #define OCC_SRAM_BYTES 4096
28 #define OCC_CMD_DATA_BYTES 4090
29 #define OCC_RESP_DATA_BYTES 4089
30
31 struct occ {
32 struct device *sbefifo;
33 char name[32];
34 int idx;
35 struct miscdevice mdev;
36 struct list_head xfrs;
37 spinlock_t list_lock;
38 struct mutex occ_lock;
39 struct work_struct work;
40 };
41
42 #define to_occ(x) container_of((x), struct occ, mdev)
43
44 struct occ_command {
45 u8 seq_no;
46 u8 cmd_type;
47 u16 data_length;
48 u8 data[OCC_CMD_DATA_BYTES];
49 u16 checksum;
50 } __packed;
51
52 struct occ_response {
53 u8 seq_no;
54 u8 cmd_type;
55 u8 return_status;
56 u16 data_length;
57 u8 data[OCC_RESP_DATA_BYTES];
58 u16 checksum;
59 } __packed;
60
61 /*
62 * transfer flags are NOT mutually exclusive
63 *
64 * Initial flags are none; transfer is created and queued from write(). All
65 * flags are cleared when the transfer is completed by closing the file or
66 * reading all of the available response data.
67 * XFR_IN_PROGRESS is set when a transfer is started from occ_worker_putsram,
68 * and cleared if the transfer fails or occ_worker_getsram completes.
69 * XFR_COMPLETE is set when a transfer fails or finishes occ_worker_getsram.
70 * XFR_CANCELED is set when the transfer's client is released.
71 * XFR_WAITING is set from read() if the transfer isn't complete and
72 * O_NONBLOCK wasn't specified. Cleared in read() when transfer completes or
73 * fails.
74 */
75 enum {
76 XFR_IN_PROGRESS,
77 XFR_COMPLETE,
78 XFR_CANCELED,
79 XFR_WAITING,
80 };
81
82 struct occ_xfr {
83 struct list_head link;
84 int rc;
85 u8 buf[OCC_SRAM_BYTES];
86 size_t cmd_data_length;
87 size_t resp_data_length;
88 unsigned long flags;
89 };
90
91 /*
92 * client flags
93 *
94 * CLIENT_NONBLOCKING is set during open() if the file was opened with the
95 * O_NONBLOCK flag.
96 * CLIENT_XFR_PENDING is set during write() and cleared when all data has been
97 * read.
98 */
99 enum {
100 CLIENT_NONBLOCKING,
101 CLIENT_XFR_PENDING,
102 };
103
104 struct occ_client {
105 struct occ *occ;
106 struct occ_xfr xfr;
107 spinlock_t lock;
108 wait_queue_head_t wait;
109 size_t read_offset;
110 unsigned long flags;
111 };
112
113 #define to_client(x) container_of((x), struct occ_client, xfr)
114
115 static struct workqueue_struct *occ_wq;
116
117 static DEFINE_IDA(occ_ida);
118
119 static void occ_enqueue_xfr(struct occ_xfr *xfr)
120 {
121 int empty;
122 struct occ_client *client = to_client(xfr);
123 struct occ *occ = client->occ;
124
125 spin_lock_irq(&occ->list_lock);
126 empty = list_empty(&occ->xfrs);
127 list_add_tail(&xfr->link, &occ->xfrs);
128 spin_unlock(&occ->list_lock);
129
130 if (empty)
131 queue_work(occ_wq, &occ->work);
132 }
133
134 static int occ_open(struct inode *inode, struct file *file)
135 {
> 136 struct miscdevice *mdev = file->private_data;
137 struct occ *occ = to_occ(mdev);
138 struct occ_client *client = kzalloc(sizeof(*client), GFP_KERNEL);
139
140 if (!client)
141 return -ENOMEM;
142
143 client->occ = occ;
144 spin_lock_init(&client->lock);
145 init_waitqueue_head(&client->wait);
146
> 147 if (file->f_flags & O_NONBLOCK)
148 set_bit(CLIENT_NONBLOCKING, &client->flags);
149
150 file->private_data = client;
151
152 return 0;
153 }
154
155 static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
156 loff_t *offset)
157 {
158 int rc;
159 size_t bytes;
160 struct occ_client *client = file->private_data;
161 struct occ_xfr *xfr = &client->xfr;
162
163 if (len > OCC_SRAM_BYTES)
164 return -EINVAL;
165
166 spin_lock_irq(&client->lock);
167 if (!test_bit(CLIENT_XFR_PENDING, &client->flags)) {
168 /* we just finished reading all data, return 0 */
169 if (client->read_offset) {
170 rc = 0;
171 client->read_offset = 0;
172 } else
173 rc = -ENOMSG;
174
175 goto done;
176 }
177
178 if (!test_bit(XFR_COMPLETE, &xfr->flags)) {
179 if (test_bit(CLIENT_NONBLOCKING, &client->flags)) {
180 rc = -EAGAIN;
181 goto done;
182 }
183
184 set_bit(XFR_WAITING, &xfr->flags);
185 spin_unlock(&client->lock);
186
187 rc = wait_event_interruptible(client->wait,
188 test_bit(XFR_COMPLETE, &xfr->flags) ||
189 test_bit(XFR_CANCELED, &xfr->flags));
190
191 spin_lock_irq(&client->lock);
192 if (test_bit(XFR_CANCELED, &xfr->flags)) {
193 spin_unlock(&client->lock);
194 kfree(client);
195 return -EBADFD;
196 }
197
198 clear_bit(XFR_WAITING, &xfr->flags);
199 if (!test_bit(XFR_COMPLETE, &xfr->flags)) {
200 rc = -EINTR;
201 goto done;
202 }
203 }
204
205 if (xfr->rc) {
206 rc = xfr->rc;
207 goto done;
208 }
209
210 if (copy_to_user(buf, &xfr->buf[client->read_offset], bytes)) {
211 rc = -EFAULT;
212 goto done;
213 }
214
215 client->read_offset += bytes;
216
217 /* xfr done */
218 if (client->read_offset == xfr->resp_data_length)
219 clear_bit(CLIENT_XFR_PENDING, &client->flags);
220
221 rc = bytes;
222
223 done:
224 spin_unlock(&client->lock);
225 return rc;
226 }
227
228 static ssize_t occ_write(struct file *file, const char __user *buf,
229 size_t len, loff_t *offset)
230 {
231 int rc;
232 unsigned int i;
233 u16 data_length, checksum = 0;
234 struct occ_client *client = file->private_data;
235 struct occ_xfr *xfr = &client->xfr;
236
237 if (len > (OCC_CMD_DATA_BYTES + 3) || len < 3)
238 return -EINVAL;
239
240 spin_lock_irq(&client->lock);
241
242 if (test_bit(CLIENT_XFR_PENDING, &client->flags)) {
243 rc = -EBUSY;
244 goto done;
245 }
246
247 memset(xfr, 0, sizeof(*xfr)); /* clear out the transfer */
248 xfr->buf[0] = 1; /* occ sequence number */
249
250 /* Assume user data follows the occ command format.
251 * byte 0: command type
252 * bytes 1-2: data length (msb first)
253 * bytes 3-n: data
254 */
255 if (copy_from_user(&xfr->buf[1], buf, len)) {
256 rc = -EFAULT;
257 goto done;
258 }
259
260 data_length = (xfr->buf[2] << 8) + xfr->buf[3];
261 if (data_length > OCC_CMD_DATA_BYTES) {
262 rc = -EINVAL;
263 goto done;
264 }
265
266 for (i = 0; i < data_length + 4; ++i)
267 checksum += xfr->buf[i];
268
269 xfr->buf[data_length + 4] = checksum >> 8;
270 xfr->buf[data_length + 5] = checksum & 0xFF;
271
272 xfr->cmd_data_length = data_length + 6;
273 client->read_offset = 0;
274 set_bit(CLIENT_XFR_PENDING, &client->flags);
275 occ_enqueue_xfr(xfr);
276
277 rc = len;
278
279 done:
280 spin_unlock(&client->lock);
281 return rc;
282 }
283
284 static int occ_release(struct inode *inode, struct file *file)
285 {
286 struct occ_client *client = file->private_data;
287 struct occ_xfr *xfr = &client->xfr;
288 struct occ *occ = client->occ;
289
290 spin_lock_irq(&client->lock);
291 if (!test_bit(CLIENT_XFR_PENDING, &client->flags)) {
292 spin_unlock(&client->lock);
293 kfree(client);
294 return 0;
295 }
296
297 spin_lock_irq(&occ->list_lock);
298 set_bit(XFR_CANCELED, &xfr->flags);
299 if (!test_bit(XFR_IN_PROGRESS, &xfr->flags)) {
300 /* already deleted from list if complete */
301 if (!test_bit(XFR_COMPLETE, &xfr->flags))
302 list_del(&xfr->link);
303
304 spin_unlock(&occ->list_lock);
305
306 if (test_bit(XFR_WAITING, &xfr->flags)) {
307 /* blocking read; let reader clean up */
308 wake_up_interruptible(&client->wait);
309 spin_unlock(&client->lock);
310 return 0;
311 }
312
313 spin_unlock(&client->lock);
314 kfree(client);
315 return 0;
316 }
317
318 /* operation is in progress; let worker clean up*/
319 spin_unlock(&occ->list_lock);
320 spin_unlock(&client->lock);
321 return 0;
322 }
323
> 324 static const struct file_operations occ_fops = {
> 325 .owner = THIS_MODULE,
> 326 .open = occ_open,
> 327 .read = occ_read,
> 328 .write = occ_write,
> 329 .release = occ_release,
330 };
331
332 static int occ_write_sbefifo(struct sbefifo_client *client, const char *buf,
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 45711 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API
2017-06-21 19:37 [PATCH linux 0/4] drivers/fsi: Add SBEFIFO and OCC drivers Eddie James
` (2 preceding siblings ...)
2017-06-21 19:38 ` [PATCH linux 3/4] drivers/fsi: Add On-Chip Controller (OCC) driver Eddie James
@ 2017-06-21 19:38 ` Eddie James
2017-06-24 12:12 ` kbuild test robot
2017-06-26 18:35 ` Rob Herring
3 siblings, 2 replies; 9+ messages in thread
From: Eddie James @ 2017-06-21 19:38 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, jk, cbostic,
joel, andrew, eajames, Edward A. James
From: "Edward A. James" <eajames@us.ibm.com>
Add an in-kernel read/write API with exported functions. This is
necessary for other drivers which want to directly interact with the
OCC. Also parse the OCC device tree node for child nodes and create
child platform devices accordingly.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
.../devicetree/bindings/fsi/ibm,p9-occ.txt | 8 ++
drivers/fsi/occ.c | 140 +++++++++++++++++----
include/linux/occ.h | 27 ++++
3 files changed, 154 insertions(+), 21 deletions(-)
create mode 100644 include/linux/occ.h
diff --git a/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
index 88002b9..71afba3 100644
--- a/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
+++ b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
@@ -6,10 +6,18 @@ Required properties:
Optional properties:
- reg = <processor index>; : index for the processor this OCC device is on
+ - <child nodes> : Drivers for devices which communicate with
+ this OCC. Child nodes have no required or
+ optional properties that the OCC driver will
+ use.
Examples:
occ@1 {
compatible = "ibm,p9-occ";
reg = <1>;
+
+ occ-hwmon@1 {
+ compatible = "ibm,p9-occ-hwmon";
+ };
};
diff --git a/drivers/fsi/occ.c b/drivers/fsi/occ.c
index a1e6e9b..c964d9e 100644
--- a/drivers/fsi/occ.c
+++ b/drivers/fsi/occ.c
@@ -16,6 +16,7 @@
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
+#include <linux/occ.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
@@ -131,33 +132,43 @@ static void occ_enqueue_xfr(struct occ_xfr *xfr)
queue_work(occ_wq, &occ->work);
}
-static int occ_open(struct inode *inode, struct file *file)
+static struct occ_client *occ_open_common(struct occ *occ, unsigned long flags)
{
- struct miscdevice *mdev = file->private_data;
- struct occ *occ = to_occ(mdev);
struct occ_client *client = kzalloc(sizeof(*client), GFP_KERNEL);
if (!client)
- return -ENOMEM;
+ return NULL;
client->occ = occ;
spin_lock_init(&client->lock);
init_waitqueue_head(&client->wait);
- if (file->f_flags & O_NONBLOCK)
+ if (flags & O_NONBLOCK)
set_bit(CLIENT_NONBLOCKING, &client->flags);
+ return client;
+}
+
+static int occ_open(struct inode *inode, struct file *file)
+{
+ struct occ_client *client;
+ struct miscdevice *mdev = file->private_data;
+ struct occ *occ = to_occ(mdev);
+
+ client = occ_open_common(occ, file->f_flags);
+ if (!client)
+ return -ENOMEM;
+
file->private_data = client;
return 0;
}
-static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
- loff_t *offset)
+static ssize_t occ_read_common(struct occ_client *client, char __user *ubuf,
+ char *kbuf, size_t len)
{
int rc;
size_t bytes;
- struct occ_client *client = file->private_data;
struct occ_xfr *xfr = &client->xfr;
if (len > OCC_SRAM_BYTES)
@@ -207,10 +218,15 @@ static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
goto done;
}
- if (copy_to_user(buf, &xfr->buf[client->read_offset], bytes)) {
- rc = -EFAULT;
- goto done;
- }
+ bytes = min(len, xfr->resp_data_length - client->read_offset);
+ if (ubuf) {
+ if (copy_to_user(ubuf, &xfr->buf[client->read_offset],
+ bytes)) {
+ rc = -EFAULT;
+ goto done;
+ }
+ } else
+ memcpy(kbuf, &xfr->buf[client->read_offset], bytes);
client->read_offset += bytes;
@@ -225,13 +241,21 @@ static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
return rc;
}
-static ssize_t occ_write(struct file *file, const char __user *buf,
- size_t len, loff_t *offset)
+static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
+ loff_t *offset)
+{
+ struct occ_client *client = file->private_data;
+
+ return occ_read_common(client, buf, NULL, len);
+}
+
+static ssize_t occ_write_common(struct occ_client *client,
+ const char __user *ubuf, const char *kbuf,
+ size_t len)
{
int rc;
unsigned int i;
u16 data_length, checksum = 0;
- struct occ_client *client = file->private_data;
struct occ_xfr *xfr = &client->xfr;
if (len > (OCC_CMD_DATA_BYTES + 3) || len < 3)
@@ -252,10 +276,13 @@ static ssize_t occ_write(struct file *file, const char __user *buf,
* bytes 1-2: data length (msb first)
* bytes 3-n: data
*/
- if (copy_from_user(&xfr->buf[1], buf, len)) {
- rc = -EFAULT;
- goto done;
- }
+ if (ubuf) {
+ if (copy_from_user(&xfr->buf[1], ubuf, len)) {
+ rc = -EFAULT;
+ goto done;
+ }
+ } else
+ memcpy(&xfr->buf[1], kbuf, len);
data_length = (xfr->buf[2] << 8) + xfr->buf[3];
if (data_length > OCC_CMD_DATA_BYTES) {
@@ -281,9 +308,16 @@ static ssize_t occ_write(struct file *file, const char __user *buf,
return rc;
}
-static int occ_release(struct inode *inode, struct file *file)
+static ssize_t occ_write(struct file *file, const char __user *buf,
+ size_t len, loff_t *offset)
{
struct occ_client *client = file->private_data;
+
+ return occ_write_common(client, buf, NULL, len);
+}
+
+static int occ_release_common(struct occ_client *client)
+{
struct occ_xfr *xfr = &client->xfr;
struct occ *occ = client->occ;
@@ -321,6 +355,13 @@ static int occ_release(struct inode *inode, struct file *file)
return 0;
}
+static int occ_release(struct inode *inode, struct file *file)
+{
+ struct occ_client *client = file->private_data;
+
+ return occ_release_common(client);
+}
+
static const struct file_operations occ_fops = {
.owner = THIS_MODULE,
.open = occ_open,
@@ -592,12 +633,55 @@ static void occ_worker(struct work_struct *work)
goto again;
}
+struct occ_client *occ_drv_open(struct device *dev, unsigned long flags)
+{
+ struct occ *occ = dev_get_drvdata(dev);
+
+ if (!occ)
+ return NULL;
+
+ return occ_open_common(occ, flags);
+}
+EXPORT_SYMBOL_GPL(occ_drv_open);
+
+int occ_drv_read(struct occ_client *client, char *buf, size_t len)
+{
+ return occ_read_common(client, NULL, buf, len);
+}
+EXPORT_SYMBOL_GPL(occ_drv_read);
+
+int occ_drv_write(struct occ_client *client, const char *buf, size_t len)
+{
+ return occ_write_common(client, NULL, buf, len);
+}
+EXPORT_SYMBOL_GPL(occ_drv_write);
+
+void occ_drv_release(struct occ_client *client)
+{
+ occ_release_common(client);
+}
+EXPORT_SYMBOL_GPL(occ_drv_release);
+
+static int occ_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 occ_probe(struct platform_device *pdev)
{
- int rc;
+ int rc, child_idx = 0;
u32 reg;
struct occ *occ;
+ struct device_node *np;
+ struct platform_device *child;
struct device *dev = &pdev->dev;
+ char child_name[32];
occ = devm_kzalloc(dev, sizeof(*occ), GFP_KERNEL);
if (!occ)
@@ -609,6 +693,9 @@ static int occ_probe(struct platform_device *pdev)
mutex_init(&occ->occ_lock);
INIT_WORK(&occ->work, occ_worker);
+ /* ensure NULL before we probe children, so they don't hang FSI */
+ platform_set_drvdata(pdev, NULL);
+
if (dev->of_node) {
rc = of_property_read_u32(dev->of_node, "reg", ®);
if (!rc) {
@@ -621,6 +708,16 @@ static int occ_probe(struct platform_device *pdev)
} else
occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX,
GFP_KERNEL);
+
+ /* create platform devs for dts child nodes (hwmon, etc) */
+ for_each_child_of_node(dev->of_node, np) {
+ snprintf(child_name, sizeof(child_name), "occ%d-dev%d",
+ occ->idx, child_idx++);
+ child = of_platform_device_create(np, child_name, dev);
+ if (!child)
+ dev_warn(dev,
+ "failed to create child node dev\n");
+ }
} else
occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX, GFP_KERNEL);
@@ -647,6 +744,7 @@ static int occ_remove(struct platform_device *pdev)
flush_work(&occ->work);
misc_deregister(&occ->mdev);
+ device_for_each_child(&pdev->dev, NULL, occ_unregister_child);
ida_simple_remove(&occ_ida, occ->idx);
return 0;
diff --git a/include/linux/occ.h b/include/linux/occ.h
new file mode 100644
index 0000000..bc588a8
--- /dev/null
+++ b/include/linux/occ.h
@@ -0,0 +1,27 @@
+/*
+ * 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_OCC_H
+#define LINUX_OCC_H
+
+struct device;
+struct occ_client;
+
+extern struct occ_client *occ_drv_open(struct device *dev,
+ unsigned long flags);
+extern int occ_drv_read(struct occ_client *client, char *buf, size_t len);
+extern int occ_drv_write(struct occ_client *client, const char *buf,
+ size_t len);
+extern void occ_drv_release(struct occ_client *client);
+
+#endif /* LINUX_OCC_H */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API
2017-06-21 19:38 ` [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API Eddie James
@ 2017-06-24 12:12 ` kbuild test robot
2017-06-26 18:35 ` Rob Herring
1 sibling, 0 replies; 9+ messages in thread
From: kbuild test robot @ 2017-06-24 12:12 UTC (permalink / raw)
To: Eddie James
Cc: kbuild-all, linux-kernel, gregkh, devicetree, robh+dt,
mark.rutland, bradleyb, jk, cbostic, joel, andrew, eajames,
Edward A. James
[-- Attachment #1: Type: text/plain, Size: 1445 bytes --]
Hi Edward,
[auto build test ERROR on next-20170619]
[cannot apply to linux/master linus/master robh/for-next v4.12-rc6 v4.12-rc5 v4.12-rc4 v4.12-rc6]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
url: https://github.com/0day-ci/linux/commits/Eddie-James/drivers-fsi-Add-SBEFIFO-and-OCC-drivers/20170623-160949
config: i386-randconfig-n0-06241643 (attached as .config)
compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901
reproduce:
# save the attached .config to linux build tree
make ARCH=i386
All errors (new ones prefixed by >>):
drivers/fsi/occ.c: In function 'occ_unregister_child':
>> drivers/fsi/occ.c:669:2: error: implicit declaration of function 'of_device_unregister' [-Werror=implicit-function-declaration]
of_device_unregister(child);
^~~~~~~~~~~~~~~~~~~~
cc1: some warnings being treated as errors
vim +/of_device_unregister +669 drivers/fsi/occ.c
663 EXPORT_SYMBOL_GPL(occ_drv_release);
664
665 static int occ_unregister_child(struct device *dev, void *data)
666 {
667 struct platform_device *child = to_platform_device(dev);
668
> 669 of_device_unregister(child);
670 if (dev->of_node)
671 of_node_clear_flag(dev->of_node, OF_POPULATED);
672
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 28859 bytes --]
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API
2017-06-21 19:38 ` [PATCH linux 4/4] drivers/fsi/occ: Add in-kernel API Eddie James
2017-06-24 12:12 ` kbuild test robot
@ 2017-06-26 18:35 ` Rob Herring
1 sibling, 0 replies; 9+ messages in thread
From: Rob Herring @ 2017-06-26 18:35 UTC (permalink / raw)
To: Eddie James
Cc: linux-kernel, gregkh, devicetree, mark.rutland, bradleyb, jk,
cbostic, joel, andrew, Edward A. James
On Wed, Jun 21, 2017 at 02:38:01PM -0500, Eddie James wrote:
> From: "Edward A. James" <eajames@us.ibm.com>
>
> Add an in-kernel read/write API with exported functions. This is
> necessary for other drivers which want to directly interact with the
> OCC. Also parse the OCC device tree node for child nodes and create
> child platform devices accordingly.
>
> Signed-off-by: Edward A. James <eajames@us.ibm.com>
> ---
> .../devicetree/bindings/fsi/ibm,p9-occ.txt | 8 ++
> drivers/fsi/occ.c | 140 +++++++++++++++++----
> include/linux/occ.h | 27 ++++
> 3 files changed, 154 insertions(+), 21 deletions(-)
> create mode 100644 include/linux/occ.h
>
> diff --git a/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
> index 88002b9..71afba3 100644
> --- a/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
> +++ b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
> @@ -6,10 +6,18 @@ Required properties:
>
> Optional properties:
> - reg = <processor index>; : index for the processor this OCC device is on
> + - <child nodes> : Drivers for devices which communicate with
> + this OCC. Child nodes have no required or
> + optional properties that the OCC driver will
> + use.
Please put all the binding in a single, separate patch.
>
> Examples:
>
> occ@1 {
> compatible = "ibm,p9-occ";
> reg = <1>;
> +
> + occ-hwmon@1 {
> + compatible = "ibm,p9-occ-hwmon";
> + };
This looks like you are creating a node just to instantiate a driver as
hwmon is a Linuxism. Just have the parent OCC driver instantiate a hwmon
driver.
Rob
^ permalink raw reply [flat|nested] 9+ messages in thread