+++ /dev/null
-From a8135d0d79e9d0ad3a4ff494fceeaae838becf38 Mon Sep 17 00:00:00 2001
-From: Peter Ujfalusi <peter.ujfalusi@ti.com>
-Date: Mon, 14 Dec 2015 22:47:40 +0200
-Subject: [PATCH 2/3] dmaengine: core: Introduce new, universal API to request
- a channel
-
-The two API function can cover most, if not all current APIs used to
-request a channel. With minimal effort dmaengine drivers, platforms and
-dmaengine user drivers can be converted to use the two function.
-
-struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask);
-
-To request any channel matching with the requested capabilities, can be
-used to request channel for memcpy, memset, xor, etc where no hardware
-synchronization is needed.
-
-struct dma_chan *dma_request_chan(struct device *dev, const char *name);
-To request a slave channel. The dma_request_chan() will try to find the
-channel via DT, ACPI or in case if the kernel booted in non DT/ACPI mode
-it will use a filter lookup table and retrieves the needed information from
-the dma_slave_map provided by the DMA drivers.
-This legacy mode needs changes in platform code, in dmaengine drivers and
-finally the dmaengine user drivers can be converted:
-
-For each dmaengine driver an array of DMA device, slave and the parameter
-for the filter function needs to be added:
-
-static const struct dma_slave_map da830_edma_map[] = {
- { "davinci-mcasp.0", "rx", EDMA_FILTER_PARAM(0, 0) },
- { "davinci-mcasp.0", "tx", EDMA_FILTER_PARAM(0, 1) },
- { "davinci-mcasp.1", "rx", EDMA_FILTER_PARAM(0, 2) },
- { "davinci-mcasp.1", "tx", EDMA_FILTER_PARAM(0, 3) },
- { "davinci-mcasp.2", "rx", EDMA_FILTER_PARAM(0, 4) },
- { "davinci-mcasp.2", "tx", EDMA_FILTER_PARAM(0, 5) },
- { "spi_davinci.0", "rx", EDMA_FILTER_PARAM(0, 14) },
- { "spi_davinci.0", "tx", EDMA_FILTER_PARAM(0, 15) },
- { "da830-mmc.0", "rx", EDMA_FILTER_PARAM(0, 16) },
- { "da830-mmc.0", "tx", EDMA_FILTER_PARAM(0, 17) },
- { "spi_davinci.1", "rx", EDMA_FILTER_PARAM(0, 18) },
- { "spi_davinci.1", "tx", EDMA_FILTER_PARAM(0, 19) },
-};
-
-This information is going to be needed by the dmaengine driver, so
-modification to the platform_data is needed, and the driver map should be
-added to the pdata of the DMA driver:
-
-da8xx_edma0_pdata.slave_map = da830_edma_map;
-da8xx_edma0_pdata.slavecnt = ARRAY_SIZE(da830_edma_map);
-
-The DMA driver then needs to configure the needed device -> filter_fn
-mapping before it registers with dma_async_device_register() :
-
-ecc->dma_slave.filter_map.map = info->slave_map;
-ecc->dma_slave.filter_map.mapcnt = info->slavecnt;
-ecc->dma_slave.filter_map.fn = edma_filter_fn;
-
-When neither DT or ACPI lookup is available the dma_request_chan() will
-try to match the requester's device name with the filter_map's list of
-device names, when a match found it will use the information from the
-dma_slave_map to get the channel with the dma_get_channel() internal
-function.
-
-Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>
-Reviewed-by: Arnd Bergmann <arnd@arndb.de>
-Signed-off-by: Vinod Koul <vinod.koul@intel.com>
----
- Documentation/dmaengine/client.txt | 23 +++-------
- drivers/dma/dmaengine.c | 89 +++++++++++++++++++++++++++++++++-----
- include/linux/dmaengine.h | 51 +++++++++++++++++++---
- 3 files changed, 127 insertions(+), 36 deletions(-)
-
---- a/Documentation/dmaengine/client.txt
-+++ b/Documentation/dmaengine/client.txt
-@@ -22,25 +22,14 @@ The slave DMA usage consists of followin
- Channel allocation is slightly different in the slave DMA context,
- client drivers typically need a channel from a particular DMA
- controller only and even in some cases a specific channel is desired.
-- To request a channel dma_request_channel() API is used.
-+ To request a channel dma_request_chan() API is used.
-
- Interface:
-- struct dma_chan *dma_request_channel(dma_cap_mask_t mask,
-- dma_filter_fn filter_fn,
-- void *filter_param);
-- where dma_filter_fn is defined as:
-- typedef bool (*dma_filter_fn)(struct dma_chan *chan, void *filter_param);
-+ struct dma_chan *dma_request_chan(struct device *dev, const char *name);
-
-- The 'filter_fn' parameter is optional, but highly recommended for
-- slave and cyclic channels as they typically need to obtain a specific
-- DMA channel.
--
-- When the optional 'filter_fn' parameter is NULL, dma_request_channel()
-- simply returns the first channel that satisfies the capability mask.
--
-- Otherwise, the 'filter_fn' routine will be called once for each free
-- channel which has a capability in 'mask'. 'filter_fn' is expected to
-- return 'true' when the desired DMA channel is found.
-+ Which will find and return the 'name' DMA channel associated with the 'dev'
-+ device. The association is done via DT, ACPI or board file based
-+ dma_slave_map matching table.
-
- A channel allocated via this interface is exclusive to the caller,
- until dma_release_channel() is called.
---- a/drivers/dma/dmaengine.c
-+++ b/drivers/dma/dmaengine.c
-@@ -43,6 +43,7 @@
-
- #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
-+#include <linux/platform_device.h>
- #include <linux/dma-mapping.h>
- #include <linux/init.h>
- #include <linux/module.h>
-@@ -665,27 +666,73 @@ struct dma_chan *__dma_request_channel(c
- }
- EXPORT_SYMBOL_GPL(__dma_request_channel);
-
-+static const struct dma_slave_map *dma_filter_match(struct dma_device *device,
-+ const char *name,
-+ struct device *dev)
-+{
-+ int i;
-+
-+ if (!device->filter.mapcnt)
-+ return NULL;
-+
-+ for (i = 0; i < device->filter.mapcnt; i++) {
-+ const struct dma_slave_map *map = &device->filter.map[i];
-+
-+ if (!strcmp(map->devname, dev_name(dev)) &&
-+ !strcmp(map->slave, name))
-+ return map;
-+ }
-+
-+ return NULL;
-+}
-+
- /**
-- * dma_request_slave_channel_reason - try to allocate an exclusive slave channel
-+ * dma_request_chan - try to allocate an exclusive slave channel
- * @dev: pointer to client device structure
- * @name: slave channel name
- *
- * Returns pointer to appropriate DMA channel on success or an error pointer.
- */
--struct dma_chan *dma_request_slave_channel_reason(struct device *dev,
-- const char *name)
-+struct dma_chan *dma_request_chan(struct device *dev, const char *name)
- {
-+ struct dma_device *d, *_d;
-+ struct dma_chan *chan = NULL;
-+
- /* If device-tree is present get slave info from here */
- if (dev->of_node)
-- return of_dma_request_slave_channel(dev->of_node, name);
-+ chan = of_dma_request_slave_channel(dev->of_node, name);
-
- /* If device was enumerated by ACPI get slave info from here */
-- if (ACPI_HANDLE(dev))
-- return acpi_dma_request_slave_chan_by_name(dev, name);
-+ if (has_acpi_companion(dev) && !chan)
-+ chan = acpi_dma_request_slave_chan_by_name(dev, name);
-+
-+ if (chan) {
-+ /* Valid channel found or requester need to be deferred */
-+ if (!IS_ERR(chan) || PTR_ERR(chan) == -EPROBE_DEFER)
-+ return chan;
-+ }
-+
-+ /* Try to find the channel via the DMA filter map(s) */
-+ mutex_lock(&dma_list_mutex);
-+ list_for_each_entry_safe(d, _d, &dma_device_list, global_node) {
-+ dma_cap_mask_t mask;
-+ const struct dma_slave_map *map = dma_filter_match(d, name, dev);
-+
-+ if (!map)
-+ continue;
-+
-+ dma_cap_zero(mask);
-+ dma_cap_set(DMA_SLAVE, mask);
-
-- return ERR_PTR(-ENODEV);
-+ chan = find_candidate(d, &mask, d->filter.fn, map->param);
-+ if (!IS_ERR(chan))
-+ break;
-+ }
-+ mutex_unlock(&dma_list_mutex);
-+
-+ return chan ? chan : ERR_PTR(-EPROBE_DEFER);
- }
--EXPORT_SYMBOL_GPL(dma_request_slave_channel_reason);
-+EXPORT_SYMBOL_GPL(dma_request_chan);
-
- /**
- * dma_request_slave_channel - try to allocate an exclusive slave channel
-@@ -697,17 +744,35 @@ EXPORT_SYMBOL_GPL(dma_request_slave_chan
- struct dma_chan *dma_request_slave_channel(struct device *dev,
- const char *name)
- {
-- struct dma_chan *ch = dma_request_slave_channel_reason(dev, name);
-+ struct dma_chan *ch = dma_request_chan(dev, name);
- if (IS_ERR(ch))
- return NULL;
-
-- dma_cap_set(DMA_PRIVATE, ch->device->cap_mask);
-- ch->device->privatecnt++;
--
- return ch;
- }
- EXPORT_SYMBOL_GPL(dma_request_slave_channel);
-
-+/**
-+ * dma_request_chan_by_mask - allocate a channel satisfying certain capabilities
-+ * @mask: capabilities that the channel must satisfy
-+ *
-+ * Returns pointer to appropriate DMA channel on success or an error pointer.
-+ */
-+struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask)
-+{
-+ struct dma_chan *chan;
-+
-+ if (!mask)
-+ return ERR_PTR(-ENODEV);
-+
-+ chan = __dma_request_channel(mask, NULL, NULL);
-+ if (!chan)
-+ chan = ERR_PTR(-ENODEV);
-+
-+ return chan;
-+}
-+EXPORT_SYMBOL_GPL(dma_request_chan_by_mask);
-+
- void dma_release_channel(struct dma_chan *chan)
- {
- mutex_lock(&dma_list_mutex);
---- a/include/linux/dmaengine.h
-+++ b/include/linux/dmaengine.h
-@@ -607,11 +607,38 @@ enum dmaengine_alignment {
- };
-
- /**
-+ * struct dma_slave_map - associates slave device and it's slave channel with
-+ * parameter to be used by a filter function
-+ * @devname: name of the device
-+ * @slave: slave channel name
-+ * @param: opaque parameter to pass to struct dma_filter.fn
-+ */
-+struct dma_slave_map {
-+ const char *devname;
-+ const char *slave;
-+ void *param;
-+};
-+
-+/**
-+ * struct dma_filter - information for slave device/channel to filter_fn/param
-+ * mapping
-+ * @fn: filter function callback
-+ * @mapcnt: number of slave device/channel in the map
-+ * @map: array of channel to filter mapping data
-+ */
-+struct dma_filter {
-+ dma_filter_fn fn;
-+ int mapcnt;
-+ const struct dma_slave_map *map;
-+};
-+
-+/**
- * struct dma_device - info on the entity supplying DMA services
- * @chancnt: how many DMA channels are supported
- * @privatecnt: how many DMA channels are requested by dma_request_channel
- * @channels: the list of struct dma_chan
- * @global_node: list_head for global dma_device_list
-+ * @filter: information for device/slave to filter function/param mapping
- * @cap_mask: one or more dma_capability flags
- * @max_xor: maximum number of xor sources, 0 if no capability
- * @max_pq: maximum number of PQ sources and PQ-continue capability
-@@ -666,6 +693,7 @@ struct dma_device {
- unsigned int privatecnt;
- struct list_head channels;
- struct list_head global_node;
-+ struct dma_filter filter;
- dma_cap_mask_t cap_mask;
- unsigned short max_xor;
- unsigned short max_pq;
-@@ -1140,9 +1168,11 @@ enum dma_status dma_wait_for_async_tx(st
- void dma_issue_pending_all(void);
- struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
- dma_filter_fn fn, void *fn_param);
--struct dma_chan *dma_request_slave_channel_reason(struct device *dev,
-- const char *name);
- struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
-+
-+struct dma_chan *dma_request_chan(struct device *dev, const char *name);
-+struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask);
-+
- void dma_release_channel(struct dma_chan *chan);
- int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps);
- #else
-@@ -1166,16 +1196,21 @@ static inline struct dma_chan *__dma_req
- {
- return NULL;
- }
--static inline struct dma_chan *dma_request_slave_channel_reason(
-- struct device *dev, const char *name)
--{
-- return ERR_PTR(-ENODEV);
--}
- static inline struct dma_chan *dma_request_slave_channel(struct device *dev,
- const char *name)
- {
- return NULL;
- }
-+static inline struct dma_chan *dma_request_chan(struct device *dev,
-+ const char *name)
-+{
-+ return ERR_PTR(-ENODEV);
-+}
-+static inline struct dma_chan *dma_request_chan_by_mask(
-+ const dma_cap_mask_t *mask)
-+{
-+ return ERR_PTR(-ENODEV);
-+}
- static inline void dma_release_channel(struct dma_chan *chan)
- {
- }
-@@ -1186,6 +1221,8 @@ static inline int dma_get_slave_caps(str
- }
- #endif
-
-+#define dma_request_slave_channel_reason(dev, name) dma_request_chan(dev, name)
-+
- static inline int dmaengine_desc_set_reuse(struct dma_async_tx_descriptor *tx)
- {
- struct dma_slave_caps caps;
projects / openwrt / staging / lynxis / omap.git / blobdiff