Merge tag 'tegra-for-4.15-firmware' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/tegra/linux into next/drivers

Pull "firmware: tegra: Changes for v4.15-rc1" from Thierry Reding:

This contains a couple of (non-critical) fixes and improvements for the
BPMP driver as well as support for debugfs.

* tag 'tegra-for-4.15-firmware' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/tegra/linux:
  firmware: tegra: Add BPMP debugfs support
  firmware: tegra: Add stubs when BPMP not enabled
  firmware: tegra: Expose tegra_bpmp_mrq_return()
  firmware: tegra: Propagate error code to caller

3 files changed, 470 insertions, 9 deletions

diff --git a/drivers/firmware/tegra/Makefile b/drivers/firmware/tegra/Makefile
index e34a2f79e1ad..1b826dcca719 100644
--- a/drivers/firmware/tegra/Makefile
+++ b/drivers/firmware/tegra/Makefile
@@ -1,2 +1,4 @@
-obj-$(CONFIG_TEGRA_BPMP)        += bpmp.o
+tegra-bpmp-y                    = bpmp.o
+tegra-bpmp-$(CONFIG_DEBUG_FS)   += bpmp-debugfs.o
+obj-$(CONFIG_TEGRA_BPMP)        += tegra-bpmp.o
 obj-$(CONFIG_TEGRA_IVC)         += ivc.o
