* [PATCH] dt-bindings: Add a RISC-V SBI firmware node
From: Palmer Dabbelt @ 2017-11-20 19:50 UTC (permalink / raw)
To: mark.rutland-5wv7dgnIgG8, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
devicetree-u79uwXL29TY76Z2rM5mHXA
Cc: patches-q3qR2WxjNRFS9aJRtSZj7A,
linux-kernel-u79uwXL29TY76Z2rM5mHXA, Palmer Dabbelt,
nathan=20Neusch=C3=A4fer?=
The RISC-V privileged ISA mandates the presence of an SBI, but there's
no reason not to put it in the device tree. This would allow us to
possibly remove the SBI later.
CC: Jonathan Neuschäfer <j.neuschaefer-hi6Y0CQ0nG0@public.gmane.org>
Signed-off-by: Palmer Dabbelt <palmer-SpMDHPYPyPbQT0dZR+AlfA@public.gmane.org>
---
.../devicetree/bindings/firmware/riscv.sbi.txt | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
create mode 100644 Documentation/devicetree/bindings/firmware/riscv.sbi.txt
diff --git a/Documentation/devicetree/bindings/firmware/riscv.sbi.txt b/Documentation/devicetree/bindings/firmware/riscv.sbi.txt
new file mode 100644
index 000000000000..42384d5d52cf
--- /dev/null
+++ b/Documentation/devicetree/bindings/firmware/riscv.sbi.txt
@@ -0,0 +1,20 @@
+RISC-V Supervisor Binary Interface (SBI)
+
+The RISC-V privileged ISA specification mandates the presence of a supervisor
+binary interface that performs some operations which might otherwise require
+particularly complicated instructions. This interface includes
+inter-processor interrupts, TLB flushes, i-cache and TLB shootdowns, a
+console, and power management.
+
+Required properties:
+- compatible: must contain one of the following
+ * "riscv,sbi" for the SBI defined by the privileged specification of the
+ system.
+
+Example:
+
+firmware {
+ sbi {
+ compatible = "riscv,sbi";
+ };
+};
--
2.13.6
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH v5 8/8] drivers/fsi: occ: Add in-kernel API
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, cbostic,
joel, eajames, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames@linux.vnet.ibm.com>
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 add a child platform device node for the associated hwmon
device.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
drivers/fsi/fsi-occ.c | 138 ++++++++++++++++++++++++++++++++++++++++--------
include/linux/fsi-occ.h | 41 ++++++++++++++
2 files changed, 157 insertions(+), 22 deletions(-)
create mode 100644 include/linux/fsi-occ.h
diff --git a/drivers/fsi/fsi-occ.c b/drivers/fsi/fsi-occ.c
index 1aeb67d..1713550 100644
--- a/drivers/fsi/fsi-occ.c
+++ b/drivers/fsi/fsi-occ.c
@@ -19,7 +19,9 @@
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
+#include <linux/fsi-occ.h>
#include <linux/of.h>
+#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/slab.h>
@@ -32,8 +34,6 @@
#define OCC_CMD_DATA_BYTES 4090
#define OCC_RESP_DATA_BYTES 4089
-#define OCC_RESP_CMD_IN_PRG 0xFF
-
#define OCC_TIMEOUT_MS 1000
#define OCC_CMD_IN_PRG_WAIT_MS 50
@@ -156,23 +156,34 @@ static void occ_put_client(struct occ_client *client)
kref_put(&client->kref, occ_client_release);
}
-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;
kref_init(&client->kref);
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;
@@ -184,15 +195,14 @@ static inline bool occ_read_ready(struct occ_xfr *xfr, struct occ *occ)
test_bit(XFR_CANCELED, &xfr->flags) || occ->cancel;
}
-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;
unsigned long flags;
size_t bytes;
struct occ_xfr *xfr;
struct occ *occ;
- struct occ_client *client = file->private_data;
if (!client)
return -ENODEV;
@@ -247,9 +257,14 @@ static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
}
bytes = min(len, xfr->resp_data_length - client->read_offset);
- if (copy_to_user(buf, &xfr->buf[client->read_offset], bytes)) {
- rc = -EFAULT;
- goto done;
+ 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;
@@ -266,15 +281,23 @@ 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 long flags;
unsigned int i;
u16 data_length, checksum = 0;
struct occ_xfr *xfr;
- struct occ_client *client = file->private_data;
if (!client)
return -ENODEV;
@@ -301,9 +324,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];
@@ -334,12 +361,19 @@ 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)
{
unsigned long flags;
struct occ *occ;
struct occ_xfr *xfr;
- struct occ_client *client = file->private_data;
if (!client)
return -ENODEV;
@@ -372,6 +406,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,
@@ -665,12 +706,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)
@@ -712,6 +796,15 @@ static int occ_probe(struct platform_device *pdev)
return rc;
}
+ /* create platform devs for dts child nodes (hwmon, etc) */
+ for_each_available_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");
+ }
+
platform_set_drvdata(pdev, occ);
return 0;
@@ -734,6 +827,7 @@ static int occ_remove(struct platform_device *pdev)
spin_unlock_irqrestore(&occ->list_lock, flags);
misc_deregister(&occ->mdev);
+ device_for_each_child(&pdev->dev, NULL, occ_unregister_child);
cancel_work_sync(&occ->work);
diff --git a/include/linux/fsi-occ.h b/include/linux/fsi-occ.h
new file mode 100644
index 0000000..0a4a54a
--- /dev/null
+++ b/include/linux/fsi-occ.h
@@ -0,0 +1,41 @@
+/*
+ * 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_OCC_H
+#define LINUX_FSI_OCC_H
+
+struct device;
+struct occ_client;
+
+#define OCC_RESP_CMD_IN_PRG 0xFF
+#define OCC_RESP_SUCCESS 0
+#define OCC_RESP_CMD_INVAL 0x11
+#define OCC_RESP_CMD_LEN_INVAL 0x12
+#define OCC_RESP_DATA_INVAL 0x13
+#define OCC_RESP_CHKSUM_ERR 0x14
+#define OCC_RESP_INT_ERR 0x15
+#define OCC_RESP_BAD_STATE 0x16
+#define OCC_RESP_CRIT_EXCEPT 0xE0
+#define OCC_RESP_CRIT_INIT 0xE1
+#define OCC_RESP_CRIT_WATCHDOG 0xE2
+#define OCC_RESP_CRIT_OCB 0xE3
+#define OCC_RESP_CRIT_HW 0xE4
+
+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_FSI_OCC_H */
--
1.8.3.1
^ permalink raw reply related
* [PATCH v5 7/8] drivers/fsi: occ: Add miscdevice
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, cbostic,
joel, eajames, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames@linux.vnet.ibm.com>
From: "Edward A. James" <eajames@us.ibm.com>
Add a miscdevice for the occ to allow userspace access through standard
file operations.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
drivers/fsi/fsi-occ.c | 264 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 264 insertions(+)
diff --git a/drivers/fsi/fsi-occ.c b/drivers/fsi/fsi-occ.c
index 99dbfa3..1aeb67d 100644
--- a/drivers/fsi/fsi-occ.c
+++ b/drivers/fsi/fsi-occ.c
@@ -16,6 +16,7 @@
#include <linux/idr.h>
#include <linux/kernel.h>
#include <linux/list.h>
+#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
@@ -40,6 +41,7 @@ struct occ {
struct device *sbefifo;
char name[32];
int idx;
+ struct miscdevice mdev;
struct list_head xfrs;
spinlock_t list_lock; /* lock access to the xfrs list */
struct mutex occ_lock; /* lock access to the hardware */
@@ -113,6 +115,29 @@ struct occ_client {
static DEFINE_IDA(occ_ida);
+static int occ_enqueue_xfr(struct occ_xfr *xfr)
+{
+ int empty;
+ unsigned long flags;
+ struct occ_client *client = to_client(xfr);
+ struct occ *occ = client->occ;
+
+ if (occ->cancel)
+ return -ENODEV;
+
+ spin_lock_irqsave(&occ->list_lock, flags);
+
+ empty = list_empty(&occ->xfrs);
+ list_add_tail(&xfr->link, &occ->xfrs);
+
+ spin_unlock_irqrestore(&occ->list_lock, flags);
+
+ if (empty)
+ queue_work(occ_wq, &occ->work);
+
+ return 0;
+}
+
static void occ_get_client(struct occ_client *client)
{
kref_get(&client->kref);
@@ -131,6 +156,230 @@ static void occ_put_client(struct occ_client *client)
kref_put(&client->kref, occ_client_release);
}
+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;
+ kref_init(&client->kref);
+ 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 inline bool occ_read_ready(struct occ_xfr *xfr, struct occ *occ)
+{
+ return test_bit(XFR_COMPLETE, &xfr->flags) ||
+ test_bit(XFR_CANCELED, &xfr->flags) || occ->cancel;
+}
+
+static ssize_t occ_read(struct file *file, char __user *buf, size_t len,
+ loff_t *offset)
+{
+ int rc;
+ unsigned long flags;
+ size_t bytes;
+ struct occ_xfr *xfr;
+ struct occ *occ;
+ struct occ_client *client = file->private_data;
+
+ if (!client)
+ return -ENODEV;
+
+ if (len > OCC_SRAM_BYTES)
+ return -EINVAL;
+
+ occ_get_client(client);
+ xfr = &client->xfr;
+ occ = client->occ;
+
+ spin_lock_irqsave(&client->lock, flags);
+
+ 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;
+ }
+
+ spin_unlock_irqrestore(&client->lock, flags);
+
+ rc = wait_event_interruptible(client->wait,
+ occ_read_ready(xfr, occ));
+
+ spin_lock_irqsave(&client->lock, flags);
+
+ if (!test_bit(XFR_COMPLETE, &xfr->flags)) {
+ if (occ->cancel || test_bit(XFR_CANCELED, &xfr->flags))
+ rc = -ENODEV;
+ else
+ rc = -EINTR;
+
+ goto done;
+ }
+ }
+
+ if (xfr->rc) {
+ rc = xfr->rc;
+ goto done;
+ }
+
+ bytes = min(len, xfr->resp_data_length - client->read_offset);
+ 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_irqrestore(&client->lock, flags);
+ occ_put_client(client);
+ return rc;
+}
+
+static ssize_t occ_write(struct file *file, const char __user *buf,
+ size_t len, loff_t *offset)
+{
+ int rc;
+ unsigned long flags;
+ unsigned int i;
+ u16 data_length, checksum = 0;
+ struct occ_xfr *xfr;
+ struct occ_client *client = file->private_data;
+
+ if (!client)
+ return -ENODEV;
+
+ if (len > (OCC_CMD_DATA_BYTES + 3) || len < 3)
+ return -EINVAL;
+
+ occ_get_client(client);
+ xfr = &client->xfr;
+
+ spin_lock_irqsave(&client->lock, flags);
+
+ 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;
+
+ rc = occ_enqueue_xfr(xfr);
+ if (rc)
+ goto done;
+
+ set_bit(CLIENT_XFR_PENDING, &client->flags);
+ rc = len;
+
+done:
+ spin_unlock_irqrestore(&client->lock, flags);
+ occ_put_client(client);
+ return rc;
+}
+
+static int occ_release(struct inode *inode, struct file *file)
+{
+ unsigned long flags;
+ struct occ *occ;
+ struct occ_xfr *xfr;
+ struct occ_client *client = file->private_data;
+
+ if (!client)
+ return -ENODEV;
+
+ xfr = &client->xfr;
+ occ = client->occ;
+
+ spin_lock_irqsave(&client->lock, flags);
+
+ set_bit(XFR_CANCELED, &xfr->flags);
+ if (!test_bit(CLIENT_XFR_PENDING, &client->flags))
+ goto done;
+
+ spin_lock(&occ->list_lock);
+
+ 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);
+
+ wake_up_all(&client->wait);
+
+done:
+ spin_unlock_irqrestore(&client->lock, flags);
+
+ occ_put_client(client);
+ 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)
{
@@ -450,6 +699,19 @@ static int occ_probe(struct platform_device *pdev)
occ->idx = ida_simple_get(&occ_ida, 1, INT_MAX, GFP_KERNEL);
}
+ 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: %d\n", rc);
+ ida_simple_remove(&occ_ida, occ->idx);
+ return rc;
+ }
+
platform_set_drvdata(pdev, occ);
return 0;
@@ -471,6 +733,8 @@ static int occ_remove(struct platform_device *pdev)
}
spin_unlock_irqrestore(&occ->list_lock, flags);
+ misc_deregister(&occ->mdev);
+
cancel_work_sync(&occ->work);
ida_simple_remove(&occ_ida, occ->idx);
--
1.8.3.1
^ permalink raw reply related
* [PATCH v5 6/8] drivers/fsi: Add On-Chip Controller (OCC) driver
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel-u79uwXL29TY76Z2rM5mHXA
Cc: gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r,
devicetree-u79uwXL29TY76Z2rM5mHXA, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
mark.rutland-5wv7dgnIgG8,
bradleyb-r5pk2Da7Bxt8sGd51Jp2sdBPR1lH4CV8,
cbostic-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8,
joel-U3u1mxZcP9KHXe+LvDLADg,
eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8@public.gmane.org>
From: "Edward A. James" <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
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-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
---
drivers/fsi/Kconfig | 10 +
drivers/fsi/Makefile | 1 +
drivers/fsi/fsi-occ.c | 518 ++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 529 insertions(+)
create mode 100644 drivers/fsi/fsi-occ.c
diff --git a/drivers/fsi/Kconfig b/drivers/fsi/Kconfig
index 8c4d903..8ed4602 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 FSI_OCC
+ 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..75fdc6d 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_FSI_OCC) += fsi-occ.o
diff --git a/drivers/fsi/fsi-occ.c b/drivers/fsi/fsi-occ.c
new file mode 100644
index 0000000..99dbfa3
--- /dev/null
+++ b/drivers/fsi/fsi-occ.c
@@ -0,0 +1,518 @@
+/*
+ * 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/errno.h>
+#include <linux/fs.h>
+#include <linux/fsi-sbefifo.h>
+#include <linux/idr.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/spinlock.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
+
+#define OCC_RESP_CMD_IN_PRG 0xFF
+
+#define OCC_TIMEOUT_MS 1000
+#define OCC_CMD_IN_PRG_WAIT_MS 50
+
+struct occ {
+ struct device *sbefifo;
+ char name[32];
+ int idx;
+ struct list_head xfrs;
+ spinlock_t list_lock; /* lock access to the xfrs list */
+ struct mutex occ_lock; /* lock access to the hardware */
+ struct work_struct work;
+ bool cancel;
+};
+
+#define to_occ(x) container_of((x), struct occ, mdev)
+
+struct occ_response {
+ u8 seq_no;
+ u8 cmd_type;
+ u8 return_status;
+ __be16 data_length;
+ u8 data[OCC_RESP_DATA_BYTES];
+ __be16 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.
+ */
+enum {
+ XFR_IN_PROGRESS,
+ XFR_COMPLETE,
+ XFR_CANCELED,
+};
+
+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 kref kref;
+ struct occ *occ;
+ struct occ_xfr xfr;
+ spinlock_t lock; /* lock access to the client state */
+ 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_get_client(struct occ_client *client)
+{
+ kref_get(&client->kref);
+}
+
+static void occ_client_release(struct kref *kref)
+{
+ struct occ_client *client = container_of(kref, struct occ_client,
+ kref);
+
+ kfree(client);
+}
+
+static void occ_put_client(struct occ_client *client)
+{
+ kref_put(&client->kref, occ_client_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 : -ENOSPC;
+}
+
+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 : -ENODATA;
+}
+
+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 = -EBADMSG;
+
+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 = -EBADMSG;
+
+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 = -EBADMSG;
+
+done:
+ sbefifo_drv_release(client);
+
+ return rc;
+}
+
+static void occ_worker(struct work_struct *work)
+{
+ int rc = 0, empty;
+ u16 resp_data_length;
+ unsigned long flags;
+ unsigned long start;
+ const unsigned long timeout = msecs_to_jiffies(OCC_TIMEOUT_MS);
+ const long int wait_time = msecs_to_jiffies(OCC_CMD_IN_PRG_WAIT_MS);
+ struct occ_xfr *xfr;
+ struct occ_response *resp;
+ struct occ_client *client;
+ struct occ *occ = container_of(work, struct occ, work);
+ struct device *sbefifo = occ->sbefifo;
+
+again:
+ if (occ->cancel)
+ return;
+
+ spin_lock_irqsave(&occ->list_lock, flags);
+
+ xfr = list_first_entry_or_null(&occ->xfrs, struct occ_xfr, link);
+ if (!xfr) {
+ spin_unlock_irqrestore(&occ->list_lock, flags);
+ return;
+ }
+
+ client = to_client(xfr);
+ occ_get_client(client);
+ resp = (struct occ_response *)xfr->buf;
+ set_bit(XFR_IN_PROGRESS, &xfr->flags);
+
+ spin_unlock_irqrestore(&occ->list_lock, flags);
+ mutex_lock(&occ->occ_lock);
+
+ start = jiffies;
+
+ /* 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 */
+ do {
+ rc = occ_getsram(sbefifo, 0xFFFBF000, xfr->buf, 8);
+ if (rc)
+ goto done;
+
+ if (resp->return_status == OCC_RESP_CMD_IN_PRG) {
+ rc = -EALREADY;
+
+ if (time_after(jiffies, start + timeout))
+ break;
+
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule_timeout(wait_time);
+ }
+ } while (rc);
+
+ resp_data_length = get_unaligned_be16(&resp->data_length);
+ if (resp_data_length > OCC_RESP_DATA_BYTES) {
+ rc = -EMSGSIZE;
+ 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;
+ set_bit(XFR_COMPLETE, &xfr->flags);
+
+ spin_lock_irqsave(&occ->list_lock, flags);
+
+ clear_bit(XFR_IN_PROGRESS, &xfr->flags);
+ list_del(&xfr->link);
+ empty = list_empty(&occ->xfrs);
+
+ spin_unlock_irqrestore(&occ->list_lock, flags);
+
+ wake_up_interruptible(&client->wait);
+ occ_put_client(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);
+
+ return 0;
+}
+
+static int occ_remove(struct platform_device *pdev)
+{
+ unsigned long flags;
+ struct occ *occ = platform_get_drvdata(pdev);
+ struct occ_xfr *xfr;
+ struct occ_client *client;
+
+ occ->cancel = true;
+
+ spin_lock_irqsave(&occ->list_lock, flags);
+ list_for_each_entry(xfr, &occ->xfrs, link) {
+ client = to_client(xfr);
+ wake_up_all(&client->wait);
+ }
+ spin_unlock_irqrestore(&occ->list_lock, flags);
+
+ cancel_work_sync(&occ->work);
+
+ 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-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>");
+MODULE_DESCRIPTION("BMC P9 OCC driver");
+MODULE_LICENSE("GPL");
--
1.8.3.1
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH v5 5/8] dt-bindings: fsi: Add OCC documentation
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel-u79uwXL29TY76Z2rM5mHXA
Cc: gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r,
devicetree-u79uwXL29TY76Z2rM5mHXA, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
mark.rutland-5wv7dgnIgG8,
bradleyb-r5pk2Da7Bxt8sGd51Jp2sdBPR1lH4CV8,
cbostic-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8,
joel-U3u1mxZcP9KHXe+LvDLADg,
eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8@public.gmane.org>
From: "Edward A. James" <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
Document the bindings for the P9 OCC device. OCC devices are accessed
through the SBEFIFO.
Signed-off-by: Edward A. James <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
---
Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
create mode 100644 Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
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..79094f5
--- /dev/null
+++ b/Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
@@ -0,0 +1,18 @@
+Device-tree bindings for P9 On-Chip Controller
+----------------------------------------------
+
+The POWER9 On-Chip Controller is accessed through the SBEFIFO. All OCC nodes
+must be child nodes of SBEFIFO devices (see ibm,p9-sbefifo.txt).
+
+Required properties:
+ - compatible = "ibm,p9-occ";
+
+Optional properties:
+ - reg = <processor index>; : Index for the processor this OCC is on.
+
+Examples:
+
+ occ@1 {
+ compatible = "ibm,p9-occ";
+ reg = <1>;
+ };
--
1.8.3.1
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH v5 4/8] drivers/fsi: sbefifo: Add in-kernel API
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, cbostic,
joel, eajames, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames@linux.vnet.ibm.com>
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 | 137 +++++++++++++++++++++++++++++++++++++-------
include/linux/fsi-sbefifo.h | 30 ++++++++++
2 files changed, 146 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 fed3739..b622c70 100644
--- a/drivers/fsi/fsi-sbefifo.c
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -15,12 +15,16 @@
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/fsi.h>
+#include <linux/fsi-sbefifo.h>
#include <linux/idr.h>
#include <linux/kernel.h>
#include <linux/kref.h>
#include <linux/list.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
@@ -92,6 +96,7 @@ struct sbefifo_client {
struct list_head xfrs;
struct sbefifo *dev;
struct kref kref;
+ unsigned long f_flags;
};
static DEFINE_IDA(sbefifo_ida);
@@ -541,6 +546,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;
}
@@ -580,10 +586,9 @@ static bool sbefifo_read_ready(struct sbefifo *sbefifo,
(xfr && test_bit(SBEFIFO_XFR_COMPLETE, &xfr->flags));
}
-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;
size_t n;
@@ -592,7 +597,7 @@ static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
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);
@@ -610,9 +615,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)) {
- ret = -EFAULT;
- goto out;
+ if (ubuf) {
+ if (copy_to_user(ubuf, READ_ONCE(client->rbuf.rpos), n)) {
+ ret = -EFAULT;
+ goto out;
+ }
+ } else {
+ memcpy(kbuf, READ_ONCE(client->rbuf.rpos), n);
}
if (sbefifo_buf_readnb(&client->rbuf, n)) {
@@ -644,6 +653,14 @@ static ssize_t sbefifo_read(struct file *file, char __user *buf, size_t len,
return ret;
}
+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 bool sbefifo_write_ready(struct sbefifo *sbefifo,
struct sbefifo_xfr *xfr,
struct sbefifo_client *client, size_t *n)
@@ -656,11 +673,11 @@ static bool sbefifo_write_ready(struct sbefifo *sbefifo,
return READ_ONCE(sbefifo->rc) || (next == xfr && *n);
}
-static ssize_t sbefifo_write(struct file *file, const char __user *buf,
- size_t len, loff_t *offset)
+static ssize_t sbefifo_write_common(struct sbefifo_client *client,
+ const char __user *ubuf, const char *kbuf,
+ size_t len)
{
unsigned long flags;
- struct sbefifo_client *client = file->private_data;
struct sbefifo *sbefifo = client->dev;
struct sbefifo_xfr *xfr;
ssize_t ret = 0;
@@ -678,7 +695,7 @@ static ssize_t sbefifo_write(struct file *file, const char __user *buf,
spin_lock_irqsave(&sbefifo->lock, flags);
xfr = sbefifo_next_xfr(sbefifo); /* next xfr to be executed */
- if ((file->f_flags & O_NONBLOCK) && xfr && n < len) {
+ if ((client->f_flags & O_NONBLOCK) && xfr && n < len) {
spin_unlock_irqrestore(&sbefifo->lock, flags);
ret = -EAGAIN;
goto out;
@@ -719,16 +736,22 @@ 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(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);
- ret = -EFAULT;
- goto out;
- }
+ if (ubuf) {
+ if (copy_from_user(READ_ONCE(client->wbuf.wpos), ubuf,
+ n)) {
+ set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
+ sbefifo_get(sbefifo);
+ if (mod_timer(&sbefifo->poll_timer, jiffies))
+ sbefifo_put(sbefifo);
+ ret = -EFAULT;
+ goto out;
+ }
- buf += n;
+ ubuf += n;
+ } else {
+ memcpy(READ_ONCE(client->wbuf.wpos), kbuf, n);
+ kbuf += n;
+ }
sbefifo_buf_wrotenb(&client->wbuf, n);
len -= n;
@@ -752,6 +775,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;
@@ -771,6 +802,56 @@ 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;
+ struct sbefifo *sbefifo = dev_get_drvdata(dev);
+
+ if (!sbefifo)
+ return NULL;
+
+ 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_request_reset(struct sbefifo *sbefifo)
{
int ret;
@@ -805,8 +886,11 @@ 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 up, down;
- int ret;
+ int ret, child_idx = 0;
dev_dbg(dev, "Found sbefifo device\n");
sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
@@ -857,6 +941,16 @@ static int sbefifo_probe(struct device *dev)
return ret;
}
+ /* create platform devs for dts child nodes (occ, etc) */
+ for_each_available_child_of_node(dev->of_node, np) {
+ snprintf(child_name, sizeof(child_name), "%s-dev%d",
+ sbefifo->name, child_idx++);
+ child = of_platform_device_create(np, child_name, dev);
+ if (!child)
+ dev_warn(dev, "failed to create child %s dev\n",
+ child_name);
+ }
+
dev_set_drvdata(dev, sbefifo);
return 0;
@@ -883,6 +977,7 @@ static int sbefifo_remove(struct device *dev)
wake_up_all(&sbefifo->wait);
misc_deregister(&sbefifo->mdev);
+ device_for_each_child(dev, NULL, sbefifo_unregister_child);
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
* [PATCH v5 3/8] drivers/fsi: sbefifo: Add miscdevice
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel-u79uwXL29TY76Z2rM5mHXA
Cc: gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r,
devicetree-u79uwXL29TY76Z2rM5mHXA, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
mark.rutland-5wv7dgnIgG8,
bradleyb-r5pk2Da7Bxt8sGd51Jp2sdBPR1lH4CV8,
cbostic-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8,
joel-U3u1mxZcP9KHXe+LvDLADg,
eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8@public.gmane.org>
From: "Edward A. James" <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
Add a miscdevice for the sbefifo to allow userspace access through
standard file operations.
Signed-off-by: Edward A. James <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
---
drivers/fsi/fsi-sbefifo.c | 355 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 355 insertions(+)
diff --git a/drivers/fsi/fsi-sbefifo.c b/drivers/fsi/fsi-sbefifo.c
index 6ba190a..fed3739 100644
--- a/drivers/fsi/fsi-sbefifo.c
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -19,6 +19,7 @@
#include <linux/kernel.h>
#include <linux/kref.h>
#include <linux/list.h>
+#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/sched.h>
@@ -54,6 +55,7 @@
struct sbefifo {
struct timer_list poll_timer;
struct fsi_device *fsi_dev;
+ struct miscdevice mdev;
wait_queue_head_t wait;
struct list_head xfrs;
struct kref kref;
@@ -256,6 +258,99 @@ 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;
+
+ if (READ_ONCE(sbefifo->rc))
+ return ERR_PTR(sbefifo->rc);
+
+ xfr = kzalloc(sizeof(*xfr), GFP_KERNEL);
+ if (!xfr)
+ return ERR_PTR(-ENOMEM);
+
+ 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 bool sbefifo_xfr_rsp_pending(struct sbefifo_client *client)
+{
+ struct sbefifo_xfr *xfr = list_first_entry_or_null(&client->xfrs,
+ struct sbefifo_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 *sbefifo;
+ struct sbefifo_client *client;
+ struct sbefifo_xfr *xfr, *tmp;
+
+ client = container_of(kref, struct sbefifo_client, kref);
+ sbefifo = client->dev;
+
+ if (!READ_ONCE(sbefifo->rc)) {
+ list_for_each_entry_safe(xfr, tmp, &client->xfrs, client) {
+ if (test_bit(SBEFIFO_XFR_COMPLETE, &xfr->flags)) {
+ list_del(&xfr->client);
+ kfree(xfr);
+ continue;
+ }
+
+ /*
+ * The client left with pending or running xfrs.
+ * Cancel them.
+ */
+ set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
+ sbefifo_get(sbefifo);
+ if (mod_timer(&client->dev->poll_timer, jiffies))
+ sbefifo_put(sbefifo);
+ }
+ }
+
+ sbefifo_put(sbefifo);
+ 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;
@@ -430,6 +525,252 @@ static void sbefifo_poll_timer(unsigned long data)
spin_unlock_irqrestore(&sbefifo->lock, flags);
}
+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 bool sbefifo_read_ready(struct sbefifo *sbefifo,
+ struct sbefifo_client *client, size_t *n,
+ size_t *ret)
+{
+ struct sbefifo_xfr *xfr = list_first_entry_or_null(&client->xfrs,
+ struct sbefifo_xfr,
+ client);
+
+ *n = sbefifo_buf_nbreadable(&client->rbuf);
+ *ret = READ_ONCE(sbefifo->rc);
+
+ return *ret || *n ||
+ (xfr && test_bit(SBEFIFO_XFR_COMPLETE, &xfr->flags));
+}
+
+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;
+ 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))
+ return -EAGAIN;
+
+ sbefifo_get_client(client);
+ if (wait_event_interruptible(sbefifo->wait,
+ sbefifo_read_ready(sbefifo, client, &n,
+ &ret))) {
+ ret = -ERESTARTSYS;
+ goto out;
+ }
+
+ if (ret) {
+ INIT_LIST_HEAD(&client->xfrs);
+ goto out;
+ }
+
+ n = min_t(size_t, n, len);
+
+ if (copy_to_user(buf, READ_ONCE(client->rbuf.rpos), n)) {
+ ret = -EFAULT;
+ goto out;
+ }
+
+ if (sbefifo_buf_readnb(&client->rbuf, n)) {
+ xfr = list_first_entry_or_null(&client->xfrs,
+ struct sbefifo_xfr, client);
+ if (!xfr) {
+ /* should be impossible to not have an xfr here */
+ WARN_ONCE(1, "no xfr in queue");
+ ret = -EPROTO;
+ goto out;
+ }
+
+ 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 {
+ list_del(&xfr->client);
+ kfree(xfr);
+ wake_up_interruptible(&sbefifo->wait);
+ }
+ }
+
+ ret = n;
+
+out:
+ sbefifo_put_client(client);
+ return ret;
+}
+
+static bool sbefifo_write_ready(struct sbefifo *sbefifo,
+ struct sbefifo_xfr *xfr,
+ struct sbefifo_client *client, size_t *n)
+{
+ struct sbefifo_xfr *next = list_first_entry_or_null(&client->xfrs,
+ struct sbefifo_xfr,
+ client);
+
+ *n = sbefifo_buf_nbwriteable(&client->wbuf);
+ return READ_ONCE(sbefifo->rc) || (next == xfr && *n);
+}
+
+static ssize_t sbefifo_write(struct file *file, const char __user *buf,
+ size_t len, loff_t *offset)
+{
+ unsigned long flags;
+ 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 (!len)
+ return 0;
+
+ sbefifo_get_client(client);
+ n = sbefifo_buf_nbwriteable(&client->wbuf);
+
+ spin_lock_irqsave(&sbefifo->lock, flags);
+ xfr = sbefifo_next_xfr(sbefifo); /* next xfr to be executed */
+
+ if ((file->f_flags & O_NONBLOCK) && xfr && n < len) {
+ spin_unlock_irqrestore(&sbefifo->lock, flags);
+ ret = -EAGAIN;
+ goto out;
+ }
+
+ xfr = sbefifo_enq_xfr(client); /* this xfr queued up */
+ if (IS_ERR(xfr)) {
+ spin_unlock_irqrestore(&sbefifo->lock, flags);
+ ret = PTR_ERR(xfr);
+ goto out;
+ }
+
+ spin_unlock_irqrestore(&sbefifo->lock, flags);
+
+ /*
+ * Partial writes are not really allowed in that EOT is sent exactly
+ * once per write.
+ */
+ while (len) {
+ if (wait_event_interruptible(sbefifo->wait,
+ sbefifo_write_ready(sbefifo, xfr,
+ client,
+ &n))) {
+ set_bit(SBEFIFO_XFR_CANCEL, &xfr->flags);
+ sbefifo_get(sbefifo);
+ if (mod_timer(&sbefifo->poll_timer, jiffies))
+ sbefifo_put(sbefifo);
+
+ ret = -ERESTARTSYS;
+ goto out;
+ }
+
+ if (sbefifo->rc) {
+ INIT_LIST_HEAD(&client->xfrs);
+ ret = sbefifo->rc;
+ goto out;
+ }
+
+ 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);
+ ret = -EFAULT;
+ goto out;
+ }
+
+ buf += n;
+
+ sbefifo_buf_wrotenb(&client->wbuf, n);
+ len -= n;
+ ret += n;
+
+ /*
+ * Set this before starting timer to avoid race condition on
+ * this flag with the timer function writer.
+ */
+ if (!len)
+ set_bit(SBEFIFO_XFR_WRITE_DONE, &xfr->flags);
+
+ /* Drain the write buffer. */
+ sbefifo_get(sbefifo);
+ if (mod_timer(&client->dev->poll_timer, jiffies))
+ sbefifo_put(sbefifo);
+ }
+
+out:
+ 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_request_reset(struct sbefifo *sbefifo)
{
int ret;
@@ -504,6 +845,18 @@ static int sbefifo_probe(struct device *dev)
setup_timer(&sbefifo->poll_timer, sbefifo_poll_timer,
(unsigned long)sbefifo);
+ sbefifo->mdev.minor = MISC_DYNAMIC_MINOR;
+ sbefifo->mdev.fops = &sbefifo_fops;
+ sbefifo->mdev.name = sbefifo->name;
+ sbefifo->mdev.parent = dev;
+ ret = misc_register(&sbefifo->mdev);
+ if (ret) {
+ dev_err(dev, "failed to register miscdevice: %d\n", ret);
+ ida_simple_remove(&sbefifo_ida, sbefifo->idx);
+ sbefifo_put(sbefifo);
+ return ret;
+ }
+
dev_set_drvdata(dev, sbefifo);
return 0;
@@ -529,6 +882,8 @@ static int sbefifo_remove(struct device *dev)
wake_up_all(&sbefifo->wait);
+ misc_deregister(&sbefifo->mdev);
+
ida_simple_remove(&sbefifo_ida, sbefifo->idx);
if (del_timer_sync(&sbefifo->poll_timer))
--
1.8.3.1
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* [PATCH v5 2/8] drivers/fsi: Add SBEFIFO FSI client device driver
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, cbostic,
joel, eajames, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames@linux.vnet.ibm.com>
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.
Contributions from 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 | 577 ++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 585 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..6ba190a
--- /dev/null
+++ b/drivers/fsi/fsi-sbefifo.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright (C) IBM Corporation 2017
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/fsi.h>
+#include <linux/idr.h>
+#include <linux/kernel.h>
+#include <linux/kref.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/poll.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/uaccess.h>
+#include <linux/wait.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_STS_RESET_REQ BIT(25)
+#define SBEFIFO_EOT_RAISE 0x08
+#define SBEFIFO_EOT_MAGIC 0xffffffff
+#define SBEFIFO_REQ_RESET 0x0C
+#define SBEFIFO_EOT_ACK 0x14
+
+#define SBEFIFO_RESCHEDULE msecs_to_jiffies(500)
+#define SBEFIFO_MAX_RESCHDULE msecs_to_jiffies(5000)
+
+struct sbefifo {
+ struct timer_list poll_timer;
+ struct fsi_device *fsi_dev;
+ wait_queue_head_t wait;
+ 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 {
+ unsigned long wait_data_timeout;
+ 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 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_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;
+ unsigned long flags;
+ struct sbefifo *sbefifo = (void *)data;
+ struct sbefifo_buf *rbuf, *wbuf;
+ struct sbefifo_xfr *xfr, *tmp;
+ struct sbefifo_buf drain;
+ size_t devn, bufn;
+ int eot = 0;
+ int ret = 0;
+ u32 sts;
+ int i;
+
+ spin_lock_irqsave(&sbefifo->lock, flags);
+ 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 +
+ SBEFIFO_RESCHEDULE;
+ 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) {
+ /*
+ * Limit the maximum waiting period for data in the
+ * FIFO. If the SBE isn't running, we will wait
+ * forever.
+ */
+ if (!xfr->wait_data_timeout) {
+ xfr->wait_data_timeout =
+ jiffies + SBEFIFO_MAX_RESCHDULE;
+ } else if (time_after(jiffies,
+ xfr->wait_data_timeout)) {
+ ret = -ETIME;
+ goto out;
+ }
+
+ /* No data yet. Reschedule. */
+ sbefifo->poll_timer.expires = jiffies +
+ SBEFIFO_RESCHEDULE;
+ add_timer(&sbefifo->poll_timer);
+ goto out_unlock;
+ } else {
+ xfr->wait_data_timeout = 0;
+ }
+
+ /* 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_safe(xfr, tmp, &sbefifo->xfrs, xfrs) {
+ list_del(&xfr->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_interruptible(&sbefifo->wait);
+
+out_unlock:
+ spin_unlock_irqrestore(&sbefifo->lock, flags);
+}
+
+static int sbefifo_request_reset(struct sbefifo *sbefifo)
+{
+ int ret;
+ u32 status;
+ unsigned long start;
+ const unsigned int wait_time = 5; /* jiffies */
+ const unsigned long timeout = msecs_to_jiffies(250);
+
+ ret = sbefifo_outw(sbefifo, SBEFIFO_UP | SBEFIFO_REQ_RESET, 1);
+ if (ret)
+ return ret;
+
+ start = jiffies;
+
+ do {
+ ret = sbefifo_inw(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &status);
+ if (ret)
+ return ret;
+
+ if (!(status & SBEFIFO_STS_RESET_REQ))
+ return 0;
+
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (schedule_timeout(wait_time) > 0)
+ return -EINTR;
+ } while (time_after(start + timeout, jiffies));
+
+ return -ETIME;
+}
+
+static int sbefifo_probe(struct device *dev)
+{
+ struct fsi_device *fsi_dev = to_fsi_dev(dev);
+ struct sbefifo *sbefifo;
+ u32 up, down;
+ int ret;
+
+ dev_dbg(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, &up);
+ if (ret)
+ return ret;
+
+ ret = sbefifo_inw(sbefifo, SBEFIFO_DWN | SBEFIFO_STS, &down);
+ if (ret)
+ return ret;
+
+ if (!(up & SBEFIFO_EMPTY) || !(down & SBEFIFO_EMPTY)) {
+ ret = sbefifo_request_reset(sbefifo);
+ if (ret) {
+ dev_err(dev,
+ "fifos weren't empty and failed the reset\n");
+ return ret;
+ }
+ }
+
+ spin_lock_init(&sbefifo->lock);
+ kref_init(&sbefifo->kref);
+ init_waitqueue_head(&sbefifo->wait);
+ INIT_LIST_HEAD(&sbefifo->xfrs);
+
+ sbefifo->idx = ida_simple_get(&sbefifo_ida, 1, INT_MAX, GFP_KERNEL);
+ snprintf(sbefifo->name, sizeof(sbefifo->name), "sbefifo%d",
+ sbefifo->idx);
+
+ /* This bit of silicon doesn't offer any interrupts... */
+ setup_timer(&sbefifo->poll_timer, sbefifo_poll_timer,
+ (unsigned long)sbefifo);
+
+ dev_set_drvdata(dev, sbefifo);
+
+ return 0;
+}
+
+static int sbefifo_remove(struct device *dev)
+{
+ unsigned long flags;
+ struct sbefifo *sbefifo = dev_get_drvdata(dev);
+ struct sbefifo_xfr *xfr, *tmp;
+
+ spin_lock_irqsave(&sbefifo->lock, flags);
+
+ WRITE_ONCE(sbefifo->rc, -ENODEV);
+ list_for_each_entry_safe(xfr, tmp, &sbefifo->xfrs, xfrs) {
+ list_del(&xfr->xfrs);
+ kfree(xfr);
+ }
+
+ INIT_LIST_HEAD(&sbefifo->xfrs);
+
+ spin_unlock_irqrestore(&sbefifo->lock, flags);
+
+ wake_up_all(&sbefifo->wait);
+
+ ida_simple_remove(&sbefifo_ida, sbefifo->idx);
+
+ if (del_timer_sync(&sbefifo->poll_timer))
+ sbefifo_put(sbefifo);
+
+ 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)
+{
+ 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
* [PATCH v5 1/8] dt-bindings: fsi: Add SBEFIFO documentation
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel
Cc: gregkh, devicetree, robh+dt, mark.rutland, bradleyb, cbostic,
joel, eajames, Edward A. James
In-Reply-To: <1511207217-14075-1-git-send-email-eajames@linux.vnet.ibm.com>
From: "Edward A. James" <eajames@us.ibm.com>
Document the bindings for the SBE CFAM device. SBE devices are
located on a CFAM off an FSI bus.
Signed-off-by: Edward A. James <eajames@us.ibm.com>
---
.../devicetree/bindings/fsi/ibm,p9-sbefifo.txt | 35 ++++++++++++++++++++++
1 file changed, 35 insertions(+)
create mode 100644 Documentation/devicetree/bindings/fsi/ibm,p9-sbefifo.txt
diff --git a/Documentation/devicetree/bindings/fsi/ibm,p9-sbefifo.txt b/Documentation/devicetree/bindings/fsi/ibm,p9-sbefifo.txt
new file mode 100644
index 0000000..e69b0c0
--- /dev/null
+++ b/Documentation/devicetree/bindings/fsi/ibm,p9-sbefifo.txt
@@ -0,0 +1,35 @@
+Device-tree bindings for P9 SBEFIFO CFAM device
+-----------------------------------------------
+
+Required properties:
+ - compatible = "ibm,p9-sbefifo";
+ - reg = < address size >; : FSI CFAM address for the SBE engine
+ and address space size.
+ - #address-cells = <1>; : Number of address cells in child
+ nodes.
+ - #size-cells = <0>; : Number of size cells in child nodes.
+
+Optional properties:
+ - <child nodes> : Devices that are accessible through
+ the SBEFIFO. Child nodes are "opaque"
+ to the SBEFIFO; the SBEFIFO needs no
+ information about a child node other
+ than if it exists or not.
+
+Child node optional properties:
+ - compatible = "dts-name"
+ - reg = < address >; : Meaningful only for the child node
+
+Examples:
+
+ sbefifo@2400 {
+ compatible = "ibm,p9-sbefifo";
+ reg = < 0x2400 0x400 >;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ occ@1 {
+ compatible = "ibm,p9-occ";
+ reg = < 1 >;
+ };
+ };
--
1.8.3.1
^ permalink raw reply related
* [PATCH v5 0/8] drivers/fsi: Add SBEFIFO and OCC client drivers
From: Eddie James @ 2017-11-20 19:46 UTC (permalink / raw)
To: linux-kernel-u79uwXL29TY76Z2rM5mHXA
Cc: gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r,
devicetree-u79uwXL29TY76Z2rM5mHXA, robh+dt-DgEjT+Ai2ygdnm+yROfE0A,
mark.rutland-5wv7dgnIgG8,
bradleyb-r5pk2Da7Bxt8sGd51Jp2sdBPR1lH4CV8,
cbostic-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8,
joel-U3u1mxZcP9KHXe+LvDLADg,
eajames-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8, Edward A. James
From: "Edward A. James" <eajames-r/Jw6+rmf7HQT0dZR+AlfA@public.gmane.org>
This series adds two FSI-based device drivers; one for the SBEFIFO and one for
the On-Chip Controller (OCC).
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 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.
Changes since v4:
* Use irqsave/irqrestore for spinlocks.
* Put the OCC driver in the same patchset as it doesn't build without SBEFIFO.
* Switch to reference counting for OCC clients.
Changes since v3:
* Add reset procedure and use it if there is data in the FIFO at probe time.
* Add timeout for waiting for data to appear in the FIFO; if the SBE isn't
running, then previously we would wait forever.
* Fix remove() order of operations for both drivers.
* Fix xfr memory leak for SBEFIFO.
* Formatting fixes.
Changes since v2:
* Rename occ.c and occ.h to fsi-occ.c and fsi-occ.h
* Improved remove() ordering in both drivers.
* Added cancel functionality to OCC driver to make sure no xfrs started during
remove().
* Fix spin_unlock with spin_unlock_irq in OCC driver.
* Fix list_first_entry with list_first_entry_or_null in OCC worker function.
* Add OCC response definitions to OCC include file.
* Handle probe() failures better.
Changes since v1:
* Split bindings into separate patch and added SBEFIFO device binding
* Fixed #includes
* Fix SBEFIFO race condition between write() and poll_timer().
* Followed Rob's suggestion to just create one platform device for hwmon
driver, instead of using the device tree.
* Also check for "command in progress" response from OCC and try a while
Edward A. James (8):
dt-bindings: fsi: Add SBEFIFO documentation
drivers/fsi: Add SBEFIFO FSI client device driver
drivers/fsi: sbefifo: Add miscdevice
drivers/fsi: sbefifo: Add in-kernel API
dt-bindings: fsi: Add OCC documentation
drivers/fsi: Add On-Chip Controller (OCC) driver
drivers/fsi: occ: Add miscdevice
drivers/fsi: occ: Add in-kernel API
.../devicetree/bindings/fsi/ibm,p9-occ.txt | 18 +
.../devicetree/bindings/fsi/ibm,p9-sbefifo.txt | 35 +
drivers/fsi/Kconfig | 17 +
drivers/fsi/Makefile | 2 +
drivers/fsi/fsi-occ.c | 876 +++++++++++++++++
drivers/fsi/fsi-sbefifo.c | 1027 ++++++++++++++++++++
include/linux/fsi-occ.h | 41 +
include/linux/fsi-sbefifo.h | 30 +
8 files changed, 2046 insertions(+)
create mode 100644 Documentation/devicetree/bindings/fsi/ibm,p9-occ.txt
create mode 100644 Documentation/devicetree/bindings/fsi/ibm,p9-sbefifo.txt
create mode 100644 drivers/fsi/fsi-occ.c
create mode 100644 drivers/fsi/fsi-sbefifo.c
create mode 100644 include/linux/fsi-occ.h
create mode 100644 include/linux/fsi-sbefifo.h
--
1.8.3.1
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [patches] Re: [PATCH v9 03/12] dt-bindings: RISC-V CPU Bindings
From: Palmer Dabbelt @ 2017-11-20 19:45 UTC (permalink / raw)
To: j.neuschaefer, Mark Rutland
Cc: patches, Arnd Bergmann, Stephen Rothwell, Olof Johansson,
linux-kernel, robh+dt, albert, yamada.masahiro, mmarek,
Will Deacon, peterz, boqun.feng, oleg, mingo, devicetree,
rminnich
In-Reply-To: <20171120073528.xkv4cydyniuhzshf@latitude>
On Sun, 19 Nov 2017 23:35:28 PST (-0800), j.neuschaefer@gmx.net wrote:
> Hi Palmer,
>
> On Thu, Oct 05, 2017 at 11:16:33AM +0100, Mark Rutland wrote:
> [...]
>> I would *strongly* recommend that from day one, you determine the SMP
>> bringup mechanism via an enable-method property, and document the
>> contract with FW/bootloader somewhere in the kernel tree.
Sorry, I forgot about this. I've prepared a patch.
> Somewhat, but not quite related: Please consider making the availability
> of the Supervisor Binary Interface explicit in the devicetree.
> I understand that the general plan is to make the SBI a mandatory
> feature of every RISC-V system capable of running Linux, but I do want
> to explore the possibility of running without run-time resident firmware
> at some point in the future. Thus it would be nice if the devicetree
> would indicate the presence of the SBI from the start, to avoid having
> to invent a way to express its *absence* later on.
>
> It could look something like this (modelled after qcom,scm):
>
> / {
> firmware {
> sbi {
> compatible = "riscv,sbi";
> };
> };
> };
>
> This topic may warrant some discussion, because other people may have
> different opinions, and there hasn't been a discussion about it, AFAICS.
I don't think there's any penalty to putting it in the device tree, I'll send a
patch.
^ permalink raw reply
* [PATCH v7 1/3] dt-bindings: net: add mt76 wireless device binding
From: Felix Fietkau @ 2017-11-20 19:35 UTC (permalink / raw)
To: linux-wireless-u79uwXL29TY76Z2rM5mHXA
Cc: kvalo-sgV2jX0FEOL9JmXXK+q4OQ, devicetree-u79uwXL29TY76Z2rM5mHXA,
Rob Herring
In-Reply-To: <20171120193549.80831-1-nbd-Vt+b4OUoWG0@public.gmane.org>
Add documentation describing how device tree can be used to configure
wireless chips supported by the mt76 driver.
Signed-off-by: Felix Fietkau <nbd-Vt+b4OUoWG0@public.gmane.org>
---
.../bindings/net/wireless/mediatek,mt76.txt | 32 ++++++++++++++++++++++
1 file changed, 32 insertions(+)
create mode 100644 Documentation/devicetree/bindings/net/wireless/mediatek,mt76.txt
diff --git a/Documentation/devicetree/bindings/net/wireless/mediatek,mt76.txt b/Documentation/devicetree/bindings/net/wireless/mediatek,mt76.txt
new file mode 100644
index 000000000000..0c17a0ec9b7b
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/wireless/mediatek,mt76.txt
@@ -0,0 +1,32 @@
+* MediaTek mt76xx devices
+
+This node provides properties for configuring the MediaTek mt76xx wireless
+device. The node is expected to be specified as a child node of the PCI
+controller to which the wireless chip is connected.
+
+Optional properties:
+
+- mac-address: See ethernet.txt in the parent directory
+- local-mac-address: See ethernet.txt in the parent directory
+- ieee80211-freq-limit: See ieee80211.txt
+- mediatek,mtd-eeprom: Specify a MTD partition + offset containing EEPROM data
+
+Optional nodes:
+- led: Properties for a connected LED
+ Optional properties:
+ - led-sources: See Documentation/devicetree/bindings/leds/common.txt
+
+&pcie {
+ pcie0 {
+ wifi@0,0 {
+ compatible = "mediatek,mt76";
+ reg = <0x0000 0 0 0 0>;
+ ieee80211-freq-limit = <5000000 6000000>;
+ mediatek,mtd-eeprom = <&factory 0x8000>;
+
+ led {
+ led-sources = <2>;
+ };
+ };
+ };
+};
--
2.14.2
^ permalink raw reply related
* [PATCH] ARM: dts: imx6qdl-udoo: disable AC'97 input pins pad drivers
From: Maciej S. Szmigiero @ 2017-11-20 19:08 UTC (permalink / raw)
To: Shawn Guo, Sascha Hauer
Cc: Fabio Estevam, linux-arm-kernel, devicetree, linux-kernel
AC'97 interface RXD and TXC pins are only used as SoC inputs, let's disable
pad drivers for them so we will be protected if, for example, TCLKDIR is
set by mistake in AUDMUX and causes TXC pin to be configured as an output.
This also changes pull direction on these pins from pull-up to pull-down
to match what the board AC'97 CODEC chip (VT1613) has on these pins.
Signed-off-by: Maciej S. Szmigiero <mail@maciej.szmigiero.name>
---
arch/arm/boot/dts/imx6qdl-udoo.dtsi | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/arch/arm/boot/dts/imx6qdl-udoo.dtsi b/arch/arm/boot/dts/imx6qdl-udoo.dtsi
index a173de20ee73..dd69e8397116 100644
--- a/arch/arm/boot/dts/imx6qdl-udoo.dtsi
+++ b/arch/arm/boot/dts/imx6qdl-udoo.dtsi
@@ -199,8 +199,8 @@
fsl,pins = <
MX6QDL_PAD_DI0_PIN2__AUD6_TXD 0x1b0b0
MX6QDL_PAD_DI0_PIN3__AUD6_TXFS 0x1b0b0
- MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x1b0b0
- MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x1b0b0
+ MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x13080
+ MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x13080
MX6QDL_PAD_EIM_EB2__GPIO2_IO30 0x1b0b0
>;
};
@@ -209,8 +209,8 @@
fsl,pins = <
MX6QDL_PAD_DI0_PIN2__AUD6_TXD 0x1b0b0
MX6QDL_PAD_DI0_PIN3__GPIO4_IO19 0x1b0b0
- MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x1b0b0
- MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x1b0b0
+ MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x13080
+ MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x13080
MX6QDL_PAD_EIM_EB2__GPIO2_IO30 0x1b0b0
>;
};
@@ -219,8 +219,8 @@
fsl,pins = <
MX6QDL_PAD_DI0_PIN2__GPIO4_IO18 0x1b0b0
MX6QDL_PAD_DI0_PIN3__GPIO4_IO19 0x1b0b0
- MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x1b0b0
- MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x1b0b0
+ MX6QDL_PAD_DI0_PIN4__AUD6_RXD 0x13080
+ MX6QDL_PAD_DI0_PIN15__AUD6_TXC 0x13080
MX6QDL_PAD_EIM_EB2__GPIO2_IO30 0x1b0b0
>;
};
--
2.14.1
^ permalink raw reply related
* Re: [PATCH v3 1/3] dt-bindings: mailbox: Introduce Hi3660 controller binding
From: Rob Herring @ 2017-11-20 19:03 UTC (permalink / raw)
To: Xu YiPing
Cc: mark.rutland-5wv7dgnIgG8, xuwei5-C8/M+/jPZTeaMJb+Lgu22Q,
catalin.marinas-5wv7dgnIgG8, will.deacon-5wv7dgnIgG8,
jassisinghbrar-Re5JQEeQqe8AvxtiuMwx3w,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA,
linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r,
guodong.xu-QSEj5FYQhm4dnm+yROfE0A,
haojian.zhuang-QSEj5FYQhm4dnm+yROfE0A,
suzhuangluan-C8/M+/jPZTeaMJb+Lgu22Q,
xuezhiliang-C8/M+/jPZTeaMJb+Lgu22Q,
kevin.wangtao-C8/M+/jPZTeaMJb+Lgu22Q,
zhongkaihua-hv44wF8Li93QT0dZR+AlfA
In-Reply-To: <1510910672-1409-2-git-send-email-xuyiping-C8/M+/jPZTeaMJb+Lgu22Q@public.gmane.org>
On Fri, Nov 17, 2017 at 05:24:30PM +0800, Xu YiPing wrote:
> From: Leo Yan <leo.yan-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
>
> Introduce a binding for the Hi3660 mailbox controller, the mailbox is
> used within application processor (AP), communication processor (CP),
> HIFI and MCU, etc.
>
> Signed-off-by: Leo Yan <leo.yan-QSEj5FYQhm4dnm+yROfE0A@public.gmane.org>
> ---
> .../bindings/mailbox/hisilicon,hi3660-mailbox.txt | 51 ++++++++++++++++++++++
> 1 file changed, 51 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/mailbox/hisilicon,hi3660-mailbox.txt
Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH] gpio: pca953x: fix vendor prefix for PCA9654
From: Rob Herring @ 2017-11-20 19:01 UTC (permalink / raw)
To: Sergei Shtylyov
Cc: Linus Walleij, linux-gpio, devicetree, Mark Rutland,
linux-renesas-soc
In-Reply-To: <20171116201842.006310882@cogentembedded.com>
On Thu, Nov 16, 2017 at 11:18:32PM +0300, Sergei Shtylyov wrote:
> Despite commit 55020c8056a8 ("of: Add vendor prefix for ON Semiconductor
> Corp.") was made long ago, the latter commit 9f49f6dd0473 ("gpio: pca953x:
> add onsemi,pca9654 id") made use of another, undocumented vendor prefix.
> Since such prefix doesn't seem to be used in any device trees, I think we
> can just fix the "compatible" string in the driver and the bindings and be
> done with that...
>
> Fixes: 9f49f6dd0473 ("gpio: pca953x: add onsemi,pca9654 id")
> Signed-off-by: Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
>
> ---
> The patch is against the 'fixes' branch of LinusW's 'linux-gpio.git' repo.
>
> Documentation/devicetree/bindings/gpio/gpio-pca953x.txt | 2 +-
> drivers/gpio/gpio-pca953x.c | 2 +-
> 2 files changed, 2 insertions(+), 2 deletions(-)
Acked-by: Rob Herring <robh@kernel.org>
^ permalink raw reply
* Re: [PATCH] gpio: pca953x: fix vendor prefix for PCA9654
From: Rob Herring @ 2017-11-20 18:59 UTC (permalink / raw)
To: Sergei Shtylyov
Cc: Geert Uytterhoeven, Linus Walleij, linux-gpio@vger.kernel.org,
devicetree@vger.kernel.org, Mark Rutland, Linux-Renesas
In-Reply-To: <7232ae40-189b-9ec5-87ef-7933e161422f@cogentembedded.com>
On Fri, Nov 17, 2017 at 01:47:04PM +0300, Sergei Shtylyov wrote:
> On 11/17/2017 12:06 PM, Geert Uytterhoeven wrote:
>
> > > Despite commit 55020c8056a8 ("of: Add vendor prefix for ON Semiconductor
> > > Corp.") was made long ago, the latter commit 9f49f6dd0473 ("gpio: pca953x:
> > > add onsemi,pca9654 id") made use of another, undocumented vendor prefix.
> >
> > Ouch...
> >
> > > Since such prefix doesn't seem to be used in any device trees, I think we
> > > can just fix the "compatible" string in the driver and the bindings and be
> > > done with that...
> > >
> > > Fixes: 9f49f6dd0473 ("gpio: pca953x: add onsemi,pca9654 id")
> > > Signed-off-by: Sergei Shtylyov <sergei.shtylyov@cogentembedded.com>
> > >
> > > ---
> > > The patch is against the 'fixes' branch of LinusW's 'linux-gpio.git' repo.
> > >
> > > Documentation/devicetree/bindings/gpio/gpio-pca953x.txt | 2 +-
> > > drivers/gpio/gpio-pca953x.c | 2 +-
> >
> > There's another (different) one in
> > Documentation/devicetree/bindings/misc/idt_89hpesx.txt
>
> Saw that. Do you think it also should be fixed (in this patch)?
IMO, separate.
^ permalink raw reply
* Re: [RFC v2 1/2] backlight: pwm_bl: linear interpolation between values of brightness-levels
From: Rob Herring @ 2017-11-20 18:58 UTC (permalink / raw)
To: Enric Balletbo i Serra
Cc: Daniel Thompson, Jingoo Han, Richard Purdie, Jacek Anaszewski,
Pavel Machek, Doug Anderson, Brian Norris, Guenter Roeck,
Lee Jones, Alexandru Stan, linux-leds, devicetree, linux-kernel
In-Reply-To: <20171116141151.21171-2-enric.balletbo@collabora.com>
On Thu, Nov 16, 2017 at 03:11:50PM +0100, Enric Balletbo i Serra wrote:
> Setting use-linear-interpolation in the dts will allow you to have linear
> interpolation between values of brightness-levels.
>
> There are now 256 between each of the values of brightness-levels. If
> something is requested halfway between 2 values, we'll use linear
> interpolation.
>
> This way a high resolution pwm duty cycle can be used without having to
> list out every possible value in the dts.
I thought we already had a way to do that.
> This system also allows for
> gamma corrected values (eg: "brightness-levels = <0 2 4 8 16 32>;").
>
> Patch based on the Alexandru M Stan work done for ChromeOS kernels.
>
> Signed-off-by: Enric Balletbo i Serra <enric.balletbo@collabora.com>
> ---
> .../bindings/leds/backlight/pwm-backlight.txt | 2 +
> drivers/video/backlight/pwm_bl.c | 55 +++++++++++++++++-----
> include/linux/pwm_backlight.h | 2 +
> 3 files changed, 47 insertions(+), 12 deletions(-)
>
> diff --git a/Documentation/devicetree/bindings/leds/backlight/pwm-backlight.txt b/Documentation/devicetree/bindings/leds/backlight/pwm-backlight.txt
> index 764db86..7c48f20 100644
> --- a/Documentation/devicetree/bindings/leds/backlight/pwm-backlight.txt
> +++ b/Documentation/devicetree/bindings/leds/backlight/pwm-backlight.txt
> @@ -17,6 +17,8 @@ Optional properties:
> "pwms" property (see PWM binding[0])
> - enable-gpios: contains a single GPIO specifier for the GPIO which enables
> and disables the backlight (see GPIO binding[1])
> + - use-linear-interpolation: set this propriety to enable linear interpolation
> + between each of the values of brightness-levels.
Isn't this really just whether you allow values not listed because what
other kind of interpolation would you do? Seems like you should just be
able to query the resolution of the PWM and decide if it can take more
values than listed.
Rob
^ permalink raw reply
* Re: [RFC PATCH 1/3] dt-bindings: pinctrl: sunxi: document new generic binding
From: Rob Herring @ 2017-11-20 18:52 UTC (permalink / raw)
To: Andre Przywara
Cc: Linus Walleij, Maxime Ripard, Chen-Yu Tsai, linux-gpio,
Mark Rutland, devicetree, linux-arm-kernel, Arnd Bergmann,
Icenowy Zheng
In-Reply-To: <20171113012523.2328-2-andre.przywara@arm.com>
On Mon, Nov 13, 2017 at 01:25:21AM +0000, Andre Przywara wrote:
> So far all the Allwinner pinctrl drivers provided a table in the
> kernel to describe all the pins and the link between the pinctrl functions
> names (strings) and their respective mux values (register values).
>
> Extend the binding to put those mappings in the DT, so that any SoC can
> describe its pinctrl and GPIO data fully there instead of relying on
> tables.
> This uses a generic compatible name, to be prepended with an SoC
> specific name in the node.
>
> Signed-off-by: Andre Przywara <andre.przywara@arm.com>
> ---
> .../bindings/pinctrl/allwinner,sunxi-pinctrl.txt | 58 ++++++++++++++++++++++
> 1 file changed, 58 insertions(+)
I'm leaving this one to Linus...
Generally, this has not been the direction we've wanted to go. What
makes this unique to Allwinner?
Rob
^ permalink raw reply
* Re: [v5 RESEND 07/17] regulator: arizona-micsupp: Add support for Cirrus Logic Madera codecs
From: Rob Herring @ 2017-11-20 18:47 UTC (permalink / raw)
To: Richard Fitzgerald
Cc: lee.jones, broonie, linus.walleij, gnurou, tglx, jason,
alsa-devel, patches, linux-gpio, devicetree, linux-kernel,
Richard Fitzgerald
In-Reply-To: <20171120141051.29467-8-rf@opensource.cirrus.com>
On Mon, Nov 20, 2017 at 02:10:41PM +0000, Richard Fitzgerald wrote:
> From: Richard Fitzgerald <rf@opensource.wolfsonmicro.com>
>
> This adds a new driver identity "madera-micsupp" and probe function
> so that this driver can be used to control the micsupp regulator on
> Cirrus Logic Madera codecs.
>
> Signed-off-by: Richard Fitzgerald <rf@opensource.wolfsonmicro.com>
> ---
> .../bindings/regulator/arizona-regulator.txt | 3 +-
Please add acks when posting a new version.
> drivers/regulator/Kconfig | 7 ++-
> drivers/regulator/arizona-micsupp.c | 71 +++++++++++++++++++++-
> 3 files changed, 76 insertions(+), 5 deletions(-)
^ permalink raw reply
* Re: [v5 RESEND 02/17] mfd: madera: Add DT bindings for Cirrus Logic Madera codecs
From: Rob Herring @ 2017-11-20 18:46 UTC (permalink / raw)
To: Richard Fitzgerald
Cc: lee.jones-QSEj5FYQhm4dnm+yROfE0A, broonie-DgEjT+Ai2ygdnm+yROfE0A,
linus.walleij-QSEj5FYQhm4dnm+yROfE0A,
gnurou-Re5JQEeQqe8AvxtiuMwx3w, tglx-hfZtesqFncYOwBW4kG4KsQ,
jason-NLaQJdtUoK4Be96aLqz0jA, alsa-devel-K7yf7f+aM1XWsZ/bQMPhNw,
patches-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E,
linux-gpio-u79uwXL29TY76Z2rM5mHXA,
devicetree-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA, Richard Fitzgerald
In-Reply-To: <20171120141051.29467-3-rf-yzvPICuk2AA4QjBA90+/kJqQE7yCjDx5@public.gmane.org>
On Mon, Nov 20, 2017 at 02:10:36PM +0000, Richard Fitzgerald wrote:
> From: Richard Fitzgerald <rf-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E@public.gmane.org>
>
> Specification of the bindings for the parent MFD driver component
> of the Cirrus Logic Madera codec drivers.
>
> Note that although the interrupt controller and GPIO are child
> drivers their required bindings are trivial, mandatory, and exist
> within the parent MFD node so are documented here.
>
> Signed-off-by: Richard Fitzgerald <rf-yzvPICuk2AATkU/dhu1WVueM+bqZidxxQQ4Iyu8u01E@public.gmane.org>
> ---
> Documentation/devicetree/bindings/mfd/madera.txt | 102 +++++++++++++++++++++++
> 1 file changed, 102 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/mfd/madera.txt
Please add acks when posting new versions.
Rob
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* [GIT PULL] DeviceTree fixes for 4.15
From: Rob Herring @ 2017-11-20 18:34 UTC (permalink / raw)
To: Linus Torvalds
Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org,
Frank Rowand, Mark Rutland
Linus,
Please pull DT fixes for 4.15.
Rob
The following changes since commit aa25e446ce76c37bfd75ac06598c316af94e9a26:
dt-bindings: usb: add #phy-cells to usb-nop-xceiv (2017-11-13 16:50:01 -0600)
are available in the git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git
tags/devicetree-fixes-for-4.15
for you to fetch changes up to def4db33e69609a43b28b399d569b6a0d3ba272a:
dt-bindings: trivial-devices: Remove fsl,mc13892 (2017-11-20 12:26:23 -0600)
----------------------------------------------------------------
DeviceTree fixes for 4.15:
- Remove mc13892 as a trivial device
- Improve of_find_node_by_name() documentation
- Fix unit test dtc warnings
- Clean-ups of USB binding documentation
- Fix potential NULL deref in of_pci_map_rid
----------------------------------------------------------------
Johan Hovold (4):
dt-bindings: usb: fix example hub node name
dt-bindings: usb: fix reg-property port-number range
dt-bindings: usb: clean up compatible property
dt-bindings: usb: document hub and host-controller properties
Jonathan Neuschäfer (1):
dt-bindings: trivial-devices: Remove fsl,mc13892
Rob Herring (2):
of: unittest: let dtc generate __local_fixups__
of: unittest: disable interrupts_property warning
Robin Murphy (1):
of/pci: Fix theoretical NULL dereference
Stephen Boyd (1):
of: Document exactly what of_find_node_by_name() puts
.../devicetree/bindings/trivial-devices.txt | 1 -
.../devicetree/bindings/usb/usb-device.txt | 33 +++++++----
drivers/of/base.c | 6 +-
drivers/of/of_pci.c | 2 +-
drivers/of/unittest-data/Makefile | 1 +
drivers/of/unittest-data/testcases.dts | 65 +---------------------
6 files changed, 29 insertions(+), 79 deletions(-)
^ permalink raw reply
* Re: [PATCH 1/5] checks: add a string checks for label, bootargs and stdout-path
From: Rob Herring @ 2017-11-20 17:26 UTC (permalink / raw)
To: David Gibson
Cc: Devicetree Compiler,
devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
In-Reply-To: <20171120000954.GF19214-K0bRW+63XPQe6aEkudXLsA@public.gmane.org>
On Sun, Nov 19, 2017 at 6:09 PM, David Gibson
<david-xT8FGy+AXnRB3Ne2BGzF6laj5H9X9Tb+@public.gmane.org> wrote:
> On Fri, Nov 17, 2017 at 08:45:11AM -0600, Rob Herring wrote:
>> Add more string property checks for label, bootargs, and stdout-path.
>
> Where does 'label' appear? I'm not immediately recalling it as a
> property with global meaning.
It's documented in DT spec/ePAPR. It can be anywhere. It's the
property for the human readable identifiers such as the label on
ethernet ports, serial ports, LEDs, etc.
> bootargs and stdout-path are from /chosen of course. I have some
> mixed feelings about whether it's reasonable to check it's a string
> everywhere, rather than specifically just in /chosen.
We don't really want to see the same property names with different
meanings. I think checking the location is a separate check. You've
generally suggested splitting up tests rather than have all in one
tests. Not sure if we should check known properties only appear in
chosen or that chosen only has known properties (assuming we can
enumerate that list. Maybe we allow things like "linux,*").
Rob
^ permalink raw reply
* Re: [PATCH v2] dt-bindings: mtd: Add sst25vf016b to the list of supported chip names
From: Cyrille Pitchen @ 2017-11-20 17:08 UTC (permalink / raw)
To: Geert Uytterhoeven
Cc: Fabrizio Castro, David Woodhouse, Brian Norris, Boris Brezillon,
Marek Vasut, Richard Weinberger, Rob Herring, Mark Rutland,
devicetree@vger.kernel.org, Chris Paterson,
linux-kernel@vger.kernel.org, Biju Das, MTD Maling List
In-Reply-To: <CAMuHMdWZ=71XvVyzsiPyiAz+0RsCZjmWqqvOKs=bDdSQMpLmnA@mail.gmail.com>
Hi Geert,
Le 20/11/2017 à 09:49, Geert Uytterhoeven a écrit :
> Hi Cyrille,
>
> On Fri, Nov 17, 2017 at 6:36 PM, Cyrille Pitchen
> <cyrille.pitchen@wedev4u.fr> wrote:
>> sorry but I won't apply this patch.
>>
>> New values for the 'compatible' DT properties should only be added for
>> memory parts not supporting the JEDEC READ ID (0x9F) command.
>
> I tent to disagree. Documenting part numbers in the DT bindings serves two
> purposes:
> 1. Documenting which parts are supported,
Documenting supported memory parts is not the same as documenting chip names
that can be used in the 'compatible' DT property. Here we are talking about
DT bindings.
> 2. Allowing checkpatch to validate compatible values in DTS files (see
> below).
>
I you want to pass the checkpatch test then use the "jedec,spi-nor" string
alone. Please have a look at the drives/mtd/devices/m25p80.c file in the
m25p_of_table[] array: this is the value to be set in the 'compatible' DT
property.
SST25 memories do support the JEDEC READ ID op code (0x9F), so there is no
reason to use any other value but "jedec,spi-nor" for the 'compatible' DT
property.
Adding useless values would go to the wrong direction:
3094fe121e75 ("mtd: m25p80: remove unused flash entries from id_table")
As I've explained, the only new values that should be added in the m25p80.c
driver and the jedec,spi-nor.txt files are those for memory parts not
supporting the JEDEC READ ID op code (0x9F). No exception to that rule.
Also please note that there are far more entries in the spi_nor_ids[] array
from drivers/mtd/spi-nor/spi-nor.c than in the m25p_ids[] array from
drivers/mtd/devices/m25p80.c. Indeed, names in the spi_nor_ids[] array are
mostly informative and should not be considered as values for the
'compatible' DT properties.
For 'compatible' values, you should consider the m25p80.c driver only.
Moreover, we should refer to the comment in the m25p_ids[] array, applying
to the sst25vf016b memory part:
"""
Entries that were used in DTs without "jedec,spi-nor" fallback and
should be kept for backward compatibility.
"""
This is for backward compatibility purpose only, with some existing DTs,
likely before the "jedec,spi-nor" string was introduced.
However new DTs using values like "sst25vf016b" are _wrong_ and that's
why this is not documented is the jedec,spi-nor.txt file.
Best regards,
Cyrille
> Unfortunately the current
> Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt
> is useless for the latter, as the values listed don't contain the vendor
> prefixes, still causing warnings like
>
> WARNING: DT compatible string "sst,sst25vf016b" appears un-documented
> -- check ./Documentation/devicetree/bindings/
> #79: FILE: arch/arm/boot/dts/r8a7743-iwg20m.dtsi:79:
> + compatible = "sst,sst25vf016b", "jedec,spi-nor";
>
This is a deprecated usage. I agree some DT use such patterns; this is
legacy and we have to deal with it however it doesn't mean that it is the
correct binding. New device trees should use "jedec,spi-nor" alone.
That's something I plan to clarify in the jedec,spi-nor.txt file once
4.15-rc1 will be released.
> So I suggest prepending all part number with the appropriate vendor prefixes
> in jedec,spi-nor.txt.
>
And which prefix should be use ? I see both "microchip,sst25vf016b" and
"sst,sst25vf016b" in device trees.
> BTW, "sst" (for Silicon Storage Technology) should be added to
> Documentation/devicetree/bindings/vendor-prefixes.txt, too, to avoid another
> warning:
>
> WARNING: DT compatible string vendor "sst" appears un-documented --
> check ./Documentation/devicetree/bindings/vendor-prefixes.txt
> #79: FILE: arch/arm/boot/dts/r8a7743-iwg20m.dtsi:79:
> + compatible = "sst,sst25vf016b", "jedec,spi-nor";
>
>> SST25 memories do support this command hence should use the "jedec,spi-nor"
>> value alone. For historical reasons, some DT nodes set their 'compatible'
>> string to something like "<vendor>,<model>", "jedec,spi-nor".
>> It should work as expected in most case however I discourage from doing so
>> in new device trees because it may have some side effects especially when
>> the m25p80.c driver is used between the spi-nor.c driver and the SPI
>> controller driver.
>
> It is considered good practice to always have in DT a compatible value for
> the real part number, not just for a generic fallback.
> This allows to discriminate using the real part number, in case an anomaly
> shows up later.
> How else are you gonna handle e.g. a production batch that accidentally
> contains a wrong JEDEC ID? And adding the part-specific compatible value
> after the discovery won't help, as it won't be present in existing DTSes.
>
>> It's all about setting the 2nd parameter of spi_nor_scan(), the 'name'
>> parameter, as NULL when possible. This parameter should be set to a non NULL
>> value only for memories not supporting the JEDEC READ ID op code (0x9F).
>>
>> Best regards,
>>
>> Cyrille
>>
>> Le 24/10/2017 à 15:50, Fabrizio Castro a écrit :
>>> There are a few DT files that make use of sst25vf016b in their
>>> compatible strings, and the driver supports this chip already.
>>> This patch improves the documentation and therefore the result
>>> of ./scripts/checkpatch.pl.
>>>
>>> Signed-off-by: Fabrizio Castro <fabrizio.castro@bp.renesas.com>
>>> Signed-off-by: Chris Paterson <Chris.Paterson2@renesas.com>
>>> Acked-by: Rob Herring <robh@kernel.org>
>>> Acked-by: Geert Uytterhoeven <geert+renesas@glider.be>
>>> ---
>>> Thank you Rob, thank you Geert, and sorry for the delay on this one.
>>> Here is v2.
>>>
>>> Changes in v2:
>>> * fixed subject prefix
>>> * added changelog
>>>
>>> Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt | 1 +
>>> 1 file changed, 1 insertion(+)
>>>
>>> diff --git a/Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt b/Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt
>>> index 4cab5d8..bf56d77 100644
>>> --- a/Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt
>>> +++ b/Documentation/devicetree/bindings/mtd/jedec,spi-nor.txt
>>> @@ -31,6 +31,7 @@ Required properties:
>>> s25sl12801
>>> s25fl008k
>>> s25fl064k
>>> + sst25vf016b
>>> sst25vf040b
>>> sst25wf040b
>>> m25p40
>
> Gr{oetje,eeting}s,
>
> Geert
>
> --
> Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- geert@linux-m68k.org
>
> In personal conversations with technical people, I call myself a hacker. But
> when I'm talking to journalists I just say "programmer" or something like that.
> -- Linus Torvalds
>
^ permalink raw reply
* Re: RFC: Copying Device Tree File into reserved area of VMLINUX before deployment
From: Frank Rowand @ 2017-11-20 16:38 UTC (permalink / raw)
To: Mark Rutland
Cc: linux-kernel-AoFPY8dbyRPQT0dZR+AlfA, LKML,
devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Rob Herring
In-Reply-To: <20171120114405.cpsf4xtvvfpuk76u-agMKViyK24J5pKCnmE3YQBJ8xKzm50AiAL8bYrjMMd8@public.gmane.org>
Ulf,
On 11/20/17 06:44, Mark Rutland wrote:
> On Sun, Nov 19, 2017 at 11:23:42PM -0500, Frank Rowand wrote:
>> adding devicetree list, devicetree maintainers
>>
>> On 11/18/17 12:59, Ulf Samuelsson wrote:
>>> I noticed when checking out the OpenWRT support for the board that they have a method to avoid having to pass the device tree address to the kernel, and can thus boot device tree based kernels with U-boots that
>>> does not support device trees.
>>>
>>> Is this something that would be considered useful for including in mainstream:
>
> On 32-bit arm, we support an appended DTB for cases like this. The DTB
> is appended to the end of the kernel image, rather than being embedded.
That is CONFIG_ARM_APPENDED_DTB, if you want to see what it looks like.
> Does mips not support something similar?
>
> Thanks,
> Mark.
>
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH 4/5] checks: check for #{size,address}-cells without child nodes
From: Rob Herring @ 2017-11-20 16:22 UTC (permalink / raw)
To: David Gibson
Cc: Devicetree Compiler,
devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
In-Reply-To: <20171120001438.GJ19214-K0bRW+63XPQe6aEkudXLsA@public.gmane.org>
On Sun, Nov 19, 2017 at 6:14 PM, David Gibson
<david-xT8FGy+AXnRB3Ne2BGzF6laj5H9X9Tb+@public.gmane.org> wrote:
> On Fri, Nov 17, 2017 at 08:45:14AM -0600, Rob Herring wrote:
>> nodes with a 'reg' property nor a ranges property.
>>
>> An exception may be an overlay that adds nodes, but this case would
>> need
>
> Sentence doesn't seem finished..
It was there until I rebased. Since the line started with #, git dropped it...
"#{size,address}-cells in the overlay to properly compile already."
> In any case, I'm not sure this is a good idea. It's not uncommon to
> have bus bridge nodes that ought to have a well defined #address and
> #size cells, but just don't happen to have any plugged devices yet.
> An overlay that adds nodes is one possibility, but a bus where the
> children can be probed is another.
Wouldn't an overlay without #{size,address}-cells have warnings from
avoid_default_addr_size?
As long as there are no child nodes, the check is not run. So we're
limited to false positives if we have a mixture of nodes with and
without unit addresses and only the nodes without unit addresses are
populated. I have seen this with PCI hosts with an interrupt
controller child node.
In general, I'm struggling with how to have tests that check for
things that we generally want to avoid, but we still allow exceptions.
Some of these may be things we want to avoid in new bindings, but
wouldn't fix for existing cases. Another example is things that
were/are valid for OF, but not FDT.
Rob
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox