bus: mhi: ep: Pass mhi_ep_buf_info struct to read/write APIs

[ Upstream commit b08ded2ef2e98768d5ee5f71da8fe768b1f7774b ]

In the preparation of DMA async support, let's pass the parameters to
read_from_host() and write_to_host() APIs using mhi_ep_buf_info structure.

No functional change.

Signed-off-by: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
Stable-dep-of: 327ec5f70609 ("PCI: epf-mhi: Fix the DMA data direction of dma_unmap_single()")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/drivers/bus/mhi/ep/main.c b/drivers/bus/mhi/ep/main.c
index 5172796..582d5c1 100644 (file)
--- a/drivers/bus/mhi/ep/main.c
+++ b/drivers/bus/mhi/ep/main.c
@@ -324,10 +324,9 @@ static int mhi_ep_read_channel(struct mhi_ep_cntrl *mhi_cntrl,
        struct mhi_ep_chan *mhi_chan = &mhi_cntrl->mhi_chan[ring->ch_id];
        struct device *dev = &mhi_cntrl->mhi_dev->dev;
        size_t tr_len, read_offset, write_offset;
+       struct mhi_ep_buf_info buf_info = {};
        struct mhi_ring_element *el;
        bool tr_done = false;
-       void *write_addr;
-       u64 read_addr;
        u32 buf_left;
        int ret;
 
@@ -356,11 +355,13 @@ static int mhi_ep_read_channel(struct mhi_ep_cntrl *mhi_cntrl,
 
                read_offset = mhi_chan->tre_size - mhi_chan->tre_bytes_left;
                write_offset = len - buf_left;
-               read_addr = mhi_chan->tre_loc + read_offset;
-               write_addr = result->buf_addr + write_offset;
+
+               buf_info.host_addr = mhi_chan->tre_loc + read_offset;
+               buf_info.dev_addr = result->buf_addr + write_offset;
+               buf_info.size = tr_len;
 
                dev_dbg(dev, "Reading %zd bytes from channel (%u)\n", tr_len, ring->ch_id);
-               ret = mhi_cntrl->read_from_host(mhi_cntrl, read_addr, write_addr, tr_len);
+               ret = mhi_cntrl->read_from_host(mhi_cntrl, &buf_info);
                if (ret < 0) {
                        dev_err(&mhi_chan->mhi_dev->dev, "Error reading from channel\n");
                        return ret;
@@ -483,12 +484,11 @@ int mhi_ep_queue_skb(struct mhi_ep_device *mhi_dev, struct sk_buff *skb)
        struct mhi_ep_cntrl *mhi_cntrl = mhi_dev->mhi_cntrl;
        struct mhi_ep_chan *mhi_chan = mhi_dev->dl_chan;
        struct device *dev = &mhi_chan->mhi_dev->dev;
+       struct mhi_ep_buf_info buf_info = {};
        struct mhi_ring_element *el;
        u32 buf_left, read_offset;
        struct mhi_ep_ring *ring;
        enum mhi_ev_ccs code;
-       void *read_addr;
-       u64 write_addr;
        size_t tr_len;
        u32 tre_len;
        int ret;
@@ -517,11 +517,13 @@ int mhi_ep_queue_skb(struct mhi_ep_device *mhi_dev, struct sk_buff *skb)
 
                tr_len = min(buf_left, tre_len);
                read_offset = skb->len - buf_left;
-               read_addr = skb->data + read_offset;
-               write_addr = MHI_TRE_DATA_GET_PTR(el);
+
+               buf_info.dev_addr = skb->data + read_offset;
+               buf_info.host_addr = MHI_TRE_DATA_GET_PTR(el);
+               buf_info.size = tr_len;
 
                dev_dbg(dev, "Writing %zd bytes to channel (%u)\n", tr_len, ring->ch_id);
-               ret = mhi_cntrl->write_to_host(mhi_cntrl, read_addr, write_addr, tr_len);
+               ret = mhi_cntrl->write_to_host(mhi_cntrl, &buf_info);
                if (ret < 0) {
                        dev_err(dev, "Error writing to the channel\n");
                        goto err_exit;
@@ -1429,7 +1431,6 @@ int mhi_ep_register_controller(struct mhi_ep_cntrl *mhi_cntrl,
                ret = -ENOMEM;
                goto err_destroy_tre_buf_cache;
        }
-
        INIT_WORK(&mhi_cntrl->state_work, mhi_ep_state_worker);
        INIT_WORK(&mhi_cntrl->reset_work, mhi_ep_reset_worker);
        INIT_WORK(&mhi_cntrl->cmd_ring_work, mhi_ep_cmd_ring_worker);

diff --git a/drivers/bus/mhi/ep/ring.c b/drivers/bus/mhi/ep/ring.c
index 115518e..c673d72 100644 (file)
--- a/drivers/bus/mhi/ep/ring.c
+++ b/drivers/bus/mhi/ep/ring.c
@@ -30,7 +30,8 @@ static int __mhi_ep_cache_ring(struct mhi_ep_ring *ring, size_t end)
 {
        struct mhi_ep_cntrl *mhi_cntrl = ring->mhi_cntrl;
        struct device *dev = &mhi_cntrl->mhi_dev->dev;
-       size_t start, copy_size;
+       struct mhi_ep_buf_info buf_info = {};
+       size_t start;
        int ret;
 
        /* Don't proceed in the case of event ring. This happens during mhi_ep_ring_start(). */
@@ -43,30 +44,34 @@ static int __mhi_ep_cache_ring(struct mhi_ep_ring *ring, size_t end)
 
        start = ring->wr_offset;
        if (start < end) {
-               copy_size = (end - start) * sizeof(struct mhi_ring_element);
-               ret = mhi_cntrl->read_from_host(mhi_cntrl, ring->rbase +
-                                               (start * sizeof(struct mhi_ring_element)),
-                                               &ring->ring_cache[start], copy_size);
+               buf_info.size = (end - start) * sizeof(struct mhi_ring_element);
+               buf_info.host_addr = ring->rbase + (start * sizeof(struct mhi_ring_element));
+               buf_info.dev_addr = &ring->ring_cache[start];
+
+               ret = mhi_cntrl->read_from_host(mhi_cntrl, &buf_info);
                if (ret < 0)
                        return ret;
        } else {
-               copy_size = (ring->ring_size - start) * sizeof(struct mhi_ring_element);
-               ret = mhi_cntrl->read_from_host(mhi_cntrl, ring->rbase +
-                                               (start * sizeof(struct mhi_ring_element)),
-                                               &ring->ring_cache[start], copy_size);
+               buf_info.size = (ring->ring_size - start) * sizeof(struct mhi_ring_element);
+               buf_info.host_addr = ring->rbase + (start * sizeof(struct mhi_ring_element));
+               buf_info.dev_addr = &ring->ring_cache[start];
+
+               ret = mhi_cntrl->read_from_host(mhi_cntrl, &buf_info);
                if (ret < 0)
                        return ret;
 
                if (end) {
-                       ret = mhi_cntrl->read_from_host(mhi_cntrl, ring->rbase,
-                                                       &ring->ring_cache[0],
-                                                       end * sizeof(struct mhi_ring_element));
+                       buf_info.host_addr = ring->rbase;
+                       buf_info.dev_addr = &ring->ring_cache[0];
+                       buf_info.size = end * sizeof(struct mhi_ring_element);
+
+                       ret = mhi_cntrl->read_from_host(mhi_cntrl, &buf_info);
                        if (ret < 0)
                                return ret;
                }
        }
 
-       dev_dbg(dev, "Cached ring: start %zu end %zu size %zu\n", start, end, copy_size);
+       dev_dbg(dev, "Cached ring: start %zu end %zu size %zu\n", start, end, buf_info.size);
 
        return 0;
 }
@@ -102,6 +107,7 @@ int mhi_ep_ring_add_element(struct mhi_ep_ring *ring, struct mhi_ring_element *e
 {
        struct mhi_ep_cntrl *mhi_cntrl = ring->mhi_cntrl;
        struct device *dev = &mhi_cntrl->mhi_dev->dev;
+       struct mhi_ep_buf_info buf_info = {};
        size_t old_offset = 0;
        u32 num_free_elem;
        __le64 rp;
@@ -133,12 +139,11 @@ int mhi_ep_ring_add_element(struct mhi_ep_ring *ring, struct mhi_ring_element *e
        rp = cpu_to_le64(ring->rd_offset * sizeof(*el) + ring->rbase);
        memcpy_toio((void __iomem *) &ring->ring_ctx->generic.rp, &rp, sizeof(u64));
 
-       ret = mhi_cntrl->write_to_host(mhi_cntrl, el, ring->rbase + (old_offset * sizeof(*el)),
-                                      sizeof(*el));
-       if (ret < 0)
-               return ret;
+       buf_info.host_addr = ring->rbase + (old_offset * sizeof(*el));
+       buf_info.dev_addr = el;
+       buf_info.size = sizeof(*el);
 
-       return 0;
+       return mhi_cntrl->write_to_host(mhi_cntrl, &buf_info);
 }
 
 void mhi_ep_ring_init(struct mhi_ep_ring *ring, enum mhi_ep_ring_type type, u32 id)

diff --git a/drivers/pci/endpoint/functions/pci-epf-mhi.c b/drivers/pci/endpoint/functions/pci-epf-mhi.c
index b7b9d3e..ec5f4a3 100644 (file)
--- a/drivers/pci/endpoint/functions/pci-epf-mhi.c
+++ b/drivers/pci/endpoint/functions/pci-epf-mhi.c
@@ -209,28 +209,28 @@ static void pci_epf_mhi_raise_irq(struct mhi_ep_cntrl *mhi_cntrl, u32 vector)
                          vector + 1);
 }
 
-static int pci_epf_mhi_iatu_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
-                                void *to, size_t size)
+static int pci_epf_mhi_iatu_read(struct mhi_ep_cntrl *mhi_cntrl,
+                                struct mhi_ep_buf_info *buf_info)
 {
        struct pci_epf_mhi *epf_mhi = to_epf_mhi(mhi_cntrl);
-       size_t offset = get_align_offset(epf_mhi, from);
+       size_t offset = get_align_offset(epf_mhi, buf_info->host_addr);
        void __iomem *tre_buf;
        phys_addr_t tre_phys;
        int ret;
 
        mutex_lock(&epf_mhi->lock);
 
-       ret = __pci_epf_mhi_alloc_map(mhi_cntrl, from, &tre_phys, &tre_buf,
-                                     offset, size);
+       ret = __pci_epf_mhi_alloc_map(mhi_cntrl, buf_info->host_addr, &tre_phys,
+                                     &tre_buf, offset, buf_info->size);
        if (ret) {
                mutex_unlock(&epf_mhi->lock);
                return ret;
        }
 
-       memcpy_fromio(to, tre_buf, size);
+       memcpy_fromio(buf_info->dev_addr, tre_buf, buf_info->size);
 
-       __pci_epf_mhi_unmap_free(mhi_cntrl, from, tre_phys, tre_buf, offset,
-                                size);
+       __pci_epf_mhi_unmap_free(mhi_cntrl, buf_info->host_addr, tre_phys,
+                                tre_buf, offset, buf_info->size);
 
        mutex_unlock(&epf_mhi->lock);
 
@@ -238,27 +238,27 @@ static int pci_epf_mhi_iatu_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
 }
 
 static int pci_epf_mhi_iatu_write(struct mhi_ep_cntrl *mhi_cntrl,
-                                 void *from, u64 to, size_t size)
+                                 struct mhi_ep_buf_info *buf_info)
 {
        struct pci_epf_mhi *epf_mhi = to_epf_mhi(mhi_cntrl);
-       size_t offset = get_align_offset(epf_mhi, to);
+       size_t offset = get_align_offset(epf_mhi, buf_info->host_addr);
        void __iomem *tre_buf;
        phys_addr_t tre_phys;
        int ret;
 
        mutex_lock(&epf_mhi->lock);
 
-       ret = __pci_epf_mhi_alloc_map(mhi_cntrl, to, &tre_phys, &tre_buf,
-                                     offset, size);
+       ret = __pci_epf_mhi_alloc_map(mhi_cntrl, buf_info->host_addr, &tre_phys,
+                                     &tre_buf, offset, buf_info->size);
        if (ret) {
                mutex_unlock(&epf_mhi->lock);
                return ret;
        }
 
-       memcpy_toio(tre_buf, from, size);
+       memcpy_toio(tre_buf, buf_info->dev_addr, buf_info->size);
 
-       __pci_epf_mhi_unmap_free(mhi_cntrl, to, tre_phys, tre_buf, offset,
-                                size);
+       __pci_epf_mhi_unmap_free(mhi_cntrl, buf_info->host_addr, tre_phys,
+                                tre_buf, offset, buf_info->size);
 
        mutex_unlock(&epf_mhi->lock);
 
@@ -270,8 +270,8 @@ static void pci_epf_mhi_dma_callback(void *param)
        complete(param);
 }
 
-static int pci_epf_mhi_edma_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
-                                void *to, size_t size)
+static int pci_epf_mhi_edma_read(struct mhi_ep_cntrl *mhi_cntrl,
+                                struct mhi_ep_buf_info *buf_info)
 {
        struct pci_epf_mhi *epf_mhi = to_epf_mhi(mhi_cntrl);
        struct device *dma_dev = epf_mhi->epf->epc->dev.parent;
@@ -284,13 +284,13 @@ static int pci_epf_mhi_edma_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
        dma_addr_t dst_addr;
        int ret;
 
-       if (size < SZ_4K)
-               return pci_epf_mhi_iatu_read(mhi_cntrl, from, to, size);
+       if (buf_info->size < SZ_4K)
+               return pci_epf_mhi_iatu_read(mhi_cntrl, buf_info);
 
        mutex_lock(&epf_mhi->lock);
 
        config.direction = DMA_DEV_TO_MEM;
-       config.src_addr = from;
+       config.src_addr = buf_info->host_addr;
 
        ret = dmaengine_slave_config(chan, &config);
        if (ret) {
@@ -298,14 +298,16 @@ static int pci_epf_mhi_edma_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
                goto err_unlock;
        }
 
-       dst_addr = dma_map_single(dma_dev, to, size, DMA_FROM_DEVICE);
+       dst_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,
+                                 DMA_FROM_DEVICE);
        ret = dma_mapping_error(dma_dev, dst_addr);
        if (ret) {
                dev_err(dev, "Failed to map remote memory\n");
                goto err_unlock;
        }
 
-       desc = dmaengine_prep_slave_single(chan, dst_addr, size, DMA_DEV_TO_MEM,
+       desc = dmaengine_prep_slave_single(chan, dst_addr, buf_info->size,
+                                          DMA_DEV_TO_MEM,
                                           DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
        if (!desc) {
                dev_err(dev, "Failed to prepare DMA\n");
@@ -332,15 +334,15 @@ static int pci_epf_mhi_edma_read(struct mhi_ep_cntrl *mhi_cntrl, u64 from,
        }
 
 err_unmap:
-       dma_unmap_single(dma_dev, dst_addr, size, DMA_FROM_DEVICE);
+       dma_unmap_single(dma_dev, dst_addr, buf_info->size, DMA_FROM_DEVICE);
 err_unlock:
        mutex_unlock(&epf_mhi->lock);
 
        return ret;
 }
 
-static int pci_epf_mhi_edma_write(struct mhi_ep_cntrl *mhi_cntrl, void *from,
-                                 u64 to, size_t size)
+static int pci_epf_mhi_edma_write(struct mhi_ep_cntrl *mhi_cntrl,
+                                 struct mhi_ep_buf_info *buf_info)
 {
        struct pci_epf_mhi *epf_mhi = to_epf_mhi(mhi_cntrl);
        struct device *dma_dev = epf_mhi->epf->epc->dev.parent;
@@ -353,13 +355,13 @@ static int pci_epf_mhi_edma_write(struct mhi_ep_cntrl *mhi_cntrl, void *from,
        dma_addr_t src_addr;
        int ret;
 
-       if (size < SZ_4K)
-               return pci_epf_mhi_iatu_write(mhi_cntrl, from, to, size);
+       if (buf_info->size < SZ_4K)
+               return pci_epf_mhi_iatu_write(mhi_cntrl, buf_info);
 
        mutex_lock(&epf_mhi->lock);
 
        config.direction = DMA_MEM_TO_DEV;
-       config.dst_addr = to;
+       config.dst_addr = buf_info->host_addr;
 
        ret = dmaengine_slave_config(chan, &config);
        if (ret) {
@@ -367,14 +369,16 @@ static int pci_epf_mhi_edma_write(struct mhi_ep_cntrl *mhi_cntrl, void *from,
                goto err_unlock;
        }
 
-       src_addr = dma_map_single(dma_dev, from, size, DMA_TO_DEVICE);
+       src_addr = dma_map_single(dma_dev, buf_info->dev_addr, buf_info->size,
+                                 DMA_TO_DEVICE);
        ret = dma_mapping_error(dma_dev, src_addr);
        if (ret) {
                dev_err(dev, "Failed to map remote memory\n");
                goto err_unlock;
        }
 
-       desc = dmaengine_prep_slave_single(chan, src_addr, size, DMA_MEM_TO_DEV,
+       desc = dmaengine_prep_slave_single(chan, src_addr, buf_info->size,
+                                          DMA_MEM_TO_DEV,
                                           DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
        if (!desc) {
                dev_err(dev, "Failed to prepare DMA\n");
@@ -401,7 +405,7 @@ static int pci_epf_mhi_edma_write(struct mhi_ep_cntrl *mhi_cntrl, void *from,
        }
 
 err_unmap:
-       dma_unmap_single(dma_dev, src_addr, size, DMA_FROM_DEVICE);
+       dma_unmap_single(dma_dev, src_addr, buf_info->size, DMA_FROM_DEVICE);
 err_unlock:
        mutex_unlock(&epf_mhi->lock);
 

diff --git a/include/linux/mhi_ep.h b/include/linux/mhi_ep.h
index ce85d42..96f3a13 100644 (file)
--- a/include/linux/mhi_ep.h
+++ b/include/linux/mhi_ep.h
@@ -50,6 +50,18 @@ struct mhi_ep_db_info {
 };
 
 /**
+ * struct mhi_ep_buf_info - MHI Endpoint transfer buffer info
+ * @dev_addr: Address of the buffer in endpoint
+ * @host_addr: Address of the bufffer in host
+ * @size: Size of the buffer
+ */
+struct mhi_ep_buf_info {
+       void *dev_addr;
+       u64 host_addr;
+       size_t size;
+};
+
+/**
  * struct mhi_ep_cntrl - MHI Endpoint controller structure
  * @cntrl_dev: Pointer to the struct device of physical bus acting as the MHI
  *             Endpoint controller
@@ -137,8 +149,8 @@ struct mhi_ep_cntrl {
                         void __iomem **virt, size_t size);
        void (*unmap_free)(struct mhi_ep_cntrl *mhi_cntrl, u64 pci_addr, phys_addr_t phys,
                           void __iomem *virt, size_t size);
-       int (*read_from_host)(struct mhi_ep_cntrl *mhi_cntrl, u64 from, void *to, size_t size);
-       int (*write_to_host)(struct mhi_ep_cntrl *mhi_cntrl, void *from, u64 to, size_t size);
+       int (*read_from_host)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
+       int (*write_to_host)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
 
        enum mhi_state mhi_state;