spi: spi-mem: Add a new API to support direct mapping

Most modern SPI controllers can directly map a SPI memory (or a portion
of the SPI memory) in the CPU address space. Most of the time this
brings significant performance improvements as it automates the whole
process of sending SPI memory operations every time a new region is
accessed.

This new API allows SPI memory drivers to create direct mappings and
then use them to access the memory instead of using spi_mem_exec_op().

Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
Reviewed-by: Miquel Raynal <miquel.raynal@bootlin.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

1 files changed, 204 insertions, 0 deletions

diff --git a/drivers/spi/spi-mem.c b/drivers/spi/spi-mem.c
index 7916e655afc8..b12a7974b665 100644
--- a/drivers/spi/spi-mem.c
+++ b/drivers/spi/spi-mem.c
@@ -432,6 +432,210 @@ int spi_mem_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
 }
 EXPORT_SYMBOL_GPL(spi_mem_adjust_op_size);
 
+static ssize_t spi_mem_no_dirmap_read(struct spi_mem_dirmap_desc *desc,
+                                      u64 offs, size_t len, void *buf)
+{
+        struct spi_mem_op op = desc->info.op_tmpl;
+        int ret;
+
+        op.addr.val = desc->info.offset + offs;
+        op.data.buf.in = buf;
+        op.data.nbytes = len;
+        ret = spi_mem_adjust_op_size(desc->mem, &op);
+        if (ret)
+                return ret;
+
+        ret = spi_mem_exec_op(desc->mem, &op);
+        if (ret)
+                return ret;
+
+        return op.data.nbytes;
+}
+
+static ssize_t spi_mem_no_dirmap_write(struct spi_mem_dirmap_desc *desc,
+                                       u64 offs, size_t len, const void *buf)
+{
+        struct spi_mem_op op = desc->info.op_tmpl;
+        int ret;
+
+        op.addr.val = desc->info.offset + offs;
+        op.data.buf.out = buf;
+        op.data.nbytes = len;
+        ret = spi_mem_adjust_op_size(desc->mem, &op);
+        if (ret)
+                return ret;
+
+        ret = spi_mem_exec_op(desc->mem, &op);
+        if (ret)
+                return ret;
+
+        return op.data.nbytes;
+}
+
+/**
+ * spi_mem_dirmap_create() - Create a direct mapping descriptor
+ * @mem: SPI mem device this direct mapping should be created for
+ * @info: direct mapping information
+ *
+ * This function is creating a direct mapping descriptor which can then be used
+ * to access the memory using spi_mem_dirmap_read() or spi_mem_dirmap_write().
+ * If the SPI controller driver does not support direct mapping, this function
+ * fallback to an implementation using spi_mem_exec_op(), so that the caller
+ * doesn't have to bother implementing a fallback on his own.
+ *
+ * Return: a valid pointer in case of success, and ERR_PTR() otherwise.
+ */
+struct spi_mem_dirmap_desc *
+spi_mem_dirmap_create(struct spi_mem *mem,
+                      const struct spi_mem_dirmap_info *info)
+{
+        struct spi_controller *ctlr = mem->spi->controller;
+        struct spi_mem_dirmap_desc *desc;
+        int ret = -ENOTSUPP;
+
+        /* Make sure the number of address cycles is between 1 and 8 bytes. */
+        if (!info->op_tmpl.addr.nbytes || info->op_tmpl.addr.nbytes > 8)
+                return ERR_PTR(-EINVAL);
+
+        /* data.dir should either be SPI_MEM_DATA_IN or SPI_MEM_DATA_OUT. */
+        if (info->op_tmpl.data.dir == SPI_MEM_NO_DATA)
+                return ERR_PTR(-EINVAL);
+
+        desc = kzalloc(sizeof(*desc), GFP_KERNEL);
+        if (!desc)
+                return ERR_PTR(-ENOMEM);
+
+        desc->mem = mem;
+        desc->info = *info;
+        if (ctlr->mem_ops && ctlr->mem_ops->dirmap_create)
+                ret = ctlr->mem_ops->dirmap_create(desc);
+
+        if (ret) {
+                desc->nodirmap = true;
+                if (!spi_mem_supports_op(desc->mem, &desc->info.op_tmpl))
+                        ret = -ENOTSUPP;
+                else
+                        ret = 0;
+        }
+
+        if (ret) {
+                kfree(desc);
+                return ERR_PTR(ret);
+        }
+
+        return desc;
+}
+EXPORT_SYMBOL_GPL(spi_mem_dirmap_create);
+
+/**
+ * spi_mem_dirmap_destroy() - Destroy a direct mapping descriptor
+ * @desc: the direct mapping descriptor to destroy
+ * @info: direct mapping information
+ *
+ * This function destroys a direct mapping descriptor previously created by
+ * spi_mem_dirmap_create().
+ */
+void spi_mem_dirmap_destroy(struct spi_mem_dirmap_desc *desc)
+{
+        struct spi_controller *ctlr = desc->mem->spi->controller;
+
+        if (!desc->nodirmap && ctlr->mem_ops && ctlr->mem_ops->dirmap_destroy)
+                ctlr->mem_ops->dirmap_destroy(desc);
+}
+EXPORT_SYMBOL_GPL(spi_mem_dirmap_destroy);
+
+/**
+ * spi_mem_dirmap_dirmap_read() - Read data through a direct mapping
+ * @desc: direct mapping descriptor
+ * @offs: offset to start reading from. Note that this is not an absolute
+ *        offset, but the offset within the direct mapping which already has
+ *        its own offset
+ * @len: length in bytes
+ * @buf: destination buffer. This buffer must be DMA-able
+ *
+ * This function reads data from a memory device using a direct mapping
+ * previously instantiated with spi_mem_dirmap_create().
+ *
+ * Return: the amount of data read from the memory device or a negative error
+ * code. Note that the returned size might be smaller than @len, and the caller
+ * is responsible for calling spi_mem_dirmap_read() again when that happens.
+ */
+ssize_t spi_mem_dirmap_read(struct spi_mem_dirmap_desc *desc,
+                            u64 offs, size_t len, void *buf)
+{
+        struct spi_controller *ctlr = desc->mem->spi->controller;
+        ssize_t ret;
+
+        if (desc->info.op_tmpl.data.dir != SPI_MEM_DATA_IN)
+                return -EINVAL;
+
+        if (!len)
+                return 0;
+
+        if (desc->nodirmap) {
+                ret = spi_mem_no_dirmap_read(desc, offs, len, buf);
+        } else if (ctlr->mem_ops && ctlr->mem_ops->dirmap_read) {
+                ret = spi_mem_access_start(desc->mem);
+                if (ret)
+                        return ret;
+
+                ret = ctlr->mem_ops->dirmap_read(desc, offs, len, buf);
+
+                spi_mem_access_end(desc->mem);
+        } else {
+                ret = -ENOTSUPP;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(spi_mem_dirmap_read);
+
+/**
+ * spi_mem_dirmap_dirmap_write() - Write data through a direct mapping
+ * @desc: direct mapping descriptor
+ * @offs: offset to start writing from. Note that this is not an absolute
+ *        offset, but the offset within the direct mapping which already has
+ *        its own offset
+ * @len: length in bytes
+ * @buf: source buffer. This buffer must be DMA-able
+ *
+ * This function writes data to a memory device using a direct mapping
+ * previously instantiated with spi_mem_dirmap_create().
+ *
+ * Return: the amount of data written to the memory device or a negative error
+ * code. Note that the returned size might be smaller than @len, and the caller
+ * is responsible for calling spi_mem_dirmap_write() again when that happens.
+ */
+ssize_t spi_mem_dirmap_write(struct spi_mem_dirmap_desc *desc,
+                             u64 offs, size_t len, const void *buf)
+{
+        struct spi_controller *ctlr = desc->mem->spi->controller;
+        ssize_t ret;
+
+        if (desc->info.op_tmpl.data.dir != SPI_MEM_DATA_OUT)
+                return -EINVAL;
+
+        if (!len)
+                return 0;
+
+        if (desc->nodirmap) {
+                ret = spi_mem_no_dirmap_write(desc, offs, len, buf);
+        } else if (ctlr->mem_ops && ctlr->mem_ops->dirmap_write) {
+                ret = spi_mem_access_start(desc->mem);
+                if (ret)
+                        return ret;
+
+                ret = ctlr->mem_ops->dirmap_write(desc, offs, len, buf);
+
+                spi_mem_access_end(desc->mem);
+        } else {
+                ret = -ENOTSUPP;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(spi_mem_dirmap_write);
+
 static inline struct spi_mem_driver *to_spi_mem_drv(struct device_driver *drv)
 {
         return container_of(drv, struct spi_mem_driver, spidrv.driver);