5 files changed, 477 insertions, 0 deletions

diff --git a/Documentation/acpi/enumeration.txt b/Documentation/acpi/enumeration.txt
index 94a656131885..2874c904f3ef 100644
--- a/Documentation/acpi/enumeration.txt
+++ b/Documentation/acpi/enumeration.txt
@@ -66,6 +66,83 @@ the ACPI device explicitly to acpi_platform_device_ids list defined in
 drivers/acpi/acpi_platform.c. This limitation is only for the platform
 devices, SPI and I2C devices are created automatically as described below.
 
+DMA support
+~~~~~~~~~~~
+DMA controllers enumerated via ACPI should be registered in the system to
+provide generic access to their resources. For example, a driver that would
+like to be accessible to slave devices via generic API call
+dma_request_slave_channel() must register itself at the end of the probe
+function like this:
+
+        err = devm_acpi_dma_controller_register(dev, xlate_func, dw);
+        /* Handle the error if it's not a case of !CONFIG_ACPI */
+
+and implement custom xlate function if needed (usually acpi_dma_simple_xlate()
+is enough) which converts the FixedDMA resource provided by struct
+acpi_dma_spec into the corresponding DMA channel. A piece of code for that case
+could look like:
+
+        #ifdef CONFIG_ACPI
+        struct filter_args {
+                /* Provide necessary information for the filter_func */
+                ...
+        };
+
+        static bool filter_func(struct dma_chan *chan, void *param)
+        {
+                /* Choose the proper channel */
+                ...
+        }
+
+        static struct dma_chan *xlate_func(struct acpi_dma_spec *dma_spec,
+                        struct acpi_dma *adma)
+        {
+                dma_cap_mask_t cap;
+                struct filter_args args;
+
+                /* Prepare arguments for filter_func */
+                ...
+                return dma_request_channel(cap, filter_func, &args);
+        }
+        #else
+        static struct dma_chan *xlate_func(struct acpi_dma_spec *dma_spec,
+                        struct acpi_dma *adma)
+        {
+                return NULL;
+        }
+        #endif
+
+dma_request_slave_channel() will call xlate_func() for each registered DMA
+controller. In the xlate function the proper channel must be chosen based on
+information in struct acpi_dma_spec and the properties of the controller
+provided by struct acpi_dma.
+
+Clients must call dma_request_slave_channel() with the string parameter that
+corresponds to a specific FixedDMA resource. By default "tx" means the first
+entry of the FixedDMA resource array, "rx" means the second entry. The table
+below shows a layout:
+
+        Device (I2C0)
+        {
+                ...
+                Method (_CRS, 0, NotSerialized)
+                {
+                        Name (DBUF, ResourceTemplate ()
+                        {
+                                FixedDMA (0x0018, 0x0004, Width32bit, _Y48)
+                                FixedDMA (0x0019, 0x0005, Width32bit, )
+                        })
+                ...
+                }
+        }
+
+So, the FixedDMA with request line 0x0018 is "tx" and next one is "rx" in
+this example.
+
+In robust cases the client unfortunately needs to call
+acpi_dma_request_slave_chan_by_index() directly and therefore choose the
+specific FixedDMA resource by its index.
+
 SPI serial bus support
 ~~~~~~~~~~~~~~~~~~~~~~
 Slave devices behind SPI bus have SpiSerialBus resource attached to them.
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index d5c58e839b27..afe5b1958382 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -326,6 +326,10 @@ config DMA_ENGINE
 config DMA_VIRTUAL_CHANNELS
         tristate
 
+config DMA_ACPI
+        def_bool y
+        depends on ACPI
+
 config DMA_OF
         def_bool y
         depends on OF
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 488e3ff85b52..268e62634bca 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -3,6 +3,7 @@ ccflags-$(CONFIG_DMADEVICES_VDEBUG) += -DVERBOSE_DEBUG
 
 obj-$(CONFIG_DMA_ENGINE) += dmaengine.o
 obj-$(CONFIG_DMA_VIRTUAL_CHANNELS) += virt-dma.o
+obj-$(CONFIG_DMA_ACPI) += acpi-dma.o
 obj-$(CONFIG_DMA_OF) += of-dma.o
 
 obj-$(CONFIG_NET_DMA) += iovlock.o
diff --git a/drivers/dma/acpi-dma.c b/drivers/dma/acpi-dma.c
new file mode 100644
index 000000000000..ba6fc62e9651
--- /dev/null
+++ b/drivers/dma/acpi-dma.c
@@ -0,0 +1,279 @@
+/*
+ * ACPI helpers for DMA request / controller
+ *
+ * Based on of-dma.c
+ *
+ * Copyright (C) 2013, Intel Corporation
+ * Author: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+ *
+ * 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/device.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/acpi.h>
+#include <linux/acpi_dma.h>
+
+static LIST_HEAD(acpi_dma_list);
+static DEFINE_MUTEX(acpi_dma_lock);
+
+/**
+ * acpi_dma_controller_register - Register a DMA controller to ACPI DMA helpers
+ * @dev:                struct device of DMA controller
+ * @acpi_dma_xlate:     translation function which converts a dma specifier
+ *                      into a dma_chan structure
+ * @data                pointer to controller specific data to be used by
+ *                      translation function
+ *
+ * Returns 0 on success or appropriate errno value on error.
+ *
+ * Allocated memory should be freed with appropriate acpi_dma_controller_free()
+ * call.
+ */
+int acpi_dma_controller_register(struct device *dev,
+                struct dma_chan *(*acpi_dma_xlate)
+                (struct acpi_dma_spec *, struct acpi_dma *),
+                void *data)
+{
+        struct acpi_device *adev;
+        struct acpi_dma *adma;
+
+        if (!dev || !acpi_dma_xlate)
+                return -EINVAL;
+
+        /* Check if the device was enumerated by ACPI */
+        if (!ACPI_HANDLE(dev))
+                return -EINVAL;
+
+        if (acpi_bus_get_device(ACPI_HANDLE(dev), &adev))
+                return -EINVAL;
+
+        adma = kzalloc(sizeof(*adma), GFP_KERNEL);
+        if (!adma)
+                return -ENOMEM;
+
+        adma->dev = dev;
+        adma->acpi_dma_xlate = acpi_dma_xlate;
+        adma->data = data;
+
+        /* Now queue acpi_dma controller structure in list */
+        mutex_lock(&acpi_dma_lock);
+        list_add_tail(&adma->dma_controllers, &acpi_dma_list);
+        mutex_unlock(&acpi_dma_lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_dma_controller_register);
+
+/**
+ * acpi_dma_controller_free - Remove a DMA controller from ACPI DMA helpers list
+ * @dev:        struct device of DMA controller
+ *
+ * Memory allocated by acpi_dma_controller_register() is freed here.
+ */
+int acpi_dma_controller_free(struct device *de