diff --git a/drivers/firmware/tegra/bpmp-debugfs.c b/drivers/firmware/tegra/bpmp-debugfs.c
new file mode 100644
index 000000000000..f7f6a0a5cb07
--- /dev/null
+++ b/drivers/firmware/tegra/bpmp-debugfs.c
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ */
+#include <linux/debugfs.h>
+#include <linux/dma-mapping.h>
+#include <linux/uaccess.h>
+
+#include <soc/tegra/bpmp.h>
+#include <soc/tegra/bpmp-abi.h>
+
+struct seqbuf {
+        char *buf;
+        size_t pos;
+        size_t size;
+};
+
+static void seqbuf_init(struct seqbuf *seqbuf, void *buf, size_t size)
+{
+        seqbuf->buf = buf;
+        seqbuf->size = size;
+        seqbuf->pos = 0;
+}
+
+static size_t seqbuf_avail(struct seqbuf *seqbuf)
+{
+        return seqbuf->pos < seqbuf->size ? seqbuf->size - seqbuf->pos : 0;
+}
+
+static size_t seqbuf_status(struct seqbuf *seqbuf)
+{
+        return seqbuf->pos <= seqbuf->size ? 0 : -EOVERFLOW;
+}
+
+static int seqbuf_eof(struct seqbuf *seqbuf)
+{
+        return seqbuf->pos >= seqbuf->size;
+}
+
+static int seqbuf_read(struct seqbuf *seqbuf, void *buf, size_t nbyte)
+{
+        nbyte = min(nbyte, seqbuf_avail(seqbuf));
+        memcpy(buf, seqbuf->buf + seqbuf->pos, nbyte);
+        seqbuf->pos += nbyte;
+        return seqbuf_status(seqbuf);
+}
+
+static int seqbuf_read_u32(struct seqbuf *seqbuf, uint32_t *v)
+{
+        int err;
+
+        err = seqbuf_read(seqbuf, v, 4);
+        *v = le32_to_cpu(*v);
+        return err;
+}
+
+static int seqbuf_read_str(struct seqbuf *seqbuf, const char **str)
+{
+        *str = seqbuf->buf + seqbuf->pos;
+        seqbuf->pos += strnlen(*str, seqbuf_avail(seqbuf));
+        seqbuf->pos++;
+        return seqbuf_status(seqbuf);
+}
+
+static void seqbuf_seek(struct seqbuf *seqbuf, ssize_t offset)
+{
+        seqbuf->pos += offset;
+}
+
+/* map filename in Linux debugfs to corresponding entry in BPMP */
+static const char *get_filename(struct tegra_bpmp *bpmp,
+                                const struct file *file, char *buf, int size)
+{
+        char root_path_buf[512];
+        const char *root_path;
+        const char *filename;
+        size_t root_len;
+
+        root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf,
+                                sizeof(root_path_buf));
+        if (IS_ERR(root_path))
+                return NULL;
+
+        root_len = strlen(root_path);
+
+        filename = dentry_path(file->f_path.dentry, buf, size);
+        if (IS_ERR(filename))
+                return NULL;
+
+        if (strlen(filename) < root_len ||
+                        strncmp(filename, root_path, root_len))
+                return NULL;
+
+        filename += root_len;
+
+        return filename;
+}
+
+static int mrq_debugfs_read(struct tegra_bpmp *bpmp,
+                            dma_addr_t name, size_t sz_name,
+                            dma_addr_t data, size_t sz_data,
+                            size_t *nbytes)
+{
+        struct mrq_debugfs_request req = {
+                .cmd = cpu_to_le32(CMD_DEBUGFS_READ),
+                .fop = {
+                        .fnameaddr = cpu_to_le32((uint32_t)name),
+                        .fnamelen = cpu_to_le32((uint32_t)sz_name),
+                        .dataaddr = cpu_to_le32((uint32_t)data),
+                        .datalen = cpu_to_le32((uint32_t)sz_data),
+                },
+        };
+        struct mrq_debugfs_response resp;
+        struct tegra_bpmp_message msg = {
+                .mrq = MRQ_DEBUGFS,
+                .tx = {
+                        .data = &req,
+                        .size = sizeof(req),
+                },
+                .rx = {
+                        .data = &resp,
+                        .size = sizeof(resp),
+                },
+        };
+        int err;
+
+        err = tegra_bpmp_transfer(bpmp, &msg);
+        if (err < 0)
+                return err;
+
+        *nbytes = (size_t)resp.fop.nbytes;
+
+        return 0;
+}
+
+static int mrq_debugfs_write(struct tegra_bpmp *bpmp,
+                             dma_addr_t name, size_t sz_name,
+                             dma_addr_t data, size_t sz_data)
+{
+        const struct mrq_debugfs_request req = {
+                .cmd = cpu_to_le32(CMD_DEBUGFS_WRITE),
+                .fop = {
+                        .fnameaddr = cpu_to_le32((uint32_t)name),
+                        .fnamelen = cpu_to_le32((uint32_t)sz_name),
+                        .dataaddr = cpu_to_le32((uint32_t)data),
+                        .datalen = cpu_to_le32((uint32_t)sz_data),
+                },
+        };
+        struct tegra_bpmp_message msg = {
+                .mrq = MRQ_DEBUGFS,
+                .tx = {
+                        .data = &req,
+                        .size = sizeof(req),
+                },
+        };
+
+        return tegra_bpmp_transfer(bpmp, &msg);
+}
+
+static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr,
+                               size_t size, size_t *nbytes)
+{
+        const struct mrq_debugfs_request req = {
+                .cmd = cpu_to_le32(CMD_DEBUGFS_DUMPDIR),
+                .dumpdir = {
+                        .dataaddr = cpu_to_le32((uint32_t)addr),
+                        .datalen = cpu_to_le32((uint32_t)size),
+                },
+        };
+        struct mrq_debugfs_response resp;
+        struct tegra_bpmp_message msg = {
+                .mrq = MRQ_DEBUGFS,
+                .tx = {
+                        .data = &req,
+                        .size = sizeof(req),
+                },
+                .rx = {
+                        .data = &resp,
+                        .size = sizeof(resp),
+                },
+        };
+        int err;
+
+        err = tegra_bpmp_transfer(bpmp, &msg);
+        if (err < 0)
+                return err;
+
+        *nbytes = (size_t)resp.dumpdir.nbytes;
+
+        return 0;
+}
+
+static int debugfs_show(struct seq_file *m, void *p)
+{
+        struct file *file = m->private;
+        struct inode *inode = file_inode(file);
+        struct tegra_bpmp *bpmp = inode->i_private;
+        const size_t datasize = m->size;
+        const size_t namesize = SZ_256;
+        void *datavirt, *namevirt;
+        dma_addr_t dataphys, namephys;
+        char buf[256];
+        const char *filename;
+        size_t len, nbytes;
+        int ret;
+
+        filename = get_filename(bpmp, file, buf, sizeof(buf));
+        if (!filename)
+                return -ENOENT;
+
+        namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
+                                      GFP_KERNEL | GFP_DMA32);
+        if (!namevirt)
+                return -ENOMEM;
+
+        datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
+                                      GFP_KERNEL | GFP_DMA32);
+        if (!datavirt) {
+                ret = -ENOMEM;
+                goto free_namebuf;
+        }
+
+        len = strlen(filename);
+        strncpy(namevirt, filename, namesize);
+
+        ret = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize,
+                               &nbytes);
+
+        if (!ret)
+                seq_write(m, datavirt, nbytes);
+
+        dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
+free_namebuf:
+        dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
+
+        return ret;
+}
+
+static int debugfs_open(struct inode *inode, struct file *file)
+{
+        return single_open_size(file, debugfs_show, file, SZ_128K);
+}
+
+static ssize_t debugfs_store(struct file *file, const char __user *buf,
+                size_t count, loff_t *f_pos)
+{
+        struct inode *inode = file_inode(file);
+        struct tegra_bpmp *bpmp = inode->i_private;
+        const size_t datasize = count;
+        const size_t namesize = SZ_256;
+        void *datavirt, *namevirt;
+        dma_addr_t dataphys, namephys;
+        char fnamebuf[256];
+        const char *filename;
+        size_t len;
+        int ret;
+
+        filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
+        if (!filename)
+                return -ENOENT;
+
+        namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
+                                      GFP_KERNEL | GFP_DMA32);
+        if (!namevirt)
+                return -ENOMEM;
+
+        datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
+                                      GFP_KERNEL | GFP_DMA32);
+        if (!datavirt) {
+                ret = -ENOMEM;
+                goto free_namebuf;
+        }
+
+        len = strlen(filename);
+        strncpy(namevirt, filename, namesize);
+
+        if (copy_from_user(datavirt, buf, count)) {
+                ret = -EFAULT;
+                goto free_databuf;
+        }
+
+        ret = mrq_debugfs_write(bpmp, namephys, len, dataphys,
+                                count);
+
+free_databuf:
+        dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
+free_namebuf:
+        dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
+
+        return ret ?: count;
+}
+
+static const struct file_operations debugfs_fops = {
+        .open           = debugfs_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .write          = debugfs_store,
+        .release        = single_release,
+};
+
+static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf,
+                             struct dentry *parent, uint32_t depth)
+{
+        int err;
+        uint32_t d, t;
+        const char *name;
+        struct dentry *dentry;
+
+        while (!seqbuf_eof(seqbuf)) {
+                err = seqbuf_read_u32(seqbuf, &d);
+                if (err < 0)
+                        return err;
+
+                if (d < depth) {
+                        seqbuf_seek(seqbuf, -4);
+                        /* go up a level */
+                        return 0;
+                } else if (d != depth) {
+                        /* malformed data received from BPMP */
+                        return -EIO;
+                }
+
+                err = seqbuf_read_u32(seqbuf, &t);
+                if (err < 0)
+                        return err;
+                err = seqbuf_read_str(seqbuf, &name);
+                if (err < 0)
+                        return err;
+
+                if (t & DEBUGFS_S_ISDIR) {
+                        dentry = debugfs_create_dir(name, parent);
+                        if (!dentry)
+                                return -ENOMEM;
+                        err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1);
+                        if (err < 0)
+                                return err;
+                } else {
+                        umode_t mode;
+
+                        mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0;
+                        mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0;
+                        dentry = debugfs_create_file(name, mode,
+                                                     parent, bpmp,
+                                                     &debugfs_fops);
+                        if (!dentry)
+                                return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+
+static int create_debugfs_mirror(struct tegra_bpmp *bpmp, void *buf,
+                                 size_t bufsize, struct dentry *root)
+{
+        struct seqbuf seqbuf;
+        int err;
+
+        bpmp->debugfs_mirror = debugfs_create_dir("debug", root);
+        if (!bpmp->debugfs_mirror)
+                return -ENOMEM;
+
+        seqbuf_init(&seqbuf, buf, bufsize);
+        err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0);
+        if (err < 0) {
+                debugfs_remove_recursive(bpmp->debugfs_mirror);
+                bpmp->debugfs_mirror = NULL;
+        }
+
+        return err;
+}
+
+static int mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)
+{
+        struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };
+        struct mrq_query_abi_response resp;
+        struct tegra_bpmp_message msg = {
+                .mrq = MRQ_QUERY_ABI,
+                .tx = {
+                        .data = &req,
+                        .size = sizeof(req),
+                },
+                .rx = {
+                        .data = &resp,
+                        .size = sizeof(resp),
+                },
+        };
+        int ret;
+
+        ret = tegra_bpmp_transfer(bpmp, &msg);
+        if (ret < 0) {
+                /* something went wrong; assume not supported */
+                dev_warn(bpmp->dev, "tegra_bpmp_transfer failed (%d)\n", ret);
+                return 0;
+        }
+
+        return resp.status ? 0 : 1;
+}
+
+int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
+{
+        dma_addr_t phys;
+        void *virt;
+        const size_t sz = SZ_256K;
+        size_t nbytes;
+        int ret;
+        struct dentry *root;
+
+        if (!mrq_is_supported(bpmp, MRQ_DEBUGFS))
+                return 0;
+
+        root = debugfs_create_dir("bpmp", NULL);
+        if (!root)
+                return -ENOMEM;
+
+        virt = dma_alloc_coherent(bpmp->dev, sz, &phys,
+                                  GFP_KERNEL | GFP_DMA32);
+        if (!virt) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        ret = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes);
+        if (ret < 0)
+                goto free;
+
+        ret = create_debugfs_mirror(bpmp, virt, nbytes, root);
+free:
+        dma_free_coherent(bpmp->dev, sz, virt, phys);
+out:
+        if (ret < 0)
+                debugfs_remove(root);
+
+        return ret;
+}
diff --git a/drivers/firmware/tegra/bpmp.c b/drivers/firmware/tegra/bpmp.c
index 73ca55b7b7ec..a7f461f2e650 100644
--- a/drivers/firmware/tegra/bpmp.c
+++ b/drivers/firmware/tegra/bpmp.c
@@ -194,16 +194,24 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
 }
 
 static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
