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);