* [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller
@ 2023-11-22 9:27 Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 1/2] dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller Binbin Zhou
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Binbin Zhou @ 2023-11-22 9:27 UTC (permalink / raw)
To: Binbin Zhou, Huacai Chen, Vinod Koul, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree
Cc: Huacai Chen, loongson-kernel, Xuerui Wang, loongarch,
Yingkun Meng, Binbin Zhou
Hi all:
This patchset introduces you to the LS2X apbdma controller.
The Loongson LS2X APB DMA controller is available on Loongson-2K chips.
It is a single-channel, configurable DMA controller IP core based on the
AXI bus, whose main function is to integrate DMA functionality on a chip
dedicated to carrying data between memory and peripherals in APB bus
(e.g. nand).
Thanks.
----
V5:
patch(2/2):
- Rebase on dmaengine/next;
- Annotate struct ls2x_dma_sg with __counted_by;
- .remove()->.remove_new();
- Drop duplicate assignments in ls2x_dma_chan_init().
Link to V4:
https://lore.kernel.org/all/cover.1691647870.git.zhoubinbin@loongson.cn/
V4:
patch(2/2)
- Drop linux/of_device.h;
- Meaningful parameter name for ls2x_dma_fill_desc(): i->sg_index;
- Check the slave config and reject invalid configurations;
- Update data width handle;
- Use generic xlate: of_dma_xlate_by_chan_id().
Link to V3:
https://lore.kernel.org/dmaengine/cover.1689075791.git.zhoubinbin@loongson.cn/
V3:
patch(1/2)
- Add clocks property;
- Drop dma-channels property, for we are single-channel dmac.
patch(2/2)
- Add clk support.
Link to V2:
https://lore.kernel.org/dmaengine/cover.1686192243.git.zhoubinbin@loongson.cn/
V2:
patch(1/2)
- Minor changes from Conor;
- Add Reviewed-by tag.
patch(2/2)
- Fix build errors from lkp@intel.com.
Link to V1:
https://lore.kernel.org/dmaengine/cover.1685448898.git.zhoubinbin@loongson.cn/
Binbin Zhou (2):
dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller
dmaengine: ls2x-apb: new driver for the Loongson LS2X APB DMA
controller
.../bindings/dma/loongson,ls2x-apbdma.yaml | 62 ++
MAINTAINERS | 7 +
drivers/dma/Kconfig | 14 +
drivers/dma/Makefile | 1 +
drivers/dma/ls2x-apb-dma.c | 705 ++++++++++++++++++
5 files changed, 789 insertions(+)
create mode 100644 Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
create mode 100644 drivers/dma/ls2x-apb-dma.c
--
2.39.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH v5 1/2] dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller
2023-11-22 9:27 [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
@ 2023-11-22 9:27 ` Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the " Binbin Zhou
2023-12-07 7:42 ` [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
2 siblings, 0 replies; 6+ messages in thread
From: Binbin Zhou @ 2023-11-22 9:27 UTC (permalink / raw)
To: Binbin Zhou, Huacai Chen, Vinod Koul, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree
Cc: Huacai Chen, loongson-kernel, Xuerui Wang, loongarch,
Yingkun Meng, Binbin Zhou, Conor Dooley
Add Loongson LS2X APB DMA controller binding with DT schema
format using json-schema.
Signed-off-by: Binbin Zhou <zhoubinbin@loongson.cn>
Reviewed-by: Conor Dooley <conor.dooley@microchip.com>
---
.../bindings/dma/loongson,ls2x-apbdma.yaml | 62 +++++++++++++++++++
MAINTAINERS | 6 ++
2 files changed, 68 insertions(+)
create mode 100644 Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
diff --git a/Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml b/Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
new file mode 100644
index 000000000000..35298c4fbfa0
--- /dev/null
+++ b/Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/dma/loongson,ls2x-apbdma.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Loongson LS2X APB DMA controller
+
+description:
+ The Loongson LS2X APB DMA controller is used for transferring data
+ between system memory and the peripherals on the APB bus.
+
+maintainers:
+ - Binbin Zhou <zhoubinbin@loongson.cn>
+
+allOf:
+ - $ref: dma-controller.yaml#
+
+properties:
+ compatible:
+ oneOf:
+ - const: loongson,ls2k1000-apbdma
+ - items:
+ - const: loongson,ls2k0500-apbdma
+ - const: loongson,ls2k1000-apbdma
+
+ reg:
+ maxItems: 1
+
+ interrupts:
+ maxItems: 1
+
+ clocks:
+ maxItems: 1
+
+ '#dma-cells':
+ const: 1
+
+required:
+ - compatible
+ - reg
+ - interrupts
+ - clocks
+ - '#dma-cells'
+
+additionalProperties: false
+
+examples:
+ - |
+ #include <dt-bindings/interrupt-controller/irq.h>
+ #include <dt-bindings/clock/loongson,ls2k-clk.h>
+
+ dma-controller@1fe00c00 {
+ compatible = "loongson,ls2k1000-apbdma";
+ reg = <0x1fe00c00 0x8>;
+ interrupt-parent = <&liointc1>;
+ interrupts = <12 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&clk LOONGSON2_APB_CLK>;
+ #dma-cells = <1>;
+ };
+
+...
diff --git a/MAINTAINERS b/MAINTAINERS
index 3e3206dc1672..eb1d9c4f85d0 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -12506,6 +12506,12 @@ S: Maintained
F: Documentation/devicetree/bindings/gpio/loongson,ls-gpio.yaml
F: drivers/gpio/gpio-loongson-64bit.c
+LOONGSON LS2X APB DMA DRIVER
+M: Binbin Zhou <zhoubinbin@loongson.cn>
+L: dmaengine@vger.kernel.org
+S: Maintained
+F: Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
+
LOONGSON LS2X I2C DRIVER
M: Binbin Zhou <zhoubinbin@loongson.cn>
L: linux-i2c@vger.kernel.org
--
2.39.3
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the Loongson LS2X APB DMA controller
2023-11-22 9:27 [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 1/2] dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller Binbin Zhou
@ 2023-11-22 9:27 ` Binbin Zhou
2023-12-11 11:39 ` Vinod Koul
2023-12-07 7:42 ` [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
2 siblings, 1 reply; 6+ messages in thread
From: Binbin Zhou @ 2023-11-22 9:27 UTC (permalink / raw)
To: Binbin Zhou, Huacai Chen, Vinod Koul, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree
Cc: Huacai Chen, loongson-kernel, Xuerui Wang, loongarch,
Yingkun Meng, Binbin Zhou
The Loongson LS2X APB DMA controller is available on Loongson-2K chips.
It is a single-channel, configurable DMA controller IP core based on the
AXI bus, whose main function is to integrate DMA functionality on a chip
dedicated to carrying data between memory and peripherals in APB bus
(e.g. nand).
Signed-off-by: Binbin Zhou <zhoubinbin@loongson.cn>
Signed-off-by: Yingkun Meng <mengyingkun@loongson.cn>
---
MAINTAINERS | 1 +
drivers/dma/Kconfig | 14 +
drivers/dma/Makefile | 1 +
drivers/dma/ls2x-apb-dma.c | 705 +++++++++++++++++++++++++++++++++++++
4 files changed, 721 insertions(+)
create mode 100644 drivers/dma/ls2x-apb-dma.c
diff --git a/MAINTAINERS b/MAINTAINERS
index eb1d9c4f85d0..6b8d7f5b241b 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -12511,6 +12511,7 @@ M: Binbin Zhou <zhoubinbin@loongson.cn>
L: dmaengine@vger.kernel.org
S: Maintained
F: Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
+F: drivers/dma/ls2x-apb-dma.c
LOONGSON LS2X I2C DRIVER
M: Binbin Zhou <zhoubinbin@loongson.cn>
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index 70ba506dabab..e928f2ca0f1e 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -378,6 +378,20 @@ config LPC18XX_DMAMUX
Enable support for DMA on NXP LPC18xx/43xx platforms
with PL080 and multiplexed DMA request lines.
+config LS2X_APB_DMA
+ tristate "Loongson LS2X APB DMA support"
+ depends on LOONGARCH || COMPILE_TEST
+ select DMA_ENGINE
+ select DMA_VIRTUAL_CHANNELS
+ help
+ Support for the Loongson LS2X APB DMA controller driver. The
+ DMA controller is having single DMA channel which can be
+ configured for different peripherals like audio, nand, sdio
+ etc which is in APB bus.
+
+ This DMA controller transfers data from memory to peripheral fifo.
+ It does not support memory to memory data transfer.
+
config MCF_EDMA
tristate "Freescale eDMA engine support, ColdFire mcf5441x SoCs"
depends on M5441x || COMPILE_TEST
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 83553a97a010..dfd40d14e408 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_INTEL_IOATDMA) += ioat/
obj-y += idxd/
obj-$(CONFIG_K3_DMA) += k3dma.o
obj-$(CONFIG_LPC18XX_DMAMUX) += lpc18xx-dmamux.o
+obj-$(CONFIG_LS2X_APB_DMA) += ls2x-apb-dma.o
obj-$(CONFIG_MILBEAUT_HDMAC) += milbeaut-hdmac.o
obj-$(CONFIG_MILBEAUT_XDMAC) += milbeaut-xdmac.o
obj-$(CONFIG_MMP_PDMA) += mmp_pdma.o
diff --git a/drivers/dma/ls2x-apb-dma.c b/drivers/dma/ls2x-apb-dma.c
new file mode 100644
index 000000000000..f60dbeae627f
--- /dev/null
+++ b/drivers/dma/ls2x-apb-dma.c
@@ -0,0 +1,705 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Driver for the Loongson LS2X APB DMA Controller
+ *
+ * Copyright (C) 2017-2023 Loongson Corporation
+ */
+
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/io-64-nonatomic-lo-hi.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_dma.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include "dmaengine.h"
+#include "virt-dma.h"
+
+/* Global Configuration Register */
+#define LDMA_ORDER_ERG 0x0
+
+/* Bitfield definitions */
+
+/* Bitfields in Global Configuration Register */
+#define LDMA_64BIT_EN BIT(0) /* 1: 64 bit support */
+#define LDMA_UNCOHERENT_EN BIT(1) /* 0: cache, 1: uncache */
+#define LDMA_ASK_VALID BIT(2)
+#define LDMA_START BIT(3) /* DMA start operation */
+#define LDMA_STOP BIT(4) /* DMA stop operation */
+#define LDMA_CONFIG_MASK GENMASK(4, 0) /* DMA controller config bits mask */
+
+/* Bitfields in ndesc_addr field of HW decriptor */
+#define LDMA_DESC_EN BIT(0) /*1: The next descriptor is valid */
+#define LDMA_DESC_ADDR_LOW GENMASK(31, 1)
+
+/* Bitfields in cmd field of HW decriptor */
+#define LDMA_INT BIT(1) /* Enable DMA interrupts */
+#define LDMA_DATA_DIRECTION BIT(12) /* 1: write to device, 0: read from device */
+
+#define LDMA_SLAVE_BUSWIDTHS (BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
+ BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
+
+#define LDMA_MAX_TRANS_LEN U32_MAX
+
+/*-- descriptors -----------------------------------------------------*/
+
+/*
+ * struct ls2x_dma_hw_desc - DMA HW descriptor
+ * @ndesc_addr: the next descriptor low address.
+ * @mem_addr: memory low address.
+ * @apb_addr: device buffer address.
+ * @len: length of a piece of carried content, in words.
+ * @step_len: length between two moved memory data blocks.
+ * @step_times: number of blocks to be carried in a single DMA operation.
+ * @cmd: descriptor command or state.
+ * @stats: DMA status.
+ * @high_ndesc_addr: the next descriptor high address.
+ * @high_mem_addr: memory high address.
+ * @reserved: reserved
+ */
+struct ls2x_dma_hw_desc {
+ u32 ndesc_addr;
+ u32 mem_addr;
+ u32 apb_addr;
+ u32 len;
+ u32 step_len;
+ u32 step_times;
+ u32 cmd;
+ u32 stats;
+ u32 high_ndesc_addr;
+ u32 high_mem_addr;
+ u32 reserved[2];
+} __packed;
+
+/*
+ * struct ls2x_dma_sg - ls2x dma scatter gather entry
+ * @hw: the pointer to DMA HW descriptor.
+ * @llp: physical address of the DMA HW descriptor.
+ * @phys: destination or source address(mem).
+ * @len: number of Bytes to read.
+ */
+struct ls2x_dma_sg {
+ struct ls2x_dma_hw_desc *hw;
+ dma_addr_t llp;
+ dma_addr_t phys;
+ u32 len;
+};
+
+/*
+ * struct ls2x_dma_desc - software descriptor
+ * @vdesc: pointer to the virtual dma descriptor.
+ * @cyclic: flag to dma cyclic
+ * @burst_size: burst size of transaction, in words.
+ * @desc_num: number of sg entries.
+ * @direction: transfer direction, to or from device.
+ * @status: dma controller status.
+ * @sg: array of sgs.
+ */
+struct ls2x_dma_desc {
+ struct virt_dma_desc vdesc;
+ bool cyclic;
+ size_t burst_size;
+ u32 desc_num;
+ enum dma_transfer_direction direction;
+ enum dma_status status;
+ struct ls2x_dma_sg sg[] __counted_by(desc_num);
+};
+
+/*-- Channels --------------------------------------------------------*/
+
+/*
+ * struct ls2x_dma_chan - internal representation of an LS2X APB DMA channel
+ * @vchan: virtual dma channel entry.
+ * @desc: pointer to the ls2x sw dma descriptor.
+ * @pool: hw desc table
+ * @irq: irq line
+ * @sconfig: configuration for slave transfers, passed via .device_config
+ */
+struct ls2x_dma_chan {
+ struct virt_dma_chan vchan;
+ struct ls2x_dma_desc *desc;
+ void *pool;
+ int irq;
+ struct dma_slave_config sconfig;
+};
+
+/*-- Controller ------------------------------------------------------*/
+
+/*
+ * struct ls2x_dma_priv - LS2X APB DMAC specific information
+ * @ddev: dmaengine dma_device object members
+ * @dma_clk: DMAC clock source
+ * @regs: memory mapped register base
+ * @lchan: channel to store ls2x_dma_chan structures
+ */
+struct ls2x_dma_priv {
+ struct dma_device ddev;
+ struct clk *dma_clk;
+ void __iomem *regs;
+ struct ls2x_dma_chan lchan;
+};
+
+/*-- Helper functions ------------------------------------------------*/
+
+static inline struct ls2x_dma_desc *to_ldma_desc(struct virt_dma_desc *vdesc)
+{
+ return container_of(vdesc, struct ls2x_dma_desc, vdesc);
+}
+
+static inline struct ls2x_dma_chan *to_ldma_chan(struct dma_chan *chan)
+{
+ return container_of(chan, struct ls2x_dma_chan, vchan.chan);
+}
+
+static inline struct ls2x_dma_priv *to_ldma_priv(struct dma_device *ddev)
+{
+ return container_of(ddev, struct ls2x_dma_priv, ddev);
+}
+
+static struct device *chan2dev(struct dma_chan *chan)
+{
+ return &chan->dev->device;
+}
+
+static void ls2x_dma_desc_free(struct virt_dma_desc *vdesc)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(vdesc->tx.chan);
+ struct ls2x_dma_desc *desc = to_ldma_desc(vdesc);
+ int i;
+
+ for (i = 0; i < desc->desc_num; i++) {
+ if (desc->sg[i].hw)
+ dma_pool_free(lchan->pool, desc->sg[i].hw,
+ desc->sg[i].llp);
+ }
+
+ kfree(desc);
+}
+
+static void ls2x_dma_write_cmd(struct ls2x_dma_chan *lchan, bool cmd)
+{
+ u64 val = 0;
+ struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
+
+ val = lo_hi_readq(priv->regs + LDMA_ORDER_ERG) & ~LDMA_CONFIG_MASK;
+ val |= LDMA_64BIT_EN | cmd;
+ lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
+}
+
+static void ls2x_dma_start_transfer(struct ls2x_dma_chan *lchan)
+{
+ struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
+ struct ls2x_dma_sg *ldma_sg;
+ struct virt_dma_desc *vdesc;
+ u64 val;
+
+ /* Get the next descriptor */
+ vdesc = vchan_next_desc(&lchan->vchan);
+ if (!vdesc) {
+ lchan->desc = NULL;
+ return;
+ }
+
+ list_del(&vdesc->node);
+ lchan->desc = to_ldma_desc(vdesc);
+ ldma_sg = &lchan->desc->sg[0];
+
+ /* Start DMA */
+ lo_hi_writeq(0, priv->regs + LDMA_ORDER_ERG);
+ val = (ldma_sg->llp & ~LDMA_CONFIG_MASK) | LDMA_64BIT_EN | LDMA_START;
+ lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
+}
+
+static size_t ls2x_dmac_detect_burst(struct ls2x_dma_chan *lchan)
+{
+ u32 maxburst, buswidth;
+
+ /* Reject definitely invalid configurations */
+ if ((lchan->sconfig.src_addr_width & LDMA_SLAVE_BUSWIDTHS) &&
+ (lchan->sconfig.dst_addr_width & LDMA_SLAVE_BUSWIDTHS))
+ return 0;
+
+ if (lchan->sconfig.direction == DMA_MEM_TO_DEV) {
+ maxburst = lchan->sconfig.dst_maxburst;
+ buswidth = lchan->sconfig.dst_addr_width;
+ } else {
+ maxburst = lchan->sconfig.src_maxburst;
+ buswidth = lchan->sconfig.src_addr_width;
+ }
+
+ /* If maxburst is zero, fallback to LDMA_MAX_TRANS_LEN */
+ return maxburst ? (maxburst * buswidth) >> 2 : LDMA_MAX_TRANS_LEN;
+}
+
+static void ls2x_dma_fill_desc(struct ls2x_dma_chan *lchan, u32 sg_index,
+ struct ls2x_dma_desc *desc)
+{
+ struct ls2x_dma_sg *ldma_sg = &desc->sg[sg_index];
+ u32 num_segments, segment_size;
+
+ if (desc->direction == DMA_MEM_TO_DEV) {
+ ldma_sg->hw->cmd = LDMA_INT | LDMA_DATA_DIRECTION;
+ ldma_sg->hw->apb_addr = lchan->sconfig.dst_addr;
+ } else {
+ ldma_sg->hw->cmd = LDMA_INT;
+ ldma_sg->hw->apb_addr = lchan->sconfig.src_addr;
+ }
+
+ ldma_sg->hw->mem_addr = lower_32_bits(ldma_sg->phys);
+ ldma_sg->hw->high_mem_addr = upper_32_bits(ldma_sg->phys);
+
+ /* Split into multiple equally sized segments if necessary */
+ num_segments = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, desc->burst_size);
+ segment_size = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, num_segments);
+
+ /* Word count register takes input in words */
+ ldma_sg->hw->len = segment_size;
+ ldma_sg->hw->step_times = num_segments;
+ ldma_sg->hw->step_len = 0;
+
+ /* lets make a link list */
+ if (sg_index) {
+ desc->sg[sg_index - 1].hw->ndesc_addr = ldma_sg->llp | LDMA_DESC_EN;
+ desc->sg[sg_index - 1].hw->high_ndesc_addr = upper_32_bits(ldma_sg->llp);
+ }
+}
+
+/*-- DMA Engine API --------------------------------------------------*/
+
+/*
+ * ls2x_dma_alloc_chan_resources - allocate resources for DMA channel
+ * @chan: allocate descriptor resources for this channel
+ *
+ * return - the number of allocated descriptors
+ */
+static int ls2x_dma_alloc_chan_resources(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+
+ /* Create a pool of consistent memory blocks for hardware descriptors */
+ lchan->pool = dma_pool_create(dev_name(chan2dev(chan)),
+ chan->device->dev, PAGE_SIZE,
+ __alignof__(struct ls2x_dma_hw_desc), 0);
+ if (!lchan->pool) {
+ dev_err(chan2dev(chan), "No memory for descriptors\n");
+ return -ENOMEM;
+ }
+
+ return 1;
+}
+
+/*
+ * ls2x_dma_free_chan_resources - free all channel resources
+ * @chan: DMA channel
+ */
+static void ls2x_dma_free_chan_resources(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+
+ vchan_free_chan_resources(to_virt_chan(chan));
+ dma_pool_destroy(lchan->pool);
+ lchan->pool = NULL;
+}
+
+/*
+ * ls2x_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
+ * @chan: DMA channel
+ * @sgl: scatterlist to transfer to/from
+ * @sg_len: number of entries in @scatterlist
+ * @direction: DMA direction
+ * @flags: tx descriptor status flags
+ * @context: transaction context (ignored)
+ *
+ * Return: Async transaction descriptor on success and NULL on failure
+ */
+static struct dma_async_tx_descriptor *
+ls2x_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
+ u32 sg_len, enum dma_transfer_direction direction,
+ unsigned long flags, void *context)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ struct ls2x_dma_desc *desc;
+ struct scatterlist *sg;
+ size_t burst_size;
+ int i;
+
+ if (unlikely(!sg_len || !is_slave_direction(direction)))
+ return NULL;
+
+ burst_size = ls2x_dmac_detect_burst(lchan);
+ if (!burst_size)
+ return NULL;
+
+ desc = kzalloc(struct_size(desc, sg, sg_len), GFP_ATOMIC);
+ if (!desc)
+ return NULL;
+
+ desc->desc_num = sg_len;
+ desc->direction = direction;
+ desc->burst_size = burst_size;
+
+ for_each_sg(sgl, sg, sg_len, i) {
+ struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
+
+ /* Allocate DMA capable memory for hardware descriptor */
+ ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
+ if (!ldma_sg->hw) {
+ desc->desc_num = i;
+ ls2x_dma_desc_free(&desc->vdesc);
+ return NULL;
+ }
+
+ ldma_sg->phys = sg_dma_address(sg);
+ ldma_sg->len = sg_dma_len(sg);
+
+ ls2x_dma_fill_desc(lchan, i, desc);
+ }
+
+ /* Setting the last descriptor enable bit */
+ desc->sg[sg_len - 1].hw->ndesc_addr &= ~LDMA_DESC_EN;
+ desc->status = DMA_IN_PROGRESS;
+
+ return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
+}
+
+/*
+ * ls2x_dma_prep_dma_cyclic - prepare the cyclic DMA transfer
+ * @chan: the DMA channel to prepare
+ * @buf_addr: physical DMA address where the buffer starts
+ * @buf_len: total number of bytes for the entire buffer
+ * @period_len: number of bytes for each period
+ * @direction: transfer direction, to or from device
+ * @flags: tx descriptor status flags
+ *
+ * Return: Async transaction descriptor on success and NULL on failure
+ */
+static struct dma_async_tx_descriptor *
+ls2x_dma_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
+ size_t period_len, enum dma_transfer_direction direction,
+ unsigned long flags)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ struct ls2x_dma_desc *desc;
+ u32 num_periods;
+ size_t burst_size;
+ int i;
+
+ if (unlikely(!buf_len || !period_len))
+ return NULL;
+
+ if (unlikely(!is_slave_direction(direction)))
+ return NULL;
+
+ burst_size = ls2x_dmac_detect_burst(lchan);
+ if (!burst_size)
+ return NULL;
+
+ num_periods = buf_len / period_len;
+ desc = kzalloc(struct_size(desc, sg, num_periods), GFP_ATOMIC);
+ if (!desc)
+ return NULL;
+
+ desc->desc_num = num_periods;
+ desc->direction = direction;
+ desc->burst_size = burst_size;
+
+ /* Build cyclic linked list */
+ for (i = 0; i < num_periods; i++) {
+ struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
+
+ /* Allocate DMA capable memory for hardware descriptor */
+ ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
+ if (!ldma_sg->hw) {
+ desc->desc_num = i;
+ ls2x_dma_desc_free(&desc->vdesc);
+ return NULL;
+ }
+
+ ldma_sg->phys = buf_addr + period_len * i;
+ ldma_sg->len = period_len;
+
+ ls2x_dma_fill_desc(lchan, i, desc);
+ }
+
+ /* Lets make a cyclic list */
+ desc->sg[num_periods - 1].hw->ndesc_addr = desc->sg[0].llp | LDMA_DESC_EN;
+ desc->sg[num_periods - 1].hw->high_ndesc_addr = upper_32_bits(desc->sg[0].llp);
+ desc->cyclic = true;
+ desc->status = DMA_IN_PROGRESS;
+
+ return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
+}
+
+/*
+ * ls2x_slave_config - set slave configuration for channel
+ * @chan: dma channel
+ * @cfg: slave configuration
+ *
+ * Sets slave configuration for channel
+ */
+static int ls2x_dma_slave_config(struct dma_chan *chan,
+ struct dma_slave_config *config)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+
+ memcpy(&lchan->sconfig, config, sizeof(*config));
+ return 0;
+}
+
+/*
+ * ls2x_dma_issue_pending - push pending transactions to the hardware
+ * @chan: channel
+ *
+ * When this function is called, all pending transactions are pushed to the
+ * hardware and executed.
+ */
+static void ls2x_dma_issue_pending(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ unsigned long flags;
+
+ spin_lock_irqsave(&lchan->vchan.lock, flags);
+ if (vchan_issue_pending(&lchan->vchan) && !lchan->desc)
+ ls2x_dma_start_transfer(lchan);
+ spin_unlock_irqrestore(&lchan->vchan.lock, flags);
+}
+
+/*
+ * ls2x_dma_terminate_all - terminate all transactions
+ * @chan: channel
+ *
+ * Stops all DMA transactions.
+ */
+static int ls2x_dma_terminate_all(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ unsigned long flags;
+ LIST_HEAD(head);
+
+ spin_lock_irqsave(&lchan->vchan.lock, flags);
+ /* Setting stop cmd */
+ ls2x_dma_write_cmd(lchan, LDMA_STOP);
+ if (lchan->desc) {
+ vchan_terminate_vdesc(&lchan->desc->vdesc);
+ lchan->desc = NULL;
+ }
+
+ vchan_get_all_descriptors(&lchan->vchan, &head);
+ spin_unlock_irqrestore(&lchan->vchan.lock, flags);
+
+ vchan_dma_desc_free_list(&lchan->vchan, &head);
+ return 0;
+}
+
+/*
+ * ls2x_dma_synchronize - Synchronizes the termination of transfers to the
+ * current context.
+ * @chan: channel
+ */
+static void ls2x_dma_synchronize(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+
+ vchan_synchronize(&lchan->vchan);
+}
+
+static int ls2x_dma_pause(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ unsigned long flags;
+
+ spin_lock_irqsave(&lchan->vchan.lock, flags);
+ if (lchan->desc && lchan->desc->status == DMA_IN_PROGRESS) {
+ ls2x_dma_write_cmd(lchan, LDMA_STOP);
+ lchan->desc->status = DMA_PAUSED;
+ }
+ spin_unlock_irqrestore(&lchan->vchan.lock, flags);
+
+ return 0;
+}
+
+static int ls2x_dma_resume(struct dma_chan *chan)
+{
+ struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
+ unsigned long flags;
+
+ spin_lock_irqsave(&lchan->vchan.lock, flags);
+ if (lchan->desc && lchan->desc->status == DMA_PAUSED) {
+ lchan->desc->status = DMA_IN_PROGRESS;
+ ls2x_dma_write_cmd(lchan, LDMA_START);
+ }
+ spin_unlock_irqrestore(&lchan->vchan.lock, flags);
+
+ return 0;
+}
+
+/*
+ * ls2x_dma_isr - LS2X DMA Interrupt handler
+ * @irq: IRQ number
+ * @dev_id: Pointer to ls2x_dma_chan
+ *
+ * Return: IRQ_HANDLED/IRQ_NONE
+ */
+static irqreturn_t ls2x_dma_isr(int irq, void *dev_id)
+{
+ struct ls2x_dma_chan *lchan = dev_id;
+ struct ls2x_dma_desc *desc;
+
+ spin_lock(&lchan->vchan.lock);
+ desc = lchan->desc;
+ if (desc) {
+ if (desc->cyclic) {
+ vchan_cyclic_callback(&desc->vdesc);
+ } else {
+ desc->status = DMA_COMPLETE;
+ vchan_cookie_complete(&desc->vdesc);
+ ls2x_dma_start_transfer(lchan);
+ }
+
+ /* ls2x_dma_start_transfer() updates lchan->desc */
+ if (!lchan->desc)
+ ls2x_dma_write_cmd(lchan, LDMA_STOP);
+ }
+ spin_unlock(&lchan->vchan.lock);
+
+ return IRQ_HANDLED;
+}
+
+static int ls2x_dma_chan_init(struct platform_device *pdev,
+ struct ls2x_dma_priv *priv)
+{
+ struct device *dev = &pdev->dev;
+ struct ls2x_dma_chan *lchan = &priv->lchan;
+ int ret;
+
+ lchan->irq = platform_get_irq(pdev, 0);
+ if (lchan->irq < 0)
+ return lchan->irq;
+
+ ret = devm_request_irq(dev, lchan->irq, ls2x_dma_isr, IRQF_TRIGGER_RISING,
+ dev_name(&pdev->dev), lchan);
+ if (ret)
+ return ret;
+
+ /* Initialize channels related values */
+ INIT_LIST_HEAD(&priv->ddev.channels);
+ lchan->vchan.desc_free = ls2x_dma_desc_free;
+ vchan_init(&lchan->vchan, &priv->ddev);
+
+ return 0;
+}
+
+/*
+ * ls2x_dma_probe - Driver probe function
+ * @pdev: Pointer to the platform_device structure
+ *
+ * Return: '0' on success and failure value on error
+ */
+static int ls2x_dma_probe(struct platform_device *pdev)
+{
+ int ret;
+ struct dma_device *ddev;
+ struct ls2x_dma_priv *priv;
+ struct device *dev = &pdev->dev;
+
+ priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->regs = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(priv->regs))
+ return dev_err_probe(dev, PTR_ERR(priv->regs),
+ "devm_platform_ioremap_resource failed.\n");
+
+ priv->dma_clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(priv->dma_clk))
+ return dev_err_probe(dev, PTR_ERR(priv->dma_clk), "devm_clk_get failed.\n");
+
+ ret = clk_prepare_enable(priv->dma_clk);
+ if (ret)
+ return dev_err_probe(dev, ret, "clk_prepare_enable failed.\n");
+
+ ret = ls2x_dma_chan_init(pdev, priv);
+ if (ret)
+ goto disable_clk;
+
+ ddev = &priv->ddev;
+ ddev->dev = dev;
+ dma_cap_zero(ddev->cap_mask);
+ dma_cap_set(DMA_SLAVE, ddev->cap_mask);
+ dma_cap_set(DMA_CYCLIC, ddev->cap_mask);
+
+ ddev->device_alloc_chan_resources = ls2x_dma_alloc_chan_resources;
+ ddev->device_free_chan_resources = ls2x_dma_free_chan_resources;
+ ddev->device_tx_status = dma_cookie_status;
+ ddev->device_issue_pending = ls2x_dma_issue_pending;
+ ddev->device_prep_slave_sg = ls2x_dma_prep_slave_sg;
+ ddev->device_prep_dma_cyclic = ls2x_dma_prep_dma_cyclic;
+ ddev->device_config = ls2x_dma_slave_config;
+ ddev->device_terminate_all = ls2x_dma_terminate_all;
+ ddev->device_synchronize = ls2x_dma_synchronize;
+ ddev->device_pause = ls2x_dma_pause;
+ ddev->device_resume = ls2x_dma_resume;
+
+ ddev->src_addr_widths = LDMA_SLAVE_BUSWIDTHS;
+ ddev->dst_addr_widths = LDMA_SLAVE_BUSWIDTHS;
+ ddev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+
+ ret = dma_async_device_register(&priv->ddev);
+ if (ret < 0)
+ goto disable_clk;
+
+ ret = of_dma_controller_register(dev->of_node, of_dma_xlate_by_chan_id, priv);
+ if (ret < 0)
+ goto unregister_dmac;
+
+ platform_set_drvdata(pdev, priv);
+
+ dev_info(dev, "Loongson LS2X APB DMA driver registered successfully.\n");
+ return 0;
+
+unregister_dmac:
+ dma_async_device_unregister(&priv->ddev);
+disable_clk:
+ clk_disable_unprepare(priv->dma_clk);
+
+ return ret;
+}
+
+/*
+ * ls2x_dma_remove - Driver remove function
+ * @pdev: Pointer to the platform_device structure
+ */
+static void ls2x_dma_remove(struct platform_device *pdev)
+{
+ struct ls2x_dma_priv *priv = platform_get_drvdata(pdev);
+
+ of_dma_controller_free(pdev->dev.of_node);
+ dma_async_device_unregister(&priv->ddev);
+ clk_disable_unprepare(priv->dma_clk);
+}
+
+static const struct of_device_id ls2x_dma_of_match_table[] = {
+ { .compatible = "loongson,ls2k1000-apbdma" },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, ls2x_dma_of_match_table);
+
+static struct platform_driver ls2x_dmac_driver = {
+ .probe = ls2x_dma_probe,
+ .remove_new = ls2x_dma_remove,
+ .driver = {
+ .name = "ls2x-apbdma",
+ .of_match_table = ls2x_dma_of_match_table,
+ },
+};
+module_platform_driver(ls2x_dmac_driver);
+
+MODULE_DESCRIPTION("Loongson LS2X APB DMA Controller driver");
+MODULE_AUTHOR("Loongson Technology Corporation Limited");
+MODULE_LICENSE("GPL");
--
2.39.3
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller
2023-11-22 9:27 [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 1/2] dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the " Binbin Zhou
@ 2023-12-07 7:42 ` Binbin Zhou
2 siblings, 0 replies; 6+ messages in thread
From: Binbin Zhou @ 2023-12-07 7:42 UTC (permalink / raw)
To: Binbin Zhou
Cc: Huacai Chen, Vinod Koul, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree, Huacai Chen,
loongson-kernel, Xuerui Wang, loongarch, Yingkun Meng
On Wed, Nov 22, 2023 at 3:27 PM Binbin Zhou <zhoubinbin@loongson.cn> wrote:
>
> Hi all:
>
> This patchset introduces you to the LS2X apbdma controller.
>
> The Loongson LS2X APB DMA controller is available on Loongson-2K chips.
> It is a single-channel, configurable DMA controller IP core based on the
> AXI bus, whose main function is to integrate DMA functionality on a chip
> dedicated to carrying data between memory and peripherals in APB bus
> (e.g. nand).
Hi Vinod:
Gentle ping. Any comments on this series of patches?
Thanks.
Binbin
>
> Thanks.
>
> ----
> V5:
> patch(2/2):
> - Rebase on dmaengine/next;
> - Annotate struct ls2x_dma_sg with __counted_by;
> - .remove()->.remove_new();
> - Drop duplicate assignments in ls2x_dma_chan_init().
>
> Link to V4:
> https://lore.kernel.org/all/cover.1691647870.git.zhoubinbin@loongson.cn/
>
> V4:
> patch(2/2)
> - Drop linux/of_device.h;
> - Meaningful parameter name for ls2x_dma_fill_desc(): i->sg_index;
> - Check the slave config and reject invalid configurations;
> - Update data width handle;
> - Use generic xlate: of_dma_xlate_by_chan_id().
>
> Link to V3:
> https://lore.kernel.org/dmaengine/cover.1689075791.git.zhoubinbin@loongson.cn/
>
> V3:
> patch(1/2)
> - Add clocks property;
> - Drop dma-channels property, for we are single-channel dmac.
> patch(2/2)
> - Add clk support.
>
> Link to V2:
> https://lore.kernel.org/dmaengine/cover.1686192243.git.zhoubinbin@loongson.cn/
>
> V2:
> patch(1/2)
> - Minor changes from Conor;
> - Add Reviewed-by tag.
> patch(2/2)
> - Fix build errors from lkp@intel.com.
>
> Link to V1:
> https://lore.kernel.org/dmaengine/cover.1685448898.git.zhoubinbin@loongson.cn/
>
> Binbin Zhou (2):
> dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller
> dmaengine: ls2x-apb: new driver for the Loongson LS2X APB DMA
> controller
>
> .../bindings/dma/loongson,ls2x-apbdma.yaml | 62 ++
> MAINTAINERS | 7 +
> drivers/dma/Kconfig | 14 +
> drivers/dma/Makefile | 1 +
> drivers/dma/ls2x-apb-dma.c | 705 ++++++++++++++++++
> 5 files changed, 789 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
> create mode 100644 drivers/dma/ls2x-apb-dma.c
>
> --
> 2.39.3
>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the Loongson LS2X APB DMA controller
2023-11-22 9:27 ` [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the " Binbin Zhou
@ 2023-12-11 11:39 ` Vinod Koul
2023-12-12 6:05 ` Binbin Zhou
0 siblings, 1 reply; 6+ messages in thread
From: Vinod Koul @ 2023-12-11 11:39 UTC (permalink / raw)
To: Binbin Zhou
Cc: Binbin Zhou, Huacai Chen, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree, Huacai Chen,
loongson-kernel, Xuerui Wang, loongarch, Yingkun Meng
On 22-11-23, 17:27, Binbin Zhou wrote:
> The Loongson LS2X APB DMA controller is available on Loongson-2K chips.
>
> It is a single-channel, configurable DMA controller IP core based on the
> AXI bus, whose main function is to integrate DMA functionality on a chip
> dedicated to carrying data between memory and peripherals in APB bus
> (e.g. nand).
>
> Signed-off-by: Binbin Zhou <zhoubinbin@loongson.cn>
> Signed-off-by: Yingkun Meng <mengyingkun@loongson.cn>
> ---
> MAINTAINERS | 1 +
> drivers/dma/Kconfig | 14 +
> drivers/dma/Makefile | 1 +
> drivers/dma/ls2x-apb-dma.c | 705 +++++++++++++++++++++++++++++++++++++
> 4 files changed, 721 insertions(+)
> create mode 100644 drivers/dma/ls2x-apb-dma.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index eb1d9c4f85d0..6b8d7f5b241b 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -12511,6 +12511,7 @@ M: Binbin Zhou <zhoubinbin@loongson.cn>
> L: dmaengine@vger.kernel.org
> S: Maintained
> F: Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
> +F: drivers/dma/ls2x-apb-dma.c
>
> LOONGSON LS2X I2C DRIVER
> M: Binbin Zhou <zhoubinbin@loongson.cn>
> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> index 70ba506dabab..e928f2ca0f1e 100644
> --- a/drivers/dma/Kconfig
> +++ b/drivers/dma/Kconfig
> @@ -378,6 +378,20 @@ config LPC18XX_DMAMUX
> Enable support for DMA on NXP LPC18xx/43xx platforms
> with PL080 and multiplexed DMA request lines.
>
> +config LS2X_APB_DMA
> + tristate "Loongson LS2X APB DMA support"
> + depends on LOONGARCH || COMPILE_TEST
> + select DMA_ENGINE
> + select DMA_VIRTUAL_CHANNELS
> + help
> + Support for the Loongson LS2X APB DMA controller driver. The
> + DMA controller is having single DMA channel which can be
> + configured for different peripherals like audio, nand, sdio
> + etc which is in APB bus.
> +
> + This DMA controller transfers data from memory to peripheral fifo.
> + It does not support memory to memory data transfer.
> +
> config MCF_EDMA
> tristate "Freescale eDMA engine support, ColdFire mcf5441x SoCs"
> depends on M5441x || COMPILE_TEST
> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> index 83553a97a010..dfd40d14e408 100644
> --- a/drivers/dma/Makefile
> +++ b/drivers/dma/Makefile
> @@ -48,6 +48,7 @@ obj-$(CONFIG_INTEL_IOATDMA) += ioat/
> obj-y += idxd/
> obj-$(CONFIG_K3_DMA) += k3dma.o
> obj-$(CONFIG_LPC18XX_DMAMUX) += lpc18xx-dmamux.o
> +obj-$(CONFIG_LS2X_APB_DMA) += ls2x-apb-dma.o
> obj-$(CONFIG_MILBEAUT_HDMAC) += milbeaut-hdmac.o
> obj-$(CONFIG_MILBEAUT_XDMAC) += milbeaut-xdmac.o
> obj-$(CONFIG_MMP_PDMA) += mmp_pdma.o
> diff --git a/drivers/dma/ls2x-apb-dma.c b/drivers/dma/ls2x-apb-dma.c
> new file mode 100644
> index 000000000000..f60dbeae627f
> --- /dev/null
> +++ b/drivers/dma/ls2x-apb-dma.c
> @@ -0,0 +1,705 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Driver for the Loongson LS2X APB DMA Controller
> + *
> + * Copyright (C) 2017-2023 Loongson Corporation
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/dmapool.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/io-64-nonatomic-lo-hi.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_dma.h>
> +#include <linux/platform_device.h>
> +#include <linux/slab.h>
> +
> +#include "dmaengine.h"
> +#include "virt-dma.h"
> +
> +/* Global Configuration Register */
> +#define LDMA_ORDER_ERG 0x0
> +
> +/* Bitfield definitions */
> +
> +/* Bitfields in Global Configuration Register */
> +#define LDMA_64BIT_EN BIT(0) /* 1: 64 bit support */
> +#define LDMA_UNCOHERENT_EN BIT(1) /* 0: cache, 1: uncache */
> +#define LDMA_ASK_VALID BIT(2)
> +#define LDMA_START BIT(3) /* DMA start operation */
> +#define LDMA_STOP BIT(4) /* DMA stop operation */
> +#define LDMA_CONFIG_MASK GENMASK(4, 0) /* DMA controller config bits mask */
> +
> +/* Bitfields in ndesc_addr field of HW decriptor */
> +#define LDMA_DESC_EN BIT(0) /*1: The next descriptor is valid */
> +#define LDMA_DESC_ADDR_LOW GENMASK(31, 1)
> +
> +/* Bitfields in cmd field of HW decriptor */
> +#define LDMA_INT BIT(1) /* Enable DMA interrupts */
> +#define LDMA_DATA_DIRECTION BIT(12) /* 1: write to device, 0: read from device */
> +
> +#define LDMA_SLAVE_BUSWIDTHS (BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
> + BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
> +
> +#define LDMA_MAX_TRANS_LEN U32_MAX
> +
> +/*-- descriptors -----------------------------------------------------*/
> +
> +/*
> + * struct ls2x_dma_hw_desc - DMA HW descriptor
> + * @ndesc_addr: the next descriptor low address.
> + * @mem_addr: memory low address.
> + * @apb_addr: device buffer address.
> + * @len: length of a piece of carried content, in words.
> + * @step_len: length between two moved memory data blocks.
> + * @step_times: number of blocks to be carried in a single DMA operation.
> + * @cmd: descriptor command or state.
> + * @stats: DMA status.
> + * @high_ndesc_addr: the next descriptor high address.
> + * @high_mem_addr: memory high address.
> + * @reserved: reserved
> + */
> +struct ls2x_dma_hw_desc {
> + u32 ndesc_addr;
> + u32 mem_addr;
> + u32 apb_addr;
> + u32 len;
> + u32 step_len;
> + u32 step_times;
> + u32 cmd;
> + u32 stats;
> + u32 high_ndesc_addr;
> + u32 high_mem_addr;
> + u32 reserved[2];
> +} __packed;
> +
> +/*
> + * struct ls2x_dma_sg - ls2x dma scatter gather entry
> + * @hw: the pointer to DMA HW descriptor.
> + * @llp: physical address of the DMA HW descriptor.
> + * @phys: destination or source address(mem).
> + * @len: number of Bytes to read.
> + */
> +struct ls2x_dma_sg {
> + struct ls2x_dma_hw_desc *hw;
> + dma_addr_t llp;
> + dma_addr_t phys;
> + u32 len;
> +};
> +
> +/*
> + * struct ls2x_dma_desc - software descriptor
> + * @vdesc: pointer to the virtual dma descriptor.
> + * @cyclic: flag to dma cyclic
> + * @burst_size: burst size of transaction, in words.
> + * @desc_num: number of sg entries.
> + * @direction: transfer direction, to or from device.
> + * @status: dma controller status.
> + * @sg: array of sgs.
> + */
> +struct ls2x_dma_desc {
> + struct virt_dma_desc vdesc;
> + bool cyclic;
> + size_t burst_size;
> + u32 desc_num;
> + enum dma_transfer_direction direction;
> + enum dma_status status;
> + struct ls2x_dma_sg sg[] __counted_by(desc_num);
> +};
> +
> +/*-- Channels --------------------------------------------------------*/
> +
> +/*
> + * struct ls2x_dma_chan - internal representation of an LS2X APB DMA channel
> + * @vchan: virtual dma channel entry.
> + * @desc: pointer to the ls2x sw dma descriptor.
> + * @pool: hw desc table
> + * @irq: irq line
> + * @sconfig: configuration for slave transfers, passed via .device_config
> + */
> +struct ls2x_dma_chan {
> + struct virt_dma_chan vchan;
> + struct ls2x_dma_desc *desc;
> + void *pool;
> + int irq;
> + struct dma_slave_config sconfig;
> +};
> +
> +/*-- Controller ------------------------------------------------------*/
> +
> +/*
> + * struct ls2x_dma_priv - LS2X APB DMAC specific information
> + * @ddev: dmaengine dma_device object members
> + * @dma_clk: DMAC clock source
> + * @regs: memory mapped register base
> + * @lchan: channel to store ls2x_dma_chan structures
> + */
> +struct ls2x_dma_priv {
> + struct dma_device ddev;
> + struct clk *dma_clk;
> + void __iomem *regs;
> + struct ls2x_dma_chan lchan;
> +};
> +
> +/*-- Helper functions ------------------------------------------------*/
> +
> +static inline struct ls2x_dma_desc *to_ldma_desc(struct virt_dma_desc *vdesc)
> +{
> + return container_of(vdesc, struct ls2x_dma_desc, vdesc);
> +}
> +
> +static inline struct ls2x_dma_chan *to_ldma_chan(struct dma_chan *chan)
> +{
> + return container_of(chan, struct ls2x_dma_chan, vchan.chan);
> +}
> +
> +static inline struct ls2x_dma_priv *to_ldma_priv(struct dma_device *ddev)
> +{
> + return container_of(ddev, struct ls2x_dma_priv, ddev);
> +}
> +
> +static struct device *chan2dev(struct dma_chan *chan)
> +{
> + return &chan->dev->device;
> +}
> +
> +static void ls2x_dma_desc_free(struct virt_dma_desc *vdesc)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(vdesc->tx.chan);
> + struct ls2x_dma_desc *desc = to_ldma_desc(vdesc);
> + int i;
> +
> + for (i = 0; i < desc->desc_num; i++) {
> + if (desc->sg[i].hw)
> + dma_pool_free(lchan->pool, desc->sg[i].hw,
> + desc->sg[i].llp);
> + }
> +
> + kfree(desc);
> +}
> +
> +static void ls2x_dma_write_cmd(struct ls2x_dma_chan *lchan, bool cmd)
> +{
> + u64 val = 0;
superfluous init
> + struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
> +
> + val = lo_hi_readq(priv->regs + LDMA_ORDER_ERG) & ~LDMA_CONFIG_MASK;
> + val |= LDMA_64BIT_EN | cmd;
should this be LDMA_64BIT_EN & cmd ?
> + lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
> +}
> +
> +static void ls2x_dma_start_transfer(struct ls2x_dma_chan *lchan)
> +{
> + struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
> + struct ls2x_dma_sg *ldma_sg;
> + struct virt_dma_desc *vdesc;
> + u64 val;
> +
> + /* Get the next descriptor */
> + vdesc = vchan_next_desc(&lchan->vchan);
> + if (!vdesc) {
> + lchan->desc = NULL;
> + return;
> + }
> +
> + list_del(&vdesc->node);
> + lchan->desc = to_ldma_desc(vdesc);
> + ldma_sg = &lchan->desc->sg[0];
> +
> + /* Start DMA */
> + lo_hi_writeq(0, priv->regs + LDMA_ORDER_ERG);
> + val = (ldma_sg->llp & ~LDMA_CONFIG_MASK) | LDMA_64BIT_EN | LDMA_START;
> + lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
> +}
> +
> +static size_t ls2x_dmac_detect_burst(struct ls2x_dma_chan *lchan)
> +{
> + u32 maxburst, buswidth;
> +
> + /* Reject definitely invalid configurations */
> + if ((lchan->sconfig.src_addr_width & LDMA_SLAVE_BUSWIDTHS) &&
> + (lchan->sconfig.dst_addr_width & LDMA_SLAVE_BUSWIDTHS))
> + return 0;
> +
> + if (lchan->sconfig.direction == DMA_MEM_TO_DEV) {
> + maxburst = lchan->sconfig.dst_maxburst;
> + buswidth = lchan->sconfig.dst_addr_width;
> + } else {
> + maxburst = lchan->sconfig.src_maxburst;
> + buswidth = lchan->sconfig.src_addr_width;
> + }
> +
> + /* If maxburst is zero, fallback to LDMA_MAX_TRANS_LEN */
> + return maxburst ? (maxburst * buswidth) >> 2 : LDMA_MAX_TRANS_LEN;
> +}
> +
> +static void ls2x_dma_fill_desc(struct ls2x_dma_chan *lchan, u32 sg_index,
> + struct ls2x_dma_desc *desc)
> +{
> + struct ls2x_dma_sg *ldma_sg = &desc->sg[sg_index];
> + u32 num_segments, segment_size;
> +
> + if (desc->direction == DMA_MEM_TO_DEV) {
> + ldma_sg->hw->cmd = LDMA_INT | LDMA_DATA_DIRECTION;
> + ldma_sg->hw->apb_addr = lchan->sconfig.dst_addr;
> + } else {
> + ldma_sg->hw->cmd = LDMA_INT;
> + ldma_sg->hw->apb_addr = lchan->sconfig.src_addr;
> + }
> +
> + ldma_sg->hw->mem_addr = lower_32_bits(ldma_sg->phys);
> + ldma_sg->hw->high_mem_addr = upper_32_bits(ldma_sg->phys);
> +
> + /* Split into multiple equally sized segments if necessary */
> + num_segments = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, desc->burst_size);
> + segment_size = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, num_segments);
> +
> + /* Word count register takes input in words */
> + ldma_sg->hw->len = segment_size;
> + ldma_sg->hw->step_times = num_segments;
> + ldma_sg->hw->step_len = 0;
> +
> + /* lets make a link list */
> + if (sg_index) {
> + desc->sg[sg_index - 1].hw->ndesc_addr = ldma_sg->llp | LDMA_DESC_EN;
> + desc->sg[sg_index - 1].hw->high_ndesc_addr = upper_32_bits(ldma_sg->llp);
> + }
> +}
> +
> +/*-- DMA Engine API --------------------------------------------------*/
> +
> +/*
> + * ls2x_dma_alloc_chan_resources - allocate resources for DMA channel
> + * @chan: allocate descriptor resources for this channel
> + *
> + * return - the number of allocated descriptors
> + */
> +static int ls2x_dma_alloc_chan_resources(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> +
> + /* Create a pool of consistent memory blocks for hardware descriptors */
> + lchan->pool = dma_pool_create(dev_name(chan2dev(chan)),
> + chan->device->dev, PAGE_SIZE,
> + __alignof__(struct ls2x_dma_hw_desc), 0);
> + if (!lchan->pool) {
> + dev_err(chan2dev(chan), "No memory for descriptors\n");
> + return -ENOMEM;
> + }
> +
> + return 1;
> +}
> +
> +/*
> + * ls2x_dma_free_chan_resources - free all channel resources
> + * @chan: DMA channel
> + */
> +static void ls2x_dma_free_chan_resources(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> +
> + vchan_free_chan_resources(to_virt_chan(chan));
> + dma_pool_destroy(lchan->pool);
> + lchan->pool = NULL;
> +}
> +
> +/*
> + * ls2x_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
> + * @chan: DMA channel
> + * @sgl: scatterlist to transfer to/from
> + * @sg_len: number of entries in @scatterlist
> + * @direction: DMA direction
> + * @flags: tx descriptor status flags
> + * @context: transaction context (ignored)
> + *
> + * Return: Async transaction descriptor on success and NULL on failure
> + */
> +static struct dma_async_tx_descriptor *
> +ls2x_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
> + u32 sg_len, enum dma_transfer_direction direction,
> + unsigned long flags, void *context)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + struct ls2x_dma_desc *desc;
> + struct scatterlist *sg;
> + size_t burst_size;
> + int i;
> +
> + if (unlikely(!sg_len || !is_slave_direction(direction)))
> + return NULL;
> +
> + burst_size = ls2x_dmac_detect_burst(lchan);
> + if (!burst_size)
> + return NULL;
> +
> + desc = kzalloc(struct_size(desc, sg, sg_len), GFP_ATOMIC);
GFP_NOWAIT pls
> + if (!desc)
> + return NULL;
> +
> + desc->desc_num = sg_len;
> + desc->direction = direction;
> + desc->burst_size = burst_size;
> +
> + for_each_sg(sgl, sg, sg_len, i) {
> + struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
> +
> + /* Allocate DMA capable memory for hardware descriptor */
> + ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
> + if (!ldma_sg->hw) {
> + desc->desc_num = i;
> + ls2x_dma_desc_free(&desc->vdesc);
> + return NULL;
> + }
> +
> + ldma_sg->phys = sg_dma_address(sg);
> + ldma_sg->len = sg_dma_len(sg);
> +
> + ls2x_dma_fill_desc(lchan, i, desc);
> + }
> +
> + /* Setting the last descriptor enable bit */
> + desc->sg[sg_len - 1].hw->ndesc_addr &= ~LDMA_DESC_EN;
> + desc->status = DMA_IN_PROGRESS;
> +
> + return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
> +}
> +
> +/*
> + * ls2x_dma_prep_dma_cyclic - prepare the cyclic DMA transfer
> + * @chan: the DMA channel to prepare
> + * @buf_addr: physical DMA address where the buffer starts
> + * @buf_len: total number of bytes for the entire buffer
> + * @period_len: number of bytes for each period
> + * @direction: transfer direction, to or from device
> + * @flags: tx descriptor status flags
> + *
> + * Return: Async transaction descriptor on success and NULL on failure
> + */
> +static struct dma_async_tx_descriptor *
> +ls2x_dma_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
> + size_t period_len, enum dma_transfer_direction direction,
> + unsigned long flags)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + struct ls2x_dma_desc *desc;
> + u32 num_periods;
> + size_t burst_size;
> + int i;
> +
> + if (unlikely(!buf_len || !period_len))
> + return NULL;
> +
> + if (unlikely(!is_slave_direction(direction)))
> + return NULL;
> +
> + burst_size = ls2x_dmac_detect_burst(lchan);
> + if (!burst_size)
> + return NULL;
> +
> + num_periods = buf_len / period_len;
> + desc = kzalloc(struct_size(desc, sg, num_periods), GFP_ATOMIC);
here too
> + if (!desc)
> + return NULL;
> +
> + desc->desc_num = num_periods;
> + desc->direction = direction;
> + desc->burst_size = burst_size;
> +
> + /* Build cyclic linked list */
> + for (i = 0; i < num_periods; i++) {
> + struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
> +
> + /* Allocate DMA capable memory for hardware descriptor */
> + ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
> + if (!ldma_sg->hw) {
> + desc->desc_num = i;
> + ls2x_dma_desc_free(&desc->vdesc);
> + return NULL;
> + }
> +
> + ldma_sg->phys = buf_addr + period_len * i;
> + ldma_sg->len = period_len;
> +
> + ls2x_dma_fill_desc(lchan, i, desc);
> + }
> +
> + /* Lets make a cyclic list */
> + desc->sg[num_periods - 1].hw->ndesc_addr = desc->sg[0].llp | LDMA_DESC_EN;
> + desc->sg[num_periods - 1].hw->high_ndesc_addr = upper_32_bits(desc->sg[0].llp);
> + desc->cyclic = true;
> + desc->status = DMA_IN_PROGRESS;
> +
> + return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
> +}
> +
> +/*
> + * ls2x_slave_config - set slave configuration for channel
> + * @chan: dma channel
> + * @cfg: slave configuration
> + *
> + * Sets slave configuration for channel
> + */
> +static int ls2x_dma_slave_config(struct dma_chan *chan,
> + struct dma_slave_config *config)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> +
> + memcpy(&lchan->sconfig, config, sizeof(*config));
> + return 0;
> +}
> +
> +/*
> + * ls2x_dma_issue_pending - push pending transactions to the hardware
> + * @chan: channel
> + *
> + * When this function is called, all pending transactions are pushed to the
> + * hardware and executed.
> + */
> +static void ls2x_dma_issue_pending(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&lchan->vchan.lock, flags);
> + if (vchan_issue_pending(&lchan->vchan) && !lchan->desc)
> + ls2x_dma_start_transfer(lchan);
> + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> +}
> +
> +/*
> + * ls2x_dma_terminate_all - terminate all transactions
> + * @chan: channel
> + *
> + * Stops all DMA transactions.
> + */
> +static int ls2x_dma_terminate_all(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + unsigned long flags;
> + LIST_HEAD(head);
> +
> + spin_lock_irqsave(&lchan->vchan.lock, flags);
> + /* Setting stop cmd */
> + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> + if (lchan->desc) {
> + vchan_terminate_vdesc(&lchan->desc->vdesc);
> + lchan->desc = NULL;
> + }
> +
> + vchan_get_all_descriptors(&lchan->vchan, &head);
> + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> +
> + vchan_dma_desc_free_list(&lchan->vchan, &head);
> + return 0;
> +}
> +
> +/*
> + * ls2x_dma_synchronize - Synchronizes the termination of transfers to the
> + * current context.
> + * @chan: channel
> + */
> +static void ls2x_dma_synchronize(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> +
> + vchan_synchronize(&lchan->vchan);
> +}
> +
> +static int ls2x_dma_pause(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&lchan->vchan.lock, flags);
> + if (lchan->desc && lchan->desc->status == DMA_IN_PROGRESS) {
> + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> + lchan->desc->status = DMA_PAUSED;
> + }
> + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> +
> + return 0;
> +}
> +
> +static int ls2x_dma_resume(struct dma_chan *chan)
> +{
> + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&lchan->vchan.lock, flags);
> + if (lchan->desc && lchan->desc->status == DMA_PAUSED) {
> + lchan->desc->status = DMA_IN_PROGRESS;
> + ls2x_dma_write_cmd(lchan, LDMA_START);
> + }
> + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> +
> + return 0;
> +}
> +
> +/*
> + * ls2x_dma_isr - LS2X DMA Interrupt handler
> + * @irq: IRQ number
> + * @dev_id: Pointer to ls2x_dma_chan
> + *
> + * Return: IRQ_HANDLED/IRQ_NONE
> + */
> +static irqreturn_t ls2x_dma_isr(int irq, void *dev_id)
> +{
> + struct ls2x_dma_chan *lchan = dev_id;
> + struct ls2x_dma_desc *desc;
> +
> + spin_lock(&lchan->vchan.lock);
> + desc = lchan->desc;
> + if (desc) {
> + if (desc->cyclic) {
> + vchan_cyclic_callback(&desc->vdesc);
> + } else {
> + desc->status = DMA_COMPLETE;
> + vchan_cookie_complete(&desc->vdesc);
> + ls2x_dma_start_transfer(lchan);
> + }
> +
> + /* ls2x_dma_start_transfer() updates lchan->desc */
> + if (!lchan->desc)
> + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> + }
> + spin_unlock(&lchan->vchan.lock);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static int ls2x_dma_chan_init(struct platform_device *pdev,
> + struct ls2x_dma_priv *priv)
> +{
> + struct device *dev = &pdev->dev;
> + struct ls2x_dma_chan *lchan = &priv->lchan;
> + int ret;
> +
> + lchan->irq = platform_get_irq(pdev, 0);
> + if (lchan->irq < 0)
> + return lchan->irq;
> +
> + ret = devm_request_irq(dev, lchan->irq, ls2x_dma_isr, IRQF_TRIGGER_RISING,
> + dev_name(&pdev->dev), lchan);
> + if (ret)
> + return ret;
> +
> + /* Initialize channels related values */
> + INIT_LIST_HEAD(&priv->ddev.channels);
> + lchan->vchan.desc_free = ls2x_dma_desc_free;
> + vchan_init(&lchan->vchan, &priv->ddev);
> +
> + return 0;
> +}
> +
> +/*
> + * ls2x_dma_probe - Driver probe function
> + * @pdev: Pointer to the platform_device structure
> + *
> + * Return: '0' on success and failure value on error
> + */
> +static int ls2x_dma_probe(struct platform_device *pdev)
> +{
> + int ret;
> + struct dma_device *ddev;
> + struct ls2x_dma_priv *priv;
> + struct device *dev = &pdev->dev;
> +
> + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
> + if (!priv)
> + return -ENOMEM;
> +
> + priv->regs = devm_platform_ioremap_resource(pdev, 0);
> + if (IS_ERR(priv->regs))
> + return dev_err_probe(dev, PTR_ERR(priv->regs),
> + "devm_platform_ioremap_resource failed.\n");
> +
> + priv->dma_clk = devm_clk_get(&pdev->dev, NULL);
> + if (IS_ERR(priv->dma_clk))
> + return dev_err_probe(dev, PTR_ERR(priv->dma_clk), "devm_clk_get failed.\n");
> +
> + ret = clk_prepare_enable(priv->dma_clk);
> + if (ret)
> + return dev_err_probe(dev, ret, "clk_prepare_enable failed.\n");
> +
> + ret = ls2x_dma_chan_init(pdev, priv);
> + if (ret)
> + goto disable_clk;
> +
> + ddev = &priv->ddev;
> + ddev->dev = dev;
> + dma_cap_zero(ddev->cap_mask);
> + dma_cap_set(DMA_SLAVE, ddev->cap_mask);
> + dma_cap_set(DMA_CYCLIC, ddev->cap_mask);
> +
> + ddev->device_alloc_chan_resources = ls2x_dma_alloc_chan_resources;
> + ddev->device_free_chan_resources = ls2x_dma_free_chan_resources;
> + ddev->device_tx_status = dma_cookie_status;
> + ddev->device_issue_pending = ls2x_dma_issue_pending;
> + ddev->device_prep_slave_sg = ls2x_dma_prep_slave_sg;
> + ddev->device_prep_dma_cyclic = ls2x_dma_prep_dma_cyclic;
> + ddev->device_config = ls2x_dma_slave_config;
> + ddev->device_terminate_all = ls2x_dma_terminate_all;
> + ddev->device_synchronize = ls2x_dma_synchronize;
> + ddev->device_pause = ls2x_dma_pause;
> + ddev->device_resume = ls2x_dma_resume;
> +
> + ddev->src_addr_widths = LDMA_SLAVE_BUSWIDTHS;
> + ddev->dst_addr_widths = LDMA_SLAVE_BUSWIDTHS;
> + ddev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
> +
> + ret = dma_async_device_register(&priv->ddev);
> + if (ret < 0)
> + goto disable_clk;
> +
> + ret = of_dma_controller_register(dev->of_node, of_dma_xlate_by_chan_id, priv);
> + if (ret < 0)
> + goto unregister_dmac;
> +
> + platform_set_drvdata(pdev, priv);
> +
> + dev_info(dev, "Loongson LS2X APB DMA driver registered successfully.\n");
> + return 0;
> +
> +unregister_dmac:
> + dma_async_device_unregister(&priv->ddev);
> +disable_clk:
> + clk_disable_unprepare(priv->dma_clk);
> +
> + return ret;
> +}
> +
> +/*
> + * ls2x_dma_remove - Driver remove function
> + * @pdev: Pointer to the platform_device structure
> + */
> +static void ls2x_dma_remove(struct platform_device *pdev)
> +{
> + struct ls2x_dma_priv *priv = platform_get_drvdata(pdev);
> +
> + of_dma_controller_free(pdev->dev.of_node);
> + dma_async_device_unregister(&priv->ddev);
> + clk_disable_unprepare(priv->dma_clk);
> +}
> +
> +static const struct of_device_id ls2x_dma_of_match_table[] = {
> + { .compatible = "loongson,ls2k1000-apbdma" },
> + { /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, ls2x_dma_of_match_table);
> +
> +static struct platform_driver ls2x_dmac_driver = {
> + .probe = ls2x_dma_probe,
> + .remove_new = ls2x_dma_remove,
> + .driver = {
> + .name = "ls2x-apbdma",
> + .of_match_table = ls2x_dma_of_match_table,
> + },
> +};
> +module_platform_driver(ls2x_dmac_driver);
> +
> +MODULE_DESCRIPTION("Loongson LS2X APB DMA Controller driver");
> +MODULE_AUTHOR("Loongson Technology Corporation Limited");
> +MODULE_LICENSE("GPL");
> --
> 2.39.3
--
~Vinod
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the Loongson LS2X APB DMA controller
2023-12-11 11:39 ` Vinod Koul
@ 2023-12-12 6:05 ` Binbin Zhou
0 siblings, 0 replies; 6+ messages in thread
From: Binbin Zhou @ 2023-12-12 6:05 UTC (permalink / raw)
To: Vinod Koul
Cc: Binbin Zhou, Huacai Chen, dmaengine, Rob Herring,
Krzysztof Kozlowski, Conor Dooley, devicetree, Huacai Chen,
loongson-kernel, Xuerui Wang, loongarch, Yingkun Meng
Hi Vinod:
Thanks for your review.
On Mon, Dec 11, 2023 at 5:39 PM Vinod Koul <vkoul@kernel.org> wrote:
>
> On 22-11-23, 17:27, Binbin Zhou wrote:
> > The Loongson LS2X APB DMA controller is available on Loongson-2K chips.
> >
> > It is a single-channel, configurable DMA controller IP core based on the
> > AXI bus, whose main function is to integrate DMA functionality on a chip
> > dedicated to carrying data between memory and peripherals in APB bus
> > (e.g. nand).
> >
> > Signed-off-by: Binbin Zhou <zhoubinbin@loongson.cn>
> > Signed-off-by: Yingkun Meng <mengyingkun@loongson.cn>
> > ---
> > MAINTAINERS | 1 +
> > drivers/dma/Kconfig | 14 +
> > drivers/dma/Makefile | 1 +
> > drivers/dma/ls2x-apb-dma.c | 705 +++++++++++++++++++++++++++++++++++++
> > 4 files changed, 721 insertions(+)
> > create mode 100644 drivers/dma/ls2x-apb-dma.c
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index eb1d9c4f85d0..6b8d7f5b241b 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -12511,6 +12511,7 @@ M: Binbin Zhou <zhoubinbin@loongson.cn>
> > L: dmaengine@vger.kernel.org
> > S: Maintained
> > F: Documentation/devicetree/bindings/dma/loongson,ls2x-apbdma.yaml
> > +F: drivers/dma/ls2x-apb-dma.c
> >
> > LOONGSON LS2X I2C DRIVER
> > M: Binbin Zhou <zhoubinbin@loongson.cn>
> > diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> > index 70ba506dabab..e928f2ca0f1e 100644
> > --- a/drivers/dma/Kconfig
> > +++ b/drivers/dma/Kconfig
> > @@ -378,6 +378,20 @@ config LPC18XX_DMAMUX
> > Enable support for DMA on NXP LPC18xx/43xx platforms
> > with PL080 and multiplexed DMA request lines.
> >
> > +config LS2X_APB_DMA
> > + tristate "Loongson LS2X APB DMA support"
> > + depends on LOONGARCH || COMPILE_TEST
> > + select DMA_ENGINE
> > + select DMA_VIRTUAL_CHANNELS
> > + help
> > + Support for the Loongson LS2X APB DMA controller driver. The
> > + DMA controller is having single DMA channel which can be
> > + configured for different peripherals like audio, nand, sdio
> > + etc which is in APB bus.
> > +
> > + This DMA controller transfers data from memory to peripheral fifo.
> > + It does not support memory to memory data transfer.
> > +
> > config MCF_EDMA
> > tristate "Freescale eDMA engine support, ColdFire mcf5441x SoCs"
> > depends on M5441x || COMPILE_TEST
> > diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> > index 83553a97a010..dfd40d14e408 100644
> > --- a/drivers/dma/Makefile
> > +++ b/drivers/dma/Makefile
> > @@ -48,6 +48,7 @@ obj-$(CONFIG_INTEL_IOATDMA) += ioat/
> > obj-y += idxd/
> > obj-$(CONFIG_K3_DMA) += k3dma.o
> > obj-$(CONFIG_LPC18XX_DMAMUX) += lpc18xx-dmamux.o
> > +obj-$(CONFIG_LS2X_APB_DMA) += ls2x-apb-dma.o
> > obj-$(CONFIG_MILBEAUT_HDMAC) += milbeaut-hdmac.o
> > obj-$(CONFIG_MILBEAUT_XDMAC) += milbeaut-xdmac.o
> > obj-$(CONFIG_MMP_PDMA) += mmp_pdma.o
> > diff --git a/drivers/dma/ls2x-apb-dma.c b/drivers/dma/ls2x-apb-dma.c
> > new file mode 100644
> > index 000000000000..f60dbeae627f
> > --- /dev/null
> > +++ b/drivers/dma/ls2x-apb-dma.c
> > @@ -0,0 +1,705 @@
> > +// SPDX-License-Identifier: GPL-2.0-or-later
> > +/*
> > + * Driver for the Loongson LS2X APB DMA Controller
> > + *
> > + * Copyright (C) 2017-2023 Loongson Corporation
> > + */
> > +
> > +#include <linux/clk.h>
> > +#include <linux/dma-mapping.h>
> > +#include <linux/dmapool.h>
> > +#include <linux/interrupt.h>
> > +#include <linux/io.h>
> > +#include <linux/io-64-nonatomic-lo-hi.h>
> > +#include <linux/module.h>
> > +#include <linux/of.h>
> > +#include <linux/of_dma.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/slab.h>
> > +
> > +#include "dmaengine.h"
> > +#include "virt-dma.h"
> > +
> > +/* Global Configuration Register */
> > +#define LDMA_ORDER_ERG 0x0
> > +
> > +/* Bitfield definitions */
> > +
> > +/* Bitfields in Global Configuration Register */
> > +#define LDMA_64BIT_EN BIT(0) /* 1: 64 bit support */
> > +#define LDMA_UNCOHERENT_EN BIT(1) /* 0: cache, 1: uncache */
> > +#define LDMA_ASK_VALID BIT(2)
> > +#define LDMA_START BIT(3) /* DMA start operation */
> > +#define LDMA_STOP BIT(4) /* DMA stop operation */
> > +#define LDMA_CONFIG_MASK GENMASK(4, 0) /* DMA controller config bits mask */
> > +
> > +/* Bitfields in ndesc_addr field of HW decriptor */
> > +#define LDMA_DESC_EN BIT(0) /*1: The next descriptor is valid */
> > +#define LDMA_DESC_ADDR_LOW GENMASK(31, 1)
> > +
> > +/* Bitfields in cmd field of HW decriptor */
> > +#define LDMA_INT BIT(1) /* Enable DMA interrupts */
> > +#define LDMA_DATA_DIRECTION BIT(12) /* 1: write to device, 0: read from device */
> > +
> > +#define LDMA_SLAVE_BUSWIDTHS (BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \
> > + BIT(DMA_SLAVE_BUSWIDTH_8_BYTES))
> > +
> > +#define LDMA_MAX_TRANS_LEN U32_MAX
> > +
> > +/*-- descriptors -----------------------------------------------------*/
> > +
> > +/*
> > + * struct ls2x_dma_hw_desc - DMA HW descriptor
> > + * @ndesc_addr: the next descriptor low address.
> > + * @mem_addr: memory low address.
> > + * @apb_addr: device buffer address.
> > + * @len: length of a piece of carried content, in words.
> > + * @step_len: length between two moved memory data blocks.
> > + * @step_times: number of blocks to be carried in a single DMA operation.
> > + * @cmd: descriptor command or state.
> > + * @stats: DMA status.
> > + * @high_ndesc_addr: the next descriptor high address.
> > + * @high_mem_addr: memory high address.
> > + * @reserved: reserved
> > + */
> > +struct ls2x_dma_hw_desc {
> > + u32 ndesc_addr;
> > + u32 mem_addr;
> > + u32 apb_addr;
> > + u32 len;
> > + u32 step_len;
> > + u32 step_times;
> > + u32 cmd;
> > + u32 stats;
> > + u32 high_ndesc_addr;
> > + u32 high_mem_addr;
> > + u32 reserved[2];
> > +} __packed;
> > +
> > +/*
> > + * struct ls2x_dma_sg - ls2x dma scatter gather entry
> > + * @hw: the pointer to DMA HW descriptor.
> > + * @llp: physical address of the DMA HW descriptor.
> > + * @phys: destination or source address(mem).
> > + * @len: number of Bytes to read.
> > + */
> > +struct ls2x_dma_sg {
> > + struct ls2x_dma_hw_desc *hw;
> > + dma_addr_t llp;
> > + dma_addr_t phys;
> > + u32 len;
> > +};
> > +
> > +/*
> > + * struct ls2x_dma_desc - software descriptor
> > + * @vdesc: pointer to the virtual dma descriptor.
> > + * @cyclic: flag to dma cyclic
> > + * @burst_size: burst size of transaction, in words.
> > + * @desc_num: number of sg entries.
> > + * @direction: transfer direction, to or from device.
> > + * @status: dma controller status.
> > + * @sg: array of sgs.
> > + */
> > +struct ls2x_dma_desc {
> > + struct virt_dma_desc vdesc;
> > + bool cyclic;
> > + size_t burst_size;
> > + u32 desc_num;
> > + enum dma_transfer_direction direction;
> > + enum dma_status status;
> > + struct ls2x_dma_sg sg[] __counted_by(desc_num);
> > +};
> > +
> > +/*-- Channels --------------------------------------------------------*/
> > +
> > +/*
> > + * struct ls2x_dma_chan - internal representation of an LS2X APB DMA channel
> > + * @vchan: virtual dma channel entry.
> > + * @desc: pointer to the ls2x sw dma descriptor.
> > + * @pool: hw desc table
> > + * @irq: irq line
> > + * @sconfig: configuration for slave transfers, passed via .device_config
> > + */
> > +struct ls2x_dma_chan {
> > + struct virt_dma_chan vchan;
> > + struct ls2x_dma_desc *desc;
> > + void *pool;
> > + int irq;
> > + struct dma_slave_config sconfig;
> > +};
> > +
> > +/*-- Controller ------------------------------------------------------*/
> > +
> > +/*
> > + * struct ls2x_dma_priv - LS2X APB DMAC specific information
> > + * @ddev: dmaengine dma_device object members
> > + * @dma_clk: DMAC clock source
> > + * @regs: memory mapped register base
> > + * @lchan: channel to store ls2x_dma_chan structures
> > + */
> > +struct ls2x_dma_priv {
> > + struct dma_device ddev;
> > + struct clk *dma_clk;
> > + void __iomem *regs;
> > + struct ls2x_dma_chan lchan;
> > +};
> > +
> > +/*-- Helper functions ------------------------------------------------*/
> > +
> > +static inline struct ls2x_dma_desc *to_ldma_desc(struct virt_dma_desc *vdesc)
> > +{
> > + return container_of(vdesc, struct ls2x_dma_desc, vdesc);
> > +}
> > +
> > +static inline struct ls2x_dma_chan *to_ldma_chan(struct dma_chan *chan)
> > +{
> > + return container_of(chan, struct ls2x_dma_chan, vchan.chan);
> > +}
> > +
> > +static inline struct ls2x_dma_priv *to_ldma_priv(struct dma_device *ddev)
> > +{
> > + return container_of(ddev, struct ls2x_dma_priv, ddev);
> > +}
> > +
> > +static struct device *chan2dev(struct dma_chan *chan)
> > +{
> > + return &chan->dev->device;
> > +}
> > +
> > +static void ls2x_dma_desc_free(struct virt_dma_desc *vdesc)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(vdesc->tx.chan);
> > + struct ls2x_dma_desc *desc = to_ldma_desc(vdesc);
> > + int i;
> > +
> > + for (i = 0; i < desc->desc_num; i++) {
> > + if (desc->sg[i].hw)
> > + dma_pool_free(lchan->pool, desc->sg[i].hw,
> > + desc->sg[i].llp);
> > + }
> > +
> > + kfree(desc);
> > +}
> > +
> > +static void ls2x_dma_write_cmd(struct ls2x_dma_chan *lchan, bool cmd)
> > +{
> > + u64 val = 0;
>
> superfluous init
Got it.
>
> > + struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
> > +
> > + val = lo_hi_readq(priv->regs + LDMA_ORDER_ERG) & ~LDMA_CONFIG_MASK;
> > + val |= LDMA_64BIT_EN | cmd;
>
> should this be LDMA_64BIT_EN & cmd ?
Emm.. I think it should be "|" here.
The cmd parameter represents the DMAC state we expect to set, e.g.,
STOP, which along with 64BIT_EN belongs to the configuration-related
bits in the order register.
The definition is as follows:
#define LDMA_64BIT_EN BIT(0) /* 1: 64 bit support */
#define LDMA_UNCOHERENT_EN BIT(1) /* 0: cache, 1: uncache */
#define LDMA_ASK_VALID BIT(2)
#define LDMA_START BIT(3) /* DMA start operation */
#define LDMA_STOP BIT(4) /* DMA stop operation */
>
> > + lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
> > +}
> > +
> > +static void ls2x_dma_start_transfer(struct ls2x_dma_chan *lchan)
> > +{
> > + struct ls2x_dma_priv *priv = to_ldma_priv(lchan->vchan.chan.device);
> > + struct ls2x_dma_sg *ldma_sg;
> > + struct virt_dma_desc *vdesc;
> > + u64 val;
> > +
> > + /* Get the next descriptor */
> > + vdesc = vchan_next_desc(&lchan->vchan);
> > + if (!vdesc) {
> > + lchan->desc = NULL;
> > + return;
> > + }
> > +
> > + list_del(&vdesc->node);
> > + lchan->desc = to_ldma_desc(vdesc);
> > + ldma_sg = &lchan->desc->sg[0];
> > +
> > + /* Start DMA */
> > + lo_hi_writeq(0, priv->regs + LDMA_ORDER_ERG);
> > + val = (ldma_sg->llp & ~LDMA_CONFIG_MASK) | LDMA_64BIT_EN | LDMA_START;
> > + lo_hi_writeq(val, priv->regs + LDMA_ORDER_ERG);
> > +}
> > +
> > +static size_t ls2x_dmac_detect_burst(struct ls2x_dma_chan *lchan)
> > +{
> > + u32 maxburst, buswidth;
> > +
> > + /* Reject definitely invalid configurations */
> > + if ((lchan->sconfig.src_addr_width & LDMA_SLAVE_BUSWIDTHS) &&
> > + (lchan->sconfig.dst_addr_width & LDMA_SLAVE_BUSWIDTHS))
> > + return 0;
> > +
> > + if (lchan->sconfig.direction == DMA_MEM_TO_DEV) {
> > + maxburst = lchan->sconfig.dst_maxburst;
> > + buswidth = lchan->sconfig.dst_addr_width;
> > + } else {
> > + maxburst = lchan->sconfig.src_maxburst;
> > + buswidth = lchan->sconfig.src_addr_width;
> > + }
> > +
> > + /* If maxburst is zero, fallback to LDMA_MAX_TRANS_LEN */
> > + return maxburst ? (maxburst * buswidth) >> 2 : LDMA_MAX_TRANS_LEN;
> > +}
> > +
> > +static void ls2x_dma_fill_desc(struct ls2x_dma_chan *lchan, u32 sg_index,
> > + struct ls2x_dma_desc *desc)
> > +{
> > + struct ls2x_dma_sg *ldma_sg = &desc->sg[sg_index];
> > + u32 num_segments, segment_size;
> > +
> > + if (desc->direction == DMA_MEM_TO_DEV) {
> > + ldma_sg->hw->cmd = LDMA_INT | LDMA_DATA_DIRECTION;
> > + ldma_sg->hw->apb_addr = lchan->sconfig.dst_addr;
> > + } else {
> > + ldma_sg->hw->cmd = LDMA_INT;
> > + ldma_sg->hw->apb_addr = lchan->sconfig.src_addr;
> > + }
> > +
> > + ldma_sg->hw->mem_addr = lower_32_bits(ldma_sg->phys);
> > + ldma_sg->hw->high_mem_addr = upper_32_bits(ldma_sg->phys);
> > +
> > + /* Split into multiple equally sized segments if necessary */
> > + num_segments = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, desc->burst_size);
> > + segment_size = DIV_ROUND_UP((ldma_sg->len + 3) >> 2, num_segments);
> > +
> > + /* Word count register takes input in words */
> > + ldma_sg->hw->len = segment_size;
> > + ldma_sg->hw->step_times = num_segments;
> > + ldma_sg->hw->step_len = 0;
> > +
> > + /* lets make a link list */
> > + if (sg_index) {
> > + desc->sg[sg_index - 1].hw->ndesc_addr = ldma_sg->llp | LDMA_DESC_EN;
> > + desc->sg[sg_index - 1].hw->high_ndesc_addr = upper_32_bits(ldma_sg->llp);
> > + }
> > +}
> > +
> > +/*-- DMA Engine API --------------------------------------------------*/
> > +
> > +/*
> > + * ls2x_dma_alloc_chan_resources - allocate resources for DMA channel
> > + * @chan: allocate descriptor resources for this channel
> > + *
> > + * return - the number of allocated descriptors
> > + */
> > +static int ls2x_dma_alloc_chan_resources(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > +
> > + /* Create a pool of consistent memory blocks for hardware descriptors */
> > + lchan->pool = dma_pool_create(dev_name(chan2dev(chan)),
> > + chan->device->dev, PAGE_SIZE,
> > + __alignof__(struct ls2x_dma_hw_desc), 0);
> > + if (!lchan->pool) {
> > + dev_err(chan2dev(chan), "No memory for descriptors\n");
> > + return -ENOMEM;
> > + }
> > +
> > + return 1;
> > +}
> > +
> > +/*
> > + * ls2x_dma_free_chan_resources - free all channel resources
> > + * @chan: DMA channel
> > + */
> > +static void ls2x_dma_free_chan_resources(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > +
> > + vchan_free_chan_resources(to_virt_chan(chan));
> > + dma_pool_destroy(lchan->pool);
> > + lchan->pool = NULL;
> > +}
> > +
> > +/*
> > + * ls2x_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
> > + * @chan: DMA channel
> > + * @sgl: scatterlist to transfer to/from
> > + * @sg_len: number of entries in @scatterlist
> > + * @direction: DMA direction
> > + * @flags: tx descriptor status flags
> > + * @context: transaction context (ignored)
> > + *
> > + * Return: Async transaction descriptor on success and NULL on failure
> > + */
> > +static struct dma_async_tx_descriptor *
> > +ls2x_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
> > + u32 sg_len, enum dma_transfer_direction direction,
> > + unsigned long flags, void *context)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + struct ls2x_dma_desc *desc;
> > + struct scatterlist *sg;
> > + size_t burst_size;
> > + int i;
> > +
> > + if (unlikely(!sg_len || !is_slave_direction(direction)))
> > + return NULL;
> > +
> > + burst_size = ls2x_dmac_detect_burst(lchan);
> > + if (!burst_size)
> > + return NULL;
> > +
> > + desc = kzalloc(struct_size(desc, sg, sg_len), GFP_ATOMIC);
>
> GFP_NOWAIT pls
got it.
>
> > + if (!desc)
> > + return NULL;
> > +
> > + desc->desc_num = sg_len;
> > + desc->direction = direction;
> > + desc->burst_size = burst_size;
> > +
> > + for_each_sg(sgl, sg, sg_len, i) {
> > + struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
> > +
> > + /* Allocate DMA capable memory for hardware descriptor */
> > + ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
> > + if (!ldma_sg->hw) {
> > + desc->desc_num = i;
> > + ls2x_dma_desc_free(&desc->vdesc);
> > + return NULL;
> > + }
> > +
> > + ldma_sg->phys = sg_dma_address(sg);
> > + ldma_sg->len = sg_dma_len(sg);
> > +
> > + ls2x_dma_fill_desc(lchan, i, desc);
> > + }
> > +
> > + /* Setting the last descriptor enable bit */
> > + desc->sg[sg_len - 1].hw->ndesc_addr &= ~LDMA_DESC_EN;
> > + desc->status = DMA_IN_PROGRESS;
> > +
> > + return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
> > +}
> > +
> > +/*
> > + * ls2x_dma_prep_dma_cyclic - prepare the cyclic DMA transfer
> > + * @chan: the DMA channel to prepare
> > + * @buf_addr: physical DMA address where the buffer starts
> > + * @buf_len: total number of bytes for the entire buffer
> > + * @period_len: number of bytes for each period
> > + * @direction: transfer direction, to or from device
> > + * @flags: tx descriptor status flags
> > + *
> > + * Return: Async transaction descriptor on success and NULL on failure
> > + */
> > +static struct dma_async_tx_descriptor *
> > +ls2x_dma_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
> > + size_t period_len, enum dma_transfer_direction direction,
> > + unsigned long flags)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + struct ls2x_dma_desc *desc;
> > + u32 num_periods;
> > + size_t burst_size;
> > + int i;
> > +
> > + if (unlikely(!buf_len || !period_len))
> > + return NULL;
> > +
> > + if (unlikely(!is_slave_direction(direction)))
> > + return NULL;
> > +
> > + burst_size = ls2x_dmac_detect_burst(lchan);
> > + if (!burst_size)
> > + return NULL;
> > +
> > + num_periods = buf_len / period_len;
> > + desc = kzalloc(struct_size(desc, sg, num_periods), GFP_ATOMIC);
>
> here too
got it.
Thanks.
Binbin
>
> > + if (!desc)
> > + return NULL;
> > +
> > + desc->desc_num = num_periods;
> > + desc->direction = direction;
> > + desc->burst_size = burst_size;
> > +
> > + /* Build cyclic linked list */
> > + for (i = 0; i < num_periods; i++) {
> > + struct ls2x_dma_sg *ldma_sg = &desc->sg[i];
> > +
> > + /* Allocate DMA capable memory for hardware descriptor */
> > + ldma_sg->hw = dma_pool_alloc(lchan->pool, GFP_NOWAIT, &ldma_sg->llp);
> > + if (!ldma_sg->hw) {
> > + desc->desc_num = i;
> > + ls2x_dma_desc_free(&desc->vdesc);
> > + return NULL;
> > + }
> > +
> > + ldma_sg->phys = buf_addr + period_len * i;
> > + ldma_sg->len = period_len;
> > +
> > + ls2x_dma_fill_desc(lchan, i, desc);
> > + }
> > +
> > + /* Lets make a cyclic list */
> > + desc->sg[num_periods - 1].hw->ndesc_addr = desc->sg[0].llp | LDMA_DESC_EN;
> > + desc->sg[num_periods - 1].hw->high_ndesc_addr = upper_32_bits(desc->sg[0].llp);
> > + desc->cyclic = true;
> > + desc->status = DMA_IN_PROGRESS;
> > +
> > + return vchan_tx_prep(&lchan->vchan, &desc->vdesc, flags);
> > +}
> > +
> > +/*
> > + * ls2x_slave_config - set slave configuration for channel
> > + * @chan: dma channel
> > + * @cfg: slave configuration
> > + *
> > + * Sets slave configuration for channel
> > + */
> > +static int ls2x_dma_slave_config(struct dma_chan *chan,
> > + struct dma_slave_config *config)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > +
> > + memcpy(&lchan->sconfig, config, sizeof(*config));
> > + return 0;
> > +}
> > +
> > +/*
> > + * ls2x_dma_issue_pending - push pending transactions to the hardware
> > + * @chan: channel
> > + *
> > + * When this function is called, all pending transactions are pushed to the
> > + * hardware and executed.
> > + */
> > +static void ls2x_dma_issue_pending(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + unsigned long flags;
> > +
> > + spin_lock_irqsave(&lchan->vchan.lock, flags);
> > + if (vchan_issue_pending(&lchan->vchan) && !lchan->desc)
> > + ls2x_dma_start_transfer(lchan);
> > + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> > +}
> > +
> > +/*
> > + * ls2x_dma_terminate_all - terminate all transactions
> > + * @chan: channel
> > + *
> > + * Stops all DMA transactions.
> > + */
> > +static int ls2x_dma_terminate_all(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + unsigned long flags;
> > + LIST_HEAD(head);
> > +
> > + spin_lock_irqsave(&lchan->vchan.lock, flags);
> > + /* Setting stop cmd */
> > + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> > + if (lchan->desc) {
> > + vchan_terminate_vdesc(&lchan->desc->vdesc);
> > + lchan->desc = NULL;
> > + }
> > +
> > + vchan_get_all_descriptors(&lchan->vchan, &head);
> > + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> > +
> > + vchan_dma_desc_free_list(&lchan->vchan, &head);
> > + return 0;
> > +}
> > +
> > +/*
> > + * ls2x_dma_synchronize - Synchronizes the termination of transfers to the
> > + * current context.
> > + * @chan: channel
> > + */
> > +static void ls2x_dma_synchronize(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > +
> > + vchan_synchronize(&lchan->vchan);
> > +}
> > +
> > +static int ls2x_dma_pause(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + unsigned long flags;
> > +
> > + spin_lock_irqsave(&lchan->vchan.lock, flags);
> > + if (lchan->desc && lchan->desc->status == DMA_IN_PROGRESS) {
> > + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> > + lchan->desc->status = DMA_PAUSED;
> > + }
> > + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> > +
> > + return 0;
> > +}
> > +
> > +static int ls2x_dma_resume(struct dma_chan *chan)
> > +{
> > + struct ls2x_dma_chan *lchan = to_ldma_chan(chan);
> > + unsigned long flags;
> > +
> > + spin_lock_irqsave(&lchan->vchan.lock, flags);
> > + if (lchan->desc && lchan->desc->status == DMA_PAUSED) {
> > + lchan->desc->status = DMA_IN_PROGRESS;
> > + ls2x_dma_write_cmd(lchan, LDMA_START);
> > + }
> > + spin_unlock_irqrestore(&lchan->vchan.lock, flags);
> > +
> > + return 0;
> > +}
> > +
> > +/*
> > + * ls2x_dma_isr - LS2X DMA Interrupt handler
> > + * @irq: IRQ number
> > + * @dev_id: Pointer to ls2x_dma_chan
> > + *
> > + * Return: IRQ_HANDLED/IRQ_NONE
> > + */
> > +static irqreturn_t ls2x_dma_isr(int irq, void *dev_id)
> > +{
> > + struct ls2x_dma_chan *lchan = dev_id;
> > + struct ls2x_dma_desc *desc;
> > +
> > + spin_lock(&lchan->vchan.lock);
> > + desc = lchan->desc;
> > + if (desc) {
> > + if (desc->cyclic) {
> > + vchan_cyclic_callback(&desc->vdesc);
> > + } else {
> > + desc->status = DMA_COMPLETE;
> > + vchan_cookie_complete(&desc->vdesc);
> > + ls2x_dma_start_transfer(lchan);
> > + }
> > +
> > + /* ls2x_dma_start_transfer() updates lchan->desc */
> > + if (!lchan->desc)
> > + ls2x_dma_write_cmd(lchan, LDMA_STOP);
> > + }
> > + spin_unlock(&lchan->vchan.lock);
> > +
> > + return IRQ_HANDLED;
> > +}
> > +
> > +static int ls2x_dma_chan_init(struct platform_device *pdev,
> > + struct ls2x_dma_priv *priv)
> > +{
> > + struct device *dev = &pdev->dev;
> > + struct ls2x_dma_chan *lchan = &priv->lchan;
> > + int ret;
> > +
> > + lchan->irq = platform_get_irq(pdev, 0);
> > + if (lchan->irq < 0)
> > + return lchan->irq;
> > +
> > + ret = devm_request_irq(dev, lchan->irq, ls2x_dma_isr, IRQF_TRIGGER_RISING,
> > + dev_name(&pdev->dev), lchan);
> > + if (ret)
> > + return ret;
> > +
> > + /* Initialize channels related values */
> > + INIT_LIST_HEAD(&priv->ddev.channels);
> > + lchan->vchan.desc_free = ls2x_dma_desc_free;
> > + vchan_init(&lchan->vchan, &priv->ddev);
> > +
> > + return 0;
> > +}
> > +
> > +/*
> > + * ls2x_dma_probe - Driver probe function
> > + * @pdev: Pointer to the platform_device structure
> > + *
> > + * Return: '0' on success and failure value on error
> > + */
> > +static int ls2x_dma_probe(struct platform_device *pdev)
> > +{
> > + int ret;
> > + struct dma_device *ddev;
> > + struct ls2x_dma_priv *priv;
> > + struct device *dev = &pdev->dev;
> > +
> > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
> > + if (!priv)
> > + return -ENOMEM;
> > +
> > + priv->regs = devm_platform_ioremap_resource(pdev, 0);
> > + if (IS_ERR(priv->regs))
> > + return dev_err_probe(dev, PTR_ERR(priv->regs),
> > + "devm_platform_ioremap_resource failed.\n");
> > +
> > + priv->dma_clk = devm_clk_get(&pdev->dev, NULL);
> > + if (IS_ERR(priv->dma_clk))
> > + return dev_err_probe(dev, PTR_ERR(priv->dma_clk), "devm_clk_get failed.\n");
> > +
> > + ret = clk_prepare_enable(priv->dma_clk);
> > + if (ret)
> > + return dev_err_probe(dev, ret, "clk_prepare_enable failed.\n");
> > +
> > + ret = ls2x_dma_chan_init(pdev, priv);
> > + if (ret)
> > + goto disable_clk;
> > +
> > + ddev = &priv->ddev;
> > + ddev->dev = dev;
> > + dma_cap_zero(ddev->cap_mask);
> > + dma_cap_set(DMA_SLAVE, ddev->cap_mask);
> > + dma_cap_set(DMA_CYCLIC, ddev->cap_mask);
> > +
> > + ddev->device_alloc_chan_resources = ls2x_dma_alloc_chan_resources;
> > + ddev->device_free_chan_resources = ls2x_dma_free_chan_resources;
> > + ddev->device_tx_status = dma_cookie_status;
> > + ddev->device_issue_pending = ls2x_dma_issue_pending;
> > + ddev->device_prep_slave_sg = ls2x_dma_prep_slave_sg;
> > + ddev->device_prep_dma_cyclic = ls2x_dma_prep_dma_cyclic;
> > + ddev->device_config = ls2x_dma_slave_config;
> > + ddev->device_terminate_all = ls2x_dma_terminate_all;
> > + ddev->device_synchronize = ls2x_dma_synchronize;
> > + ddev->device_pause = ls2x_dma_pause;
> > + ddev->device_resume = ls2x_dma_resume;
> > +
> > + ddev->src_addr_widths = LDMA_SLAVE_BUSWIDTHS;
> > + ddev->dst_addr_widths = LDMA_SLAVE_BUSWIDTHS;
> > + ddev->directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
> > +
> > + ret = dma_async_device_register(&priv->ddev);
> > + if (ret < 0)
> > + goto disable_clk;
> > +
> > + ret = of_dma_controller_register(dev->of_node, of_dma_xlate_by_chan_id, priv);
> > + if (ret < 0)
> > + goto unregister_dmac;
> > +
> > + platform_set_drvdata(pdev, priv);
> > +
> > + dev_info(dev, "Loongson LS2X APB DMA driver registered successfully.\n");
> > + return 0;
> > +
> > +unregister_dmac:
> > + dma_async_device_unregister(&priv->ddev);
> > +disable_clk:
> > + clk_disable_unprepare(priv->dma_clk);
> > +
> > + return ret;
> > +}
> > +
> > +/*
> > + * ls2x_dma_remove - Driver remove function
> > + * @pdev: Pointer to the platform_device structure
> > + */
> > +static void ls2x_dma_remove(struct platform_device *pdev)
> > +{
> > + struct ls2x_dma_priv *priv = platform_get_drvdata(pdev);
> > +
> > + of_dma_controller_free(pdev->dev.of_node);
> > + dma_async_device_unregister(&priv->ddev);
> > + clk_disable_unprepare(priv->dma_clk);
> > +}
> > +
> > +static const struct of_device_id ls2x_dma_of_match_table[] = {
> > + { .compatible = "loongson,ls2k1000-apbdma" },
> > + { /* sentinel */ }
> > +};
> > +MODULE_DEVICE_TABLE(of, ls2x_dma_of_match_table);
> > +
> > +static struct platform_driver ls2x_dmac_driver = {
> > + .probe = ls2x_dma_probe,
> > + .remove_new = ls2x_dma_remove,
> > + .driver = {
> > + .name = "ls2x-apbdma",
> > + .of_match_table = ls2x_dma_of_match_table,
> > + },
> > +};
> > +module_platform_driver(ls2x_dmac_driver);
> > +
> > +MODULE_DESCRIPTION("Loongson LS2X APB DMA Controller driver");
> > +MODULE_AUTHOR("Loongson Technology Corporation Limited");
> > +MODULE_LICENSE("GPL");
> > --
> > 2.39.3
>
> --
> ~Vinod
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2023-12-12 6:05 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2023-11-22 9:27 [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 1/2] dt-bindings: dmaengine: Add Loongson LS2X APB DMA controller Binbin Zhou
2023-11-22 9:27 ` [PATCH v5 2/2] dmaengine: ls2x-apb: new driver for the " Binbin Zhou
2023-12-11 11:39 ` Vinod Koul
2023-12-12 6:05 ` Binbin Zhou
2023-12-07 7:42 ` [PATCH v5 0/2] New driver for the Loongson LS2X APB DMA Controller Binbin Zhou
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).