-                                         void *data, size_t size)
+                                         void *data, size_t size, int *ret)
 {
+        int err;
+
         if (data && size > 0)
                 memcpy(data, channel->ib->data, size);
 
-        return tegra_ivc_read_advance(channel->ivc);
+        err = tegra_ivc_read_advance(channel->ivc);
+        if (err < 0)
+                return err;
+
+        *ret = channel->ib->code;
+
+        return 0;
 }
 
 static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
-                                       void *data, size_t size)
+                                       void *data, size_t size, int *ret)
 {
         struct tegra_bpmp *bpmp = channel->bpmp;
         unsigned long flags;
@@ -217,7 +225,7 @@ static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
         }
 
         spin_lock_irqsave(&bpmp->lock, flags);
-        err = __tegra_bpmp_channel_read(channel, data, size);
+        err = __tegra_bpmp_channel_read(channel, data, size, ret);
         clear_bit(index, bpmp->threaded.allocated);
         spin_unlock_irqrestore(&bpmp->lock, flags);
 
@@ -337,7 +345,8 @@ int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,
         if (err < 0)
                 return err;
 
-        return __tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size);
+        return __tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,
+                                         &msg->rx.ret);
 }
 EXPORT_SYMBOL_GPL(tegra_bpmp_transfer_atomic);
 
