dma: acpi-dma: introduce ACPI DMA helpers
There is a new generic API to get a DMA channel for a slave device (commit9a6cecc8"dmaengine: add helper function to request a slave DMA channel"). In similar fashion to the DT case (commitaa3da644"of: Add generic device tree DMA helpers") we introduce helpers to the DMAC drivers which are enumerated by ACPI. The proposed extension provides the following API calls: acpi_dma_controller_register(), devm_acpi_dma_controller_register() acpi_dma_controller_free(), devm_acpi_dma_controller_free() acpi_dma_simple_xlate() acpi_dma_request_slave_chan_by_index() acpi_dma_request_slave_chan_by_name() The first two should be used, for example, at probe() and remove() of the corresponding DMAC driver. At the register stage the DMAC driver supplies a custom xlate() function to translate a struct dma_spec into struct dma_chan. Accordingly to the ACPI Fixed DMA resource specification the only two pieces of information the slave device has are the channel id and the request line (slave id). Those two are represented by struct dma_spec. The acpi_dma_request_slave_chan_by_index() provides access to the specifix FixedDMA resource by its index. Whereas dma_request_slave_channel() takes a string parameter to identify the DMA resources required by the slave device. To make a slave device driver work with both DeviceTree and ACPI enumeration a simple convention is established: "tx" corresponds to the index 0 and "rx" to the index 1. In case of robust configuration the slave device driver unfortunately needs to call acpi_dma_request_slave_chan_by_index() directly. Additionally the patch provides "managed" version of the register/free pair i.e. devm_acpi_dma_controller_register() and devm_acpi_dma_controller_free(). Usually, the driver uses only devm_acpi_dma_controller_register(). Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com> Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Signed-off-by: Vinod Koul <vinod.koul@intel.com>
This commit is contained in:
Andy Shevchenko
Vinod Koul
Родитель
eceec44ecd
Коммит
1b2e98bc1e
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 *dev)
|
||||
{
|
||||
struct acpi_dma *adma;
|
||||
|
||||
if (!dev)
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&acpi_dma_lock);
|
||||
|
||||
list_for_each_entry(adma, &acpi_dma_list, dma_controllers)
|
||||
if (adma->dev == dev) {
|
||||
list_del(&adma->dma_controllers);
|
||||
mutex_unlock(&acpi_dma_lock);
|
||||
kfree(adma);
|
||||
return 0;
|
||||
}
|
||||
|
||||
mutex_unlock(&acpi_dma_lock);
|
||||
return -ENODEV;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_dma_controller_free);
|
||||
|
||||
static void devm_acpi_dma_release(struct device *dev, void *res)
|
||||
{
|
||||
acpi_dma_controller_free(dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* devm_acpi_dma_controller_register - resource managed acpi_dma_controller_register()
|
||||
* @dev: device that is registering this DMA controller
|
||||
* @acpi_dma_xlate: translation function
|
||||
* @data pointer to controller specific data
|
||||
*
|
||||
* Managed acpi_dma_controller_register(). DMA controller registered by this
|
||||
* function are automatically freed on driver detach. See
|
||||
* acpi_dma_controller_register() for more information.
|
||||
*/
|
||||
int devm_acpi_dma_controller_register(struct device *dev,
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *),
|
||||
void *data)
|
||||
{
|
||||
void *res;
|
||||
int ret;
|
||||
|
||||
res = devres_alloc(devm_acpi_dma_release, 0, GFP_KERNEL);
|
||||
if (!res)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = acpi_dma_controller_register(dev, acpi_dma_xlate, data);
|
||||
if (ret) {
|
||||
devres_free(res);
|
||||
return ret;
|
||||
}
|
||||
devres_add(dev, res);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_acpi_dma_controller_register);
|
||||
|
||||
/**
|
||||
* devm_acpi_dma_controller_free - resource managed acpi_dma_controller_free()
|
||||
*
|
||||
* Unregister a DMA controller registered with
|
||||
* devm_acpi_dma_controller_register(). Normally this function will not need to
|
||||
* be called and the resource management code will ensure that the resource is
|
||||
* freed.
|
||||
*/
|
||||
void devm_acpi_dma_controller_free(struct device *dev)
|
||||
{
|
||||
WARN_ON(devres_destroy(dev, devm_acpi_dma_release, NULL, NULL));
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_acpi_dma_controller_free);
|
||||
|
||||
struct acpi_dma_parser_data {
|
||||
struct acpi_dma_spec dma_spec;
|
||||
size_t index;
|
||||
size_t n;
|
||||
};
|
||||
|
||||
/**
|
||||
* acpi_dma_parse_fixed_dma - Parse FixedDMA ACPI resources to a DMA specifier
|
||||
* @res: struct acpi_resource to get FixedDMA resources from
|
||||
* @data: pointer to a helper struct acpi_dma_parser_data
|
||||
*/
|
||||
static int acpi_dma_parse_fixed_dma(struct acpi_resource *res, void *data)
|
||||
{
|
||||
struct acpi_dma_parser_data *pdata = data;
|
||||
|
||||
if (res->type == ACPI_RESOURCE_TYPE_FIXED_DMA) {
|
||||
struct acpi_resource_fixed_dma *dma = &res->data.fixed_dma;
|
||||
|
||||
if (pdata->n++ == pdata->index) {
|
||||
pdata->dma_spec.chan_id = dma->channels;
|
||||
pdata->dma_spec.slave_id = dma->request_lines;
|
||||
}
|
||||
}
|
||||
|
||||
/* Tell the ACPI core to skip this resource */
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_dma_request_slave_chan_by_index - Get the DMA slave channel
|
||||
* @dev: struct device to get DMA request from
|
||||
* @index: index of FixedDMA descriptor for @dev
|
||||
*
|
||||
* Returns pointer to appropriate dma channel on success or NULL on error.
|
||||
*/
|
||||
struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev,
|
||||
size_t index)
|
||||
{
|
||||
struct acpi_dma_parser_data pdata;
|
||||
struct acpi_dma_spec *dma_spec = &pdata.dma_spec;
|
||||
struct list_head resource_list;
|
||||
struct acpi_device *adev;
|
||||
struct acpi_dma *adma;
|
||||
struct dma_chan *chan = NULL;
|
||||
|
||||
/* Check if the device was enumerated by ACPI */
|
||||
if (!dev || !ACPI_HANDLE(dev))
|
||||
return NULL;
|
||||
|
||||
if (acpi_bus_get_device(ACPI_HANDLE(dev), &adev))
|
||||
return NULL;
|
||||
|
||||
memset(&pdata, 0, sizeof(pdata));
|
||||
pdata.index = index;
|
||||
|
||||
/* Initial values for the request line and channel */
|
||||
dma_spec->chan_id = -1;
|
||||
dma_spec->slave_id = -1;
|
||||
|
||||
INIT_LIST_HEAD(&resource_list);
|
||||
acpi_dev_get_resources(adev, &resource_list,
|
||||
acpi_dma_parse_fixed_dma, &pdata);
|
||||
acpi_dev_free_resource_list(&resource_list);
|
||||
|
||||
if (dma_spec->slave_id < 0 || dma_spec->chan_id < 0)
|
||||
return NULL;
|
||||
|
||||
mutex_lock(&acpi_dma_lock);
|
||||
|
||||
list_for_each_entry(adma, &acpi_dma_list, dma_controllers) {
|
||||
dma_spec->dev = adma->dev;
|
||||
chan = adma->acpi_dma_xlate(dma_spec, adma);
|
||||
if (chan)
|
||||
break;
|
||||
}
|
||||
|
||||
mutex_unlock(&acpi_dma_lock);
|
||||
return chan;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_dma_request_slave_chan_by_index);
|
||||
|
||||
/**
|
||||
* acpi_dma_request_slave_chan_by_name - Get the DMA slave channel
|
||||
* @dev: struct device to get DMA request from
|
||||
* @name: represents corresponding FixedDMA descriptor for @dev
|
||||
*
|
||||
* In order to support both Device Tree and ACPI in a single driver we
|
||||
* translate the names "tx" and "rx" here based on the most common case where
|
||||
* the first FixedDMA descriptor is TX and second is RX.
|
||||
*
|
||||
* Returns pointer to appropriate dma channel on success or NULL on error.
|
||||
*/
|
||||
struct dma_chan *acpi_dma_request_slave_chan_by_name(struct device *dev,
|
||||
const char *name)
|
||||
{
|
||||
size_t index;
|
||||
|
||||
if (!strcmp(name, "tx"))
|
||||
index = 0;
|
||||
else if (!strcmp(name, "rx"))
|
||||
index = 1;
|
||||
else
|
||||
return NULL;
|
||||
|
||||
return acpi_dma_request_slave_chan_by_index(dev, index);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_dma_request_slave_chan_by_name);
|
||||
|
||||
/**
|
||||
* acpi_dma_simple_xlate - Simple ACPI DMA engine translation helper
|
||||
* @dma_spec: pointer to ACPI DMA specifier
|
||||
* @adma: pointer to ACPI DMA controller data
|
||||
*
|
||||
* A simple translation function for ACPI based devices. Passes &struct
|
||||
* dma_spec to the DMA controller driver provided filter function. Returns
|
||||
* pointer to the channel if found or %NULL otherwise.
|
||||
*/
|
||||
struct dma_chan *acpi_dma_simple_xlate(struct acpi_dma_spec *dma_spec,
|
||||
struct acpi_dma *adma)
|
||||
{
|
||||
struct acpi_dma_filter_info *info = adma->data;
|
||||
|
||||
if (!info || !info->filter_fn)
|
||||
return NULL;
|
||||
|
||||
return dma_request_channel(info->dma_cap, info->filter_fn, dma_spec);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(acpi_dma_simple_xlate);
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
/*
|
||||
* ACPI helpers for DMA request / controller
|
||||
*
|
||||
* Based on of_dma.h
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_ACPI_DMA_H
|
||||
#define __LINUX_ACPI_DMA_H
|
||||
|
||||
#include <linux/list.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/dmaengine.h>
|
||||
|
||||
/**
|
||||
* struct acpi_dma_spec - slave device DMA resources
|
||||
* @chan_id: channel unique id
|
||||
* @slave_id: request line unique id
|
||||
* @dev: struct device of the DMA controller to be used in the filter
|
||||
* function
|
||||
*/
|
||||
struct acpi_dma_spec {
|
||||
int chan_id;
|
||||
int slave_id;
|
||||
struct device *dev;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct acpi_dma - representation of the registered DMAC
|
||||
* @dma_controllers: linked list node
|
||||
* @dev: struct device of this controller
|
||||
* @acpi_dma_xlate: callback function to find a suitable channel
|
||||
* @data: private data used by a callback function
|
||||
*/
|
||||
struct acpi_dma {
|
||||
struct list_head dma_controllers;
|
||||
struct device *dev;
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *);
|
||||
void *data;
|
||||
};
|
||||
|
||||
/* Used with acpi_dma_simple_xlate() */
|
||||
struct acpi_dma_filter_info {
|
||||
dma_cap_mask_t dma_cap;
|
||||
dma_filter_fn filter_fn;
|
||||
};
|
||||
|
||||
#ifdef CONFIG_DMA_ACPI
|
||||
|
||||
int acpi_dma_controller_register(struct device *dev,
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *),
|
||||
void *data);
|
||||
int acpi_dma_controller_free(struct device *dev);
|
||||
int devm_acpi_dma_controller_register(struct device *dev,
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *),
|
||||
void *data);
|
||||
void devm_acpi_dma_controller_free(struct device *dev);
|
||||
|
||||
struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev,
|
||||
size_t index);
|
||||
struct dma_chan *acpi_dma_request_slave_chan_by_name(struct device *dev,
|
||||
const char *name);
|
||||
|
||||
struct dma_chan *acpi_dma_simple_xlate(struct acpi_dma_spec *dma_spec,
|
||||
struct acpi_dma *adma);
|
||||
#else
|
||||
|
||||
static inline int acpi_dma_controller_register(struct device *dev,
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *),
|
||||
void *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int acpi_dma_controller_free(struct device *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int devm_acpi_dma_controller_register(struct device *dev,
|
||||
struct dma_chan *(*acpi_dma_xlate)
|
||||
(struct acpi_dma_spec *, struct acpi_dma *),
|
||||
void *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void devm_acpi_dma_controller_free(struct device *dev)
|
||||
{
|
||||
}
|
||||
|
||||
static inline struct dma_chan *acpi_dma_request_slave_chan_by_index(
|
||||
struct device *dev, size_t index)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
static inline struct dma_chan *acpi_dma_request_slave_chan_by_name(
|
||||
struct device *dev, const char *name)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#define acpi_dma_simple_xlate NULL
|
||||
|
||||
#endif
|
||||
|
||||
#define acpi_dma_request_slave_channel acpi_dma_request_slave_chan_by_index
|
||||
|
||||
#endif /* __LINUX_ACPI_DMA_H */
|
||||
Загрузка…
Ссылка в новой задаче