dmaengine: append hsu DMA driver

The HSU DMA is developed to support High Speed UART controllers found in
particular on Intel MID platforms such as Intel Medfield.

The existing implementation is tighten to the drivers/tty/serial/mfd.c driver
and has a lot of disadvantages. Besides that we would like to get rid of the
old HS UART driver in regarding to extending the 8250 which supports generic
DMAEngine API. That's why the current driver has been developed.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

9 files changed, 840 insertions, 0 deletions

diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index a874b6ec6650..074ffad334a7 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -125,6 +125,8 @@ config FSL_DMA
           EloPlus is on mpc85xx and mpc86xx and Pxxx parts, and the Elo3 is on
           some Txxx and Bxxx parts.
 
+source "drivers/dma/hsu/Kconfig"
+
 config MPC512X_DMA
         tristate "Freescale MPC512x built-in DMA engine support"
         depends on PPC_MPC512x || PPC_MPC831x
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index f915f61ec574..bf4485800c60 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_DMATEST) += dmatest.o
 obj-$(CONFIG_INTEL_IOATDMA) += ioat/
 obj-$(CONFIG_INTEL_IOP_ADMA) += iop-adma.o
 obj-$(CONFIG_FSL_DMA) += fsldma.o
+obj-$(CONFIG_HSU_DMA) += hsu/
 obj-$(CONFIG_MPC512X_DMA) += mpc512x_dma.o
 obj-$(CONFIG_PPC_BESTCOMM) += bestcomm/
 obj-$(CONFIG_MV_XOR) += mv_xor.o
diff --git a/drivers/dma/hsu/Kconfig b/drivers/dma/hsu/Kconfig
new file mode 100644
index 000000000000..7e98eff7440e
--- /dev/null
+++ b/drivers/dma/hsu/Kconfig
@@ -0,0 +1,14 @@
+# DMA engine configuration for hsu
+config HSU_DMA
+        tristate "High Speed UART DMA support"
+        select DMA_ENGINE
+        select DMA_VIRTUAL_CHANNELS
+
+config HSU_DMA_PCI
+        tristate "High Speed UART DMA PCI driver"
+        depends on PCI
+        select HSU_DMA
+        help
+          Support the High Speed UART DMA on the platfroms that
+          enumerate it as a PCI device. For example, Intel Medfield
+          has integrated this HSU DMA controller.
diff --git a/drivers/dma/hsu/Makefile b/drivers/dma/hsu/Makefile
new file mode 100644
index 000000000000..b8f9af032ef1
--- /dev/null
+++ b/drivers/dma/hsu/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_HSU_DMA)           += hsu_dma.o
+hsu_dma-objs            := hsu.o
+
+obj-$(CONFIG_HSU_DMA_PCI)       += hsu_dma_pci.o
+hsu_dma_pci-objs        := pci.o
diff --git a/drivers/dma/hsu/hsu.c b/drivers/dma/hsu/hsu.c
new file mode 100644
index 000000000000..683ba9b62795
--- /dev/null
+++ b/drivers/dma/hsu/hsu.c
@@ -0,0 +1,504 @@
+/*
+ * Core driver for the High Speed UART DMA
+ *
+ * Copyright (C) 2015 Intel Corporation
+ * Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+ *
+ * Partially based on the bits found in drivers/tty/serial/mfd.c.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * DMA channel allocation:
+ * 1. Even number chans are used for DMA Read (UART TX), odd chans for DMA
+ *    Write (UART RX).
+ * 2. 0/1 channel are assigned to port 0, 2/3 chan to port 1, 4/5 chan to
+ *    port 3, and so on.
+ */
+
+#include <linux/delay.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "hsu.h"
+
+#define HSU_DMA_BUSWIDTHS                               \
+        BIT(DMA_SLAVE_BUSWIDTH_UNDEFINED)       |       \
+        BIT(DMA_SLAVE_BUSWIDTH_1_BYTE)          |       \
+        BIT(DMA_SLAVE_BUSWIDTH_2_BYTES)         |       \
+        BIT(DMA_SLAVE_BUSWIDTH_3_BYTES)         |       \
+        BIT(DMA_SLAVE_BUSWIDTH_4_BYTES)         |       \
+        BIT(DMA_SLAVE_BUSWIDTH_8_BYTES)         |       \
+        BIT(DMA_SLAVE_BUSWIDTH_16_BYTES)
+
+static inline void hsu_chan_disable(struct hsu_dma_chan *hsuc)
+{
+        hsu_chan_writel(hsuc, HSU_CH_CR, 0);
+}
+
+static inline void hsu_chan_enable(struct hsu_dma_chan *hsuc)
+{
+        u32 cr = HSU_CH_CR_CHA;
+
+        if (hsuc->direction == DMA_MEM_TO_DEV)
+                cr &= ~HSU_CH_CR_CHD;
+        else if (hsuc->direction == DMA_DEV_TO_MEM)
+                cr |= HSU_CH_CR_CHD;
+
+        hsu_chan_writel(hsuc, HSU_CH_CR, cr);
+}
+
+static void hsu_dma_chan_start(struct hsu_dma_chan *hsuc)
+{
+        struct dma_slave_config *config = &hsuc->config;
+        struct hsu_dma_desc *desc = hsuc->desc;
+        u32 bsr, mtsr;
+        u32 dcr = HSU_CH_DCR_CHSOE | HSU_CH_DCR_CHEI;
+        unsigned int i, count;
+
+        if (hsuc->direction == DMA_MEM_TO_DEV) {
+                bsr = config->dst_maxburst;
+                mtsr = config->dst_addr_width;
+        } else if (hsuc->direction == DMA_DEV_TO_MEM) {
+                bsr = config->src_maxburst;
+                mtsr = config->src_addr_width;
+        } else {
+                /* Not supported direction */
+                return;
+        }
+
+        hsu_chan_disable(hsuc);
+
+        hsu_chan_writel(hsuc, HSU_CH_DCR, 0);
+        hsu_chan_writel(hsuc, HSU_CH_BSR, bsr);
+        hsu_chan_writel(hsuc, HSU_CH_MTSR, mtsr);
+
+        /* Set descriptors */
+        count = (desc->nents - desc->active) % HSU_DMA_CHAN_NR_DESC;
+        for (i = 0; i < count; i++) {
+                hsu_chan_writel(hsuc, HSU_CH_DxSAR(i), desc->sg[i].addr);
+                hsu_chan_writel(hsuc, HSU_CH_DxTSR(i), desc->sg[i].len);
+
+                /* Prepare value for DCR */
+                dcr |= HSU_CH_DCR_DESCA(i);
+                dcr |= HSU_CH_DCR_CHTOI(i);     /* timeout bit, see HSU Errata 1 */
+
+                desc->active++;
+        }
+        /* Only for the last descriptor in the chain */
+        dcr |= HSU_CH_DCR_CHSOD(count - 1);
+        dcr |= HSU_CH_DCR_CHDI(count - 1);
+
+        hsu_chan_writel(hsuc, HSU_CH_DCR, dcr);
+
+        hsu_chan_enable(hsuc);
+}
+
+static void hsu_dma_stop_channel(struct hsu_dma_chan *hsuc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        hsu_chan_disable(hsuc);
+        hsu_chan_writel(hsuc, HSU_CH_DCR, 0);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+}
+
+static void hsu_dma_start_channel(struct hsu_dma_chan *hsuc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        hsu_dma_chan_start(hsuc);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+}
+
+static void hsu_dma_start_transfer(struct hsu_dma_chan *hsuc)
+{
+        struct virt_dma_desc *vdesc;
+
+        /* Get the next descriptor */
+        vdesc = vchan_next_desc(&hsuc->vchan);
+        if (!vdesc) {
+                hsuc->desc = NULL;
+                return;
+        }
+
+        list_del(&vdesc->node);
+        hsuc->desc = to_hsu_dma_desc(vdesc);
+
+        /* Start the channel with a new descriptor */
+        hsu_dma_start_channel(hsuc);
+}
+
+static u32 hsu_dma_chan_get_sr(struct hsu_dma_chan *hsuc)
+{
+        unsigned long flags;
+        u32 sr;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        sr = hsu_chan_readl(hsuc, HSU_CH_SR);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+
+        return sr;
+}
+
+irqreturn_t hsu_dma_irq(struct hsu_dma_chip *chip, unsigned short nr)
+{
+        struct hsu_dma_chan *hsuc;
+        struct hsu_dma_desc *desc;
+        unsigned long flags;
+        u32 sr;
+
+        /* Sanity check */
+        if (nr >= chip->pdata->nr_channels)
+                return IRQ_NONE;
+
+        hsuc = &chip->hsu->chan[nr];
+
+        /*
+         * No matter what situation, need read clear the IRQ status
+         * There is a bug, see Errata 5, HSD 2900918
+         */
+        sr = hsu_dma_chan_get_sr(hsuc);
+        if (!sr)
+                return IRQ_NONE;
+
+        /* Timeout IRQ, need wait some time, see Errata 2 */
+        if (hsuc->direction == DMA_DEV_TO_MEM && (sr & HSU_CH_SR_DESCTO_ANY))
+                udelay(2);
+
+        sr &= ~HSU_CH_SR_DESCTO_ANY;
+        if (!sr)
+                return IRQ_HANDLED;
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+        desc = hsuc->desc;
+        if (desc) {
+                if (sr & HSU_CH_SR_CHE) {
+                        desc->status = DMA_ERROR;
+                } else if (desc->active < desc->nents) {
+                        hsu_dma_start_channel(hsuc);
+                } else {
+                        vchan_cookie_complete(&desc->vdesc);
+                        desc->status = DMA_COMPLETE;
+                        hsu_dma_start_transfer(hsuc);
+                }
+        }
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+
+        return IRQ_HANDLED;
+}
+EXPORT_SYMBOL_GPL(hsu_dma_irq);
+
+static struct hsu_dma_desc *hsu_dma_alloc_desc(unsigned int nents)
+{
+        struct hsu_dma_desc *desc;
+
+        desc = kzalloc(sizeof(*desc), GFP_ATOMIC);
+        if (!desc)
+                return NULL;
+
+        desc->sg = kcalloc(nents, sizeof(*desc->sg), GFP_ATOMIC);
+        if (!desc->sg) {
+                kfree(desc);
+                return NULL;
+        }
+
+        return desc;
+}
+
+static void hsu_dma_desc_free(struct virt_dma_desc *vdesc)
+{
+        struct hsu_dma_desc *desc = to_hsu_dma_desc(vdesc);
+
+        kfree(desc->sg);
+        kfree(desc);
+}
+
+static struct dma_async_tx_descriptor *hsu_dma_prep_slave_sg(
+                struct dma_chan *chan, struct scatterlist *sgl,
+                unsigned int sg_len, enum dma_transfer_direction direction,
+                unsigned long flags, void *context)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        struct hsu_dma_desc *desc;
+        struct scatterlist *sg;
+        unsigned int i;
+
+        desc = hsu_dma_alloc_desc(sg_len);
+        if (!desc)
+                return NULL;
+
+        for_each_sg(sgl, sg, sg_len, i) {
+                desc->sg[i].addr = sg_dma_address(sg);
+                desc->sg[i].len = sg_dma_len(sg);
+        }
+
+        desc->nents = sg_len;
+        desc->direction = direction;
+        desc->active = 0;
+        desc->status = DMA_IN_PROGRESS;
+
+        return vchan_tx_prep(&hsuc->vchan, &desc->vdesc, flags);
+}
+
+static void hsu_dma_issue_pending(struct dma_chan *chan)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+        if (vchan_issue_pending(&hsuc->vchan) && !hsuc->desc)
+                hsu_dma_start_transfer(hsuc);
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+}
+
+static size_t hsu_dma_desc_size(struct hsu_dma_desc *desc)
+{
+        size_t bytes = 0;
+        unsigned int i;
+
+        for (i = desc->active; i < desc->nents; i++)
+                bytes += desc->sg[i].len;
+
+        return bytes;
+}
+
+static size_t hsu_dma_active_desc_size(struct hsu_dma_chan *hsuc)
+{
+        struct hsu_dma_desc *desc = hsuc->desc;
+        size_t bytes = hsu_dma_desc_size(desc);
+        int i;
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        i = desc->active % HSU_DMA_CHAN_NR_DESC;
+        do {
+                bytes += hsu_chan_readl(hsuc, HSU_CH_DxTSR(i));
+        } while (--i >= 0);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+
+        return bytes;
+}
+
+static enum dma_status hsu_dma_tx_status(struct dma_chan *chan,
+        dma_cookie_t cookie, struct dma_tx_state *state)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        struct virt_dma_desc *vdesc;
+        enum dma_status status;
+        size_t bytes;
+        unsigned long flags;
+
+        status = dma_cookie_status(chan, cookie, state);
+        if (status == DMA_COMPLETE)
+                return status;
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+        vdesc = vchan_find_desc(&hsuc->vchan, cookie);
+        if (hsuc->desc && cookie == hsuc->desc->vdesc.tx.cookie) {
+                bytes = hsu_dma_active_desc_size(hsuc);
+                dma_set_residue(state, bytes);
+                status = hsuc->desc->status;
+        } else if (vdesc) {
+                bytes = hsu_dma_desc_size(to_hsu_dma_desc(vdesc));
+                dma_set_residue(state, bytes);
+        }
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+
+        return status;
+}
+
+static int hsu_dma_slave_config(struct dma_chan *chan,
+                                struct dma_slave_config *config)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+
+        /* Check if chan will be configured for slave transfers */
+        if (!is_slave_direction(config->direction))
+                return -EINVAL;
+
+        memcpy(&hsuc->config, config, sizeof(hsuc->config));
+
+        return 0;
+}
+
+static void hsu_dma_chan_deactivate(struct hsu_dma_chan *hsuc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        hsu_chan_disable(hsuc);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+}
+
+static void hsu_dma_chan_activate(struct hsu_dma_chan *hsuc)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->lock, flags);
+        hsu_chan_enable(hsuc);
+        spin_unlock_irqrestore(&hsuc->lock, flags);
+}
+
+static int hsu_dma_pause(struct dma_chan *chan)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+        if (hsuc->desc && hsuc->desc->status == DMA_IN_PROGRESS) {
+                hsu_dma_chan_deactivate(hsuc);
+                hsuc->desc->status = DMA_PAUSED;
+        }
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+
+        return 0;
+}
+
+static int hsu_dma_resume(struct dma_chan *chan)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+        if (hsuc->desc && hsuc->desc->status == DMA_PAUSED) {
+                hsuc->desc->status = DMA_IN_PROGRESS;
+                hsu_dma_chan_activate(hsuc);
+        }
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+
+        return 0;
+}
+
+static int hsu_dma_terminate_all(struct dma_chan *chan)
+{
+        struct hsu_dma_chan *hsuc = to_hsu_dma_chan(chan);
+        unsigned long flags;
+        LIST_HEAD(head);
+
+        spin_lock_irqsave(&hsuc->vchan.lock, flags);
+
+        hsu_dma_stop_channel(hsuc);
+        hsuc->desc = NULL;
+
+        vchan_get_all_descriptors(&hsuc->vchan, &head);
+        spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
+        vchan_dma_desc_free_list(&hsuc->vchan, &head);
+
+        return 0;
+}
+
+static int hsu_dma_alloc_chan_resources(struct dma_chan *chan)
+{
+        return 0;
+}
+
+static void hsu_dma_free_chan_resources(struct dma_chan *chan)
+{
+        vchan_free_chan_resources(to_virt_chan(chan));
+}
+
+int hsu_dma_probe(struct hsu_dma_chip *chip)
+{
+        struct hsu_dma *hsu;
+        struct hsu_dma_platform_data *pdata = chip->pdata;
+        void __iomem *addr = chip->regs + chip->offset;
+        unsigned short i;
+        int ret;
+
+        hsu = devm_kzalloc(chip->dev, sizeof(*hsu), GFP_KERNEL);
+        if (!hsu)
+                return -ENOMEM;
+
+        chip->hsu = hsu;
+
+        if (!pdata) {
+                pdata = devm_kzalloc(chip->dev, sizeof(*pdata), GFP_KERNEL);
+                if (!pdata)
+                        return -ENOMEM;
+
+                chip->pdata = pdata;
+
+                /* Guess nr_channels from the IO space length */
+                pdata->nr_channels = (chip->length - chip->offset) /
+                                     HSU_DMA_CHAN_LENGTH;
+        }
+
+        hsu->chan = devm_kcalloc(chip->dev, pdata->nr_channels,
+                                 sizeof(*hsu->chan), GFP_KERNEL);
+        if (!hsu->chan)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&hsu->dma.channels);
+        for (i = 0; i < pdata->nr_channels; i++) {
+                struct hsu_dma_chan *hsuc = &hsu->chan[i];
+
+                hsuc->vchan.desc_free = hsu_dma_desc_free;
+                vchan_init(&hsuc->vchan, &hsu->dma);
+
+                hsuc->direction = (i & 0x1) ? DMA_DEV_TO_MEM : DMA_MEM_TO_DEV;
+                hsuc->reg = addr + i * HSU_DMA_CHAN_LENGTH;
+
+                spin_lock_init(&hsuc->lock);
+        }
+
+        dma_cap_set(DMA_SLAVE, hsu->dma.cap_mask);
+        dma_cap_set(DMA_PRIVATE, hsu->dma.cap_mask);
+
+        hsu->dma.device_alloc_chan_resources = hsu_dma_alloc_chan_resources;
+        hsu->dma.device_free_chan_resources = hsu_dma_free_chan_resources;
+
+        hsu->dma.device_prep_slave_sg = hsu_dma_prep_slave_sg;
+
+        hsu->dma.device_issue_pending = hsu_dma_issue_pending;
+        hsu->dma.device_tx_status = hsu_dma_tx_status;
+
+        hsu->dma.device_config = hsu_dma_slave_config;
+        hsu->dma.device_pause = hsu_dma_pause;
+        hsu->dma.device_resume = hsu_dma_resume;
+        hsu->dma.device_terminate_all = hsu_dma_terminate_all;
+
+        hsu->dma.src_addr_widths = HSU_DMA_BUSWIDTHS;
+        hsu->dma.dst_addr_widths = HSU_DMA_BUSWIDTHS;
+        hsu->dma.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
+        hsu->dma.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
+
+        hsu->dma.dev = chip->dev;
+
+        ret = dma_async_device_register(&hsu->dma);
+        if (ret)
+                return ret;
+
+        dev_info(chip->dev, "Found HSU DMA, %d channels\n", pdata->nr_channels);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(hsu_dma_probe);
+
+int hsu_dma_remove(struct hsu_dma_chip *chip)
+{
+        struct hsu_dma *hsu = chip->hsu;
+        unsigned short i;
+
+        dma_async_device_unregister(&hsu->dma);
+
+        for (i = 0; i < chip->pdata->nr_channels; i++) {
+                struct hsu_dma_chan *hsuc = &hsu->chan[i];
+
+                tasklet_kill(&hsuc->vchan.task);
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(hsu_dma_remove);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("High Speed UART DMA core driver");
+MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
diff --git a/drivers/dma/hsu/hsu.h b/drivers/dma/hsu/hsu.h
new file mode 100644
index 000000000000..0275233cf550
--- /dev/null
+++ b/drivers/dma/hsu/hsu.h
@@ -0,0 +1,118 @@
+/*
+ * Driver for the High Speed UART DMA
+ *
+ * Copyright (C) 2015 Intel Corporation
+ *
+ * Partially based on the bits found in drivers/tty/serial/mfd.c.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __DMA_HSU_H__
+#define __DMA_HSU_H__
+
+#include <linux/spinlock.h>
+#include <linux/dma/hsu.h>
+
+#include "../virt-dma.h"
+
+#define HSU_CH_SR               0x00                    /* channel status */
+#define HSU_CH_CR               0x04                    /* channel control */
+#define HSU_CH_DCR              0x08                    /* descriptor control */
+#define HSU_CH_BSR              0x10                    /* FIFO buffer size */
+#define HSU_CH_MTSR             0x14                    /* minimum transfer size */
+#define HSU_CH_DxSAR(x)         (0x20 + 8 * (x))        /* desc start addr */
+#define HSU_CH_DxTSR(x)         (0x24 + 8 * (x))        /* desc transfer size */
+#define HSU_CH_D0SAR            0x20                    /* desc 0 start addr */
+#define HSU_CH_D0TSR            0x24                    /* desc 0 transfer size */
+#define HSU_CH_D1SAR            0x28
+#define HSU_CH_D1TSR            0x2c
+#define HSU_CH_D2SAR            0x30
+#define HSU_CH_D2TSR            0x34
+#define HSU_CH_D3SAR            0x38
+#define HSU_CH_D3TSR            0x3c
+
+#define HSU_DMA_CHAN_NR_DESC    4
+#define HSU_DMA_CHAN_LENGTH     0x40
+
+/* Bits in HSU_CH_SR */
+#define HSU_CH_SR_DESCTO(x)     BIT(8 + (x))
+#define HSU_CH_SR_DESCTO_ANY    (BIT(11) | BIT(10) | BIT(9) | BIT(8))
+#define HSU_CH_SR_CHE           BIT(15)
+
+/* Bits in HSU_CH_CR */
+#define HSU_CH_CR_CHA           BIT(0)
+#define HSU_CH_CR_CHD           BIT(1)
+
+/* Bits in HSU_CH_DCR */
+#define HSU_CH_DCR_DESCA(x)     BIT(0 + (x))
+#define HSU_CH_DCR_CHSOD(x)     BIT(8 + (x))
+#define HSU_CH_DCR_CHSOTO       BIT(14)
+#define HSU_CH_DCR_CHSOE        BIT(15)
+#define HSU_CH_DCR_CHDI(x)      BIT(16 + (x))
+#define HSU_CH_DCR_CHEI         BIT(23)
+#define HSU_CH_DCR_CHTOI(x)     BIT(24 + (x))
+
+struct hsu_dma_sg {
+        dma_addr_t addr;
+        unsigned int len;
+};
+
+struct hsu_dma_desc {
+        struct virt_dma_desc vdesc;
+        enum dma_transfer_direction direction;
+        struct hsu_dma_sg *sg;
+        unsigned int nents;
+        unsigned int active;
+        enum dma_status status;
+};
+
+static inline struct hsu_dma_desc *to_hsu_dma_desc(struct virt_dma_desc *vdesc)
+{
+        return container_of(vdesc, struct hsu_dma_desc, vdesc);
+}
+
+struct hsu_dma_chan {
+        struct virt_dma_chan vchan;
+
+        void __iomem *reg;
+        spinlock_t lock;
+
+        /* hardware configuration */
+        enum dma_transfer_direction direction;
+        struct dma_slave_config config;
+
+        struct hsu_dma_desc *desc;
+};
+
+static inline struct hsu_dma_chan *to_hsu_dma_chan(struct dma_chan *chan)
+{
+        return container_of(chan, struct hsu_dma_chan, vchan.chan);
+}
+
+static inline u32 hsu_chan_readl(struct hsu_dma_chan *hsuc, int offset)
+{
+        return readl(hsuc->reg + offset);
+}
+
+static inline void hsu_chan_writel(struct hsu_dma_chan *hsuc, int offset,
+                                   u32 value)
+{
+        writel(value, hsuc->reg + offset);
+}
+
+struct hsu_dma {
+        struct dma_device               dma;
+
+        /* channels */
+        struct hsu_dma_chan             *chan;
+};
+
+static inline struct hsu_dma *to_hsu_dma(struct dma_device *ddev)
+{
+        return container_of(ddev, struct hsu_dma, dma);
+}
+
+#endif /* __DMA_HSU_H__ */
diff --git a/drivers/dma/hsu/pci.c b/drivers/dma/hsu/pci.c
new file mode 100644
index 000000000000..563b4685d766
--- /dev/null
+++ b/drivers/dma/hsu/pci.c
@@ -0,0 +1,123 @@
+/*
+ * PCI driver for the High Speed UART DMA
+ *
+ * Copyright (C) 2015 Intel Corporation
+ * Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+ *
+ * Partially based on the bits found in drivers/tty/serial/mfd.c.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/bitops.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+
+#include "hsu.h"
+
+#define HSU_PCI_DMASR           0x00
+#define HSU_PCI_DMAISR          0x04
+
+#define HSU_PCI_CHAN_OFFSET     0x100
+
+static irqreturn_t hsu_pci_irq(int irq, void *dev)
+{
+        struct hsu_dma_chip *chip = dev;
+        u32 dmaisr;
+        unsigned short i;
+        irqreturn_t ret = IRQ_NONE;
+
+        dmaisr = readl(chip->regs + HSU_PCI_DMAISR);
+        for (i = 0; i < chip->pdata->nr_channels; i++) {
+                if (dmaisr & 0x1)
+                        ret |= hsu_dma_irq(chip, i);
+                dmaisr >>= 1;
+        }
+
+        return ret;
+}
+
+static int hsu_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct hsu_dma_chip *chip;
+        int ret;
+
+        ret = pcim_enable_device(pdev);
+        if (ret)
+                return ret;
+
+        ret = pcim_iomap_regions(pdev, BIT(0), pci_name(pdev));
+        if (ret) {
+                dev_err(&pdev->dev, "I/O memory remapping failed\n");
+                return ret;
+        }
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
+
+        ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
+
+        chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        chip->dev = &pdev->dev;
+        chip->regs = pcim_iomap_table(pdev)[0];
+        chip->length = pci_resource_len(pdev, 0);
+        chip->offset = HSU_PCI_CHAN_OFFSET;
+        chip->irq = pdev->irq;
+
+        pci_enable_msi(pdev);
+
+        ret = hsu_dma_probe(chip);
+        if (ret)
+                return ret;
+
+        ret = request_irq(chip->irq, hsu_pci_irq, 0, "hsu_dma_pci", chip);
+        if (ret)
+                goto err_register_irq;
+
+        pci_set_drvdata(pdev, chip);
+
+        return 0;
+
+err_register_irq:
+        hsu_dma_remove(chip);
+        return ret;
+}
+
+static void hsu_pci_remove(struct pci_dev *pdev)
+{
+        struct hsu_dma_chip *chip = pci_get_drvdata(pdev);
+
+        free_irq(chip->irq, chip);
+        hsu_dma_remove(chip);
+}
+
+static const struct pci_device_id hsu_pci_id_table[] = {
+        { PCI_VDEVICE(INTEL, 0x081e), 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, hsu_pci_id_table);
+
+static struct pci_driver hsu_pci_driver = {
+        .name           = "hsu_dma_pci",
+        .id_table       = hsu_pci_id_table,
+        .probe          = hsu_pci_probe,
+        .remove         = hsu_pci_remove,
+};
+
+module_pci_driver(hsu_pci_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("High Speed UART DMA PCI driver");
+MODULE_AUTHOR("Andy Shevchenko <andriy.shevchenko@linux.intel.com>");
diff --git a/include/linux/dma/hsu.h b/include/linux/dma/hsu.h
new file mode 100644
index 000000000000..234393a6997b
--- /dev/null
+++ b/include/linux/dma/hsu.h
@@ -0,0 +1,48 @@
+/*
+ * Driver for the High Speed UART DMA
+ *
+ * Copyright (C) 2015 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _DMA_HSU_H
+#define _DMA_HSU_H
+
+#include <linux/device.h>
+#include <linux/interrupt.h>
+
+#include <linux/platform_data/dma-hsu.h>
+
+struct hsu_dma;
+
+/**
+ * struct hsu_dma_chip - representation of HSU DMA hardware
+ * @dev:                 struct device of the DMA controller
+ * @irq:                 irq line
+ * @regs:                memory mapped I/O space
+ * @length:              I/O space length
+ * @offset:              offset of the I/O space where registers are located
+ * @hsu:                 struct hsu_dma that is filed by ->probe()
+ * @pdata:               platform data for the DMA controller if provided
+ */
+struct hsu_dma_chip {
+        struct device                   *dev;
+        int                             irq;
+        void __iomem                    *regs;
+        unsigned int                    length;
+        unsigned int                    offset;
+        struct hsu_dma                  *hsu;
+        struct hsu_dma_platform_data    *pdata;
+};
+
+/* Export to the internal users */
+irqreturn_t hsu_dma_irq(struct hsu_dma_chip *chip, unsigned short nr);
+
+/* Export to the platform drivers */
+int hsu_dma_probe(struct hsu_dma_chip *chip);
+int hsu_dma_remove(struct hsu_dma_chip *chip);
+
+#endif /* _DMA_HSU_H */
diff --git a/include/linux/platform_data/dma-hsu.h b/include/linux/platform_data/dma-hsu.h
new file mode 100644
index 000000000000..8a1f6a4920b2
--- /dev/null
+++ b/include/linux/platform_data/dma-hsu.h
@@ -0,0 +1,25 @@
+/*
+ * Driver for the High Speed UART DMA
+ *
+ * Copyright (C) 2015 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _PLATFORM_DATA_DMA_HSU_H
+#define _PLATFORM_DATA_DMA_HSU_H
+
+#include <linux/device.h>
+
+struct hsu_dma_slave {
+        struct device   *dma_dev;
+        int             chan_id;
+};
+
+struct hsu_dma_platform_data {
+        unsigned short  nr_channels;
+};
+
+#endif /* _PLATFORM_DATA_DMA_HSU_H */