@@ -371,7 +380,8 @@ int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,
         if (err == 0)
                 return -ETIMEDOUT;
 
-        return tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size);
+        return tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,
+                                       &msg->rx.ret);
 }
 EXPORT_SYMBOL_GPL(tegra_bpmp_transfer);
 
@@ -387,8 +397,8 @@ static struct tegra_bpmp_mrq *tegra_bpmp_find_mrq(struct tegra_bpmp *bpmp,
         return NULL;
 }
 
-static void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel,
-                                  int code, const void *data, size_t size)
+void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,
+                           const void *data, size_t size)
 {
         unsigned long flags = channel->ib->flags;
         struct tegra_bpmp *bpmp = channel->bpmp;
@@ -426,6 +436,7 @@ static void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel,
                 mbox_client_txdone(bpmp->mbox.channel, 0);
         }
 }
+EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);
 
 static void tegra_bpmp_handle_mrq(struct tegra_bpmp *bpmp,
                                   unsigned int mrq,
@@ -824,6 +835,10 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
         if (err < 0)
                 goto free_mrq;
 
+        err = tegra_bpmp_init_debugfs(bpmp);
+        if (err < 0)
+                dev_err(&pdev->dev, "debugfs initialization failed: %d\n", err);
+
         return 0;
 
 free_mrq: