* [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i
@ 2014-06-16 3:50 Emilio López
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
` (9 more replies)
0 siblings, 10 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
Hi everyone,
As part of Google Summer of Code, I've tasked myself with implementing
DMA support for the earlier Allwinner platforms. This first round of
patches is the result of said effort.
The first patch is the actual driver to support these platforms. Patches
four and five add the corresponding DMA node to the device trees.
Patches two and three are two patches I created to test the driver with
some memory to device / device to memory transfers. The former lets
the 8250_dw driver, used for the sunxi UARTs, use DMA transfers. After
testing for a while, it seems there is an issue with DMA transfers on
the UARTs - for normal user-interactive operation it seems to work okay,
but pasting some chunk of text to it seems to hang the UART and some
messages about "too much work for IRQ" show up with the UART IRQ number.
I was not able to investigate further because I'm interacting with the
device via the UART.
The latter patch for the SPI driver lets me use DMA for SPI transfers
of <=64 bytes. Anything larger than the FIFO size seems to stall; is
this expected behaviour?
Patches six and seven add the DMA properties to SPI so you can test with
the third patch. Patch eight does the same for the UARTs. The last two
patches add a dummy SPIdev device to both cubieboard and cubietruck to
facilitate testing with spidev_test.
My main testing procedure for SPI has been spidev_test from the kernel
tree, with and without shorting MISO and MOSI. For memory to memory
transfers, I have used dmatest.ko with various configurations. I have
done testing on a cubieboard (A10, sun4i) and cubietruck (A20, sun7i)
and while I expect no issues to show up, I will be repeating my tests
on an A10S olinuxino as well.
You will find some extra remarks on individual patches after their
descriptions. All comments are welcome.
Thanks!
Emilio
Emilio L?pez (10):
dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
serial: 8250_dw: support DMA on the OF case
spi: sun4i: add DMA support
ARM: sun7i: Add node to represent the DMA controller
ARM: sun4i: Add node to represent the DMA controller
ARM: sun7i: enable DMA on SPI
ARM: sun4i: enable DMA on SPI
ARM: sun7i: add DMA properties to UARTs
ARM: sun4i: cubieboard: add an SPIdev device for testing
ARM: sun7i: cubietruck: add an SPIdev device for testing
.../devicetree/bindings/dma/sun4i-dma.txt | 45 +
arch/arm/boot/dts/sun4i-a10-cubieboard.dts | 12 +
arch/arm/boot/dts/sun4i-a10.dtsi | 23 +
arch/arm/boot/dts/sun7i-a20-cubietruck.dts | 12 +
arch/arm/boot/dts/sun7i-a20.dtsi | 32 +
drivers/dma/Kconfig | 10 +
drivers/dma/Makefile | 1 +
drivers/dma/sun4i-dma.c | 1065 ++++++++++++++++++++
drivers/spi/spi-sun4i.c | 146 ++-
drivers/tty/serial/8250/8250_dw.c | 7 +-
10 files changed, 1345 insertions(+), 8 deletions(-)
create mode 100644 Documentation/devicetree/bindings/dma/sun4i-dma.txt
create mode 100644 drivers/dma/sun4i-dma.c
--
2.0.0
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-21 13:51 ` Chen-Yu Tsai
2014-06-25 18:42 ` Maxime Ripard
2014-06-16 3:50 ` [PATCH 02/10] serial: 8250_dw: support DMA on the OF case Emilio López
` (8 subsequent siblings)
9 siblings, 2 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
This patch adds support for the DMA engine present on Allwinner A10,
A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
and dedicated. The main difference is in the mode of operation;
while a single normal channel may be operating at any given time,
dedicated channels may operate simultaneously provided there is no
overlap of source or destination.
Hardware documentation can be found on A10 User Manual (section 12), A13
User Manual (section 14) and A20 User Manual (section 1.12)
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
For some mem2dev/dev2mem transfers, we need to configure some magic delays
for things to work - on my experimental testing, 0x00010001 seems to work
for SPI. Is there some place in the API to pass these kinds of values from
client drivers when configuring a transfer? Currently I have just hardcoded
this value on the driver, but it'll probably cause trouble in the future
for other devices.
.../devicetree/bindings/dma/sun4i-dma.txt | 45 +
drivers/dma/Kconfig | 10 +
drivers/dma/Makefile | 1 +
drivers/dma/sun4i-dma.c | 1065 ++++++++++++++++++++
4 files changed, 1121 insertions(+)
create mode 100644 Documentation/devicetree/bindings/dma/sun4i-dma.txt
create mode 100644 drivers/dma/sun4i-dma.c
diff --git a/Documentation/devicetree/bindings/dma/sun4i-dma.txt b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
new file mode 100644
index 0000000..f5661a5
--- /dev/null
+++ b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
@@ -0,0 +1,45 @@
+Allwinner A10 DMA Controller
+
+This driver follows the generic DMA bindings defined in dma.txt.
+
+Required properties:
+
+- compatible: Must be "allwinner,sun4i-a10-dma"
+- reg: Should contain the registers base address and length
+- interrupts: Should contain a reference to the interrupt used by this device
+- clocks: Should contain a reference to the parent AHB clock
+- #dma-cells : Should be 1, a single cell holding a line request number
+
+Example:
+ dma: dma-controller at 01c02000 {
+ compatible = "allwinner,sun4i-a10-dma";
+ reg = <0x01c02000 0x1000>;
+ interrupts = <27>;
+ clocks = <&ahb_gates 6>;
+ #dma-cells = <1>;
+ };
+
+Clients:
+
+DMA clients connected to the Allwinner A10 DMA controller must use the
+format described in the dma.txt file, using a three-cell specifier for
+each channel: a phandle plus two integer cells.
+The three cells in order are:
+
+1. A phandle pointing to the DMA controller.
+2. Whether it is using normal (0) or dedicated (1) channels
+2. The port ID as specified in the datasheet
+
+Example:
+ spi2: spi at 01c17000 {
+ compatible = "allwinner,sun4i-a10-spi";
+ reg = <0x01c17000 0x1000>;
+ interrupts = <0 12 4>;
+ clocks = <&ahb_gates 22>, <&spi2_clk>;
+ clock-names = "ahb", "mod";
+ dmas = <&dma 1 29>, <&dma 1 28>;
+ dma-names = "rx", "tx";
+ status = "disabled";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ };
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index ba06d1d..a9ee0c9 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -361,6 +361,16 @@ config FSL_EDMA
multiplexing capability for DMA request sources(slot).
This module can be found on Freescale Vybrid and LS-1 SoCs.
+config SUN4I_DMA
+ tristate "Allwinner A10/A10S/A13/A20 DMA support"
+ depends on ARCH_SUNXI
+ select DMA_ENGINE
+ select DMA_OF
+ select DMA_VIRTUAL_CHANNELS
+ help
+ Enable support for the DMA controller present in the sun4i,
+ sun5i and sun7i Allwinner ARM SoCs.
+
config DMA_ENGINE
bool
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 5150c82..13a7d5d 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
+obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
new file mode 100644
index 0000000..0b14b3f
--- /dev/null
+++ b/drivers/dma/sun4i-dma.c
@@ -0,0 +1,1065 @@
+/*
+ * Copyright (C) 2014 Emilio L?pez
+ * Emilio L?pez <emilio@elopez.com.ar>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/bitmap.h>
+#include <linux/bitops.h>
+#include <linux/clk.h>
+#include <linux/dmaengine.h>
+#include <linux/dmapool.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/of_dma.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+
+#include "virt-dma.h"
+
+/** General DMA register values **/
+
+/* DMA source/destination burst length values */
+#define DMA_BURST_LENGTH_1 0
+#define DMA_BURST_LENGTH_4 1
+#define DMA_BURST_LENGTH_8 2
+
+/* DMA source/destination data width */
+#define DMA_DATA_WIDTH_8BIT 0
+#define DMA_DATA_WIDTH_16BIT 1
+#define DMA_DATA_WIDTH_32BIT 2
+
+/** Normal DMA register values **/
+
+/* Normal DMA source/destination data request type values */
+#define NDMA_DRQ_TYPE_IR0 0x0
+#define NDMA_DRQ_TYPE_IR1 0x1
+#define NDMA_DRQ_TYPE_SPDIF 0x2
+#define NDMA_DRQ_TYPE_IIS0 0x3
+#define NDMA_DRQ_TYPE_IIS1 0x4
+#define NDMA_DRQ_TYPE_AC97 0x5
+#define NDMA_DRQ_TYPE_IIS2 0x6
+#define NDMA_DRQ_TYPE_UART0 0x8
+#define NDMA_DRQ_TYPE_UART1 0x9
+#define NDMA_DRQ_TYPE_UART2 0xA
+#define NDMA_DRQ_TYPE_UART3 0xB
+#define NDMA_DRQ_TYPE_UART4 0xC
+#define NDMA_DRQ_TYPE_UART5 0xD
+#define NDMA_DRQ_TYPE_UART6 0xE
+#define NDMA_DRQ_TYPE_UART7 0xF
+#define NDMA_DRQ_TYPE_HDMI_DDC 0x10
+#define NDMA_DRQ_TYPE_USB_EP1 0x11
+#define NDMA_DRQ_TYPE_AUDIO_CODEC 0x13
+#define NDMA_DRQ_TYPE_SRAM 0x15
+#define NDMA_DRQ_TYPE_SDRAM 0x16
+#define NDMA_DRQ_TYPE_TP_AD 0x17
+#define NDMA_DRQ_TYPE_SPI0 0x18
+#define NDMA_DRQ_TYPE_SPI1 0x19
+#define NDMA_DRQ_TYPE_SPI2 0x1A
+#define NDMA_DRQ_TYPE_SPI3 0x1B
+#define NDMA_DRQ_TYPE_USB_EP2 0x1C
+#define NDMA_DRQ_TYPE_USB_EP3 0x1D
+#define NDMA_DRQ_TYPE_USB_EP4 0x1E
+#define NDMA_DRQ_TYPE_USB_EP5 0x1F
+#define NDMA_DRQ_TYPE_LIMIT (0x1F+1)
+
+/** Normal DMA register layout **/
+
+/* Normal DMA configuration register layout */
+#define NDMA_CFG_LOADING BIT(31)
+#define NDMA_CFG_CONT_MODE BIT(30)
+#define NDMA_CFG_WAIT_STATE(n) (n << 27)
+#define NDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
+#define NDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
+#define NDMA_CFG_DEST_NON_SECURE BIT(22)
+#define NDMA_CFG_DEST_FIXED_ADDR BIT(21)
+#define NDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
+#define NDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
+#define NDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
+#define NDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
+#define NDMA_CFG_SRC_NON_SECURE BIT(6)
+#define NDMA_CFG_SRC_FIXED_ADDR BIT(5)
+#define NDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
+
+/** Dedicated DMA register values **/
+
+/* Dedicated DMA source/destination address mode values */
+#define DDMA_ADDR_MODE_LINEAR 0
+#define DDMA_ADDR_MODE_IO 1
+#define DDMA_ADDR_MODE_HORIZONTAL_PAGE 2
+#define DDMA_ADDR_MODE_VERTICAL_PAGE 3
+
+/* Dedicated DMA source/destination data request type values
+ * Note: some of these values are only sensible when used only as
+ * source or destination */
+#define DDMA_DRQ_TYPE_SRAM 0x0
+#define DDMA_DRQ_TYPE_SDRAM 0x1
+#define DDMA_DRQ_TYPE_PATA 0x2
+#define DDMA_DRQ_TYPE_NFC 0x3
+#define DDMA_DRQ_TYPE_USB0 0x4
+#define DDMA_DRQ_TYPE_EMAC_TX 0x6
+#define DDMA_DRQ_TYPE_EMAC_RX 0x7
+#define DDMA_DRQ_TYPE_SPI1_TX 0x8
+#define DDMA_DRQ_TYPE_SPI1_RX 0x9
+#define DDMA_DRQ_TYPE_SS_TX 0xA
+#define DDMA_DRQ_TYPE_SS_RX 0xB
+#define DDMA_DRQ_TYPE_TCON0 0xE
+#define DDMA_DRQ_TYPE_TCON1 0xF
+#define DDMA_DRQ_TYPE_MSC 0x17
+#define DDMA_DRQ_TYPE_HDMI_AUDIO 0x18
+#define DDMA_DRQ_TYPE_SPI0_TX 0x1A
+#define DDMA_DRQ_TYPE_SPI0_RX 0x1B
+#define DDMA_DRQ_TYPE_SPI2_TX 0x1C
+#define DDMA_DRQ_TYPE_SPI2_RX 0x1D
+#define DDMA_DRQ_TYPE_SPI3_TX 0x1E
+#define DDMA_DRQ_TYPE_SPI3_RX 0x1F
+#define DDMA_DRQ_TYPE_LIMIT (0x1F+1)
+
+/** Dedicated DMA register layout **/
+
+/* Dedicated DMA configuration register layout */
+#define DDMA_CFG_LOADING BIT(31)
+#define DDMA_CFG_BUSY BIT(30)
+#define DDMA_CFG_CONT_MODE BIT(29)
+#define DDMA_CFG_DEST_NON_SECURE BIT(28)
+#define DDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
+#define DDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
+#define DDMA_CFG_DEST_ADDR_MODE(mode) (mode << 21)
+#define DDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
+#define DDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
+#define DDMA_CFG_SRC_NON_SECURE BIT(12)
+#define DDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
+#define DDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
+#define DDMA_CFG_SRC_ADDR_MODE(mode) (mode << 5)
+#define DDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
+
+/* Dedicated DMA parameter register layout */
+#define DDMA_PARA_DEST_DATA_BLK_SIZE(n) (n-1 << 24)
+#define DDMA_PARA_DEST_WAIT_CYCLES(n) (n-1 << 16)
+#define DDMA_PARA_SRC_DATA_BLK_SIZE(n) (n-1 << 8)
+#define DDMA_PARA_SRC_WAIT_CYCLES(n) (n-1 << 0)
+
+/** DMA register offsets **/
+
+/* Normal DMA register offsets */
+#define NDMA_CHANNEL_REG_BASE(n) (0x100+n*0x20)
+#define NDMA_CFG_REG 0x0
+#define NDMA_SRC_ADDR_REG 0x4
+#define NDMA_DEST_ADDR_REG 0x8
+#define NDMA_BYTE_COUNT_REG 0xC
+
+/* Dedicated DMA register offsets */
+#define DDMA_CHANNEL_REG_BASE(n) (0x300+n*0x20)
+#define DDMA_CFG_REG 0x0
+#define DDMA_SRC_ADDR_REG 0x4
+#define DDMA_DEST_ADDR_REG 0x8
+#define DDMA_BYTE_COUNT_REG 0xC
+#define DDMA_PARA_REG 0x18
+
+/* General register offsets */
+#define DMA_IRQ_ENABLE_REG 0x0
+#define DMA_IRQ_PENDING_STATUS_REG 0x4
+
+/** DMA Driver **/
+
+/* Normal DMA has 8 channels, and Dedicated DMA has another 8, so that's
+ * 16 channels. As for endpoints, there's 29 and 21 respectively. Given
+ * that the Normal DMA endpoints can be used as tx/rx, we need 79 vchans
+ * in total
+ */
+#define NDMA_NR_MAX_CHANNELS 8
+#define DDMA_NR_MAX_CHANNELS 8
+#define DMA_NR_MAX_CHANNELS (NDMA_NR_MAX_CHANNELS + DDMA_NR_MAX_CHANNELS)
+#define NDMA_NR_MAX_VCHANS (29*2)
+#define DDMA_NR_MAX_VCHANS 21
+#define DMA_NR_MAX_VCHANS (NDMA_NR_MAX_VCHANS + DDMA_NR_MAX_VCHANS)
+
+struct sun4i_dma_pchan {
+ /* Register base of channel */
+ void __iomem *base;
+ /* vchan currently being serviced */
+ struct sun4i_dma_vchan *vchan;
+ /* Is this a dedicated pchan? */
+ int is_dedicated;
+};
+
+struct sun4i_dma_vchan {
+ struct virt_dma_chan vc;
+ struct dma_slave_config cfg;
+ struct sun4i_dma_pchan *pchan;
+ struct sun4i_dma_promise *processing;
+ struct sun4i_dma_contract *contract;
+ u8 endpoint;
+ int is_dedicated;
+};
+
+struct sun4i_dma_promise {
+ u32 cfg;
+ u32 para;
+ dma_addr_t src;
+ dma_addr_t dst;
+ size_t len;
+ struct list_head list;
+};
+
+/* A contract is a set of promises */
+struct sun4i_dma_contract {
+ struct virt_dma_desc vd;
+ struct list_head demands;
+ struct list_head completed_demands;
+};
+
+struct sun4i_dma_dev {
+ DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
+ struct tasklet_struct tasklet;
+ struct dma_device slave;
+ struct sun4i_dma_pchan *pchans;
+ struct sun4i_dma_vchan *vchans;
+ void __iomem *base;
+ struct clk *clk;
+ int irq;
+ spinlock_t lock;
+};
+
+static struct sun4i_dma_dev *to_sun4i_dma_dev(struct dma_device *dev)
+{
+ return container_of(dev, struct sun4i_dma_dev, slave);
+}
+
+static struct sun4i_dma_vchan *to_sun4i_dma_vchan(struct dma_chan *chan)
+{
+ return container_of(chan, struct sun4i_dma_vchan, vc.chan);
+}
+
+static struct sun4i_dma_contract *to_sun4i_dma_contract(struct virt_dma_desc *vd)
+{
+ return container_of(vd, struct sun4i_dma_contract, vd);
+}
+
+static struct device *chan2dev(struct dma_chan *chan)
+{
+ return &chan->dev->device;
+}
+
+static int convert_burst(u32 maxburst)
+{
+ if (maxburst > 8)
+ maxburst = 8;
+
+ /* 1 -> 0, 4 -> 1, 8 -> 2 */
+ return (maxburst >> 2);
+}
+
+static int convert_buswidth(enum dma_slave_buswidth addr_width)
+{
+ if (addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES)
+ return -EINVAL;
+
+ /* 8 -> 0, 16 -> 1, 32 -> 2 */
+ return (addr_width >> 4);
+}
+
+static int sun4i_dma_alloc_chan_resources(struct dma_chan *chan)
+{
+ return 0;
+}
+
+static void sun4i_dma_free_chan_resources(struct dma_chan *chan)
+{
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+
+ vchan_free_chan_resources(&vchan->vc);
+}
+
+static struct sun4i_dma_pchan *find_and_use_pchan(struct sun4i_dma_dev *priv,
+ struct sun4i_dma_vchan *vchan)
+{
+ struct sun4i_dma_pchan *pchan = NULL, *pchans = priv->pchans;
+ unsigned long flags;
+ int i, max;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ /* pchans 0-NDMA_NR_MAX_CHANNELS are normal, and
+ * NDMA_NR_MAX_CHANNELS+ are dedicated ones */
+ if (vchan->is_dedicated) {
+ i = NDMA_NR_MAX_CHANNELS;
+ max = DMA_NR_MAX_CHANNELS;
+ } else {
+ i = 0;
+ max = NDMA_NR_MAX_CHANNELS;
+ }
+
+ for_each_clear_bit_from(i, &priv->pchans_used, max) {
+ pchan = &pchans[i];
+ pchan->vchan = vchan;
+ set_bit(i, priv->pchans_used);
+ break;
+ }
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return pchan;
+}
+
+static void release_pchan(struct sun4i_dma_dev *priv,
+ struct sun4i_dma_pchan *pchan)
+{
+ unsigned long flags;
+ int nr = pchan - priv->pchans;
+
+ spin_lock_irqsave(&priv->lock, flags);
+
+ clear_bit(nr, priv->pchans_used);
+ pchan->vchan = NULL;
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static void configure_pchan(struct sun4i_dma_pchan *pchan,
+ struct sun4i_dma_promise *d)
+{
+ if (pchan->is_dedicated) {
+ /* Configure addresses and misc parameters */
+ writel_relaxed(d->src, pchan->base + DDMA_SRC_ADDR_REG);
+ writel_relaxed(d->dst, pchan->base + DDMA_DEST_ADDR_REG);
+ writel_relaxed(d->len, pchan->base + DDMA_BYTE_COUNT_REG);
+ writel_relaxed(d->para, pchan->base + DDMA_PARA_REG);
+
+ /* We use a writel here because CFG_LOADING may be set,
+ * and it requires that the rest of the configuration
+ * takes place before the engine is started */
+ writel(d->cfg, pchan->base + DDMA_CFG_REG);
+ } else {
+ /* Configure addresses and misc parameters */
+ writel_relaxed(d->src, pchan->base + NDMA_SRC_ADDR_REG);
+ writel_relaxed(d->dst, pchan->base + NDMA_DEST_ADDR_REG);
+ writel_relaxed(d->len, pchan->base + NDMA_BYTE_COUNT_REG);
+
+ /* We use a writel here because CFG_LOADING may be set,
+ * and it requires that the rest of the configuration
+ * takes place before the engine is started */
+ writel(d->cfg, pchan->base + NDMA_CFG_REG);
+ }
+}
+
+static void set_pchan_interrupt(struct sun4i_dma_dev *priv,
+ struct sun4i_dma_pchan *pchan,
+ int half, int end)
+{
+ u32 reg = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
+ int pchan_number = pchan - priv->pchans;
+
+ if (half)
+ reg |= BIT(pchan_number*2);
+ else
+ reg &= ~BIT(pchan_number*2);
+
+ if (end)
+ reg |= BIT(pchan_number*2 + 1);
+ else
+ reg &= ~BIT(pchan_number*2 + 1);
+
+ writel(reg, priv->base + DMA_IRQ_ENABLE_REG);
+}
+
+static int execute_vchan_pending(struct sun4i_dma_dev *priv,
+ struct sun4i_dma_vchan *vchan)
+{
+ struct sun4i_dma_promise *promise = NULL;
+ struct sun4i_dma_contract *contract = NULL;
+ struct sun4i_dma_pchan *pchan;
+ struct virt_dma_desc *vd;
+ unsigned long flags;
+ int ret;
+
+ /* We need a pchan to do anything, so secure one if available */
+ pchan = find_and_use_pchan(priv, vchan);
+ if (!pchan)
+ return -EBUSY;
+
+ spin_lock_irqsave(&vchan->vc.lock, flags);
+
+ /* Channel endpoints must not be repeated, so if this vchan
+ * has already submitted some work, we can't do anything else
+ */
+ if (vchan->processing) {
+ dev_dbg(chan2dev(&vchan->vc.chan),
+ "processing something to this endpoint already\n");
+ ret = -EBUSY;
+ goto release_pchan;
+ }
+
+ do {
+ /* Figure out which contract we're working with today */
+ vd = vchan_next_desc(&vchan->vc);
+ if (!vd) {
+ dev_dbg(chan2dev(&vchan->vc.chan),
+ "No pending contract found");
+ ret = 0;
+ goto release_pchan;
+ }
+
+ contract = to_sun4i_dma_contract(vd);
+ if (list_empty(&contract->demands)) {
+ /* The contract has been completed so mark it as such */
+ list_del(&contract->vd.node);
+ vchan_cookie_complete(&contract->vd);
+ dev_dbg(chan2dev(&vchan->vc.chan),
+ "Empty contract found and marked complete");
+ }
+ } while (list_empty(&contract->demands));
+
+ /* Now find out what we need to do */
+ promise = list_first_entry(&contract->demands, struct sun4i_dma_promise, list);
+ vchan->processing = promise;
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+
+ /* ... and make it reality */
+ if (promise) {
+ vchan->contract = contract;
+ set_pchan_interrupt(priv, pchan, 0, 1);
+ configure_pchan(pchan, promise);
+ }
+
+ return 0;
+
+release_pchan:
+ release_pchan(priv, pchan);
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+ return ret;
+}
+
+/**
+ * Generate a promise, to be used in a normal DMA contract.
+ *
+ * A NDMA promise contains all the information required to program the
+ * normal part of the DMA Engine and get data copied. A non-executed
+ * promise will live in the demands list on a contract. Once it has been
+ * completed, it will be moved to the completed demands list for later freeing.
+ * All linked promises will be freed when the corresponding contract is freed
+ */
+static struct sun4i_dma_promise *
+generate_ndma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
+ size_t len, struct dma_slave_config *sconfig)
+{
+ struct sun4i_dma_promise *promise;
+ int ret;
+
+ promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
+ if (!promise)
+ return NULL;
+
+ promise->src = src;
+ promise->dst = dest;
+ promise->len = len;
+ promise->cfg = NDMA_CFG_LOADING | NDMA_CFG_BYTE_COUNT_MODE_REMAIN;
+
+ /* Source burst */
+ ret = convert_burst(sconfig->src_maxburst);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= NDMA_CFG_SRC_BURST_LENGTH(ret);
+
+ /* Destination burst */
+ ret = convert_burst(sconfig->dst_maxburst);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= NDMA_CFG_DEST_BURST_LENGTH(ret);
+
+ /* Source bus width */
+ ret = convert_buswidth(sconfig->src_addr_width);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= NDMA_CFG_SRC_DATA_WIDTH(ret);
+
+ /* Destination bus width */
+ ret = convert_buswidth(sconfig->dst_addr_width);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= NDMA_CFG_DEST_DATA_WIDTH(ret);
+
+ return promise;
+
+fail:
+ kfree(promise);
+ return NULL;
+}
+
+/**
+ * Generate a promise, to be used in a dedicated DMA contract.
+ *
+ * A DDMA promise contains all the information required to program the
+ * Dedicated part of the DMA Engine and get data copied. A non-executed
+ * promise will live in the demands list on a contract. Once it has been
+ * completed, it will be moved to the completed demands list for later freeing.
+ * All linked promises will be freed when the corresponding contract is freed
+ */
+static struct sun4i_dma_promise *
+generate_ddma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
+ size_t len, struct dma_slave_config *sconfig)
+{
+ struct sun4i_dma_promise *promise;
+ int ret;
+
+ promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
+ if (!promise)
+ return NULL;
+
+ promise->src = src;
+ promise->dst = dest;
+ promise->len = len;
+ promise->cfg = DDMA_CFG_LOADING | DDMA_CFG_BYTE_COUNT_MODE_REMAIN;
+
+ /* Source burst */
+ ret = convert_burst(sconfig->src_maxburst);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= DDMA_CFG_SRC_BURST_LENGTH(ret);
+
+ /* Destination burst */
+ ret = convert_burst(sconfig->dst_maxburst);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= DDMA_CFG_DEST_BURST_LENGTH(ret);
+
+ /* Source bus width */
+ ret = convert_buswidth(sconfig->src_addr_width);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= DDMA_CFG_SRC_DATA_WIDTH(ret);
+
+ /* Destination bus width */
+ ret = convert_buswidth(sconfig->dst_addr_width);
+ if (IS_ERR_VALUE(ret))
+ goto fail;
+ promise->cfg |= DDMA_CFG_DEST_DATA_WIDTH(ret);
+
+ return promise;
+
+fail:
+ kfree(promise);
+ return NULL;
+}
+
+/**
+ * Generate a contract
+ *
+ * Contracts function as DMA descriptors. As our hardware does not support
+ * linked lists, we need to implement SG via software. We use a contract
+ * to hold all the pieces of the request and process them serially one
+ * after another. Each piece is represented as a promise.
+ */
+static struct sun4i_dma_contract *generate_dma_contract(void)
+{
+ struct sun4i_dma_contract *contract;
+
+ contract = kzalloc(sizeof(*contract), GFP_NOWAIT);
+ if (!contract)
+ return NULL;
+
+ INIT_LIST_HEAD(&contract->demands);
+ INIT_LIST_HEAD(&contract->completed_demands);
+
+ return contract;
+}
+
+/**
+ * Free a contract and all its associated promises
+ */
+static void sun4i_dma_free_contract(struct virt_dma_desc *vd)
+{
+ struct sun4i_dma_contract *contract = to_sun4i_dma_contract(vd);
+ struct sun4i_dma_promise *promise;
+
+ /* Free all the demands and completed demands */
+ list_for_each_entry(promise, &contract->demands, list) {
+ kfree(promise);
+ }
+
+ list_for_each_entry(promise, &contract->completed_demands, list) {
+ kfree(promise);
+ }
+
+ kfree(contract);
+}
+
+static struct dma_async_tx_descriptor *
+sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
+ dma_addr_t src, size_t len, unsigned long flags)
+{
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+ struct dma_slave_config *sconfig = &vchan->cfg;
+ struct sun4i_dma_promise *promise;
+ struct sun4i_dma_contract *contract;
+
+ contract = generate_dma_contract();
+ if (!contract)
+ return NULL;
+
+ if (vchan->is_dedicated)
+ promise = generate_ddma_promise(chan, src, dest, len, sconfig);
+ else
+ promise = generate_ndma_promise(chan, src, dest, len, sconfig);
+
+ if (!promise) {
+ kfree(contract);
+ return NULL;
+ }
+
+ /* Configure memcpy mode */
+ if (vchan->is_dedicated) {
+ promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
+ DDMA_CFG_SRC_NON_SECURE |
+ DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
+ DDMA_CFG_DEST_NON_SECURE;
+ } else {
+ promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
+ NDMA_CFG_SRC_NON_SECURE |
+ NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
+ NDMA_CFG_DEST_NON_SECURE;
+ }
+
+ /* Fill the contract with our only promise */
+ list_add_tail(&promise->list, &contract->demands);
+
+ /* And add it to the vchan */
+ return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
+}
+
+static struct dma_async_tx_descriptor *
+sun4i_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
+ unsigned int sg_len, enum dma_transfer_direction dir,
+ unsigned long flags, void *context)
+{
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+ struct dma_slave_config *sconfig = &vchan->cfg;
+ struct sun4i_dma_promise *promise;
+ struct sun4i_dma_contract *contract;
+ struct scatterlist *sg;
+ dma_addr_t srcaddr, dstaddr;
+ u32 endpoints, para;
+ int i;
+
+ if (!sgl)
+ return NULL;
+
+ if (!is_slave_direction(dir)) {
+ dev_err(chan2dev(chan), "Invalid DMA direction\n");
+ return NULL;
+ }
+
+ contract = generate_dma_contract();
+ if (!contract)
+ return NULL;
+
+ /* Figure out endpoints */
+ if (vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
+ endpoints = DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
+ DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_LINEAR) |
+ DDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
+ DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_IO);
+ } else if (!vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
+ endpoints = NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
+ NDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
+ NDMA_CFG_DEST_FIXED_ADDR;
+ } else if (vchan->is_dedicated) {
+ endpoints = DDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
+ DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_IO) |
+ DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
+ DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_LINEAR);
+ } else {
+ endpoints = NDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
+ NDMA_CFG_SRC_FIXED_ADDR |
+ NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM);
+ }
+
+ for_each_sg(sgl, sg, sg_len, i) {
+ /* Figure out addresses */
+ if (dir == DMA_MEM_TO_DEV) {
+ srcaddr = sg_dma_address(sg);
+ dstaddr = sconfig->dst_addr;
+ para = 0;
+ } else {
+ srcaddr = sconfig->src_addr;
+ dstaddr = sg_dma_address(sg);
+ para = 0x00010001; /* TODO spi magic? */
+ }
+
+ /* And make a suitable promise */
+ promise = generate_ddma_promise(chan, srcaddr, dstaddr,
+ sg_dma_len(sg), sconfig);
+ if (!promise)
+ return NULL; /* TODO */
+
+ promise->cfg |= endpoints;
+ promise->para = para;
+
+ /* Then add it to the contract */
+ list_add_tail(&promise->list, &contract->demands);
+ }
+
+ /* Once we've got all the promises ready, add the contract
+ * to the pending list on the vchan */
+ return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
+}
+
+static int sun4i_dma_terminate_all(struct sun4i_dma_vchan *vchan)
+{
+ struct sun4i_dma_pchan *pchan = vchan->pchan;
+ LIST_HEAD(head);
+ unsigned long flags, timeout;
+ u32 d_busy = DDMA_CFG_LOADING | DDMA_CFG_BUSY;
+ u32 n_busy = NDMA_CFG_LOADING;
+
+
+ spin_lock_irqsave(&vchan->vc.lock, flags);
+ vchan_get_all_descriptors(&vchan->vc, &head);
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+
+ /* If this vchan is operating, wait until it's no longer busy */
+ if (pchan) {
+ timeout = jiffies + msecs_to_jiffies(2000);
+ if (pchan->is_dedicated) {
+ while (readl(pchan->base + DDMA_CFG_REG) & d_busy)
+ if (time_after(jiffies, timeout))
+ return -ETIMEDOUT;
+ } else {
+ while (readl(pchan->base + NDMA_CFG_REG) & n_busy)
+ if (time_after(jiffies, timeout))
+ return -ETIMEDOUT;
+ }
+ }
+
+ /* TODO: wait until IRQ handler has run? */
+
+ spin_lock_irqsave(&vchan->vc.lock, flags);
+ vchan_dma_desc_free_list(&vchan->vc, &head);
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+
+ return 0;
+}
+
+static int sun4i_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
+ unsigned long arg)
+{
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+ int ret = 0;
+
+ switch (cmd) {
+ case DMA_RESUME:
+ case DMA_PAUSE:
+ ret = -EINVAL;
+ break;
+
+ case DMA_TERMINATE_ALL:
+ dev_dbg(chan2dev(chan), "Terminating everything on channel\n");
+ ret = sun4i_dma_terminate_all(vchan);
+ break;
+
+ case DMA_SLAVE_CONFIG:
+ memcpy(&vchan->cfg, (void *)arg, sizeof(vchan->cfg));
+ break;
+
+ default:
+ ret = -ENXIO;
+ break;
+ }
+
+ return ret;
+}
+
+static struct dma_chan *sun4i_dma_of_xlate(struct of_phandle_args *dma_spec,
+ struct of_dma *ofdma)
+{
+ struct sun4i_dma_dev *priv = ofdma->of_dma_data;
+ struct sun4i_dma_vchan *vchan;
+ struct dma_chan *chan;
+ u8 is_dedicated = dma_spec->args[0];
+ u8 endpoint = dma_spec->args[1];
+
+ /* Check if type is Normal or Dedicated */
+ if (is_dedicated != 0 && is_dedicated != 1)
+ return NULL;
+
+ /* Make sure the endpoint looks sane */
+ if ((is_dedicated && endpoint >= DDMA_DRQ_TYPE_LIMIT) ||
+ (!is_dedicated && endpoint >= NDMA_DRQ_TYPE_LIMIT))
+ return NULL;
+
+ chan = dma_get_any_slave_channel(&priv->slave);
+ if (!chan)
+ return NULL;
+
+ /* Assign the endpoint to the vchan */
+ vchan = to_sun4i_dma_vchan(chan);
+ vchan->is_dedicated = is_dedicated;
+ vchan->endpoint = endpoint;
+
+ return chan;
+}
+
+static enum dma_status sun4i_dma_tx_status(struct dma_chan *chan,
+ dma_cookie_t cookie,
+ struct dma_tx_state *state)
+{
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+ struct sun4i_dma_pchan *pchan = vchan->pchan;
+ struct sun4i_dma_contract *contract;
+ struct sun4i_dma_promise *promise = NULL;
+ struct virt_dma_desc *vd;
+ unsigned long flags;
+ enum dma_status ret;
+ size_t bytes = 0;
+
+ ret = dma_cookie_status(chan, cookie, state);
+ if (ret == DMA_COMPLETE)
+ return ret;
+
+ spin_lock_irqsave(&vchan->vc.lock, flags);
+ vd = vchan_find_desc(&vchan->vc, cookie);
+ if (!vd) /* TODO */
+ goto exit;
+ contract = to_sun4i_dma_contract(vd);
+
+ list_for_each_entry_reverse(promise, &contract->demands, list) {
+ bytes += promise->len;
+ }
+
+ /* The hardware is configured to return the remaining byte
+ * quantity. If possible, replace the first listed element's
+ * full size with the actual remaining amount */
+ if (promise && pchan) {
+ bytes -= promise->len;
+ if (pchan->is_dedicated)
+ bytes += readl(pchan->base + DDMA_BYTE_COUNT_REG);
+ else
+ bytes += readl(pchan->base + NDMA_BYTE_COUNT_REG);
+ }
+
+exit:
+
+ dma_set_residue(state, bytes);
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+
+ return ret;
+}
+
+static void sun4i_dma_issue_pending(struct dma_chan *chan)
+{
+ struct sun4i_dma_dev *priv = to_sun4i_dma_dev(chan->device);
+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
+ unsigned long flags;
+
+ spin_lock_irqsave(&vchan->vc.lock, flags);
+
+ /* If there are pending transactions for this vchan, schedule
+ * the tasklet so they are issued soon */
+ if (vchan_issue_pending(&vchan->vc))
+ tasklet_schedule(&priv->tasklet);
+
+ spin_unlock_irqrestore(&vchan->vc.lock, flags);
+}
+
+static irqreturn_t sun4i_dma_interrupt(int irq, void *dev_id)
+{
+ struct sun4i_dma_dev *priv = dev_id;
+ struct sun4i_dma_pchan *pchans = priv->pchans, *pchan;
+ struct sun4i_dma_vchan *vchan;
+ struct sun4i_dma_contract *contract;
+ unsigned long pendirq, irqs;
+ int bit;
+
+ pendirq = readl_relaxed(priv->base + DMA_IRQ_PENDING_STATUS_REG);
+ irqs = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
+
+ for_each_set_bit(bit, &pendirq, 32) {
+ pchan = &pchans[bit >> 1];
+ vchan = pchan->vchan;
+ contract = vchan->contract;
+
+ /* Disable the IRQ and free the pchan if it's an end
+ * interrupt (odd bit) */
+ if (bit & 1) {
+ spin_lock(&vchan->vc.lock);
+ /* Move the promise into the completed list now that
+ * we're done with it */
+ list_del(&vchan->processing->list);
+ list_add_tail(&vchan->processing->list, &contract->completed_demands);
+ vchan->processing = NULL;
+ vchan->pchan = NULL;
+ spin_unlock(&vchan->vc.lock);
+
+ irqs &= ~BIT(bit);
+ release_pchan(priv, pchan);
+ }
+ }
+
+ writel_relaxed(irqs, priv->base + DMA_IRQ_ENABLE_REG);
+
+ /* Writing 1 to the pending field will clear the pending interrupt */
+ writel(pendirq, priv->base + DMA_IRQ_PENDING_STATUS_REG);
+
+ tasklet_schedule(&priv->tasklet);
+
+ return IRQ_HANDLED;
+}
+
+static void sun4i_dma_tasklet(unsigned long data)
+{
+ struct sun4i_dma_dev *priv = (void *)data;
+ int i;
+
+ for (i = 0; i < DMA_NR_MAX_VCHANS; i++)
+ execute_vchan_pending(priv, &priv->vchans[i]);
+}
+
+static int sun4i_dma_probe(struct platform_device *pdev)
+{
+ struct sun4i_dma_dev *priv;
+ struct resource *res;
+ int i, j, ret;
+
+ priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ priv->base = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(priv->base))
+ return PTR_ERR(priv->base);
+
+ priv->irq = platform_get_irq(pdev, 0);
+ if (priv->irq < 0) {
+ dev_err(&pdev->dev, "Cannot claim IRQ\n");
+ return priv->irq;
+ }
+
+ priv->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(priv->clk)) {
+ dev_err(&pdev->dev, "No clock specified\n");
+ return PTR_ERR(priv->clk);
+ }
+
+ platform_set_drvdata(pdev, priv);
+ spin_lock_init(&priv->lock);
+ tasklet_init(&priv->tasklet, sun4i_dma_tasklet, (unsigned long)priv);
+
+ dma_cap_zero(priv->slave.cap_mask);
+ dma_cap_set(DMA_PRIVATE, priv->slave.cap_mask);
+ dma_cap_set(DMA_MEMCPY, priv->slave.cap_mask);
+ dma_cap_set(DMA_SLAVE, priv->slave.cap_mask);
+
+ INIT_LIST_HEAD(&priv->slave.channels);
+ priv->slave.device_alloc_chan_resources = sun4i_dma_alloc_chan_resources;
+ priv->slave.device_free_chan_resources = sun4i_dma_free_chan_resources;
+ priv->slave.device_tx_status = sun4i_dma_tx_status;
+ priv->slave.device_issue_pending = sun4i_dma_issue_pending;
+ priv->slave.device_prep_slave_sg = sun4i_dma_prep_slave_sg;
+ priv->slave.device_prep_dma_memcpy = sun4i_dma_prep_dma_memcpy;
+ priv->slave.device_control = sun4i_dma_control;
+ priv->slave.chancnt = DDMA_NR_MAX_VCHANS;
+
+ priv->slave.dev = &pdev->dev;
+
+ priv->pchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_CHANNELS,
+ sizeof(struct sun4i_dma_pchan), GFP_KERNEL);
+ priv->vchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_VCHANS,
+ sizeof(struct sun4i_dma_vchan), GFP_KERNEL);
+ if (!priv->vchans || !priv->pchans)
+ return -ENOMEM;
+
+ /* [0..NDMA_NR_MAX_CHANNELS) are normal pchans, and
+ * [NDMA_NR_MAX_CHANNELS..DMA_NR_MAX_CHANNELS) are dedicated ones */
+ for (i = 0; i < NDMA_NR_MAX_CHANNELS; i++)
+ priv->pchans[i].base = priv->base + NDMA_CHANNEL_REG_BASE(i);
+ for (j = 0; i < DMA_NR_MAX_CHANNELS; i++, j++) {
+ priv->pchans[i].base = priv->base + DDMA_CHANNEL_REG_BASE(j);
+ priv->pchans[i].is_dedicated = 1;
+ }
+
+ for (i = 0; i < DMA_NR_MAX_VCHANS; i++) {
+ struct sun4i_dma_vchan *vchan = &priv->vchans[i];
+
+ spin_lock_init(&vchan->vc.lock);
+ vchan->vc.desc_free = sun4i_dma_free_contract;
+ vchan_init(&vchan->vc, &priv->slave);
+ }
+
+ ret = clk_prepare_enable(priv->clk);
+ if (ret) {
+ dev_err(&pdev->dev, "Couldn't enable the clock\n");
+ return ret;
+ }
+
+ ret = devm_request_irq(&pdev->dev, priv->irq, sun4i_dma_interrupt, 0,
+ dev_name(&pdev->dev), priv);
+ if (ret) {
+ dev_err(&pdev->dev, "Cannot request IRQ\n");
+ goto err_clk_disable;
+ }
+
+ ret = dma_async_device_register(&priv->slave);
+ if (ret) {
+ dev_warn(&pdev->dev, "Failed to register DMA engine device\n");
+ goto err_clk_disable;
+ }
+
+ ret = of_dma_controller_register(pdev->dev.of_node, sun4i_dma_of_xlate,
+ priv);
+ if (ret) {
+ dev_err(&pdev->dev, "of_dma_controller_register failed\n");
+ goto err_dma_unregister;
+ }
+
+ dev_dbg(&pdev->dev, "Successfully probed SUN4I_DMA\n");
+
+ return 0;
+
+err_dma_unregister:
+ dma_async_device_unregister(&priv->slave);
+err_clk_disable:
+ clk_disable_unprepare(priv->clk);
+ return ret;
+}
+
+static int sun4i_dma_remove(struct platform_device *pdev)
+{
+ struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
+
+ /* Disable IRQ so the tasklet doesn't schedule any longer, then
+ * kill it */
+ disable_irq(priv->irq);
+ tasklet_kill(&priv->tasklet);
+
+ of_dma_controller_free(pdev->dev.of_node);
+ dma_async_device_unregister(&priv->slave);
+
+ clk_disable_unprepare(priv->clk);
+
+ return 0;
+}
+
+static struct of_device_id sun4i_dma_match[] = {
+ { .compatible = "allwinner,sun4i-a10-dma" }
+};
+
+static struct platform_driver sun4i_dma_driver = {
+ .probe = sun4i_dma_probe,
+ .remove = sun4i_dma_remove,
+ .driver = {
+ .name = "sun4i-dma",
+ .of_match_table = sun4i_dma_match,
+ },
+};
+
+module_platform_driver(sun4i_dma_driver);
+
+MODULE_DESCRIPTION("Allwinner A10 Dedicated DMA Controller Driver");
+MODULE_AUTHOR("Emilio L?pez <emilio@elopez.com.ar>");
+MODULE_LICENSE("GPL");
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 02/10] serial: 8250_dw: support DMA on the OF case
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-21 13:56 ` Chen-Yu Tsai
2014-06-16 3:50 ` [PATCH 03/10] spi: sun4i: add DMA support Emilio López
` (7 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
Currently, DMA properties on the DT are ignored when using the 8250_dw
driver. With this patch, DMA will be used when available.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
drivers/tty/serial/8250/8250_dw.c | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index ed31135..f75c0bf 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -222,6 +222,8 @@ static int dw8250_probe_of(struct uart_port *p,
struct dw8250_data *data)
{
struct device_node *np = p->dev->of_node;
+ struct uart_8250_port *up = container_of(p, struct uart_8250_port,
+ port);
u32 val;
bool has_ucv = true;
@@ -254,11 +256,14 @@ static int dw8250_probe_of(struct uart_port *p,
}
}
if (has_ucv)
- dw8250_setup_port(container_of(p, struct uart_8250_port, port));
+ dw8250_setup_port(up);
if (!of_property_read_u32(np, "reg-shift", &val))
p->regshift = val;
+ if (of_get_property(np, "dmas", NULL))
+ up->dma = &data->dma;
+
/* clock got configured through clk api, all done */
if (p->uartclk)
return 0;
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 03/10] spi: sun4i: add DMA support
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
2014-06-16 3:50 ` [PATCH 02/10] serial: 8250_dw: support DMA on the OF case Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-25 18:48 ` Maxime Ripard
2014-06-16 3:50 ` [PATCH 04/10] ARM: sun7i: Add node to represent the DMA controller Emilio López
` (6 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
This patch adds DMA support for 64 byte transfers on the sun4i SPI
controller. Bigger transfers did not seem to work when tested, and if
the hardware actually supports those, it will need further
investigation as to how to issue them correctly.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
This is a straight adaptation of a similar patch Maxime made for the
sun6i SPI driver.
drivers/spi/spi-sun4i.c | 146 +++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 139 insertions(+), 7 deletions(-)
diff --git a/drivers/spi/spi-sun4i.c b/drivers/spi/spi-sun4i.c
index d266a87..7e1d155 100644
--- a/drivers/spi/spi-sun4i.c
+++ b/drivers/spi/spi-sun4i.c
@@ -14,6 +14,8 @@
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/device.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
@@ -35,6 +37,7 @@
#define SUN4I_CTL_CPHA BIT(2)
#define SUN4I_CTL_CPOL BIT(3)
#define SUN4I_CTL_CS_ACTIVE_LOW BIT(4)
+#define SUN4I_CTL_DMAMC_DEDICATED BIT(5)
#define SUN4I_CTL_LMTF BIT(6)
#define SUN4I_CTL_TF_RST BIT(8)
#define SUN4I_CTL_RF_RST BIT(9)
@@ -52,6 +55,8 @@
#define SUN4I_INT_STA_REG 0x10
#define SUN4I_DMA_CTL_REG 0x14
+#define SUN4I_DMA_CTL_RF_READY BIT(0)
+#define SUN4I_DMA_CTL_TF_NOT_FULL BIT(10)
#define SUN4I_WAIT_REG 0x18
@@ -85,6 +90,9 @@ struct sun4i_spi {
const u8 *tx_buf;
u8 *rx_buf;
int len;
+
+ struct dma_chan *rx_dma_chan;
+ struct dma_chan *tx_dma_chan;
};
static inline u32 sun4i_spi_read(struct sun4i_spi *sspi, u32 reg)
@@ -131,6 +139,24 @@ static inline void sun4i_spi_fill_fifo(struct sun4i_spi *sspi, int len)
}
}
+static bool sun4i_spi_can_dma(struct spi_master *master,
+ struct spi_device *spi,
+ struct spi_transfer *tfr)
+{
+ return tfr->len >= SUN4I_FIFO_DEPTH;
+}
+
+static int sun4i_spi_prepare_message(struct spi_master *master,
+ struct spi_message *msg)
+{
+ struct sun4i_spi *sspi = spi_master_get_devdata(master);
+
+ master->dma_rx = sspi->rx_dma_chan;
+ master->dma_tx = sspi->tx_dma_chan;
+
+ return 0;
+}
+
static void sun4i_spi_set_cs(struct spi_device *spi, bool enable)
{
struct sun4i_spi *sspi = spi_master_get_devdata(spi->master);
@@ -170,6 +196,7 @@ static int sun4i_spi_transfer_one(struct spi_master *master,
struct spi_transfer *tfr)
{
struct sun4i_spi *sspi = spi_master_get_devdata(master);
+ struct dma_async_tx_descriptor *desc_tx, *desc_rx;
unsigned int mclk_rate, div, timeout;
unsigned int tx_len = 0;
int ret = 0;
@@ -187,7 +214,6 @@ static int sun4i_spi_transfer_one(struct spi_master *master,
/* Clear pending interrupts */
sun4i_spi_write(sspi, SUN4I_INT_STA_REG, ~0);
-
reg = sun4i_spi_read(sspi, SUN4I_CTL_REG);
/* Reset FIFOs */
@@ -270,12 +296,55 @@ static int sun4i_spi_transfer_one(struct spi_master *master,
sun4i_spi_write(sspi, SUN4I_BURST_CNT_REG, SUN4I_BURST_CNT(tfr->len));
sun4i_spi_write(sspi, SUN4I_XMIT_CNT_REG, SUN4I_XMIT_CNT(tx_len));
- /* Fill the TX FIFO */
- sun4i_spi_fill_fifo(sspi, SUN4I_FIFO_DEPTH);
-
/* Enable the interrupts */
sun4i_spi_write(sspi, SUN4I_INT_CTL_REG, SUN4I_INT_CTL_TC);
+ if (sun4i_spi_can_dma(master, spi, tfr)) {
+ dev_dbg(&sspi->master->dev, "Using DMA mode for transfer\n");
+
+ if (sspi->tx_buf) {
+ desc_tx = dmaengine_prep_slave_sg(sspi->tx_dma_chan,
+ tfr->tx_sg.sgl, tfr->tx_sg.nents,
+ DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+ if (!desc_tx) {
+ dev_err(&sspi->master->dev, "Couldn't prepare dma slave\n");
+ return -EIO;
+ }
+
+ dmaengine_submit(desc_tx);
+ }
+
+ if (sspi->rx_buf) {
+ desc_rx = dmaengine_prep_slave_sg(sspi->rx_dma_chan,
+ tfr->rx_sg.sgl, tfr->rx_sg.nents,
+ DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+ if (!desc_rx) {
+ dev_err(&sspi->master->dev, "Couldn't prepare dma slave\n");
+ return -EIO;
+ }
+
+ dmaengine_submit(desc_rx);
+ }
+
+ /* Enable DMA requests */
+ reg = sun4i_spi_read(sspi, SUN4I_CTL_REG);
+ sun4i_spi_write(sspi, SUN4I_CTL_REG, reg | SUN4I_CTL_DMAMC_DEDICATED);
+ sun4i_spi_write(sspi, SUN4I_DMA_CTL_REG, SUN4I_DMA_CTL_TF_NOT_FULL | SUN4I_DMA_CTL_RF_READY);
+
+ dma_async_issue_pending(sspi->rx_dma_chan);
+ dma_async_issue_pending(sspi->tx_dma_chan);
+ } else {
+ dev_dbg(&sspi->master->dev, "Using PIO mode for transfer\n");
+
+ /* Disable DMA requests */
+ reg = sun4i_spi_read(sspi, SUN4I_CTL_REG);
+ sun4i_spi_write(sspi, SUN4I_CTL_REG, reg & ~SUN4I_CTL_DMAMC_DEDICATED);
+ sun4i_spi_write(sspi, SUN4I_DMA_CTL_REG, 0);
+
+ /* Fill the TX FIFO */
+ sun4i_spi_fill_fifo(sspi, SUN4I_FIFO_DEPTH);
+ }
+
/* Start the transfer */
reg = sun4i_spi_read(sspi, SUN4I_CTL_REG);
sun4i_spi_write(sspi, SUN4I_CTL_REG, reg | SUN4I_CTL_XCH);
@@ -287,7 +356,15 @@ static int sun4i_spi_transfer_one(struct spi_master *master,
goto out;
}
- sun4i_spi_drain_fifo(sspi, SUN4I_FIFO_DEPTH);
+ if (sspi->tx_buf && sspi->rx_buf && sun4i_spi_can_dma(master, spi, tfr)) {
+ /* For some reason, doing this seems to crash and burn more
+ * often than not
+ * dma_wait_for_async_tx(desc_tx);
+ * dma_wait_for_async_tx(desc_rx);
+ */
+ } else {
+ sun4i_spi_drain_fifo(sspi, SUN4I_FIFO_DEPTH);
+ }
out:
sun4i_spi_write(sspi, SUN4I_INT_CTL_REG, 0);
@@ -352,6 +429,7 @@ static int sun4i_spi_runtime_suspend(struct device *dev)
static int sun4i_spi_probe(struct platform_device *pdev)
{
+ struct dma_slave_config dma_sconfig;
struct spi_master *master;
struct sun4i_spi *sspi;
struct resource *res;
@@ -387,7 +465,10 @@ static int sun4i_spi_probe(struct platform_device *pdev)
goto err_free_master;
}
+ init_completion(&sspi->done);
sspi->master = master;
+ master->can_dma = sun4i_spi_can_dma;
+ master->prepare_message = sun4i_spi_prepare_message;
master->set_cs = sun4i_spi_set_cs;
master->transfer_one = sun4i_spi_transfer_one;
master->num_chipselect = 4;
@@ -410,7 +491,45 @@ static int sun4i_spi_probe(struct platform_device *pdev)
goto err_free_master;
}
- init_completion(&sspi->done);
+ sspi->tx_dma_chan = dma_request_slave_channel_reason(&pdev->dev, "tx");
+ if (IS_ERR(sspi->tx_dma_chan)) {
+ dev_err(&pdev->dev, "Unable to acquire DMA channel TX\n");
+ ret = PTR_ERR(sspi->tx_dma_chan);
+ goto err_free_master;
+ }
+
+ dma_sconfig.direction = DMA_MEM_TO_DEV;
+ dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+ dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+ dma_sconfig.dst_addr = res->start + SUN4I_TXDATA_REG;
+ dma_sconfig.src_maxburst = 1;
+ dma_sconfig.dst_maxburst = 1;
+
+ ret = dmaengine_slave_config(sspi->tx_dma_chan, &dma_sconfig);
+ if (ret) {
+ dev_err(&pdev->dev, "Unable to configure TX DMA slave\n");
+ goto err_tx_dma_release;
+ }
+
+ sspi->rx_dma_chan = dma_request_slave_channel_reason(&pdev->dev, "rx");
+ if (IS_ERR(sspi->rx_dma_chan)) {
+ dev_err(&pdev->dev, "Unable to acquire DMA channel RX\n");
+ ret = PTR_ERR(sspi->rx_dma_chan);
+ goto err_tx_dma_release;
+ }
+
+ dma_sconfig.direction = DMA_DEV_TO_MEM;
+ dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+ dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+ dma_sconfig.src_addr = res->start + SUN4I_RXDATA_REG;
+ dma_sconfig.src_maxburst = 1;
+ dma_sconfig.dst_maxburst = 1;
+
+ ret = dmaengine_slave_config(sspi->rx_dma_chan, &dma_sconfig);
+ if (ret) {
+ dev_err(&pdev->dev, "Unable to configure RX DMA slave\n");
+ goto err_rx_dma_release;
+ }
/*
* This wake-up/shutdown pattern is to be able to have the
@@ -419,7 +538,7 @@ static int sun4i_spi_probe(struct platform_device *pdev)
ret = sun4i_spi_runtime_resume(&pdev->dev);
if (ret) {
dev_err(&pdev->dev, "Couldn't resume the device\n");
- goto err_free_master;
+ goto err_rx_dma_release;
}
pm_runtime_set_active(&pdev->dev);
@@ -437,6 +556,10 @@ static int sun4i_spi_probe(struct platform_device *pdev)
err_pm_disable:
pm_runtime_disable(&pdev->dev);
sun4i_spi_runtime_suspend(&pdev->dev);
+err_rx_dma_release:
+ dma_release_channel(sspi->rx_dma_chan);
+err_tx_dma_release:
+ dma_release_channel(sspi->tx_dma_chan);
err_free_master:
spi_master_put(master);
return ret;
@@ -444,8 +567,17 @@ err_free_master:
static int sun4i_spi_remove(struct platform_device *pdev)
{
+ struct spi_master *master = platform_get_drvdata(pdev);
+ struct sun4i_spi *sspi = spi_master_get_devdata(master);
+
+ if (pm_runtime_active(&pdev->dev))
+ sun4i_spi_runtime_suspend(&pdev->dev);
+
pm_runtime_disable(&pdev->dev);
+ dma_release_channel(sspi->rx_dma_chan);
+ dma_release_channel(sspi->tx_dma_chan);
+
return 0;
}
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 04/10] ARM: sun7i: Add node to represent the DMA controller
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (2 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 03/10] spi: sun4i: add DMA support Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-16 3:50 ` [PATCH 05/10] ARM: sun4i: " Emilio López
` (5 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
The A20 SoC has a sun4i-compatible DMA controller. Let's add a node to
represent it on the device tree.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
arch/arm/boot/dts/sun7i-a20.dtsi | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
index 32efc10..c72fad4 100644
--- a/arch/arm/boot/dts/sun7i-a20.dtsi
+++ b/arch/arm/boot/dts/sun7i-a20.dtsi
@@ -409,6 +409,14 @@
interrupts = <0 0 4>;
};
+ dma: dma-controller at 01c02000 {
+ compatible = "allwinner,sun4i-a10-dma";
+ reg = <0x01c02000 0x1000>;
+ interrupts = <0 27 4>;
+ clocks = <&ahb_gates 6>;
+ #dma-cells = <2>;
+ };
+
spi0: spi at 01c05000 {
compatible = "allwinner,sun4i-a10-spi";
reg = <0x01c05000 0x1000>;
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 05/10] ARM: sun4i: Add node to represent the DMA controller
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (3 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 04/10] ARM: sun7i: Add node to represent the DMA controller Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-16 3:50 ` [PATCH 06/10] ARM: sun7i: enable DMA on SPI Emilio López
` (4 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
Let's add a node to represent the A10 DMA controller on the device tree.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
arch/arm/boot/dts/sun4i-a10.dtsi | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/arch/arm/boot/dts/sun4i-a10.dtsi b/arch/arm/boot/dts/sun4i-a10.dtsi
index 9174724..6e61518 100644
--- a/arch/arm/boot/dts/sun4i-a10.dtsi
+++ b/arch/arm/boot/dts/sun4i-a10.dtsi
@@ -339,6 +339,14 @@
#size-cells = <1>;
ranges;
+ dma: dma-controller at 01c02000 {
+ compatible = "allwinner,sun4i-a10-dma";
+ reg = <0x01c02000 0x1000>;
+ interrupts = <27>;
+ clocks = <&ahb_gates 6>;
+ #dma-cells = <2>;
+ };
+
spi0: spi at 01c05000 {
compatible = "allwinner,sun4i-a10-spi";
reg = <0x01c05000 0x1000>;
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 06/10] ARM: sun7i: enable DMA on SPI
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (4 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 05/10] ARM: sun4i: " Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-16 3:50 ` [PATCH 07/10] ARM: sun4i: " Emilio López
` (3 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
All of our SPI controllers support DMA transfers, so let's add the
properties here so they can be used when it's best to do so.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
arch/arm/boot/dts/sun7i-a20.dtsi | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
index c72fad4..c054ad3 100644
--- a/arch/arm/boot/dts/sun7i-a20.dtsi
+++ b/arch/arm/boot/dts/sun7i-a20.dtsi
@@ -423,6 +423,8 @@
interrupts = <0 10 4>;
clocks = <&ahb_gates 20>, <&spi0_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 27>, <&dma 1 26>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -434,6 +436,8 @@
interrupts = <0 11 4>;
clocks = <&ahb_gates 21>, <&spi1_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 9>, <&dma 1 8>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -493,6 +497,8 @@
interrupts = <0 12 4>;
clocks = <&ahb_gates 22>, <&spi2_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 29>, <&dma 1 28>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -532,6 +538,8 @@
interrupts = <0 50 4>;
clocks = <&ahb_gates 23>, <&spi3_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 31>, <&dma 1 30>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 07/10] ARM: sun4i: enable DMA on SPI
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (5 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 06/10] ARM: sun7i: enable DMA on SPI Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-16 3:50 ` [PATCH 08/10] ARM: sun7i: add DMA properties to UARTs Emilio López
` (2 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
All of our SPI controllers support DMA transfers, so let's add the
properties here so they can be used when it's best to do so.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
arch/arm/boot/dts/sun4i-a10.dtsi | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/arch/arm/boot/dts/sun4i-a10.dtsi b/arch/arm/boot/dts/sun4i-a10.dtsi
index 6e61518..c66c39e 100644
--- a/arch/arm/boot/dts/sun4i-a10.dtsi
+++ b/arch/arm/boot/dts/sun4i-a10.dtsi
@@ -353,6 +353,8 @@
interrupts = <10>;
clocks = <&ahb_gates 20>, <&spi0_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 27>, <&dma 1 26>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -364,6 +366,8 @@
interrupts = <11>;
clocks = <&ahb_gates 21>, <&spi1_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 9>, <&dma 1 8>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -423,6 +427,8 @@
interrupts = <12>;
clocks = <&ahb_gates 22>, <&spi2_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 29>, <&dma 1 28>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
@@ -462,6 +468,8 @@
interrupts = <50>;
clocks = <&ahb_gates 23>, <&spi3_clk>;
clock-names = "ahb", "mod";
+ dmas = <&dma 1 31>, <&dma 1 30>;
+ dma-names = "rx", "tx";
status = "disabled";
#address-cells = <1>;
#size-cells = <0>;
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 08/10] ARM: sun7i: add DMA properties to UARTs
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (6 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 07/10] ARM: sun4i: " Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-16 3:50 ` [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing Emilio López
2014-06-16 3:50 ` [PATCH 10/10] ARM: sun7i: cubietruck: " Emilio López
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
Our UARTs also support DMA transfers, let's enable them for the sake of
testing.
Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
---
arch/arm/boot/dts/sun7i-a20.dtsi | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
index c054ad3..3a33e62 100644
--- a/arch/arm/boot/dts/sun7i-a20.dtsi
+++ b/arch/arm/boot/dts/sun7i-a20.dtsi
@@ -712,6 +712,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 16>;
+ dmas = <&dma 0 8>, <&dma 0 8>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -722,6 +724,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 17>;
+ dmas = <&dma 0 9>, <&dma 0 9>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -732,6 +736,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 18>;
+ dmas = <&dma 0 10>, <&dma 0 10>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -742,6 +748,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 19>;
+ dmas = <&dma 0 11>, <&dma 0 11>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -752,6 +760,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 20>;
+ dmas = <&dma 0 12>, <&dma 0 12>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -762,6 +772,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 21>;
+ dmas = <&dma 0 13>, <&dma 0 13>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -772,6 +784,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 22>;
+ dmas = <&dma 0 14>, <&dma 0 14>;
+ dma-names = "rx", "tx";
status = "disabled";
};
@@ -782,6 +796,8 @@
reg-shift = <2>;
reg-io-width = <4>;
clocks = <&apb1_gates 23>;
+ dmas = <&dma 0 15>, <&dma 0 15>;
+ dma-names = "rx", "tx";
status = "disabled";
};
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (7 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 08/10] ARM: sun7i: add DMA properties to UARTs Emilio López
@ 2014-06-16 3:50 ` Emilio López
2014-06-25 21:22 ` Maxime Ripard
2014-06-16 3:50 ` [PATCH 10/10] ARM: sun7i: cubietruck: " Emilio López
9 siblings, 1 reply; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
---
arch/arm/boot/dts/sun4i-a10-cubieboard.dts | 12 ++++++++++++
arch/arm/boot/dts/sun4i-a10.dtsi | 7 +++++++
2 files changed, 19 insertions(+)
diff --git a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
index 4684cbe..9b8d6b0 100644
--- a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
+++ b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
@@ -61,6 +61,18 @@
status = "okay";
};
+ spi0: spi at 01c05000 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&spi0_pins_a>;
+ status = "okay";
+
+ dac0: dh2228 at 2 {
+ compatible = "rohm,dh2228fv";
+ reg = <2>;
+ spi-max-frequency = <100000>;
+ };
+ };
+
pinctrl at 01c20800 {
led_pins_cubieboard: led_pins at 0 {
allwinner,pins = "PH20", "PH21";
diff --git a/arch/arm/boot/dts/sun4i-a10.dtsi b/arch/arm/boot/dts/sun4i-a10.dtsi
index c66c39e..aefde20 100644
--- a/arch/arm/boot/dts/sun4i-a10.dtsi
+++ b/arch/arm/boot/dts/sun4i-a10.dtsi
@@ -535,6 +535,13 @@
allwinner,pull = <0>;
};
+ spi0_pins_a: spi0 at 0 {
+ allwinner,pins = "PI10", "PI11", "PI12", "PI13";
+ allwinner,function = "spi0";
+ allwinner,drive = <0>;
+ allwinner,pull = <0>;
+ };
+
emac_pins_a: emac0 at 0 {
allwinner,pins = "PA0", "PA1", "PA2",
"PA3", "PA4", "PA5", "PA6",
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 10/10] ARM: sun7i: cubietruck: add an SPIdev device for testing
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
` (8 preceding siblings ...)
2014-06-16 3:50 ` [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing Emilio López
@ 2014-06-16 3:50 ` Emilio López
9 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-16 3:50 UTC (permalink / raw)
To: linux-arm-kernel
---
arch/arm/boot/dts/sun7i-a20-cubietruck.dts | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
index cb25d3c..2c852aa 100644
--- a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
+++ b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
@@ -47,6 +47,18 @@
status = "okay";
};
+ spi2: spi at 01c17000 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&spi2_pins_a>;
+ status = "okay";
+
+ dac0: dh2228 at 2 {
+ compatible = "rohm,dh2228fv";
+ reg = <2>;
+ spi-max-frequency = <100000>;
+ };
+ };
+
pinctrl at 01c20800 {
ahci_pwr_pin_cubietruck: ahci_pwr_pin at 1 {
allwinner,pins = "PH12";
--
2.0.0
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
@ 2014-06-21 13:51 ` Chen-Yu Tsai
2014-06-24 13:02 ` Emilio López
2014-06-25 18:42 ` Maxime Ripard
1 sibling, 1 reply; 21+ messages in thread
From: Chen-Yu Tsai @ 2014-06-21 13:51 UTC (permalink / raw)
To: linux-arm-kernel
On Mon, Jun 16, 2014 at 11:50 AM, Emilio L?pez <emilio@elopez.com.ar> wrote:
> This patch adds support for the DMA engine present on Allwinner A10,
> A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
> and dedicated. The main difference is in the mode of operation;
> while a single normal channel may be operating at any given time,
> dedicated channels may operate simultaneously provided there is no
> overlap of source or destination.
>
> Hardware documentation can be found on A10 User Manual (section 12), A13
> User Manual (section 14) and A20 User Manual (section 1.12)
>
> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
> ---
>
> For some mem2dev/dev2mem transfers, we need to configure some magic delays
> for things to work - on my experimental testing, 0x00010001 seems to work
> for SPI. Is there some place in the API to pass these kinds of values from
> client drivers when configuring a transfer? Currently I have just hardcoded
> this value on the driver, but it'll probably cause trouble in the future
> for other devices.
>
> .../devicetree/bindings/dma/sun4i-dma.txt | 45 +
> drivers/dma/Kconfig | 10 +
> drivers/dma/Makefile | 1 +
> drivers/dma/sun4i-dma.c | 1065 ++++++++++++++++++++
> 4 files changed, 1121 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/dma/sun4i-dma.txt
> create mode 100644 drivers/dma/sun4i-dma.c
>
> diff --git a/Documentation/devicetree/bindings/dma/sun4i-dma.txt b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
> new file mode 100644
> index 0000000..f5661a5
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
> @@ -0,0 +1,45 @@
> +Allwinner A10 DMA Controller
> +
> +This driver follows the generic DMA bindings defined in dma.txt.
> +
> +Required properties:
> +
> +- compatible: Must be "allwinner,sun4i-a10-dma"
> +- reg: Should contain the registers base address and length
> +- interrupts: Should contain a reference to the interrupt used by this device
> +- clocks: Should contain a reference to the parent AHB clock
> +- #dma-cells : Should be 1, a single cell holding a line request number
> +
> +Example:
> + dma: dma-controller at 01c02000 {
> + compatible = "allwinner,sun4i-a10-dma";
> + reg = <0x01c02000 0x1000>;
> + interrupts = <27>;
> + clocks = <&ahb_gates 6>;
> + #dma-cells = <1>;
> + };
> +
> +Clients:
> +
> +DMA clients connected to the Allwinner A10 DMA controller must use the
> +format described in the dma.txt file, using a three-cell specifier for
> +each channel: a phandle plus two integer cells.
> +The three cells in order are:
> +
> +1. A phandle pointing to the DMA controller.
> +2. Whether it is using normal (0) or dedicated (1) channels
> +2. The port ID as specified in the datasheet
> +
> +Example:
> + spi2: spi at 01c17000 {
> + compatible = "allwinner,sun4i-a10-spi";
> + reg = <0x01c17000 0x1000>;
> + interrupts = <0 12 4>;
> + clocks = <&ahb_gates 22>, <&spi2_clk>;
> + clock-names = "ahb", "mod";
> + dmas = <&dma 1 29>, <&dma 1 28>;
> + dma-names = "rx", "tx";
> + status = "disabled";
> + #address-cells = <1>;
> + #size-cells = <0>;
> + };
> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> index ba06d1d..a9ee0c9 100644
> --- a/drivers/dma/Kconfig
> +++ b/drivers/dma/Kconfig
> @@ -361,6 +361,16 @@ config FSL_EDMA
> multiplexing capability for DMA request sources(slot).
> This module can be found on Freescale Vybrid and LS-1 SoCs.
>
> +config SUN4I_DMA
> + tristate "Allwinner A10/A10S/A13/A20 DMA support"
> + depends on ARCH_SUNXI
> + select DMA_ENGINE
> + select DMA_OF
> + select DMA_VIRTUAL_CHANNELS
> + help
> + Enable support for the DMA controller present in the sun4i,
> + sun5i and sun7i Allwinner ARM SoCs.
> +
Conflict here and in drivers/dma/Makefile when applied to 3.16-rc1.
> config DMA_ENGINE
> bool
>
> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> index 5150c82..13a7d5d 100644
> --- a/drivers/dma/Makefile
> +++ b/drivers/dma/Makefile
> @@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
> obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
> obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
> obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
> +obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
> diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
> new file mode 100644
> index 0000000..0b14b3f
> --- /dev/null
> +++ b/drivers/dma/sun4i-dma.c
> @@ -0,0 +1,1065 @@
> +/*
> + * Copyright (C) 2014 Emilio L?pez
> + * Emilio L?pez <emilio@elopez.com.ar>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +#include <linux/bitmap.h>
> +#include <linux/bitops.h>
> +#include <linux/clk.h>
> +#include <linux/dmaengine.h>
> +#include <linux/dmapool.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/of_dma.h>
> +#include <linux/platform_device.h>
> +#include <linux/slab.h>
> +#include <linux/spinlock.h>
> +
> +#include "virt-dma.h"
> +
> +/** General DMA register values **/
> +
> +/* DMA source/destination burst length values */
> +#define DMA_BURST_LENGTH_1 0
> +#define DMA_BURST_LENGTH_4 1
> +#define DMA_BURST_LENGTH_8 2
> +
> +/* DMA source/destination data width */
> +#define DMA_DATA_WIDTH_8BIT 0
> +#define DMA_DATA_WIDTH_16BIT 1
> +#define DMA_DATA_WIDTH_32BIT 2
> +
> +/** Normal DMA register values **/
> +
> +/* Normal DMA source/destination data request type values */
> +#define NDMA_DRQ_TYPE_IR0 0x0
> +#define NDMA_DRQ_TYPE_IR1 0x1
> +#define NDMA_DRQ_TYPE_SPDIF 0x2
> +#define NDMA_DRQ_TYPE_IIS0 0x3
> +#define NDMA_DRQ_TYPE_IIS1 0x4
> +#define NDMA_DRQ_TYPE_AC97 0x5
> +#define NDMA_DRQ_TYPE_IIS2 0x6
> +#define NDMA_DRQ_TYPE_UART0 0x8
> +#define NDMA_DRQ_TYPE_UART1 0x9
> +#define NDMA_DRQ_TYPE_UART2 0xA
> +#define NDMA_DRQ_TYPE_UART3 0xB
> +#define NDMA_DRQ_TYPE_UART4 0xC
> +#define NDMA_DRQ_TYPE_UART5 0xD
> +#define NDMA_DRQ_TYPE_UART6 0xE
> +#define NDMA_DRQ_TYPE_UART7 0xF
> +#define NDMA_DRQ_TYPE_HDMI_DDC 0x10
> +#define NDMA_DRQ_TYPE_USB_EP1 0x11
> +#define NDMA_DRQ_TYPE_AUDIO_CODEC 0x13
> +#define NDMA_DRQ_TYPE_SRAM 0x15
> +#define NDMA_DRQ_TYPE_SDRAM 0x16
> +#define NDMA_DRQ_TYPE_TP_AD 0x17
> +#define NDMA_DRQ_TYPE_SPI0 0x18
> +#define NDMA_DRQ_TYPE_SPI1 0x19
> +#define NDMA_DRQ_TYPE_SPI2 0x1A
> +#define NDMA_DRQ_TYPE_SPI3 0x1B
> +#define NDMA_DRQ_TYPE_USB_EP2 0x1C
> +#define NDMA_DRQ_TYPE_USB_EP3 0x1D
> +#define NDMA_DRQ_TYPE_USB_EP4 0x1E
> +#define NDMA_DRQ_TYPE_USB_EP5 0x1F
> +#define NDMA_DRQ_TYPE_LIMIT (0x1F+1)
> +
> +/** Normal DMA register layout **/
> +
> +/* Normal DMA configuration register layout */
> +#define NDMA_CFG_LOADING BIT(31)
> +#define NDMA_CFG_CONT_MODE BIT(30)
> +#define NDMA_CFG_WAIT_STATE(n) (n << 27)
> +#define NDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
> +#define NDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
> +#define NDMA_CFG_DEST_NON_SECURE BIT(22)
> +#define NDMA_CFG_DEST_FIXED_ADDR BIT(21)
> +#define NDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
> +#define NDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
> +#define NDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
> +#define NDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
> +#define NDMA_CFG_SRC_NON_SECURE BIT(6)
> +#define NDMA_CFG_SRC_FIXED_ADDR BIT(5)
> +#define NDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
> +
> +/** Dedicated DMA register values **/
> +
> +/* Dedicated DMA source/destination address mode values */
> +#define DDMA_ADDR_MODE_LINEAR 0
> +#define DDMA_ADDR_MODE_IO 1
> +#define DDMA_ADDR_MODE_HORIZONTAL_PAGE 2
> +#define DDMA_ADDR_MODE_VERTICAL_PAGE 3
> +
> +/* Dedicated DMA source/destination data request type values
> + * Note: some of these values are only sensible when used only as
> + * source or destination */
> +#define DDMA_DRQ_TYPE_SRAM 0x0
> +#define DDMA_DRQ_TYPE_SDRAM 0x1
> +#define DDMA_DRQ_TYPE_PATA 0x2
> +#define DDMA_DRQ_TYPE_NFC 0x3
> +#define DDMA_DRQ_TYPE_USB0 0x4
> +#define DDMA_DRQ_TYPE_EMAC_TX 0x6
> +#define DDMA_DRQ_TYPE_EMAC_RX 0x7
> +#define DDMA_DRQ_TYPE_SPI1_TX 0x8
> +#define DDMA_DRQ_TYPE_SPI1_RX 0x9
> +#define DDMA_DRQ_TYPE_SS_TX 0xA
> +#define DDMA_DRQ_TYPE_SS_RX 0xB
> +#define DDMA_DRQ_TYPE_TCON0 0xE
> +#define DDMA_DRQ_TYPE_TCON1 0xF
> +#define DDMA_DRQ_TYPE_MSC 0x17
> +#define DDMA_DRQ_TYPE_HDMI_AUDIO 0x18
> +#define DDMA_DRQ_TYPE_SPI0_TX 0x1A
> +#define DDMA_DRQ_TYPE_SPI0_RX 0x1B
> +#define DDMA_DRQ_TYPE_SPI2_TX 0x1C
> +#define DDMA_DRQ_TYPE_SPI2_RX 0x1D
> +#define DDMA_DRQ_TYPE_SPI3_TX 0x1E
> +#define DDMA_DRQ_TYPE_SPI3_RX 0x1F
> +#define DDMA_DRQ_TYPE_LIMIT (0x1F+1)
> +
> +/** Dedicated DMA register layout **/
> +
> +/* Dedicated DMA configuration register layout */
> +#define DDMA_CFG_LOADING BIT(31)
> +#define DDMA_CFG_BUSY BIT(30)
> +#define DDMA_CFG_CONT_MODE BIT(29)
> +#define DDMA_CFG_DEST_NON_SECURE BIT(28)
> +#define DDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
> +#define DDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
> +#define DDMA_CFG_DEST_ADDR_MODE(mode) (mode << 21)
> +#define DDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
> +#define DDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
> +#define DDMA_CFG_SRC_NON_SECURE BIT(12)
> +#define DDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
> +#define DDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
> +#define DDMA_CFG_SRC_ADDR_MODE(mode) (mode << 5)
> +#define DDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
> +
> +/* Dedicated DMA parameter register layout */
> +#define DDMA_PARA_DEST_DATA_BLK_SIZE(n) (n-1 << 24)
> +#define DDMA_PARA_DEST_WAIT_CYCLES(n) (n-1 << 16)
> +#define DDMA_PARA_SRC_DATA_BLK_SIZE(n) (n-1 << 8)
> +#define DDMA_PARA_SRC_WAIT_CYCLES(n) (n-1 << 0)
> +
> +/** DMA register offsets **/
> +
> +/* Normal DMA register offsets */
> +#define NDMA_CHANNEL_REG_BASE(n) (0x100+n*0x20)
> +#define NDMA_CFG_REG 0x0
> +#define NDMA_SRC_ADDR_REG 0x4
> +#define NDMA_DEST_ADDR_REG 0x8
> +#define NDMA_BYTE_COUNT_REG 0xC
> +
> +/* Dedicated DMA register offsets */
> +#define DDMA_CHANNEL_REG_BASE(n) (0x300+n*0x20)
> +#define DDMA_CFG_REG 0x0
> +#define DDMA_SRC_ADDR_REG 0x4
> +#define DDMA_DEST_ADDR_REG 0x8
> +#define DDMA_BYTE_COUNT_REG 0xC
> +#define DDMA_PARA_REG 0x18
> +
> +/* General register offsets */
> +#define DMA_IRQ_ENABLE_REG 0x0
> +#define DMA_IRQ_PENDING_STATUS_REG 0x4
> +
> +/** DMA Driver **/
> +
> +/* Normal DMA has 8 channels, and Dedicated DMA has another 8, so that's
> + * 16 channels. As for endpoints, there's 29 and 21 respectively. Given
> + * that the Normal DMA endpoints can be used as tx/rx, we need 79 vchans
> + * in total
> + */
> +#define NDMA_NR_MAX_CHANNELS 8
> +#define DDMA_NR_MAX_CHANNELS 8
> +#define DMA_NR_MAX_CHANNELS (NDMA_NR_MAX_CHANNELS + DDMA_NR_MAX_CHANNELS)
> +#define NDMA_NR_MAX_VCHANS (29*2)
> +#define DDMA_NR_MAX_VCHANS 21
> +#define DMA_NR_MAX_VCHANS (NDMA_NR_MAX_VCHANS + DDMA_NR_MAX_VCHANS)
> +
> +struct sun4i_dma_pchan {
> + /* Register base of channel */
> + void __iomem *base;
> + /* vchan currently being serviced */
> + struct sun4i_dma_vchan *vchan;
> + /* Is this a dedicated pchan? */
> + int is_dedicated;
> +};
> +
> +struct sun4i_dma_vchan {
> + struct virt_dma_chan vc;
> + struct dma_slave_config cfg;
> + struct sun4i_dma_pchan *pchan;
> + struct sun4i_dma_promise *processing;
> + struct sun4i_dma_contract *contract;
> + u8 endpoint;
> + int is_dedicated;
> +};
> +
> +struct sun4i_dma_promise {
> + u32 cfg;
> + u32 para;
> + dma_addr_t src;
> + dma_addr_t dst;
> + size_t len;
> + struct list_head list;
> +};
> +
> +/* A contract is a set of promises */
> +struct sun4i_dma_contract {
> + struct virt_dma_desc vd;
> + struct list_head demands;
> + struct list_head completed_demands;
> +};
> +
> +struct sun4i_dma_dev {
> + DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
Should be DMA_NR_MAX_CHANNELS, right?
> + struct tasklet_struct tasklet;
> + struct dma_device slave;
> + struct sun4i_dma_pchan *pchans;
> + struct sun4i_dma_vchan *vchans;
> + void __iomem *base;
> + struct clk *clk;
> + int irq;
> + spinlock_t lock;
> +};
> +
> +static struct sun4i_dma_dev *to_sun4i_dma_dev(struct dma_device *dev)
> +{
> + return container_of(dev, struct sun4i_dma_dev, slave);
> +}
> +
> +static struct sun4i_dma_vchan *to_sun4i_dma_vchan(struct dma_chan *chan)
> +{
> + return container_of(chan, struct sun4i_dma_vchan, vc.chan);
> +}
> +
> +static struct sun4i_dma_contract *to_sun4i_dma_contract(struct virt_dma_desc *vd)
> +{
> + return container_of(vd, struct sun4i_dma_contract, vd);
> +}
> +
> +static struct device *chan2dev(struct dma_chan *chan)
> +{
> + return &chan->dev->device;
> +}
> +
> +static int convert_burst(u32 maxburst)
> +{
> + if (maxburst > 8)
> + maxburst = 8;
> +
> + /* 1 -> 0, 4 -> 1, 8 -> 2 */
> + return (maxburst >> 2);
> +}
> +
> +static int convert_buswidth(enum dma_slave_buswidth addr_width)
> +{
> + if (addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES)
> + return -EINVAL;
> +
> + /* 8 -> 0, 16 -> 1, 32 -> 2 */
> + return (addr_width >> 4);
> +}
> +
> +static int sun4i_dma_alloc_chan_resources(struct dma_chan *chan)
> +{
> + return 0;
> +}
> +
> +static void sun4i_dma_free_chan_resources(struct dma_chan *chan)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> +
> + vchan_free_chan_resources(&vchan->vc);
> +}
> +
> +static struct sun4i_dma_pchan *find_and_use_pchan(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_pchan *pchan = NULL, *pchans = priv->pchans;
> + unsigned long flags;
> + int i, max;
> +
> + spin_lock_irqsave(&priv->lock, flags);
> +
> + /* pchans 0-NDMA_NR_MAX_CHANNELS are normal, and
> + * NDMA_NR_MAX_CHANNELS+ are dedicated ones */
> + if (vchan->is_dedicated) {
> + i = NDMA_NR_MAX_CHANNELS;
> + max = DMA_NR_MAX_CHANNELS;
> + } else {
> + i = 0;
> + max = NDMA_NR_MAX_CHANNELS;
> + }
> +
> + for_each_clear_bit_from(i, &priv->pchans_used, max) {
> + pchan = &pchans[i];
> + pchan->vchan = vchan;
> + set_bit(i, priv->pchans_used);
> + break;
> + }
> +
> + spin_unlock_irqrestore(&priv->lock, flags);
> +
> + return pchan;
> +}
> +
> +static void release_pchan(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_pchan *pchan)
> +{
> + unsigned long flags;
> + int nr = pchan - priv->pchans;
> +
> + spin_lock_irqsave(&priv->lock, flags);
> +
> + clear_bit(nr, priv->pchans_used);
> + pchan->vchan = NULL;
> +
> + spin_unlock_irqrestore(&priv->lock, flags);
> +}
> +
> +static void configure_pchan(struct sun4i_dma_pchan *pchan,
> + struct sun4i_dma_promise *d)
> +{
> + if (pchan->is_dedicated) {
> + /* Configure addresses and misc parameters */
> + writel_relaxed(d->src, pchan->base + DDMA_SRC_ADDR_REG);
> + writel_relaxed(d->dst, pchan->base + DDMA_DEST_ADDR_REG);
> + writel_relaxed(d->len, pchan->base + DDMA_BYTE_COUNT_REG);
> + writel_relaxed(d->para, pchan->base + DDMA_PARA_REG);
> +
> + /* We use a writel here because CFG_LOADING may be set,
> + * and it requires that the rest of the configuration
> + * takes place before the engine is started */
> + writel(d->cfg, pchan->base + DDMA_CFG_REG);
> + } else {
> + /* Configure addresses and misc parameters */
> + writel_relaxed(d->src, pchan->base + NDMA_SRC_ADDR_REG);
> + writel_relaxed(d->dst, pchan->base + NDMA_DEST_ADDR_REG);
> + writel_relaxed(d->len, pchan->base + NDMA_BYTE_COUNT_REG);
> +
> + /* We use a writel here because CFG_LOADING may be set,
> + * and it requires that the rest of the configuration
> + * takes place before the engine is started */
> + writel(d->cfg, pchan->base + NDMA_CFG_REG);
> + }
> +}
> +
> +static void set_pchan_interrupt(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_pchan *pchan,
> + int half, int end)
> +{
> + u32 reg = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
> + int pchan_number = pchan - priv->pchans;
> +
> + if (half)
> + reg |= BIT(pchan_number*2);
> + else
> + reg &= ~BIT(pchan_number*2);
> +
> + if (end)
> + reg |= BIT(pchan_number*2 + 1);
> + else
> + reg &= ~BIT(pchan_number*2 + 1);
> +
> + writel(reg, priv->base + DMA_IRQ_ENABLE_REG);
> +}
> +
> +static int execute_vchan_pending(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_promise *promise = NULL;
> + struct sun4i_dma_contract *contract = NULL;
> + struct sun4i_dma_pchan *pchan;
> + struct virt_dma_desc *vd;
> + unsigned long flags;
> + int ret;
> +
> + /* We need a pchan to do anything, so secure one if available */
> + pchan = find_and_use_pchan(priv, vchan);
> + if (!pchan)
> + return -EBUSY;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> +
> + /* Channel endpoints must not be repeated, so if this vchan
> + * has already submitted some work, we can't do anything else
> + */
> + if (vchan->processing) {
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "processing something to this endpoint already\n");
> + ret = -EBUSY;
> + goto release_pchan;
> + }
> +
> + do {
> + /* Figure out which contract we're working with today */
> + vd = vchan_next_desc(&vchan->vc);
> + if (!vd) {
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "No pending contract found");
> + ret = 0;
> + goto release_pchan;
> + }
> +
> + contract = to_sun4i_dma_contract(vd);
> + if (list_empty(&contract->demands)) {
> + /* The contract has been completed so mark it as such */
> + list_del(&contract->vd.node);
> + vchan_cookie_complete(&contract->vd);
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "Empty contract found and marked complete");
> + }
> + } while (list_empty(&contract->demands));
> +
> + /* Now find out what we need to do */
> + promise = list_first_entry(&contract->demands, struct sun4i_dma_promise, list);
> + vchan->processing = promise;
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + /* ... and make it reality */
> + if (promise) {
> + vchan->contract = contract;
> + set_pchan_interrupt(priv, pchan, 0, 1);
> + configure_pchan(pchan, promise);
> + }
> +
> + return 0;
> +
> +release_pchan:
> + release_pchan(priv, pchan);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> + return ret;
> +}
> +
> +/**
> + * Generate a promise, to be used in a normal DMA contract.
> + *
> + * A NDMA promise contains all the information required to program the
> + * normal part of the DMA Engine and get data copied. A non-executed
> + * promise will live in the demands list on a contract. Once it has been
> + * completed, it will be moved to the completed demands list for later freeing.
> + * All linked promises will be freed when the corresponding contract is freed
> + */
> +static struct sun4i_dma_promise *
> +generate_ndma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
> + size_t len, struct dma_slave_config *sconfig)
> +{
> + struct sun4i_dma_promise *promise;
> + int ret;
> +
> + promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
> + if (!promise)
> + return NULL;
> +
> + promise->src = src;
> + promise->dst = dest;
> + promise->len = len;
> + promise->cfg = NDMA_CFG_LOADING | NDMA_CFG_BYTE_COUNT_MODE_REMAIN;
> +
> + /* Source burst */
> + ret = convert_burst(sconfig->src_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_SRC_BURST_LENGTH(ret);
> +
> + /* Destination burst */
> + ret = convert_burst(sconfig->dst_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_DEST_BURST_LENGTH(ret);
> +
> + /* Source bus width */
> + ret = convert_buswidth(sconfig->src_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_SRC_DATA_WIDTH(ret);
> +
> + /* Destination bus width */
> + ret = convert_buswidth(sconfig->dst_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_DEST_DATA_WIDTH(ret);
> +
> + return promise;
> +
> +fail:
> + kfree(promise);
> + return NULL;
> +}
> +
> +/**
> + * Generate a promise, to be used in a dedicated DMA contract.
> + *
> + * A DDMA promise contains all the information required to program the
> + * Dedicated part of the DMA Engine and get data copied. A non-executed
> + * promise will live in the demands list on a contract. Once it has been
> + * completed, it will be moved to the completed demands list for later freeing.
> + * All linked promises will be freed when the corresponding contract is freed
> + */
> +static struct sun4i_dma_promise *
> +generate_ddma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
> + size_t len, struct dma_slave_config *sconfig)
> +{
> + struct sun4i_dma_promise *promise;
> + int ret;
> +
> + promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
> + if (!promise)
> + return NULL;
> +
> + promise->src = src;
> + promise->dst = dest;
> + promise->len = len;
> + promise->cfg = DDMA_CFG_LOADING | DDMA_CFG_BYTE_COUNT_MODE_REMAIN;
> +
> + /* Source burst */
> + ret = convert_burst(sconfig->src_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_SRC_BURST_LENGTH(ret);
> +
> + /* Destination burst */
> + ret = convert_burst(sconfig->dst_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_DEST_BURST_LENGTH(ret);
> +
> + /* Source bus width */
> + ret = convert_buswidth(sconfig->src_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_SRC_DATA_WIDTH(ret);
> +
> + /* Destination bus width */
> + ret = convert_buswidth(sconfig->dst_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_DEST_DATA_WIDTH(ret);
> +
> + return promise;
> +
> +fail:
> + kfree(promise);
> + return NULL;
> +}
> +
> +/**
> + * Generate a contract
> + *
> + * Contracts function as DMA descriptors. As our hardware does not support
> + * linked lists, we need to implement SG via software. We use a contract
> + * to hold all the pieces of the request and process them serially one
> + * after another. Each piece is represented as a promise.
> + */
> +static struct sun4i_dma_contract *generate_dma_contract(void)
> +{
> + struct sun4i_dma_contract *contract;
> +
> + contract = kzalloc(sizeof(*contract), GFP_NOWAIT);
> + if (!contract)
> + return NULL;
> +
> + INIT_LIST_HEAD(&contract->demands);
> + INIT_LIST_HEAD(&contract->completed_demands);
> +
> + return contract;
> +}
> +
> +/**
> + * Free a contract and all its associated promises
> + */
> +static void sun4i_dma_free_contract(struct virt_dma_desc *vd)
> +{
> + struct sun4i_dma_contract *contract = to_sun4i_dma_contract(vd);
> + struct sun4i_dma_promise *promise;
> +
> + /* Free all the demands and completed demands */
> + list_for_each_entry(promise, &contract->demands, list) {
> + kfree(promise);
> + }
> +
> + list_for_each_entry(promise, &contract->completed_demands, list) {
> + kfree(promise);
> + }
> +
> + kfree(contract);
> +}
> +
> +static struct dma_async_tx_descriptor *
> +sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
> + dma_addr_t src, size_t len, unsigned long flags)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct dma_slave_config *sconfig = &vchan->cfg;
> + struct sun4i_dma_promise *promise;
> + struct sun4i_dma_contract *contract;
> +
> + contract = generate_dma_contract();
> + if (!contract)
> + return NULL;
> +
> + if (vchan->is_dedicated)
> + promise = generate_ddma_promise(chan, src, dest, len, sconfig);
> + else
> + promise = generate_ndma_promise(chan, src, dest, len, sconfig);
> +
> + if (!promise) {
> + kfree(contract);
> + return NULL;
> + }
> +
> + /* Configure memcpy mode */
> + if (vchan->is_dedicated) {
> + promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_SRC_NON_SECURE |
> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_DEST_NON_SECURE;
Are you sure this works? The manual says dedicated DMA can only do
device to memory or memory to device.
Anyway we won't be using this I guess.
> + } else {
> + promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_SRC_NON_SECURE |
> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_DEST_NON_SECURE;
> + }
> +
> + /* Fill the contract with our only promise */
> + list_add_tail(&promise->list, &contract->demands);
> +
> + /* And add it to the vchan */
> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
> +}
> +
> +static struct dma_async_tx_descriptor *
> +sun4i_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
> + unsigned int sg_len, enum dma_transfer_direction dir,
> + unsigned long flags, void *context)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct dma_slave_config *sconfig = &vchan->cfg;
> + struct sun4i_dma_promise *promise;
> + struct sun4i_dma_contract *contract;
> + struct scatterlist *sg;
> + dma_addr_t srcaddr, dstaddr;
> + u32 endpoints, para;
> + int i;
> +
> + if (!sgl)
> + return NULL;
> +
> + if (!is_slave_direction(dir)) {
> + dev_err(chan2dev(chan), "Invalid DMA direction\n");
> + return NULL;
> + }
> +
> + contract = generate_dma_contract();
> + if (!contract)
> + return NULL;
> +
> + /* Figure out endpoints */
> + if (vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_LINEAR) |
> + DDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_IO);
> + } else if (!vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
> + NDMA_CFG_DEST_FIXED_ADDR;
> + } else if (vchan->is_dedicated) {
> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_IO) |
> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_LINEAR);
> + } else {
> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
> + NDMA_CFG_SRC_FIXED_ADDR |
> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM);
> + }
> +
> + for_each_sg(sgl, sg, sg_len, i) {
> + /* Figure out addresses */
> + if (dir == DMA_MEM_TO_DEV) {
> + srcaddr = sg_dma_address(sg);
> + dstaddr = sconfig->dst_addr;
> + para = 0;
> + } else {
> + srcaddr = sconfig->src_addr;
> + dstaddr = sg_dma_address(sg);
> + para = 0x00010001; /* TODO spi magic? */
> + }
> +
> + /* And make a suitable promise */
> + promise = generate_ddma_promise(chan, srcaddr, dstaddr,
> + sg_dma_len(sg), sconfig);
What about ndma?
> + if (!promise)
> + return NULL; /* TODO */
> +
> + promise->cfg |= endpoints;
> + promise->para = para;
> +
> + /* Then add it to the contract */
> + list_add_tail(&promise->list, &contract->demands);
> + }
> +
> + /* Once we've got all the promises ready, add the contract
> + * to the pending list on the vchan */
> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
> +}
> +
> +static int sun4i_dma_terminate_all(struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_pchan *pchan = vchan->pchan;
> + LIST_HEAD(head);
> + unsigned long flags, timeout;
> + u32 d_busy = DDMA_CFG_LOADING | DDMA_CFG_BUSY;
> + u32 n_busy = NDMA_CFG_LOADING;
> +
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vchan_get_all_descriptors(&vchan->vc, &head);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + /* If this vchan is operating, wait until it's no longer busy */
> + if (pchan) {
> + timeout = jiffies + msecs_to_jiffies(2000);
> + if (pchan->is_dedicated) {
> + while (readl(pchan->base + DDMA_CFG_REG) & d_busy)
> + if (time_after(jiffies, timeout))
> + return -ETIMEDOUT;
> + } else {
> + while (readl(pchan->base + NDMA_CFG_REG) & n_busy)
> + if (time_after(jiffies, timeout))
> + return -ETIMEDOUT;
> + }
> + }
> +
> + /* TODO: wait until IRQ handler has run? */
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vchan_dma_desc_free_list(&vchan->vc, &head);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + return 0;
> +}
> +
> +static int sun4i_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
> + unsigned long arg)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + int ret = 0;
> +
> + switch (cmd) {
> + case DMA_RESUME:
> + case DMA_PAUSE:
> + ret = -EINVAL;
> + break;
> +
> + case DMA_TERMINATE_ALL:
> + dev_dbg(chan2dev(chan), "Terminating everything on channel\n");
> + ret = sun4i_dma_terminate_all(vchan);
> + break;
> +
> + case DMA_SLAVE_CONFIG:
> + memcpy(&vchan->cfg, (void *)arg, sizeof(vchan->cfg));
> + break;
> +
> + default:
> + ret = -ENXIO;
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static struct dma_chan *sun4i_dma_of_xlate(struct of_phandle_args *dma_spec,
> + struct of_dma *ofdma)
> +{
> + struct sun4i_dma_dev *priv = ofdma->of_dma_data;
> + struct sun4i_dma_vchan *vchan;
> + struct dma_chan *chan;
> + u8 is_dedicated = dma_spec->args[0];
> + u8 endpoint = dma_spec->args[1];
> +
> + /* Check if type is Normal or Dedicated */
> + if (is_dedicated != 0 && is_dedicated != 1)
> + return NULL;
> +
> + /* Make sure the endpoint looks sane */
> + if ((is_dedicated && endpoint >= DDMA_DRQ_TYPE_LIMIT) ||
> + (!is_dedicated && endpoint >= NDMA_DRQ_TYPE_LIMIT))
> + return NULL;
> +
> + chan = dma_get_any_slave_channel(&priv->slave);
> + if (!chan)
> + return NULL;
> +
> + /* Assign the endpoint to the vchan */
> + vchan = to_sun4i_dma_vchan(chan);
> + vchan->is_dedicated = is_dedicated;
> + vchan->endpoint = endpoint;
> +
> + return chan;
> +}
> +
> +static enum dma_status sun4i_dma_tx_status(struct dma_chan *chan,
> + dma_cookie_t cookie,
> + struct dma_tx_state *state)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct sun4i_dma_pchan *pchan = vchan->pchan;
> + struct sun4i_dma_contract *contract;
> + struct sun4i_dma_promise *promise = NULL;
> + struct virt_dma_desc *vd;
> + unsigned long flags;
> + enum dma_status ret;
> + size_t bytes = 0;
> +
> + ret = dma_cookie_status(chan, cookie, state);
> + if (ret == DMA_COMPLETE)
> + return ret;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vd = vchan_find_desc(&vchan->vc, cookie);
> + if (!vd) /* TODO */
> + goto exit;
> + contract = to_sun4i_dma_contract(vd);
> +
> + list_for_each_entry_reverse(promise, &contract->demands, list) {
> + bytes += promise->len;
> + }
> +
> + /* The hardware is configured to return the remaining byte
> + * quantity. If possible, replace the first listed element's
> + * full size with the actual remaining amount */
> + if (promise && pchan) {
> + bytes -= promise->len;
> + if (pchan->is_dedicated)
> + bytes += readl(pchan->base + DDMA_BYTE_COUNT_REG);
> + else
> + bytes += readl(pchan->base + NDMA_BYTE_COUNT_REG);
> + }
> +
> +exit:
> +
> + dma_set_residue(state, bytes);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + return ret;
> +}
> +
> +static void sun4i_dma_issue_pending(struct dma_chan *chan)
> +{
> + struct sun4i_dma_dev *priv = to_sun4i_dma_dev(chan->device);
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> +
> + /* If there are pending transactions for this vchan, schedule
> + * the tasklet so they are issued soon */
> + if (vchan_issue_pending(&vchan->vc))
> + tasklet_schedule(&priv->tasklet);
> +
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +}
> +
> +static irqreturn_t sun4i_dma_interrupt(int irq, void *dev_id)
> +{
> + struct sun4i_dma_dev *priv = dev_id;
> + struct sun4i_dma_pchan *pchans = priv->pchans, *pchan;
> + struct sun4i_dma_vchan *vchan;
> + struct sun4i_dma_contract *contract;
> + unsigned long pendirq, irqs;
> + int bit;
> +
> + pendirq = readl_relaxed(priv->base + DMA_IRQ_PENDING_STATUS_REG);
> + irqs = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
> +
> + for_each_set_bit(bit, &pendirq, 32) {
> + pchan = &pchans[bit >> 1];
> + vchan = pchan->vchan;
> + contract = vchan->contract;
> +
> + /* Disable the IRQ and free the pchan if it's an end
> + * interrupt (odd bit) */
> + if (bit & 1) {
> + spin_lock(&vchan->vc.lock);
> + /* Move the promise into the completed list now that
> + * we're done with it */
> + list_del(&vchan->processing->list);
> + list_add_tail(&vchan->processing->list, &contract->completed_demands);
> + vchan->processing = NULL;
> + vchan->pchan = NULL;
> + spin_unlock(&vchan->vc.lock);
> +
> + irqs &= ~BIT(bit);
> + release_pchan(priv, pchan);
> + }
> + }
> +
> + writel_relaxed(irqs, priv->base + DMA_IRQ_ENABLE_REG);
> +
> + /* Writing 1 to the pending field will clear the pending interrupt */
> + writel(pendirq, priv->base + DMA_IRQ_PENDING_STATUS_REG);
> +
> + tasklet_schedule(&priv->tasklet);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static void sun4i_dma_tasklet(unsigned long data)
> +{
> + struct sun4i_dma_dev *priv = (void *)data;
> + int i;
> +
> + for (i = 0; i < DMA_NR_MAX_VCHANS; i++)
> + execute_vchan_pending(priv, &priv->vchans[i]);
> +}
> +
> +static int sun4i_dma_probe(struct platform_device *pdev)
> +{
> + struct sun4i_dma_dev *priv;
> + struct resource *res;
> + int i, j, ret;
> +
> + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
> + if (!priv)
> + return -ENOMEM;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + priv->base = devm_ioremap_resource(&pdev->dev, res);
> + if (IS_ERR(priv->base))
> + return PTR_ERR(priv->base);
> +
> + priv->irq = platform_get_irq(pdev, 0);
> + if (priv->irq < 0) {
> + dev_err(&pdev->dev, "Cannot claim IRQ\n");
> + return priv->irq;
> + }
> +
> + priv->clk = devm_clk_get(&pdev->dev, NULL);
> + if (IS_ERR(priv->clk)) {
> + dev_err(&pdev->dev, "No clock specified\n");
> + return PTR_ERR(priv->clk);
> + }
> +
> + platform_set_drvdata(pdev, priv);
> + spin_lock_init(&priv->lock);
> + tasklet_init(&priv->tasklet, sun4i_dma_tasklet, (unsigned long)priv);
> +
> + dma_cap_zero(priv->slave.cap_mask);
> + dma_cap_set(DMA_PRIVATE, priv->slave.cap_mask);
> + dma_cap_set(DMA_MEMCPY, priv->slave.cap_mask);
> + dma_cap_set(DMA_SLAVE, priv->slave.cap_mask);
> +
> + INIT_LIST_HEAD(&priv->slave.channels);
> + priv->slave.device_alloc_chan_resources = sun4i_dma_alloc_chan_resources;
> + priv->slave.device_free_chan_resources = sun4i_dma_free_chan_resources;
> + priv->slave.device_tx_status = sun4i_dma_tx_status;
> + priv->slave.device_issue_pending = sun4i_dma_issue_pending;
> + priv->slave.device_prep_slave_sg = sun4i_dma_prep_slave_sg;
> + priv->slave.device_prep_dma_memcpy = sun4i_dma_prep_dma_memcpy;
> + priv->slave.device_control = sun4i_dma_control;
> + priv->slave.chancnt = DDMA_NR_MAX_VCHANS;
> +
> + priv->slave.dev = &pdev->dev;
> +
> + priv->pchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_CHANNELS,
> + sizeof(struct sun4i_dma_pchan), GFP_KERNEL);
> + priv->vchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_VCHANS,
> + sizeof(struct sun4i_dma_vchan), GFP_KERNEL);
> + if (!priv->vchans || !priv->pchans)
> + return -ENOMEM;
> +
> + /* [0..NDMA_NR_MAX_CHANNELS) are normal pchans, and
> + * [NDMA_NR_MAX_CHANNELS..DMA_NR_MAX_CHANNELS) are dedicated ones */
> + for (i = 0; i < NDMA_NR_MAX_CHANNELS; i++)
> + priv->pchans[i].base = priv->base + NDMA_CHANNEL_REG_BASE(i);
> + for (j = 0; i < DMA_NR_MAX_CHANNELS; i++, j++) {
> + priv->pchans[i].base = priv->base + DDMA_CHANNEL_REG_BASE(j);
> + priv->pchans[i].is_dedicated = 1;
> + }
> +
> + for (i = 0; i < DMA_NR_MAX_VCHANS; i++) {
> + struct sun4i_dma_vchan *vchan = &priv->vchans[i];
> +
> + spin_lock_init(&vchan->vc.lock);
> + vchan->vc.desc_free = sun4i_dma_free_contract;
> + vchan_init(&vchan->vc, &priv->slave);
> + }
> +
> + ret = clk_prepare_enable(priv->clk);
> + if (ret) {
> + dev_err(&pdev->dev, "Couldn't enable the clock\n");
> + return ret;
> + }
> +
> + ret = devm_request_irq(&pdev->dev, priv->irq, sun4i_dma_interrupt, 0,
> + dev_name(&pdev->dev), priv);
> + if (ret) {
> + dev_err(&pdev->dev, "Cannot request IRQ\n");
> + goto err_clk_disable;
> + }
> +
> + ret = dma_async_device_register(&priv->slave);
> + if (ret) {
> + dev_warn(&pdev->dev, "Failed to register DMA engine device\n");
> + goto err_clk_disable;
> + }
> +
> + ret = of_dma_controller_register(pdev->dev.of_node, sun4i_dma_of_xlate,
> + priv);
> + if (ret) {
> + dev_err(&pdev->dev, "of_dma_controller_register failed\n");
> + goto err_dma_unregister;
> + }
> +
> + dev_dbg(&pdev->dev, "Successfully probed SUN4I_DMA\n");
> +
> + return 0;
> +
> +err_dma_unregister:
> + dma_async_device_unregister(&priv->slave);
> +err_clk_disable:
> + clk_disable_unprepare(priv->clk);
> + return ret;
> +}
> +
> +static int sun4i_dma_remove(struct platform_device *pdev)
> +{
> + struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
> +
> + /* Disable IRQ so the tasklet doesn't schedule any longer, then
> + * kill it */
> + disable_irq(priv->irq);
> + tasklet_kill(&priv->tasklet);
> +
> + of_dma_controller_free(pdev->dev.of_node);
> + dma_async_device_unregister(&priv->slave);
> +
> + clk_disable_unprepare(priv->clk);
> +
> + return 0;
> +}
> +
> +static struct of_device_id sun4i_dma_match[] = {
> + { .compatible = "allwinner,sun4i-a10-dma" }
> +};
> +
> +static struct platform_driver sun4i_dma_driver = {
> + .probe = sun4i_dma_probe,
> + .remove = sun4i_dma_remove,
> + .driver = {
> + .name = "sun4i-dma",
> + .of_match_table = sun4i_dma_match,
> + },
> +};
> +
> +module_platform_driver(sun4i_dma_driver);
> +
> +MODULE_DESCRIPTION("Allwinner A10 Dedicated DMA Controller Driver");
> +MODULE_AUTHOR("Emilio L?pez <emilio@elopez.com.ar>");
> +MODULE_LICENSE("GPL");
The rest looks OK, but I'm not very familiar with the dmaengine API.
Best have a second pair of eyes on it.
Thanks for working on this!
Cheers
ChenYu
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 02/10] serial: 8250_dw: support DMA on the OF case
2014-06-16 3:50 ` [PATCH 02/10] serial: 8250_dw: support DMA on the OF case Emilio López
@ 2014-06-21 13:56 ` Chen-Yu Tsai
2014-06-24 13:19 ` Emilio López
0 siblings, 1 reply; 21+ messages in thread
From: Chen-Yu Tsai @ 2014-06-21 13:56 UTC (permalink / raw)
To: linux-arm-kernel
On Mon, Jun 16, 2014 at 11:50 AM, Emilio L?pez <emilio@elopez.com.ar> wrote:
> Currently, DMA properties on the DT are ignored when using the 8250_dw
> driver. With this patch, DMA will be used when available.
>
> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
> ---
> drivers/tty/serial/8250/8250_dw.c | 7 ++++++-
> 1 file changed, 6 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
> index ed31135..f75c0bf 100644
> --- a/drivers/tty/serial/8250/8250_dw.c
> +++ b/drivers/tty/serial/8250/8250_dw.c
> @@ -222,6 +222,8 @@ static int dw8250_probe_of(struct uart_port *p,
> struct dw8250_data *data)
> {
> struct device_node *np = p->dev->of_node;
> + struct uart_8250_port *up = container_of(p, struct uart_8250_port,
> + port);
> u32 val;
> bool has_ucv = true;
>
> @@ -254,11 +256,14 @@ static int dw8250_probe_of(struct uart_port *p,
> }
> }
> if (has_ucv)
> - dw8250_setup_port(container_of(p, struct uart_8250_port, port));
> + dw8250_setup_port(up);
>
> if (!of_property_read_u32(np, "reg-shift", &val))
> p->regshift = val;
>
> + if (of_get_property(np, "dmas", NULL))
> + up->dma = &data->dma;
> +
I suggest adding a comment here. Looking just at the patch,
it's not very intuitive. But otherwise the patch looks good.
ChenYu
> /* clock got configured through clk api, all done */
> if (p->uartclk)
> return 0;
> --
> 2.0.0
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-21 13:51 ` Chen-Yu Tsai
@ 2014-06-24 13:02 ` Emilio López
0 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-24 13:02 UTC (permalink / raw)
To: linux-arm-kernel
Hi,
El 21/06/14 10:51, Chen-Yu Tsai escribi?:
> On Mon, Jun 16, 2014 at 11:50 AM, Emilio L?pez <emilio@elopez.com.ar> wrote:
>> This patch adds support for the DMA engine present on Allwinner A10,
>> A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
>> and dedicated. The main difference is in the mode of operation;
>> while a single normal channel may be operating at any given time,
>> dedicated channels may operate simultaneously provided there is no
>> overlap of source or destination.
>>
>> Hardware documentation can be found on A10 User Manual (section 12), A13
>> User Manual (section 14) and A20 User Manual (section 1.12)
>>
>> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
>> ---
>>
>> For some mem2dev/dev2mem transfers, we need to configure some magic delays
>> for things to work - on my experimental testing, 0x00010001 seems to work
>> for SPI. Is there some place in the API to pass these kinds of values from
>> client drivers when configuring a transfer? Currently I have just hardcoded
>> this value on the driver, but it'll probably cause trouble in the future
>> for other devices.
>>
>> .../devicetree/bindings/dma/sun4i-dma.txt | 45 +
>> drivers/dma/Kconfig | 10 +
>> drivers/dma/Makefile | 1 +
>> drivers/dma/sun4i-dma.c | 1065 ++++++++++++++++++++
>> 4 files changed, 1121 insertions(+)
>> create mode 100644 Documentation/devicetree/bindings/dma/sun4i-dma.txt
>> create mode 100644 drivers/dma/sun4i-dma.c
>>
>> diff --git a/Documentation/devicetree/bindings/dma/sun4i-dma.txt b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
>> new file mode 100644
>> index 0000000..f5661a5
>> --- /dev/null
>> +++ b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
>> @@ -0,0 +1,45 @@
>> +Allwinner A10 DMA Controller
>> +
>> +This driver follows the generic DMA bindings defined in dma.txt.
>> +
>> +Required properties:
>> +
>> +- compatible: Must be "allwinner,sun4i-a10-dma"
>> +- reg: Should contain the registers base address and length
>> +- interrupts: Should contain a reference to the interrupt used by this device
>> +- clocks: Should contain a reference to the parent AHB clock
>> +- #dma-cells : Should be 1, a single cell holding a line request number
>> +
>> +Example:
>> + dma: dma-controller at 01c02000 {
>> + compatible = "allwinner,sun4i-a10-dma";
>> + reg = <0x01c02000 0x1000>;
>> + interrupts = <27>;
>> + clocks = <&ahb_gates 6>;
>> + #dma-cells = <1>;
>> + };
>> +
>> +Clients:
>> +
>> +DMA clients connected to the Allwinner A10 DMA controller must use the
>> +format described in the dma.txt file, using a three-cell specifier for
>> +each channel: a phandle plus two integer cells.
>> +The three cells in order are:
>> +
>> +1. A phandle pointing to the DMA controller.
>> +2. Whether it is using normal (0) or dedicated (1) channels
>> +2. The port ID as specified in the datasheet
>> +
>> +Example:
>> + spi2: spi at 01c17000 {
>> + compatible = "allwinner,sun4i-a10-spi";
>> + reg = <0x01c17000 0x1000>;
>> + interrupts = <0 12 4>;
>> + clocks = <&ahb_gates 22>, <&spi2_clk>;
>> + clock-names = "ahb", "mod";
>> + dmas = <&dma 1 29>, <&dma 1 28>;
>> + dma-names = "rx", "tx";
>> + status = "disabled";
>> + #address-cells = <1>;
>> + #size-cells = <0>;
>> + };
>> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
>> index ba06d1d..a9ee0c9 100644
>> --- a/drivers/dma/Kconfig
>> +++ b/drivers/dma/Kconfig
>> @@ -361,6 +361,16 @@ config FSL_EDMA
>> multiplexing capability for DMA request sources(slot).
>> This module can be found on Freescale Vybrid and LS-1 SoCs.
>>
>> +config SUN4I_DMA
>> + tristate "Allwinner A10/A10S/A13/A20 DMA support"
>> + depends on ARCH_SUNXI
>> + select DMA_ENGINE
>> + select DMA_OF
>> + select DMA_VIRTUAL_CHANNELS
>> + help
>> + Enable support for the DMA controller present in the sun4i,
>> + sun5i and sun7i Allwinner ARM SoCs.
>> +
>
> Conflict here and in drivers/dma/Makefile when applied to 3.16-rc1.
I worked on this on top of 3.15, so it's not really unexpected :) I'll
rebase it for v2.
>
>> config DMA_ENGINE
>> bool
>>
>> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
>> index 5150c82..13a7d5d 100644
>> --- a/drivers/dma/Makefile
>> +++ b/drivers/dma/Makefile
>> @@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
>> obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
>> obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
>> obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
>> +obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
>> diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
>> new file mode 100644
>> index 0000000..0b14b3f
>> --- /dev/null
>> +++ b/drivers/dma/sun4i-dma.c
(...)
>> +/* A contract is a set of promises */
>> +struct sun4i_dma_contract {
>> + struct virt_dma_desc vd;
>> + struct list_head demands;
>> + struct list_head completed_demands;
>> +};
>> +
>> +struct sun4i_dma_dev {
>> + DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
>
> Should be DMA_NR_MAX_CHANNELS, right?
Indeed, I'll fix it.
>
>> + struct tasklet_struct tasklet;
>> + struct dma_device slave;
>> + struct sun4i_dma_pchan *pchans;
>> + struct sun4i_dma_vchan *vchans;
>> + void __iomem *base;
>> + struct clk *clk;
>> + int irq;
>> + spinlock_t lock;
>> +};
(...)
>> +static struct dma_async_tx_descriptor *
>> +sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
>> + dma_addr_t src, size_t len, unsigned long flags)
>> +{
>> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
>> + struct dma_slave_config *sconfig = &vchan->cfg;
>> + struct sun4i_dma_promise *promise;
>> + struct sun4i_dma_contract *contract;
>> +
>> + contract = generate_dma_contract();
>> + if (!contract)
>> + return NULL;
>> +
>> + if (vchan->is_dedicated)
>> + promise = generate_ddma_promise(chan, src, dest, len, sconfig);
>> + else
>> + promise = generate_ndma_promise(chan, src, dest, len, sconfig);
>> +
>> + if (!promise) {
>> + kfree(contract);
>> + return NULL;
>> + }
>> +
>> + /* Configure memcpy mode */
>> + if (vchan->is_dedicated) {
>> + promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_SRC_NON_SECURE |
>> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_DEST_NON_SECURE;
>
> Are you sure this works? The manual says dedicated DMA can only do
> device to memory or memory to device.
I started by implementing dedicated DMA, and dmatest was happy with it,
so I suppose it works ok, despite what the manual says.
> Anyway we won't be using this I guess.
>
>> + } else {
>> + promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
>> + NDMA_CFG_SRC_NON_SECURE |
>> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
>> + NDMA_CFG_DEST_NON_SECURE;
>> + }
>> +
>> + /* Fill the contract with our only promise */
>> + list_add_tail(&promise->list, &contract->demands);
>> +
>> + /* And add it to the vchan */
>> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
>> +}
>> +
>> +static struct dma_async_tx_descriptor *
>> +sun4i_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
>> + unsigned int sg_len, enum dma_transfer_direction dir,
>> + unsigned long flags, void *context)
>> +{
>> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
>> + struct dma_slave_config *sconfig = &vchan->cfg;
>> + struct sun4i_dma_promise *promise;
>> + struct sun4i_dma_contract *contract;
>> + struct scatterlist *sg;
>> + dma_addr_t srcaddr, dstaddr;
>> + u32 endpoints, para;
>> + int i;
>> +
>> + if (!sgl)
>> + return NULL;
>> +
>> + if (!is_slave_direction(dir)) {
>> + dev_err(chan2dev(chan), "Invalid DMA direction\n");
>> + return NULL;
>> + }
>> +
>> + contract = generate_dma_contract();
>> + if (!contract)
>> + return NULL;
>> +
>> + /* Figure out endpoints */
>> + if (vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
>> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_LINEAR) |
>> + DDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
>> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_IO);
>> + } else if (!vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
>> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
>> + NDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
>> + NDMA_CFG_DEST_FIXED_ADDR;
>> + } else if (vchan->is_dedicated) {
>> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
>> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_IO) |
>> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_LINEAR);
>> + } else {
>> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
>> + NDMA_CFG_SRC_FIXED_ADDR |
>> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM);
>> + }
>> +
>> + for_each_sg(sgl, sg, sg_len, i) {
>> + /* Figure out addresses */
>> + if (dir == DMA_MEM_TO_DEV) {
>> + srcaddr = sg_dma_address(sg);
>> + dstaddr = sconfig->dst_addr;
>> + para = 0;
>> + } else {
>> + srcaddr = sconfig->src_addr;
>> + dstaddr = sg_dma_address(sg);
>> + para = 0x00010001; /* TODO spi magic? */
>> + }
>> +
>> + /* And make a suitable promise */
>> + promise = generate_ddma_promise(chan, srcaddr, dstaddr,
>> + sg_dma_len(sg), sconfig);
>
> What about ndma?
Good question :)
>
>> + if (!promise)
>> + return NULL; /* TODO */
>> +
>> + promise->cfg |= endpoints;
>> + promise->para = para;
>> +
>> + /* Then add it to the contract */
>> + list_add_tail(&promise->list, &contract->demands);
>> + }
>> +
>> + /* Once we've got all the promises ready, add the contract
>> + * to the pending list on the vchan */
>> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
>> +}
(...)
>> +static struct platform_driver sun4i_dma_driver = {
>> + .probe = sun4i_dma_probe,
>> + .remove = sun4i_dma_remove,
>> + .driver = {
>> + .name = "sun4i-dma",
>> + .of_match_table = sun4i_dma_match,
>> + },
>> +};
>> +
>> +module_platform_driver(sun4i_dma_driver);
>> +
>> +MODULE_DESCRIPTION("Allwinner A10 Dedicated DMA Controller Driver");
>> +MODULE_AUTHOR("Emilio L?pez <emilio@elopez.com.ar>");
>> +MODULE_LICENSE("GPL");
>
> The rest looks OK, but I'm not very familiar with the dmaengine API.
> Best have a second pair of eyes on it.
Thanks for the review!
Cheers,
Emilio
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 02/10] serial: 8250_dw: support DMA on the OF case
2014-06-21 13:56 ` Chen-Yu Tsai
@ 2014-06-24 13:19 ` Emilio López
0 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-24 13:19 UTC (permalink / raw)
To: linux-arm-kernel
Hi,
El 21/06/14 10:56, Chen-Yu Tsai escribi?:
> On Mon, Jun 16, 2014 at 11:50 AM, Emilio L?pez <emilio@elopez.com.ar> wrote:
>> Currently, DMA properties on the DT are ignored when using the 8250_dw
>> driver. With this patch, DMA will be used when available.
>>
>> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
>> ---
>> drivers/tty/serial/8250/8250_dw.c | 7 ++++++-
>> 1 file changed, 6 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
>> index ed31135..f75c0bf 100644
>> --- a/drivers/tty/serial/8250/8250_dw.c
>> +++ b/drivers/tty/serial/8250/8250_dw.c
>> @@ -222,6 +222,8 @@ static int dw8250_probe_of(struct uart_port *p,
>> struct dw8250_data *data)
>> {
>> struct device_node *np = p->dev->of_node;
>> + struct uart_8250_port *up = container_of(p, struct uart_8250_port,
>> + port);
>> u32 val;
>> bool has_ucv = true;
>>
>> @@ -254,11 +256,14 @@ static int dw8250_probe_of(struct uart_port *p,
>> }
>> }
>> if (has_ucv)
>> - dw8250_setup_port(container_of(p, struct uart_8250_port, port));
>> + dw8250_setup_port(up);
>>
>> if (!of_property_read_u32(np, "reg-shift", &val))
>> p->regshift = val;
>>
>> + if (of_get_property(np, "dmas", NULL))
>> + up->dma = &data->dma;
>> +
>
> I suggest adding a comment here. Looking just at the patch,
> it's not very intuitive. But otherwise the patch looks good.
Sure, I can do that
Thanks!
Emilio
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
2014-06-21 13:51 ` Chen-Yu Tsai
@ 2014-06-25 18:42 ` Maxime Ripard
2014-06-25 22:46 ` Emilio López
1 sibling, 1 reply; 21+ messages in thread
From: Maxime Ripard @ 2014-06-25 18:42 UTC (permalink / raw)
To: linux-arm-kernel
On Mon, Jun 16, 2014 at 12:50:26AM -0300, Emilio L?pez wrote:
> This patch adds support for the DMA engine present on Allwinner A10,
> A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
> and dedicated. The main difference is in the mode of operation;
> while a single normal channel may be operating at any given time,
> dedicated channels may operate simultaneously provided there is no
> overlap of source or destination.
>
> Hardware documentation can be found on A10 User Manual (section 12), A13
> User Manual (section 14) and A20 User Manual (section 1.12)
>
> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
> ---
>
> For some mem2dev/dev2mem transfers, we need to configure some magic delays
> for things to work - on my experimental testing, 0x00010001 seems to work
> for SPI. Is there some place in the API to pass these kinds of values from
> client drivers when configuring a transfer? Currently I have just hardcoded
> this value on the driver, but it'll probably cause trouble in the future
> for other devices.
>
> .../devicetree/bindings/dma/sun4i-dma.txt | 45 +
> drivers/dma/Kconfig | 10 +
> drivers/dma/Makefile | 1 +
> drivers/dma/sun4i-dma.c | 1065 ++++++++++++++++++++
> 4 files changed, 1121 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/dma/sun4i-dma.txt
> create mode 100644 drivers/dma/sun4i-dma.c
>
> diff --git a/Documentation/devicetree/bindings/dma/sun4i-dma.txt b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
> new file mode 100644
> index 0000000..f5661a5
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/dma/sun4i-dma.txt
> @@ -0,0 +1,45 @@
> +Allwinner A10 DMA Controller
> +
> +This driver follows the generic DMA bindings defined in dma.txt.
> +
> +Required properties:
> +
> +- compatible: Must be "allwinner,sun4i-a10-dma"
> +- reg: Should contain the registers base address and length
> +- interrupts: Should contain a reference to the interrupt used by this device
> +- clocks: Should contain a reference to the parent AHB clock
> +- #dma-cells : Should be 1, a single cell holding a line request number
> +
> +Example:
> + dma: dma-controller at 01c02000 {
> + compatible = "allwinner,sun4i-a10-dma";
> + reg = <0x01c02000 0x1000>;
> + interrupts = <27>;
> + clocks = <&ahb_gates 6>;
> + #dma-cells = <1>;
> + };
> +
> +Clients:
> +
> +DMA clients connected to the Allwinner A10 DMA controller must use the
> +format described in the dma.txt file, using a three-cell specifier for
> +each channel: a phandle plus two integer cells.
> +The three cells in order are:
> +
> +1. A phandle pointing to the DMA controller.
> +2. Whether it is using normal (0) or dedicated (1) channels
> +2. The port ID as specified in the datasheet
> +
> +Example:
> + spi2: spi at 01c17000 {
> + compatible = "allwinner,sun4i-a10-spi";
> + reg = <0x01c17000 0x1000>;
> + interrupts = <0 12 4>;
> + clocks = <&ahb_gates 22>, <&spi2_clk>;
> + clock-names = "ahb", "mod";
> + dmas = <&dma 1 29>, <&dma 1 28>;
> + dma-names = "rx", "tx";
> + status = "disabled";
> + #address-cells = <1>;
> + #size-cells = <0>;
> + };
> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> index ba06d1d..a9ee0c9 100644
> --- a/drivers/dma/Kconfig
> +++ b/drivers/dma/Kconfig
> @@ -361,6 +361,16 @@ config FSL_EDMA
> multiplexing capability for DMA request sources(slot).
> This module can be found on Freescale Vybrid and LS-1 SoCs.
>
> +config SUN4I_DMA
> + tristate "Allwinner A10/A10S/A13/A20 DMA support"
> + depends on ARCH_SUNXI
MACH_SUN4I || MACH_SUN5I || MACH_SUN7I ?
That would probably be a good idea to add COMPILE_TEST to the list
too.
> + select DMA_ENGINE
> + select DMA_OF
> + select DMA_VIRTUAL_CHANNELS
> + help
> + Enable support for the DMA controller present in the sun4i,
> + sun5i and sun7i Allwinner ARM SoCs.
> +
> config DMA_ENGINE
> bool
>
> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> index 5150c82..13a7d5d 100644
> --- a/drivers/dma/Makefile
> +++ b/drivers/dma/Makefile
> @@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
> obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
> obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
> obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
> +obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
> diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
> new file mode 100644
> index 0000000..0b14b3f
> --- /dev/null
> +++ b/drivers/dma/sun4i-dma.c
> @@ -0,0 +1,1065 @@
> +/*
> + * Copyright (C) 2014 Emilio L?pez
> + * Emilio L?pez <emilio@elopez.com.ar>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + */
> +
> +#include <linux/bitmap.h>
> +#include <linux/bitops.h>
> +#include <linux/clk.h>
> +#include <linux/dmaengine.h>
> +#include <linux/dmapool.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/of_dma.h>
> +#include <linux/platform_device.h>
> +#include <linux/slab.h>
> +#include <linux/spinlock.h>
> +
> +#include "virt-dma.h"
> +
> +/** General DMA register values **/
> +
> +/* DMA source/destination burst length values */
> +#define DMA_BURST_LENGTH_1 0
> +#define DMA_BURST_LENGTH_4 1
> +#define DMA_BURST_LENGTH_8 2
An enum maybe?
You're not using this anywhere though.
> +/* DMA source/destination data width */
> +#define DMA_DATA_WIDTH_8BIT 0
> +#define DMA_DATA_WIDTH_16BIT 1
> +#define DMA_DATA_WIDTH_32BIT 2
And you're not using this either.
> +/** Normal DMA register values **/
> +
> +/* Normal DMA source/destination data request type values */
> +#define NDMA_DRQ_TYPE_IR0 0x0
> +#define NDMA_DRQ_TYPE_IR1 0x1
> +#define NDMA_DRQ_TYPE_SPDIF 0x2
> +#define NDMA_DRQ_TYPE_IIS0 0x3
> +#define NDMA_DRQ_TYPE_IIS1 0x4
> +#define NDMA_DRQ_TYPE_AC97 0x5
> +#define NDMA_DRQ_TYPE_IIS2 0x6
> +#define NDMA_DRQ_TYPE_UART0 0x8
> +#define NDMA_DRQ_TYPE_UART1 0x9
> +#define NDMA_DRQ_TYPE_UART2 0xA
> +#define NDMA_DRQ_TYPE_UART3 0xB
> +#define NDMA_DRQ_TYPE_UART4 0xC
> +#define NDMA_DRQ_TYPE_UART5 0xD
> +#define NDMA_DRQ_TYPE_UART6 0xE
> +#define NDMA_DRQ_TYPE_UART7 0xF
> +#define NDMA_DRQ_TYPE_HDMI_DDC 0x10
> +#define NDMA_DRQ_TYPE_USB_EP1 0x11
> +#define NDMA_DRQ_TYPE_AUDIO_CODEC 0x13
> +#define NDMA_DRQ_TYPE_SRAM 0x15
> +#define NDMA_DRQ_TYPE_SDRAM 0x16
> +#define NDMA_DRQ_TYPE_TP_AD 0x17
> +#define NDMA_DRQ_TYPE_SPI0 0x18
> +#define NDMA_DRQ_TYPE_SPI1 0x19
> +#define NDMA_DRQ_TYPE_SPI2 0x1A
> +#define NDMA_DRQ_TYPE_SPI3 0x1B
> +#define NDMA_DRQ_TYPE_USB_EP2 0x1C
> +#define NDMA_DRQ_TYPE_USB_EP3 0x1D
> +#define NDMA_DRQ_TYPE_USB_EP4 0x1E
> +#define NDMA_DRQ_TYPE_USB_EP5 0x1F
> +#define NDMA_DRQ_TYPE_LIMIT (0x1F+1)
This isn't used anywhere, and is both useless, and probably not true
for all these SoCs.
> +/** Normal DMA register layout **/
> +
> +/* Normal DMA configuration register layout */
> +#define NDMA_CFG_LOADING BIT(31)
> +#define NDMA_CFG_CONT_MODE BIT(30)
> +#define NDMA_CFG_WAIT_STATE(n) (n << 27)
You probably want to add parenthesis around n.
> +#define NDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
ditto.
> +#define NDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
ditto.
> +#define NDMA_CFG_DEST_NON_SECURE BIT(22)
> +#define NDMA_CFG_DEST_FIXED_ADDR BIT(21)
> +#define NDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
ditto.
> +#define NDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
> +#define NDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
> +#define NDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
ditto.
> +#define NDMA_CFG_SRC_NON_SECURE BIT(6)
> +#define NDMA_CFG_SRC_FIXED_ADDR BIT(5)
> +#define NDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
ditto.
> +
> +/** Dedicated DMA register values **/
> +
> +/* Dedicated DMA source/destination address mode values */
> +#define DDMA_ADDR_MODE_LINEAR 0
> +#define DDMA_ADDR_MODE_IO 1
> +#define DDMA_ADDR_MODE_HORIZONTAL_PAGE 2
> +#define DDMA_ADDR_MODE_VERTICAL_PAGE 3
> +
> +/* Dedicated DMA source/destination data request type values
> + * Note: some of these values are only sensible when used only as
> + * source or destination */
> +#define DDMA_DRQ_TYPE_SRAM 0x0
> +#define DDMA_DRQ_TYPE_SDRAM 0x1
> +#define DDMA_DRQ_TYPE_PATA 0x2
> +#define DDMA_DRQ_TYPE_NFC 0x3
> +#define DDMA_DRQ_TYPE_USB0 0x4
> +#define DDMA_DRQ_TYPE_EMAC_TX 0x6
> +#define DDMA_DRQ_TYPE_EMAC_RX 0x7
> +#define DDMA_DRQ_TYPE_SPI1_TX 0x8
> +#define DDMA_DRQ_TYPE_SPI1_RX 0x9
> +#define DDMA_DRQ_TYPE_SS_TX 0xA
> +#define DDMA_DRQ_TYPE_SS_RX 0xB
> +#define DDMA_DRQ_TYPE_TCON0 0xE
> +#define DDMA_DRQ_TYPE_TCON1 0xF
> +#define DDMA_DRQ_TYPE_MSC 0x17
> +#define DDMA_DRQ_TYPE_HDMI_AUDIO 0x18
> +#define DDMA_DRQ_TYPE_SPI0_TX 0x1A
> +#define DDMA_DRQ_TYPE_SPI0_RX 0x1B
> +#define DDMA_DRQ_TYPE_SPI2_TX 0x1C
> +#define DDMA_DRQ_TYPE_SPI2_RX 0x1D
> +#define DDMA_DRQ_TYPE_SPI3_TX 0x1E
> +#define DDMA_DRQ_TYPE_SPI3_RX 0x1F
> +#define DDMA_DRQ_TYPE_LIMIT (0x1F+1)
Useless, and redundant.
> +
> +/** Dedicated DMA register layout **/
> +
> +/* Dedicated DMA configuration register layout */
> +#define DDMA_CFG_LOADING BIT(31)
> +#define DDMA_CFG_BUSY BIT(30)
> +#define DDMA_CFG_CONT_MODE BIT(29)
> +#define DDMA_CFG_DEST_NON_SECURE BIT(28)
> +#define DDMA_CFG_DEST_DATA_WIDTH(width) (width << 25)
> +#define DDMA_CFG_DEST_BURST_LENGTH(len) (len << 23)
> +#define DDMA_CFG_DEST_ADDR_MODE(mode) (mode << 21)
> +#define DDMA_CFG_DEST_DRQ_TYPE(type) (type << 16)
> +#define DDMA_CFG_BYTE_COUNT_MODE_REMAIN BIT(15)
> +#define DDMA_CFG_SRC_NON_SECURE BIT(12)
> +#define DDMA_CFG_SRC_DATA_WIDTH(width) (width << 9)
> +#define DDMA_CFG_SRC_BURST_LENGTH(len) (len << 7)
> +#define DDMA_CFG_SRC_ADDR_MODE(mode) (mode << 5)
> +#define DDMA_CFG_SRC_DRQ_TYPE(type) (type << 0)
Parenthesis.
> +
> +/* Dedicated DMA parameter register layout */
> +#define DDMA_PARA_DEST_DATA_BLK_SIZE(n) (n-1 << 24)
> +#define DDMA_PARA_DEST_WAIT_CYCLES(n) (n-1 << 16)
> +#define DDMA_PARA_SRC_DATA_BLK_SIZE(n) (n-1 << 8)
> +#define DDMA_PARA_SRC_WAIT_CYCLES(n) (n-1 << 0)
Since the minus operations has precedence over the shift, I wonder how
this can work.
(plus, parenthesis around n, and spaces around the minus)
> +
> +/** DMA register offsets **/
> +
> +/* Normal DMA register offsets */
> +#define NDMA_CHANNEL_REG_BASE(n) (0x100+n*0x20)
> +#define NDMA_CFG_REG 0x0
> +#define NDMA_SRC_ADDR_REG 0x4
> +#define NDMA_DEST_ADDR_REG 0x8
> +#define NDMA_BYTE_COUNT_REG 0xC
It would be much easier to read if the bits definitions were right by
the register they belong.
> +/* Dedicated DMA register offsets */
> +#define DDMA_CHANNEL_REG_BASE(n) (0x300+n*0x20)
Spaces and parenthesis.
> +#define DDMA_CFG_REG 0x0
> +#define DDMA_SRC_ADDR_REG 0x4
> +#define DDMA_DEST_ADDR_REG 0x8
> +#define DDMA_BYTE_COUNT_REG 0xC
> +#define DDMA_PARA_REG 0x18
> +
> +/* General register offsets */
> +#define DMA_IRQ_ENABLE_REG 0x0
> +#define DMA_IRQ_PENDING_STATUS_REG 0x4
These should probably be defined first.
> +
> +/** DMA Driver **/
> +
> +/* Normal DMA has 8 channels, and Dedicated DMA has another 8, so that's
> + * 16 channels. As for endpoints, there's 29 and 21 respectively. Given
> + * that the Normal DMA endpoints can be used as tx/rx, we need 79 vchans
> + * in total
> + */
> +#define NDMA_NR_MAX_CHANNELS 8
> +#define DDMA_NR_MAX_CHANNELS 8
> +#define DMA_NR_MAX_CHANNELS (NDMA_NR_MAX_CHANNELS + DDMA_NR_MAX_CHANNELS)
> +#define NDMA_NR_MAX_VCHANS (29*2)
I'm counting 29 + 28
> +#define DDMA_NR_MAX_VCHANS 21
> +#define DMA_NR_MAX_VCHANS (NDMA_NR_MAX_VCHANS + DDMA_NR_MAX_VCHANS)
> +
> +struct sun4i_dma_pchan {
> + /* Register base of channel */
> + void __iomem *base;
> + /* vchan currently being serviced */
> + struct sun4i_dma_vchan *vchan;
> + /* Is this a dedicated pchan? */
> + int is_dedicated;
> +};
> +
> +struct sun4i_dma_vchan {
> + struct virt_dma_chan vc;
> + struct dma_slave_config cfg;
> + struct sun4i_dma_pchan *pchan;
> + struct sun4i_dma_promise *processing;
> + struct sun4i_dma_contract *contract;
> + u8 endpoint;
> + int is_dedicated;
> +};
> +
> +struct sun4i_dma_promise {
> + u32 cfg;
> + u32 para;
> + dma_addr_t src;
> + dma_addr_t dst;
> + size_t len;
> + struct list_head list;
> +};
> +
> +/* A contract is a set of promises */
> +struct sun4i_dma_contract {
> + struct virt_dma_desc vd;
> + struct list_head demands;
> + struct list_head completed_demands;
> +};
> +
> +struct sun4i_dma_dev {
> + DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
> + struct tasklet_struct tasklet;
> + struct dma_device slave;
> + struct sun4i_dma_pchan *pchans;
> + struct sun4i_dma_vchan *vchans;
> + void __iomem *base;
> + struct clk *clk;
> + int irq;
> + spinlock_t lock;
> +};
> +
> +static struct sun4i_dma_dev *to_sun4i_dma_dev(struct dma_device *dev)
> +{
> + return container_of(dev, struct sun4i_dma_dev, slave);
> +}
> +
> +static struct sun4i_dma_vchan *to_sun4i_dma_vchan(struct dma_chan *chan)
> +{
> + return container_of(chan, struct sun4i_dma_vchan, vc.chan);
> +}
> +
> +static struct sun4i_dma_contract *to_sun4i_dma_contract(struct virt_dma_desc *vd)
> +{
> + return container_of(vd, struct sun4i_dma_contract, vd);
> +}
> +
> +static struct device *chan2dev(struct dma_chan *chan)
> +{
> + return &chan->dev->device;
> +}
> +
> +static int convert_burst(u32 maxburst)
> +{
> + if (maxburst > 8)
> + maxburst = 8;
returning an error would be better here.
> +
> + /* 1 -> 0, 4 -> 1, 8 -> 2 */
4 seems to be an invalid value on the A20
> + return (maxburst >> 2);
> +}
> +
> +static int convert_buswidth(enum dma_slave_buswidth addr_width)
> +{
> + if (addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES)
> + return -EINVAL;
especially if you're returning one here.
> +
> + /* 8 -> 0, 16 -> 1, 32 -> 2 */
16 seems to be an invalid value on the A20
> + return (addr_width >> 4);
> +}
> +
> +static int sun4i_dma_alloc_chan_resources(struct dma_chan *chan)
> +{
> + return 0;
> +}
> +
> +static void sun4i_dma_free_chan_resources(struct dma_chan *chan)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> +
> + vchan_free_chan_resources(&vchan->vc);
> +}
> +
> +static struct sun4i_dma_pchan *find_and_use_pchan(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_pchan *pchan = NULL, *pchans = priv->pchans;
> + unsigned long flags;
> + int i, max;
> +
> + spin_lock_irqsave(&priv->lock, flags);
> +
> + /* pchans 0-NDMA_NR_MAX_CHANNELS are normal, and
> + * NDMA_NR_MAX_CHANNELS+ are dedicated ones */
> + if (vchan->is_dedicated) {
> + i = NDMA_NR_MAX_CHANNELS;
> + max = DMA_NR_MAX_CHANNELS;
> + } else {
> + i = 0;
> + max = NDMA_NR_MAX_CHANNELS;
> + }
> +
> + for_each_clear_bit_from(i, &priv->pchans_used, max) {
> + pchan = &pchans[i];
> + pchan->vchan = vchan;
> + set_bit(i, priv->pchans_used);
> + break;
> + }
> +
> + spin_unlock_irqrestore(&priv->lock, flags);
> +
> + return pchan;
> +}
> +
> +static void release_pchan(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_pchan *pchan)
> +{
> + unsigned long flags;
> + int nr = pchan - priv->pchans;
> +
> + spin_lock_irqsave(&priv->lock, flags);
> +
> + clear_bit(nr, priv->pchans_used);
> + pchan->vchan = NULL;
> +
> + spin_unlock_irqrestore(&priv->lock, flags);
> +}
> +
> +static void configure_pchan(struct sun4i_dma_pchan *pchan,
> + struct sun4i_dma_promise *d)
> +{
> + if (pchan->is_dedicated) {
> + /* Configure addresses and misc parameters */
> + writel_relaxed(d->src, pchan->base + DDMA_SRC_ADDR_REG);
> + writel_relaxed(d->dst, pchan->base + DDMA_DEST_ADDR_REG);
> + writel_relaxed(d->len, pchan->base + DDMA_BYTE_COUNT_REG);
> + writel_relaxed(d->para, pchan->base + DDMA_PARA_REG);
> +
> + /* We use a writel here because CFG_LOADING may be set,
> + * and it requires that the rest of the configuration
> + * takes place before the engine is started */
You should be ok here.
See http://permalink.gmane.org/gmane.linux.ports.arm.kernel/117640
> + writel(d->cfg, pchan->base + DDMA_CFG_REG);
> + } else {
> + /* Configure addresses and misc parameters */
> + writel_relaxed(d->src, pchan->base + NDMA_SRC_ADDR_REG);
> + writel_relaxed(d->dst, pchan->base + NDMA_DEST_ADDR_REG);
> + writel_relaxed(d->len, pchan->base + NDMA_BYTE_COUNT_REG);
> +
> + /* We use a writel here because CFG_LOADING may be set,
> + * and it requires that the rest of the configuration
> + * takes place before the engine is started */
> + writel(d->cfg, pchan->base + NDMA_CFG_REG);
> + }
> +}
> +
> +static void set_pchan_interrupt(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_pchan *pchan,
> + int half, int end)
> +{
> + u32 reg = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
> + int pchan_number = pchan - priv->pchans;
> +
> + if (half)
> + reg |= BIT(pchan_number*2);
> + else
> + reg &= ~BIT(pchan_number*2);
> +
> + if (end)
> + reg |= BIT(pchan_number*2 + 1);
> + else
> + reg &= ~BIT(pchan_number*2 + 1);
spaces.
> +
> + writel(reg, priv->base + DMA_IRQ_ENABLE_REG);
> +}
> +
> +static int execute_vchan_pending(struct sun4i_dma_dev *priv,
> + struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_promise *promise = NULL;
> + struct sun4i_dma_contract *contract = NULL;
> + struct sun4i_dma_pchan *pchan;
> + struct virt_dma_desc *vd;
> + unsigned long flags;
> + int ret;
> +
> + /* We need a pchan to do anything, so secure one if available */
> + pchan = find_and_use_pchan(priv, vchan);
> + if (!pchan)
> + return -EBUSY;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> +
> + /* Channel endpoints must not be repeated, so if this vchan
> + * has already submitted some work, we can't do anything else
> + */
This is not the proper multiline comment style.
> + if (vchan->processing) {
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "processing something to this endpoint already\n");
> + ret = -EBUSY;
> + goto release_pchan;
> + }
> +
> + do {
> + /* Figure out which contract we're working with today */
> + vd = vchan_next_desc(&vchan->vc);
> + if (!vd) {
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "No pending contract found");
> + ret = 0;
> + goto release_pchan;
> + }
> +
> + contract = to_sun4i_dma_contract(vd);
> + if (list_empty(&contract->demands)) {
> + /* The contract has been completed so mark it as such */
> + list_del(&contract->vd.node);
> + vchan_cookie_complete(&contract->vd);
> + dev_dbg(chan2dev(&vchan->vc.chan),
> + "Empty contract found and marked complete");
> + }
> + } while (list_empty(&contract->demands));
> +
> + /* Now find out what we need to do */
> + promise = list_first_entry(&contract->demands, struct sun4i_dma_promise, list);
> + vchan->processing = promise;
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + /* ... and make it reality */
> + if (promise) {
> + vchan->contract = contract;
> + set_pchan_interrupt(priv, pchan, 0, 1);
> + configure_pchan(pchan, promise);
> + }
> +
> + return 0;
> +
> +release_pchan:
> + release_pchan(priv, pchan);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> + return ret;
> +}
> +
> +/**
> + * Generate a promise, to be used in a normal DMA contract.
> + *
> + * A NDMA promise contains all the information required to program the
> + * normal part of the DMA Engine and get data copied. A non-executed
> + * promise will live in the demands list on a contract. Once it has been
> + * completed, it will be moved to the completed demands list for later freeing.
> + * All linked promises will be freed when the corresponding contract is freed
> + */
> +static struct sun4i_dma_promise *
> +generate_ndma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
> + size_t len, struct dma_slave_config *sconfig)
> +{
> + struct sun4i_dma_promise *promise;
> + int ret;
> +
> + promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
> + if (!promise)
> + return NULL;
> +
> + promise->src = src;
> + promise->dst = dest;
> + promise->len = len;
> + promise->cfg = NDMA_CFG_LOADING | NDMA_CFG_BYTE_COUNT_MODE_REMAIN;
> +
> + /* Source burst */
> + ret = convert_burst(sconfig->src_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_SRC_BURST_LENGTH(ret);
> +
> + /* Destination burst */
> + ret = convert_burst(sconfig->dst_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_DEST_BURST_LENGTH(ret);
> +
> + /* Source bus width */
> + ret = convert_buswidth(sconfig->src_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_SRC_DATA_WIDTH(ret);
> +
> + /* Destination bus width */
> + ret = convert_buswidth(sconfig->dst_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= NDMA_CFG_DEST_DATA_WIDTH(ret);
> +
> + return promise;
> +
> +fail:
> + kfree(promise);
> + return NULL;
> +}
> +
> +/**
> + * Generate a promise, to be used in a dedicated DMA contract.
> + *
> + * A DDMA promise contains all the information required to program the
> + * Dedicated part of the DMA Engine and get data copied. A non-executed
> + * promise will live in the demands list on a contract. Once it has been
> + * completed, it will be moved to the completed demands list for later freeing.
> + * All linked promises will be freed when the corresponding contract is freed
> + */
> +static struct sun4i_dma_promise *
> +generate_ddma_promise(struct dma_chan *chan, dma_addr_t src, dma_addr_t dest,
> + size_t len, struct dma_slave_config *sconfig)
> +{
> + struct sun4i_dma_promise *promise;
> + int ret;
> +
> + promise = kzalloc(sizeof(*promise), GFP_NOWAIT);
> + if (!promise)
> + return NULL;
> +
> + promise->src = src;
> + promise->dst = dest;
> + promise->len = len;
> + promise->cfg = DDMA_CFG_LOADING | DDMA_CFG_BYTE_COUNT_MODE_REMAIN;
> +
> + /* Source burst */
> + ret = convert_burst(sconfig->src_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_SRC_BURST_LENGTH(ret);
> +
> + /* Destination burst */
> + ret = convert_burst(sconfig->dst_maxburst);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_DEST_BURST_LENGTH(ret);
> +
> + /* Source bus width */
> + ret = convert_buswidth(sconfig->src_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_SRC_DATA_WIDTH(ret);
> +
> + /* Destination bus width */
> + ret = convert_buswidth(sconfig->dst_addr_width);
> + if (IS_ERR_VALUE(ret))
> + goto fail;
> + promise->cfg |= DDMA_CFG_DEST_DATA_WIDTH(ret);
> +
> + return promise;
> +
> +fail:
> + kfree(promise);
> + return NULL;
> +}
> +
> +/**
> + * Generate a contract
> + *
> + * Contracts function as DMA descriptors. As our hardware does not support
> + * linked lists, we need to implement SG via software. We use a contract
> + * to hold all the pieces of the request and process them serially one
> + * after another. Each piece is represented as a promise.
> + */
> +static struct sun4i_dma_contract *generate_dma_contract(void)
> +{
> + struct sun4i_dma_contract *contract;
> +
> + contract = kzalloc(sizeof(*contract), GFP_NOWAIT);
> + if (!contract)
> + return NULL;
> +
> + INIT_LIST_HEAD(&contract->demands);
> + INIT_LIST_HEAD(&contract->completed_demands);
> +
> + return contract;
> +}
> +
> +/**
> + * Free a contract and all its associated promises
> + */
> +static void sun4i_dma_free_contract(struct virt_dma_desc *vd)
> +{
> + struct sun4i_dma_contract *contract = to_sun4i_dma_contract(vd);
> + struct sun4i_dma_promise *promise;
> +
> + /* Free all the demands and completed demands */
> + list_for_each_entry(promise, &contract->demands, list) {
> + kfree(promise);
> + }
> +
> + list_for_each_entry(promise, &contract->completed_demands, list) {
> + kfree(promise);
> + }
> +
> + kfree(contract);
> +}
> +
> +static struct dma_async_tx_descriptor *
> +sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
> + dma_addr_t src, size_t len, unsigned long flags)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct dma_slave_config *sconfig = &vchan->cfg;
> + struct sun4i_dma_promise *promise;
> + struct sun4i_dma_contract *contract;
> +
> + contract = generate_dma_contract();
> + if (!contract)
> + return NULL;
> +
> + if (vchan->is_dedicated)
> + promise = generate_ddma_promise(chan, src, dest, len, sconfig);
> + else
> + promise = generate_ndma_promise(chan, src, dest, len, sconfig);
> +
> + if (!promise) {
> + kfree(contract);
> + return NULL;
> + }
> +
> + /* Configure memcpy mode */
> + if (vchan->is_dedicated) {
> + promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_SRC_NON_SECURE |
> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_DEST_NON_SECURE;
> + } else {
> + promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_SRC_NON_SECURE |
> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_DEST_NON_SECURE;
Hmm, are you sure about that non-secure? Depending on the mode the
kernel execute in, wouldn't that change?
> + }
> +
> + /* Fill the contract with our only promise */
> + list_add_tail(&promise->list, &contract->demands);
> +
> + /* And add it to the vchan */
> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
> +}
> +
> +static struct dma_async_tx_descriptor *
> +sun4i_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
> + unsigned int sg_len, enum dma_transfer_direction dir,
> + unsigned long flags, void *context)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct dma_slave_config *sconfig = &vchan->cfg;
> + struct sun4i_dma_promise *promise;
> + struct sun4i_dma_contract *contract;
> + struct scatterlist *sg;
> + dma_addr_t srcaddr, dstaddr;
> + u32 endpoints, para;
> + int i;
> +
> + if (!sgl)
> + return NULL;
> +
> + if (!is_slave_direction(dir)) {
> + dev_err(chan2dev(chan), "Invalid DMA direction\n");
> + return NULL;
> + }
> +
> + contract = generate_dma_contract();
> + if (!contract)
> + return NULL;
> +
> + /* Figure out endpoints */
> + if (vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_LINEAR) |
> + DDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_IO);
> + } else if (!vchan->is_dedicated && dir == DMA_MEM_TO_DEV) {
> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> + NDMA_CFG_DEST_DRQ_TYPE(vchan->endpoint) |
> + NDMA_CFG_DEST_FIXED_ADDR;
> + } else if (vchan->is_dedicated) {
> + endpoints = DDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
> + DDMA_CFG_SRC_ADDR_MODE(DDMA_ADDR_MODE_IO) |
> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> + DDMA_CFG_DEST_ADDR_MODE(DDMA_ADDR_MODE_LINEAR);
> + } else {
> + endpoints = NDMA_CFG_SRC_DRQ_TYPE(vchan->endpoint) |
> + NDMA_CFG_SRC_FIXED_ADDR |
> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM);
> + }
> +
> + for_each_sg(sgl, sg, sg_len, i) {
> + /* Figure out addresses */
> + if (dir == DMA_MEM_TO_DEV) {
> + srcaddr = sg_dma_address(sg);
> + dstaddr = sconfig->dst_addr;
> + para = 0;
> + } else {
> + srcaddr = sconfig->src_addr;
> + dstaddr = sg_dma_address(sg);
> + para = 0x00010001; /* TODO spi magic? */
> + }
> +
> + /* And make a suitable promise */
> + promise = generate_ddma_promise(chan, srcaddr, dstaddr,
> + sg_dma_len(sg), sconfig);
> + if (!promise)
> + return NULL; /* TODO */
> +
> + promise->cfg |= endpoints;
> + promise->para = para;
> +
> + /* Then add it to the contract */
> + list_add_tail(&promise->list, &contract->demands);
> + }
> +
> + /* Once we've got all the promises ready, add the contract
> + * to the pending list on the vchan */
> + return vchan_tx_prep(&vchan->vc, &contract->vd, flags);
> +}
> +
> +static int sun4i_dma_terminate_all(struct sun4i_dma_vchan *vchan)
> +{
> + struct sun4i_dma_pchan *pchan = vchan->pchan;
> + LIST_HEAD(head);
> + unsigned long flags, timeout;
> + u32 d_busy = DDMA_CFG_LOADING | DDMA_CFG_BUSY;
> + u32 n_busy = NDMA_CFG_LOADING;
> +
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vchan_get_all_descriptors(&vchan->vc, &head);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + /* If this vchan is operating, wait until it's no longer busy */
> + if (pchan) {
> + timeout = jiffies + msecs_to_jiffies(2000);
> + if (pchan->is_dedicated) {
> + while (readl(pchan->base + DDMA_CFG_REG) & d_busy)
> + if (time_after(jiffies, timeout))
> + return -ETIMEDOUT;
> + } else {
> + while (readl(pchan->base + NDMA_CFG_REG) & n_busy)
> + if (time_after(jiffies, timeout))
> + return -ETIMEDOUT;
> + }
> + }
> +
> + /* TODO: wait until IRQ handler has run? */
I don't think so. The IRQ handler can be run for different channels,
or this vchan can even no longer have a physical channel associated
(and hence, no link to an interrupt anymore)
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vchan_dma_desc_free_list(&vchan->vc, &head);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + return 0;
> +}
> +
> +static int sun4i_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
> + unsigned long arg)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + int ret = 0;
> +
> + switch (cmd) {
> + case DMA_RESUME:
> + case DMA_PAUSE:
> + ret = -EINVAL;
> + break;
> +
> + case DMA_TERMINATE_ALL:
> + dev_dbg(chan2dev(chan), "Terminating everything on channel\n");
> + ret = sun4i_dma_terminate_all(vchan);
> + break;
> +
> + case DMA_SLAVE_CONFIG:
> + memcpy(&vchan->cfg, (void *)arg, sizeof(vchan->cfg));
> + break;
> +
> + default:
> + ret = -ENXIO;
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static struct dma_chan *sun4i_dma_of_xlate(struct of_phandle_args *dma_spec,
> + struct of_dma *ofdma)
> +{
> + struct sun4i_dma_dev *priv = ofdma->of_dma_data;
> + struct sun4i_dma_vchan *vchan;
> + struct dma_chan *chan;
> + u8 is_dedicated = dma_spec->args[0];
> + u8 endpoint = dma_spec->args[1];
> +
> + /* Check if type is Normal or Dedicated */
> + if (is_dedicated != 0 && is_dedicated != 1)
> + return NULL;
> +
> + /* Make sure the endpoint looks sane */
> + if ((is_dedicated && endpoint >= DDMA_DRQ_TYPE_LIMIT) ||
> + (!is_dedicated && endpoint >= NDMA_DRQ_TYPE_LIMIT))
> + return NULL;
> +
> + chan = dma_get_any_slave_channel(&priv->slave);
> + if (!chan)
> + return NULL;
> +
> + /* Assign the endpoint to the vchan */
> + vchan = to_sun4i_dma_vchan(chan);
> + vchan->is_dedicated = is_dedicated;
> + vchan->endpoint = endpoint;
> +
> + return chan;
> +}
> +
> +static enum dma_status sun4i_dma_tx_status(struct dma_chan *chan,
> + dma_cookie_t cookie,
> + struct dma_tx_state *state)
> +{
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + struct sun4i_dma_pchan *pchan = vchan->pchan;
> + struct sun4i_dma_contract *contract;
> + struct sun4i_dma_promise *promise = NULL;
> + struct virt_dma_desc *vd;
> + unsigned long flags;
> + enum dma_status ret;
> + size_t bytes = 0;
> +
> + ret = dma_cookie_status(chan, cookie, state);
> + if (ret == DMA_COMPLETE)
> + return ret;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> + vd = vchan_find_desc(&vchan->vc, cookie);
> + if (!vd) /* TODO */
TODO?
> + goto exit;
> + contract = to_sun4i_dma_contract(vd);
> +
> + list_for_each_entry_reverse(promise, &contract->demands, list) {
> + bytes += promise->len;
> + }
> +
> + /* The hardware is configured to return the remaining byte
> + * quantity. If possible, replace the first listed element's
> + * full size with the actual remaining amount */
Comment style.
> + if (promise && pchan) {
> + bytes -= promise->len;
> + if (pchan->is_dedicated)
> + bytes += readl(pchan->base + DDMA_BYTE_COUNT_REG);
> + else
> + bytes += readl(pchan->base + NDMA_BYTE_COUNT_REG);
> + }
> +
> +exit:
> +
> + dma_set_residue(state, bytes);
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +
> + return ret;
> +}
> +
> +static void sun4i_dma_issue_pending(struct dma_chan *chan)
> +{
> + struct sun4i_dma_dev *priv = to_sun4i_dma_dev(chan->device);
> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&vchan->vc.lock, flags);
> +
> + /* If there are pending transactions for this vchan, schedule
> + * the tasklet so they are issued soon */
Ditto.
> + if (vchan_issue_pending(&vchan->vc))
> + tasklet_schedule(&priv->tasklet);
> +
> + spin_unlock_irqrestore(&vchan->vc.lock, flags);
> +}
> +
> +static irqreturn_t sun4i_dma_interrupt(int irq, void *dev_id)
> +{
> + struct sun4i_dma_dev *priv = dev_id;
> + struct sun4i_dma_pchan *pchans = priv->pchans, *pchan;
> + struct sun4i_dma_vchan *vchan;
> + struct sun4i_dma_contract *contract;
> + unsigned long pendirq, irqs;
> + int bit;
> +
> + pendirq = readl_relaxed(priv->base + DMA_IRQ_PENDING_STATUS_REG);
> + irqs = readl_relaxed(priv->base + DMA_IRQ_ENABLE_REG);
> +
> + for_each_set_bit(bit, &pendirq, 32) {
> + pchan = &pchans[bit >> 1];
> + vchan = pchan->vchan;
> + contract = vchan->contract;
> +
> + /* Disable the IRQ and free the pchan if it's an end
> + * interrupt (odd bit) */
> + if (bit & 1) {
> + spin_lock(&vchan->vc.lock);
> + /* Move the promise into the completed list now that
> + * we're done with it */
> + list_del(&vchan->processing->list);
> + list_add_tail(&vchan->processing->list, &contract->completed_demands);
> + vchan->processing = NULL;
> + vchan->pchan = NULL;
> + spin_unlock(&vchan->vc.lock);
> +
> + irqs &= ~BIT(bit);
> + release_pchan(priv, pchan);
> + }
> + }
> +
> + writel_relaxed(irqs, priv->base + DMA_IRQ_ENABLE_REG);
> +
> + /* Writing 1 to the pending field will clear the pending interrupt */
> + writel(pendirq, priv->base + DMA_IRQ_PENDING_STATUS_REG);
> +
> + tasklet_schedule(&priv->tasklet);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static void sun4i_dma_tasklet(unsigned long data)
> +{
> + struct sun4i_dma_dev *priv = (void *)data;
> + int i;
> +
> + for (i = 0; i < DMA_NR_MAX_VCHANS; i++)
> + execute_vchan_pending(priv, &priv->vchans[i]);
> +}
> +
> +static int sun4i_dma_probe(struct platform_device *pdev)
> +{
> + struct sun4i_dma_dev *priv;
> + struct resource *res;
> + int i, j, ret;
> +
> + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
> + if (!priv)
> + return -ENOMEM;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + priv->base = devm_ioremap_resource(&pdev->dev, res);
> + if (IS_ERR(priv->base))
> + return PTR_ERR(priv->base);
> +
> + priv->irq = platform_get_irq(pdev, 0);
> + if (priv->irq < 0) {
> + dev_err(&pdev->dev, "Cannot claim IRQ\n");
> + return priv->irq;
> + }
> +
> + priv->clk = devm_clk_get(&pdev->dev, NULL);
> + if (IS_ERR(priv->clk)) {
> + dev_err(&pdev->dev, "No clock specified\n");
> + return PTR_ERR(priv->clk);
> + }
> +
> + platform_set_drvdata(pdev, priv);
> + spin_lock_init(&priv->lock);
> + tasklet_init(&priv->tasklet, sun4i_dma_tasklet, (unsigned long)priv);
> +
> + dma_cap_zero(priv->slave.cap_mask);
> + dma_cap_set(DMA_PRIVATE, priv->slave.cap_mask);
> + dma_cap_set(DMA_MEMCPY, priv->slave.cap_mask);
> + dma_cap_set(DMA_SLAVE, priv->slave.cap_mask);
> +
> + INIT_LIST_HEAD(&priv->slave.channels);
> + priv->slave.device_alloc_chan_resources = sun4i_dma_alloc_chan_resources;
> + priv->slave.device_free_chan_resources = sun4i_dma_free_chan_resources;
> + priv->slave.device_tx_status = sun4i_dma_tx_status;
> + priv->slave.device_issue_pending = sun4i_dma_issue_pending;
> + priv->slave.device_prep_slave_sg = sun4i_dma_prep_slave_sg;
> + priv->slave.device_prep_dma_memcpy = sun4i_dma_prep_dma_memcpy;
> + priv->slave.device_control = sun4i_dma_control;
> + priv->slave.chancnt = DDMA_NR_MAX_VCHANS;
> +
> + priv->slave.dev = &pdev->dev;
> +
> + priv->pchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_CHANNELS,
> + sizeof(struct sun4i_dma_pchan), GFP_KERNEL);
> + priv->vchans = devm_kcalloc(&pdev->dev, DMA_NR_MAX_VCHANS,
> + sizeof(struct sun4i_dma_vchan), GFP_KERNEL);
> + if (!priv->vchans || !priv->pchans)
> + return -ENOMEM;
> +
> + /* [0..NDMA_NR_MAX_CHANNELS) are normal pchans, and
> + * [NDMA_NR_MAX_CHANNELS..DMA_NR_MAX_CHANNELS) are dedicated ones */
Ditto.
> + for (i = 0; i < NDMA_NR_MAX_CHANNELS; i++)
> + priv->pchans[i].base = priv->base + NDMA_CHANNEL_REG_BASE(i);
newline
> + for (j = 0; i < DMA_NR_MAX_CHANNELS; i++, j++) {
> + priv->pchans[i].base = priv->base + DDMA_CHANNEL_REG_BASE(j);
> + priv->pchans[i].is_dedicated = 1;
> + }
> +
> + for (i = 0; i < DMA_NR_MAX_VCHANS; i++) {
> + struct sun4i_dma_vchan *vchan = &priv->vchans[i];
> +
> + spin_lock_init(&vchan->vc.lock);
> + vchan->vc.desc_free = sun4i_dma_free_contract;
> + vchan_init(&vchan->vc, &priv->slave);
> + }
> +
> + ret = clk_prepare_enable(priv->clk);
> + if (ret) {
> + dev_err(&pdev->dev, "Couldn't enable the clock\n");
> + return ret;
> + }
> +
> + ret = devm_request_irq(&pdev->dev, priv->irq, sun4i_dma_interrupt, 0,
> + dev_name(&pdev->dev), priv);
> + if (ret) {
> + dev_err(&pdev->dev, "Cannot request IRQ\n");
> + goto err_clk_disable;
> + }
> +
> + ret = dma_async_device_register(&priv->slave);
> + if (ret) {
> + dev_warn(&pdev->dev, "Failed to register DMA engine device\n");
> + goto err_clk_disable;
> + }
> +
> + ret = of_dma_controller_register(pdev->dev.of_node, sun4i_dma_of_xlate,
> + priv);
> + if (ret) {
> + dev_err(&pdev->dev, "of_dma_controller_register failed\n");
> + goto err_dma_unregister;
> + }
> +
> + dev_dbg(&pdev->dev, "Successfully probed SUN4I_DMA\n");
> +
> + return 0;
> +
> +err_dma_unregister:
> + dma_async_device_unregister(&priv->slave);
> +err_clk_disable:
> + clk_disable_unprepare(priv->clk);
> + return ret;
> +}
> +
> +static int sun4i_dma_remove(struct platform_device *pdev)
> +{
> + struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
> +
> + /* Disable IRQ so the tasklet doesn't schedule any longer, then
> + * kill it */
> + disable_irq(priv->irq);
> + tasklet_kill(&priv->tasklet);
You might still have your tasklet pending to be scheduled. This is not
the proper way to bail out from a tasklet.
See https://lwn.net/Articles/588457/
> + of_dma_controller_free(pdev->dev.of_node);
> + dma_async_device_unregister(&priv->slave);
> +
> + clk_disable_unprepare(priv->clk);
> +
> + return 0;
> +}
> +
> +static struct of_device_id sun4i_dma_match[] = {
> + { .compatible = "allwinner,sun4i-a10-dma" }
The two IPs seem to differ from A10 to A20. Maybe it would be great to
introduce several compatibles here?
And no null entry?
> +};
> +
> +static struct platform_driver sun4i_dma_driver = {
> + .probe = sun4i_dma_probe,
> + .remove = sun4i_dma_remove,
> + .driver = {
> + .name = "sun4i-dma",
> + .of_match_table = sun4i_dma_match,
> + },
> +};
> +
> +module_platform_driver(sun4i_dma_driver);
> +
> +MODULE_DESCRIPTION("Allwinner A10 Dedicated DMA Controller Driver");
> +MODULE_AUTHOR("Emilio L?pez <emilio@elopez.com.ar>");
> +MODULE_LICENSE("GPL");
Thanks for your work!
Maxime
--
Maxime Ripard, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140625/5faa4af3/attachment-0001.sig>
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 03/10] spi: sun4i: add DMA support
2014-06-16 3:50 ` [PATCH 03/10] spi: sun4i: add DMA support Emilio López
@ 2014-06-25 18:48 ` Maxime Ripard
0 siblings, 0 replies; 21+ messages in thread
From: Maxime Ripard @ 2014-06-25 18:48 UTC (permalink / raw)
To: linux-arm-kernel
On Mon, Jun 16, 2014 at 12:50:28AM -0300, Emilio L?pez wrote:
> This patch adds DMA support for 64 byte transfers on the sun4i SPI
> controller. Bigger transfers did not seem to work when tested, and if
> the hardware actually supports those, it will need further
> investigation as to how to issue them correctly.
Since you're only using DMA with 64+ bytes transfer, I'd say your DMA
transfers don't actually work :)
>
> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
> ---
>
> This is a straight adaptation of a similar patch Maxime made for the
> sun6i SPI driver.
Which was not working either ;)
Maxime
--
Maxime Ripard, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140625/cfa2f3f3/attachment-0001.sig>
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing
2014-06-16 3:50 ` [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing Emilio López
@ 2014-06-25 21:22 ` Maxime Ripard
2014-06-25 21:33 ` Emilio López
0 siblings, 1 reply; 21+ messages in thread
From: Maxime Ripard @ 2014-06-25 21:22 UTC (permalink / raw)
To: linux-arm-kernel
On Mon, Jun 16, 2014 at 12:50:34AM -0300, Emilio L?pez wrote:
> ---
> arch/arm/boot/dts/sun4i-a10-cubieboard.dts | 12 ++++++++++++
> arch/arm/boot/dts/sun4i-a10.dtsi | 7 +++++++
> 2 files changed, 19 insertions(+)
>
> diff --git a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
> index 4684cbe..9b8d6b0 100644
> --- a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
> +++ b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
> @@ -61,6 +61,18 @@
> status = "okay";
> };
>
> + spi0: spi at 01c05000 {
> + pinctrl-names = "default";
> + pinctrl-0 = <&spi0_pins_a>;
> + status = "okay";
> +
> + dac0: dh2228 at 2 {
> + compatible = "rohm,dh2228fv";
Nope, this is not going to happen.
It's not even what's connected on this bus.
spidev isn't supposed to be described in DT, because it's just not
hardware related at all.
Maxime
--
Maxime Ripard, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140625/162abfdc/attachment.sig>
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing
2014-06-25 21:22 ` Maxime Ripard
@ 2014-06-25 21:33 ` Emilio López
0 siblings, 0 replies; 21+ messages in thread
From: Emilio López @ 2014-06-25 21:33 UTC (permalink / raw)
To: linux-arm-kernel
Hi Maxime,
El 25/06/14 18:22, Maxime Ripard escribi?:
> On Mon, Jun 16, 2014 at 12:50:34AM -0300, Emilio L?pez wrote:
>> ---
>> arch/arm/boot/dts/sun4i-a10-cubieboard.dts | 12 ++++++++++++
>> arch/arm/boot/dts/sun4i-a10.dtsi | 7 +++++++
>> 2 files changed, 19 insertions(+)
>>
>> diff --git a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
>> index 4684cbe..9b8d6b0 100644
>> --- a/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
>> +++ b/arch/arm/boot/dts/sun4i-a10-cubieboard.dts
>> @@ -61,6 +61,18 @@
>> status = "okay";
>> };
>>
>> + spi0: spi at 01c05000 {
>> + pinctrl-names = "default";
>> + pinctrl-0 = <&spi0_pins_a>;
>> + status = "okay";
>> +
>> + dac0: dh2228 at 2 {
>> + compatible = "rohm,dh2228fv";
>
> Nope, this is not going to happen.
>
> It's not even what's connected on this bus.
>
> spidev isn't supposed to be described in DT, because it's just not
> hardware related at all.
Patches 9 and 10 are not intended to be merged, I am just sending them
to facilitate testing. I suppose I could've been clearer on the cover
letter, sorry.
Cheers,
Emilio
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-25 18:42 ` Maxime Ripard
@ 2014-06-25 22:46 ` Emilio López
2014-06-29 13:23 ` Maxime Ripard
0 siblings, 1 reply; 21+ messages in thread
From: Emilio López @ 2014-06-25 22:46 UTC (permalink / raw)
To: linux-arm-kernel
Hi Maxime,
[I have not replied to every single comment; you can assume I fixed all
the missing parentheses, spaces and comment style issues you pointed out.]
El 25/06/14 15:42, Maxime Ripard escribi?:
> On Mon, Jun 16, 2014 at 12:50:26AM -0300, Emilio L?pez wrote:
>> This patch adds support for the DMA engine present on Allwinner A10,
>> A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
>> and dedicated. The main difference is in the mode of operation;
>> while a single normal channel may be operating at any given time,
>> dedicated channels may operate simultaneously provided there is no
>> overlap of source or destination.
>>
>> Hardware documentation can be found on A10 User Manual (section 12), A13
>> User Manual (section 14) and A20 User Manual (section 1.12)
>>
>> Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
>> ---
(...)
>> diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
>> index ba06d1d..a9ee0c9 100644
>> --- a/drivers/dma/Kconfig
>> +++ b/drivers/dma/Kconfig
>> @@ -361,6 +361,16 @@ config FSL_EDMA
>> multiplexing capability for DMA request sources(slot).
>> This module can be found on Freescale Vybrid and LS-1 SoCs.
>>
>> +config SUN4I_DMA
>> + tristate "Allwinner A10/A10S/A13/A20 DMA support"
>> + depends on ARCH_SUNXI
>
> MACH_SUN4I || MACH_SUN5I || MACH_SUN7I ?
>
> That would probably be a good idea to add COMPILE_TEST to the list
> too.
Yes, now that they're split I'll change it and add COMPILE_TEST.
>> + select DMA_ENGINE
>> + select DMA_OF
>> + select DMA_VIRTUAL_CHANNELS
>> + help
>> + Enable support for the DMA controller present in the sun4i,
>> + sun5i and sun7i Allwinner ARM SoCs.
>> +
>> config DMA_ENGINE
>> bool
>>
>> diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
>> index 5150c82..13a7d5d 100644
>> --- a/drivers/dma/Makefile
>> +++ b/drivers/dma/Makefile
>> @@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
>> obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
>> obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
>> obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
>> +obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
>> diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
>> new file mode 100644
>> index 0000000..0b14b3f
>> --- /dev/null
>> +++ b/drivers/dma/sun4i-dma.c
>> @@ -0,0 +1,1065 @@
>> +/*
>> + * Copyright (C) 2014 Emilio L?pez
>> + * Emilio L?pez <emilio@elopez.com.ar>
>> + *
>> + * This program is free software; you can redistribute it and/or modify
>> + * it under the terms of the GNU General Public License as published by
>> + * the Free Software Foundation; either version 2 of the License, or
>> + * (at your option) any later version.
>> + */
>> +
>> +#include <linux/bitmap.h>
>> +#include <linux/bitops.h>
>> +#include <linux/clk.h>
>> +#include <linux/dmaengine.h>
>> +#include <linux/dmapool.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/module.h>
>> +#include <linux/of_dma.h>
>> +#include <linux/platform_device.h>
>> +#include <linux/slab.h>
>> +#include <linux/spinlock.h>
>> +
>> +#include "virt-dma.h"
>> +
>> +/** General DMA register values **/
>> +
>> +/* DMA source/destination burst length values */
>> +#define DMA_BURST_LENGTH_1 0
>> +#define DMA_BURST_LENGTH_4 1
>> +#define DMA_BURST_LENGTH_8 2
>
> An enum maybe?
>
> You're not using this anywhere though.
>
>> +/* DMA source/destination data width */
>> +#define DMA_DATA_WIDTH_8BIT 0
>> +#define DMA_DATA_WIDTH_16BIT 1
>> +#define DMA_DATA_WIDTH_32BIT 2
>
> And you're not using this either.
As discussed on IRC, I'll drop the unused #defines
(...)
>> +
>> +/* Dedicated DMA parameter register layout */
>> +#define DDMA_PARA_DEST_DATA_BLK_SIZE(n) (n-1 << 24)
>> +#define DDMA_PARA_DEST_WAIT_CYCLES(n) (n-1 << 16)
>> +#define DDMA_PARA_SRC_DATA_BLK_SIZE(n) (n-1 << 8)
>> +#define DDMA_PARA_SRC_WAIT_CYCLES(n) (n-1 << 0)
>
> Since the minus operations has precedence over the shift, I wonder how
> this can work.
>
> (plus, parenthesis around n, and spaces around the minus)
It works because it's not used :)
(...)
>
>> +
>> +/** DMA Driver **/
>> +
>> +/* Normal DMA has 8 channels, and Dedicated DMA has another 8, so that's
>> + * 16 channels. As for endpoints, there's 29 and 21 respectively. Given
>> + * that the Normal DMA endpoints can be used as tx/rx, we need 79 vchans
>> + * in total
>> + */
>> +#define NDMA_NR_MAX_CHANNELS 8
>> +#define DDMA_NR_MAX_CHANNELS 8
>> +#define DMA_NR_MAX_CHANNELS (NDMA_NR_MAX_CHANNELS + DDMA_NR_MAX_CHANNELS)
>> +#define NDMA_NR_MAX_VCHANS (29*2)
>
> I'm counting 29 + 28
I just counted them again, there's 29 on NDMA, and you may want to read
from or write to them, so 29*2. I could drop one to compensate mem2mem
being counted twice though, if we want to be really exact with this.
>> +#define DDMA_NR_MAX_VCHANS 21
>> +#define DMA_NR_MAX_VCHANS (NDMA_NR_MAX_VCHANS + DDMA_NR_MAX_VCHANS)
>> +
>> +struct sun4i_dma_pchan {
>> + /* Register base of channel */
>> + void __iomem *base;
>> + /* vchan currently being serviced */
>> + struct sun4i_dma_vchan *vchan;
>> + /* Is this a dedicated pchan? */
>> + int is_dedicated;
>> +};
>> +
>> +struct sun4i_dma_vchan {
>> + struct virt_dma_chan vc;
>> + struct dma_slave_config cfg;
>> + struct sun4i_dma_pchan *pchan;
>> + struct sun4i_dma_promise *processing;
>> + struct sun4i_dma_contract *contract;
>> + u8 endpoint;
>> + int is_dedicated;
>> +};
>> +
>> +struct sun4i_dma_promise {
>> + u32 cfg;
>> + u32 para;
>> + dma_addr_t src;
>> + dma_addr_t dst;
>> + size_t len;
>> + struct list_head list;
>> +};
>> +
>> +/* A contract is a set of promises */
>> +struct sun4i_dma_contract {
>> + struct virt_dma_desc vd;
>> + struct list_head demands;
>> + struct list_head completed_demands;
>> +};
>> +
>> +struct sun4i_dma_dev {
>> + DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
>> + struct tasklet_struct tasklet;
>> + struct dma_device slave;
>> + struct sun4i_dma_pchan *pchans;
>> + struct sun4i_dma_vchan *vchans;
>> + void __iomem *base;
>> + struct clk *clk;
>> + int irq;
>> + spinlock_t lock;
>> +};
>> +
>> +static struct sun4i_dma_dev *to_sun4i_dma_dev(struct dma_device *dev)
>> +{
>> + return container_of(dev, struct sun4i_dma_dev, slave);
>> +}
>> +
>> +static struct sun4i_dma_vchan *to_sun4i_dma_vchan(struct dma_chan *chan)
>> +{
>> + return container_of(chan, struct sun4i_dma_vchan, vc.chan);
>> +}
>> +
>> +static struct sun4i_dma_contract *to_sun4i_dma_contract(struct virt_dma_desc *vd)
>> +{
>> + return container_of(vd, struct sun4i_dma_contract, vd);
>> +}
>> +
>> +static struct device *chan2dev(struct dma_chan *chan)
>> +{
>> + return &chan->dev->device;
>> +}
>> +
>> +static int convert_burst(u32 maxburst)
>> +{
>> + if (maxburst > 8)
>> + maxburst = 8;
>
> returning an error would be better here.
Ok, I'll do that.
>> +
>> + /* 1 -> 0, 4 -> 1, 8 -> 2 */
>
> 4 seems to be an invalid value on the A20
They define it on the SDK DMA driver though
https://github.com/linux-sunxi/linux-sunxi/blob/sunxi-3.4/arch/arm/mach-sun7i/include/mach/dma.h#L38
And actually use it on the sound codec driver, among other parts
https://github.com/linux-sunxi/linux-sunxi/blob/sunxi-3.4/sound/soc/sunxi/sunxi-codec.c#L1143
So I would prefer to keep it, unless we hear it's actually not supported
from Allwinner themselves.
>
>> + return (maxburst >> 2);
>> +}
>> +
>> +static int convert_buswidth(enum dma_slave_buswidth addr_width)
>> +{
>> + if (addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES)
>> + return -EINVAL;
>
> especially if you're returning one here.
>
>> +
>> + /* 8 -> 0, 16 -> 1, 32 -> 2 */
>
> 16 seems to be an invalid value on the A20
Ditto
>
>> + return (addr_width >> 4);
>> +}
>> +
(...)
>> +static void configure_pchan(struct sun4i_dma_pchan *pchan,
>> + struct sun4i_dma_promise *d)
>> +{
>> + if (pchan->is_dedicated) {
>> + /* Configure addresses and misc parameters */
>> + writel_relaxed(d->src, pchan->base + DDMA_SRC_ADDR_REG);
>> + writel_relaxed(d->dst, pchan->base + DDMA_DEST_ADDR_REG);
>> + writel_relaxed(d->len, pchan->base + DDMA_BYTE_COUNT_REG);
>> + writel_relaxed(d->para, pchan->base + DDMA_PARA_REG);
>> +
>> + /* We use a writel here because CFG_LOADING may be set,
>> + * and it requires that the rest of the configuration
>> + * takes place before the engine is started */
>
> You should be ok here.
>
> See http://permalink.gmane.org/gmane.linux.ports.arm.kernel/117640
>
>> + writel(d->cfg, pchan->base + DDMA_CFG_REG);
Ok, I've switched this to writel_relaxed as well after the explanation
on IRC.
>> + } else {
>> + /* Configure addresses and misc parameters */
>> + writel_relaxed(d->src, pchan->base + NDMA_SRC_ADDR_REG);
>> + writel_relaxed(d->dst, pchan->base + NDMA_DEST_ADDR_REG);
>> + writel_relaxed(d->len, pchan->base + NDMA_BYTE_COUNT_REG);
(...)
>> +static struct dma_async_tx_descriptor *
>> +sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
>> + dma_addr_t src, size_t len, unsigned long flags)
>> +{
>> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
>> + struct dma_slave_config *sconfig = &vchan->cfg;
>> + struct sun4i_dma_promise *promise;
>> + struct sun4i_dma_contract *contract;
>> +
>> + contract = generate_dma_contract();
>> + if (!contract)
>> + return NULL;
>> +
>> + if (vchan->is_dedicated)
>> + promise = generate_ddma_promise(chan, src, dest, len, sconfig);
>> + else
>> + promise = generate_ndma_promise(chan, src, dest, len, sconfig);
>> +
>> + if (!promise) {
>> + kfree(contract);
>> + return NULL;
>> + }
>> +
>> + /* Configure memcpy mode */
>> + if (vchan->is_dedicated) {
>> + promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_SRC_NON_SECURE |
>> + DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
>> + DDMA_CFG_DEST_NON_SECURE;
>> + } else {
>> + promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
>> + NDMA_CFG_SRC_NON_SECURE |
>> + NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
>> + NDMA_CFG_DEST_NON_SECURE;
>
> Hmm, are you sure about that non-secure? Depending on the mode the
> kernel execute in, wouldn't that change?
dmatest seems to be happy either way on my A20. It's not clear to me
from the documentation what this flag does, so I suppose I can just drop
it for now and we can worry about it in the future if it turns out we
need it for something.
>> +static enum dma_status sun4i_dma_tx_status(struct dma_chan *chan,
>> + dma_cookie_t cookie,
>> + struct dma_tx_state *state)
>> +{
>> + struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
>> + struct sun4i_dma_pchan *pchan = vchan->pchan;
>> + struct sun4i_dma_contract *contract;
>> + struct sun4i_dma_promise *promise = NULL;
>> + struct virt_dma_desc *vd;
>> + unsigned long flags;
>> + enum dma_status ret;
>> + size_t bytes = 0;
>> +
>> + ret = dma_cookie_status(chan, cookie, state);
>> + if (ret == DMA_COMPLETE)
>> + return ret;
>> +
>> + spin_lock_irqsave(&vchan->vc.lock, flags);
>> + vd = vchan_find_desc(&vchan->vc, cookie);
>> + if (!vd) /* TODO */
>
> TODO?
I don't actually recall what was left to do here, I should've written a
better comment :|
(...)
>> +static int sun4i_dma_remove(struct platform_device *pdev)
>> +{
>> + struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
>> +
>> + /* Disable IRQ so the tasklet doesn't schedule any longer, then
>> + * kill it */
>> + disable_irq(priv->irq);
>> + tasklet_kill(&priv->tasklet);
>
> You might still have your tasklet pending to be scheduled. This is not
> the proper way to bail out from a tasklet.
>
> See https://lwn.net/Articles/588457/
As we talked on IRC, the tasklet does not reschedule itself, and after
disabling the interrupt, there should be no way for it to get
rescheduled, so I think calling task_kill should be ok.
>> + of_dma_controller_free(pdev->dev.of_node);
>> + dma_async_device_unregister(&priv->slave);
>> +
>> + clk_disable_unprepare(priv->clk);
>> +
>> + return 0;
>> +}
>> +
>> +static struct of_device_id sun4i_dma_match[] = {
>> + { .compatible = "allwinner,sun4i-a10-dma" }
>
> The two IPs seem to differ from A10 to A20. Maybe it would be great to
> introduce several compatibles here?
I'm ok with introducing several compatibles, but as far as I can tell
the IP is the same - I have not needed to add any conditionals depending
on the SoC or anything.
> And no null entry?
Oops. I've fixed that now.
>> +};
>> +
>> +static struct platform_driver sun4i_dma_driver = {
>> + .probe = sun4i_dma_probe,
>> + .remove = sun4i_dma_remove,
>> + .driver = {
>> + .name = "sun4i-dma",
>> + .of_match_table = sun4i_dma_match,
>> + },
>> +};
>> +
>> +module_platform_driver(sun4i_dma_driver);
>> +
>> +MODULE_DESCRIPTION("Allwinner A10 Dedicated DMA Controller Driver");
>> +MODULE_AUTHOR("Emilio L?pez <emilio@elopez.com.ar>");
>> +MODULE_LICENSE("GPL");
>
> Thanks for your work!
And thank you for reviewing it! :)
Cheers,
Emilio
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs
2014-06-25 22:46 ` Emilio López
@ 2014-06-29 13:23 ` Maxime Ripard
0 siblings, 0 replies; 21+ messages in thread
From: Maxime Ripard @ 2014-06-29 13:23 UTC (permalink / raw)
To: linux-arm-kernel
On Wed, Jun 25, 2014 at 07:46:54PM -0300, Emilio L?pez wrote:
> Hi Maxime,
>
> [I have not replied to every single comment; you can assume I fixed
> all the missing parentheses, spaces and comment style issues you
> pointed out.]
>
> El 25/06/14 15:42, Maxime Ripard escribi?:
> >On Mon, Jun 16, 2014 at 12:50:26AM -0300, Emilio L?pez wrote:
> >>This patch adds support for the DMA engine present on Allwinner A10,
> >>A13, A10S and A20 SoCs. This engine has two kinds of channels: normal
> >>and dedicated. The main difference is in the mode of operation;
> >>while a single normal channel may be operating at any given time,
> >>dedicated channels may operate simultaneously provided there is no
> >>overlap of source or destination.
> >>
> >>Hardware documentation can be found on A10 User Manual (section 12), A13
> >>User Manual (section 14) and A20 User Manual (section 1.12)
> >>
> >>Signed-off-by: Emilio L?pez <emilio@elopez.com.ar>
> >>---
> (...)
> >>diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
> >>index ba06d1d..a9ee0c9 100644
> >>--- a/drivers/dma/Kconfig
> >>+++ b/drivers/dma/Kconfig
> >>@@ -361,6 +361,16 @@ config FSL_EDMA
> >> multiplexing capability for DMA request sources(slot).
> >> This module can be found on Freescale Vybrid and LS-1 SoCs.
> >>
> >>+config SUN4I_DMA
> >>+ tristate "Allwinner A10/A10S/A13/A20 DMA support"
> >>+ depends on ARCH_SUNXI
> >
> >MACH_SUN4I || MACH_SUN5I || MACH_SUN7I ?
> >
> >That would probably be a good idea to add COMPILE_TEST to the list
> >too.
>
> Yes, now that they're split I'll change it and add COMPILE_TEST.
If you're using writel_relaxed, then forget about
COMPILE_TEST. *_relaxed accessors are not standard one, and are not
defined on all the architectures.
>
> >>+ select DMA_ENGINE
> >>+ select DMA_OF
> >>+ select DMA_VIRTUAL_CHANNELS
> >>+ help
> >>+ Enable support for the DMA controller present in the sun4i,
> >>+ sun5i and sun7i Allwinner ARM SoCs.
> >>+
> >> config DMA_ENGINE
> >> bool
> >>
> >>diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
> >>index 5150c82..13a7d5d 100644
> >>--- a/drivers/dma/Makefile
> >>+++ b/drivers/dma/Makefile
> >>@@ -46,3 +46,4 @@ obj-$(CONFIG_K3_DMA) += k3dma.o
> >> obj-$(CONFIG_MOXART_DMA) += moxart-dma.o
> >> obj-$(CONFIG_FSL_EDMA) += fsl-edma.o
> >> obj-$(CONFIG_QCOM_BAM_DMA) += qcom_bam_dma.o
> >>+obj-$(CONFIG_SUN4I_DMA) += sun4i-dma.o
> >>diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c
> >>new file mode 100644
> >>index 0000000..0b14b3f
> >>--- /dev/null
> >>+++ b/drivers/dma/sun4i-dma.c
> >>@@ -0,0 +1,1065 @@
> >>+/*
> >>+ * Copyright (C) 2014 Emilio L?pez
> >>+ * Emilio L?pez <emilio@elopez.com.ar>
> >>+ *
> >>+ * This program is free software; you can redistribute it and/or modify
> >>+ * it under the terms of the GNU General Public License as published by
> >>+ * the Free Software Foundation; either version 2 of the License, or
> >>+ * (at your option) any later version.
> >>+ */
> >>+
> >>+#include <linux/bitmap.h>
> >>+#include <linux/bitops.h>
> >>+#include <linux/clk.h>
> >>+#include <linux/dmaengine.h>
> >>+#include <linux/dmapool.h>
> >>+#include <linux/interrupt.h>
> >>+#include <linux/module.h>
> >>+#include <linux/of_dma.h>
> >>+#include <linux/platform_device.h>
> >>+#include <linux/slab.h>
> >>+#include <linux/spinlock.h>
> >>+
> >>+#include "virt-dma.h"
> >>+
> >>+/** General DMA register values **/
> >>+
> >>+/* DMA source/destination burst length values */
> >>+#define DMA_BURST_LENGTH_1 0
> >>+#define DMA_BURST_LENGTH_4 1
> >>+#define DMA_BURST_LENGTH_8 2
> >
> >An enum maybe?
> >
> >You're not using this anywhere though.
> >
> >>+/* DMA source/destination data width */
> >>+#define DMA_DATA_WIDTH_8BIT 0
> >>+#define DMA_DATA_WIDTH_16BIT 1
> >>+#define DMA_DATA_WIDTH_32BIT 2
> >
> >And you're not using this either.
>
> As discussed on IRC, I'll drop the unused #defines
>
> (...)
>
> >>+
> >>+/* Dedicated DMA parameter register layout */
> >>+#define DDMA_PARA_DEST_DATA_BLK_SIZE(n) (n-1 << 24)
> >>+#define DDMA_PARA_DEST_WAIT_CYCLES(n) (n-1 << 16)
> >>+#define DDMA_PARA_SRC_DATA_BLK_SIZE(n) (n-1 << 8)
> >>+#define DDMA_PARA_SRC_WAIT_CYCLES(n) (n-1 << 0)
> >
> >Since the minus operations has precedence over the shift, I wonder how
> >this can work.
> >
> >(plus, parenthesis around n, and spaces around the minus)
>
> It works because it's not used :)
>
> (...)
>
> >
> >>+
> >>+/** DMA Driver **/
> >>+
> >>+/* Normal DMA has 8 channels, and Dedicated DMA has another 8, so that's
> >>+ * 16 channels. As for endpoints, there's 29 and 21 respectively. Given
> >>+ * that the Normal DMA endpoints can be used as tx/rx, we need 79 vchans
> >>+ * in total
> >>+ */
> >>+#define NDMA_NR_MAX_CHANNELS 8
> >>+#define DDMA_NR_MAX_CHANNELS 8
> >>+#define DMA_NR_MAX_CHANNELS (NDMA_NR_MAX_CHANNELS + DDMA_NR_MAX_CHANNELS)
> >>+#define NDMA_NR_MAX_VCHANS (29*2)
> >
> >I'm counting 29 + 28
>
> I just counted them again, there's 29 on NDMA, and you may want to
> read from or write to them, so 29*2. I could drop one to compensate
> mem2mem being counted twice though, if we want to be really exact
> with this.
Ok.
>
> >>+#define DDMA_NR_MAX_VCHANS 21
> >>+#define DMA_NR_MAX_VCHANS (NDMA_NR_MAX_VCHANS + DDMA_NR_MAX_VCHANS)
> >>+
> >>+struct sun4i_dma_pchan {
> >>+ /* Register base of channel */
> >>+ void __iomem *base;
> >>+ /* vchan currently being serviced */
> >>+ struct sun4i_dma_vchan *vchan;
> >>+ /* Is this a dedicated pchan? */
> >>+ int is_dedicated;
> >>+};
> >>+
> >>+struct sun4i_dma_vchan {
> >>+ struct virt_dma_chan vc;
> >>+ struct dma_slave_config cfg;
> >>+ struct sun4i_dma_pchan *pchan;
> >>+ struct sun4i_dma_promise *processing;
> >>+ struct sun4i_dma_contract *contract;
> >>+ u8 endpoint;
> >>+ int is_dedicated;
> >>+};
> >>+
> >>+struct sun4i_dma_promise {
> >>+ u32 cfg;
> >>+ u32 para;
> >>+ dma_addr_t src;
> >>+ dma_addr_t dst;
> >>+ size_t len;
> >>+ struct list_head list;
> >>+};
> >>+
> >>+/* A contract is a set of promises */
> >>+struct sun4i_dma_contract {
> >>+ struct virt_dma_desc vd;
> >>+ struct list_head demands;
> >>+ struct list_head completed_demands;
> >>+};
> >>+
> >>+struct sun4i_dma_dev {
> >>+ DECLARE_BITMAP(pchans_used, DDMA_NR_MAX_CHANNELS);
> >>+ struct tasklet_struct tasklet;
> >>+ struct dma_device slave;
> >>+ struct sun4i_dma_pchan *pchans;
> >>+ struct sun4i_dma_vchan *vchans;
> >>+ void __iomem *base;
> >>+ struct clk *clk;
> >>+ int irq;
> >>+ spinlock_t lock;
> >>+};
> >>+
> >>+static struct sun4i_dma_dev *to_sun4i_dma_dev(struct dma_device *dev)
> >>+{
> >>+ return container_of(dev, struct sun4i_dma_dev, slave);
> >>+}
> >>+
> >>+static struct sun4i_dma_vchan *to_sun4i_dma_vchan(struct dma_chan *chan)
> >>+{
> >>+ return container_of(chan, struct sun4i_dma_vchan, vc.chan);
> >>+}
> >>+
> >>+static struct sun4i_dma_contract *to_sun4i_dma_contract(struct virt_dma_desc *vd)
> >>+{
> >>+ return container_of(vd, struct sun4i_dma_contract, vd);
> >>+}
> >>+
> >>+static struct device *chan2dev(struct dma_chan *chan)
> >>+{
> >>+ return &chan->dev->device;
> >>+}
> >>+
> >>+static int convert_burst(u32 maxburst)
> >>+{
> >>+ if (maxburst > 8)
> >>+ maxburst = 8;
> >
> >returning an error would be better here.
>
> Ok, I'll do that.
>
> >>+
> >>+ /* 1 -> 0, 4 -> 1, 8 -> 2 */
> >
> >4 seems to be an invalid value on the A20
>
> They define it on the SDK DMA driver though
>
> https://github.com/linux-sunxi/linux-sunxi/blob/sunxi-3.4/arch/arm/mach-sun7i/include/mach/dma.h#L38
>
> And actually use it on the sound codec driver, among other parts
>
> https://github.com/linux-sunxi/linux-sunxi/blob/sunxi-3.4/sound/soc/sunxi/sunxi-codec.c#L1143
>
> So I would prefer to keep it, unless we hear it's actually not
> supported from Allwinner themselves.
Hmmm, weird. Ok.
>
> >
> >>+ return (maxburst >> 2);
> >>+}
> >>+
> >>+static int convert_buswidth(enum dma_slave_buswidth addr_width)
> >>+{
> >>+ if (addr_width > DMA_SLAVE_BUSWIDTH_4_BYTES)
> >>+ return -EINVAL;
> >
> >especially if you're returning one here.
> >
> >>+
> >>+ /* 8 -> 0, 16 -> 1, 32 -> 2 */
> >
> >16 seems to be an invalid value on the A20
>
> Ditto
>
> >
> >>+ return (addr_width >> 4);
> >>+}
> >>+
> (...)
> >>+static void configure_pchan(struct sun4i_dma_pchan *pchan,
> >>+ struct sun4i_dma_promise *d)
> >>+{
> >>+ if (pchan->is_dedicated) {
> >>+ /* Configure addresses and misc parameters */
> >>+ writel_relaxed(d->src, pchan->base + DDMA_SRC_ADDR_REG);
> >>+ writel_relaxed(d->dst, pchan->base + DDMA_DEST_ADDR_REG);
> >>+ writel_relaxed(d->len, pchan->base + DDMA_BYTE_COUNT_REG);
> >>+ writel_relaxed(d->para, pchan->base + DDMA_PARA_REG);
> >>+
> >>+ /* We use a writel here because CFG_LOADING may be set,
> >>+ * and it requires that the rest of the configuration
> >>+ * takes place before the engine is started */
> >
> >You should be ok here.
> >
> >See http://permalink.gmane.org/gmane.linux.ports.arm.kernel/117640
> >
> >>+ writel(d->cfg, pchan->base + DDMA_CFG_REG);
>
> Ok, I've switched this to writel_relaxed as well after the
> explanation on IRC.
>
> >>+ } else {
> >>+ /* Configure addresses and misc parameters */
> >>+ writel_relaxed(d->src, pchan->base + NDMA_SRC_ADDR_REG);
> >>+ writel_relaxed(d->dst, pchan->base + NDMA_DEST_ADDR_REG);
> >>+ writel_relaxed(d->len, pchan->base + NDMA_BYTE_COUNT_REG);
> (...)
> >>+static struct dma_async_tx_descriptor *
> >>+sun4i_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
> >>+ dma_addr_t src, size_t len, unsigned long flags)
> >>+{
> >>+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> >>+ struct dma_slave_config *sconfig = &vchan->cfg;
> >>+ struct sun4i_dma_promise *promise;
> >>+ struct sun4i_dma_contract *contract;
> >>+
> >>+ contract = generate_dma_contract();
> >>+ if (!contract)
> >>+ return NULL;
> >>+
> >>+ if (vchan->is_dedicated)
> >>+ promise = generate_ddma_promise(chan, src, dest, len, sconfig);
> >>+ else
> >>+ promise = generate_ndma_promise(chan, src, dest, len, sconfig);
> >>+
> >>+ if (!promise) {
> >>+ kfree(contract);
> >>+ return NULL;
> >>+ }
> >>+
> >>+ /* Configure memcpy mode */
> >>+ if (vchan->is_dedicated) {
> >>+ promise->cfg |= DDMA_CFG_SRC_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> >>+ DDMA_CFG_SRC_NON_SECURE |
> >>+ DDMA_CFG_DEST_DRQ_TYPE(DDMA_DRQ_TYPE_SDRAM) |
> >>+ DDMA_CFG_DEST_NON_SECURE;
> >>+ } else {
> >>+ promise->cfg |= NDMA_CFG_SRC_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> >>+ NDMA_CFG_SRC_NON_SECURE |
> >>+ NDMA_CFG_DEST_DRQ_TYPE(NDMA_DRQ_TYPE_SDRAM) |
> >>+ NDMA_CFG_DEST_NON_SECURE;
> >
> >Hmm, are you sure about that non-secure? Depending on the mode the
> >kernel execute in, wouldn't that change?
>
> dmatest seems to be happy either way on my A20. It's not clear to me
> from the documentation what this flag does, so I suppose I can just
> drop it for now and we can worry about it in the future if it turns
> out we need it for something.
Even when you're starting the kernel itself in secure and !secure?
>
> >>+static enum dma_status sun4i_dma_tx_status(struct dma_chan *chan,
> >>+ dma_cookie_t cookie,
> >>+ struct dma_tx_state *state)
> >>+{
> >>+ struct sun4i_dma_vchan *vchan = to_sun4i_dma_vchan(chan);
> >>+ struct sun4i_dma_pchan *pchan = vchan->pchan;
> >>+ struct sun4i_dma_contract *contract;
> >>+ struct sun4i_dma_promise *promise = NULL;
> >>+ struct virt_dma_desc *vd;
> >>+ unsigned long flags;
> >>+ enum dma_status ret;
> >>+ size_t bytes = 0;
> >>+
> >>+ ret = dma_cookie_status(chan, cookie, state);
> >>+ if (ret == DMA_COMPLETE)
> >>+ return ret;
> >>+
> >>+ spin_lock_irqsave(&vchan->vc.lock, flags);
> >>+ vd = vchan_find_desc(&vchan->vc, cookie);
> >>+ if (!vd) /* TODO */
> >
> >TODO?
>
> I don't actually recall what was left to do here, I should've
> written a better comment :|
>
> (...)
> >>+static int sun4i_dma_remove(struct platform_device *pdev)
> >>+{
> >>+ struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
> >>+
> >>+ /* Disable IRQ so the tasklet doesn't schedule any longer, then
> >>+ * kill it */
> >>+ disable_irq(priv->irq);
> >>+ tasklet_kill(&priv->tasklet);
> >
> >You might still have your tasklet pending to be scheduled. This is not
> >the proper way to bail out from a tasklet.
> >
> >See https://lwn.net/Articles/588457/
>
> As we talked on IRC, the tasklet does not reschedule itself, and
> after disabling the interrupt, there should be no way for it to get
> rescheduled, so I think calling task_kill should be ok.
>
> >>+ of_dma_controller_free(pdev->dev.of_node);
> >>+ dma_async_device_unregister(&priv->slave);
> >>+
> >>+ clk_disable_unprepare(priv->clk);
> >>+
> >>+ return 0;
> >>+}
> >>+
> >>+static struct of_device_id sun4i_dma_match[] = {
> >>+ { .compatible = "allwinner,sun4i-a10-dma" }
> >
> >The two IPs seem to differ from A10 to A20. Maybe it would be great to
> >introduce several compatibles here?
>
> I'm ok with introducing several compatibles, but as far as I can
> tell the IP is the same - I have not needed to add any conditionals
> depending on the SoC or anything.
Ok.
Maxime
--
Maxime Ripard, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140629/881ed126/attachment-0001.sig>
^ permalink raw reply [flat|nested] 21+ messages in thread
end of thread, other threads:[~2014-06-29 13:23 UTC | newest]
Thread overview: 21+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-06-16 3:50 [PATCH 00/10] DMAEngine support for sun4i, sun5i & sun7i Emilio López
2014-06-16 3:50 ` [PATCH 01/10] dma: sun4i: Add support for the DMA engine on sun[457]i SoCs Emilio López
2014-06-21 13:51 ` Chen-Yu Tsai
2014-06-24 13:02 ` Emilio López
2014-06-25 18:42 ` Maxime Ripard
2014-06-25 22:46 ` Emilio López
2014-06-29 13:23 ` Maxime Ripard
2014-06-16 3:50 ` [PATCH 02/10] serial: 8250_dw: support DMA on the OF case Emilio López
2014-06-21 13:56 ` Chen-Yu Tsai
2014-06-24 13:19 ` Emilio López
2014-06-16 3:50 ` [PATCH 03/10] spi: sun4i: add DMA support Emilio López
2014-06-25 18:48 ` Maxime Ripard
2014-06-16 3:50 ` [PATCH 04/10] ARM: sun7i: Add node to represent the DMA controller Emilio López
2014-06-16 3:50 ` [PATCH 05/10] ARM: sun4i: " Emilio López
2014-06-16 3:50 ` [PATCH 06/10] ARM: sun7i: enable DMA on SPI Emilio López
2014-06-16 3:50 ` [PATCH 07/10] ARM: sun4i: " Emilio López
2014-06-16 3:50 ` [PATCH 08/10] ARM: sun7i: add DMA properties to UARTs Emilio López
2014-06-16 3:50 ` [PATCH 09/10] ARM: sun4i: cubieboard: add an SPIdev device for testing Emilio López
2014-06-25 21:22 ` Maxime Ripard
2014-06-25 21:33 ` Emilio López
2014-06-16 3:50 ` [PATCH 10/10] ARM: sun7i: cubietruck: " Emilio López
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.