dma: add channels support

This adds channels support for dma controllers that have multiple channels
which can transfer data to/from different devices (enet, usb...).

DMA channle API:
 dma_get_by_index()
 dma_get_by_name()
 dma_request()
 dma_free()
 dma_enable()
 dma_disable()
 dma_prepare_rcv_buf()
 dma_receive()
 dma_send()

Reviewed-by: Tom Rini <trini@konsulko.com>
Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>
[grygorii.strashko@ti.com: drop unused dma_get_by_index_platdata(),
 add metadata to send/receive ops, add dma_prepare_rcv_buf(),
 minor clean up]
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Álvaro Fernández Rojas 2018-11-28 19:17:50 +01:00 committed by Tom Rini
parent 10b4dc5208
commit 27ab27f850
4 changed files with 532 additions and 7 deletions

View file

@ -12,6 +12,13 @@ config DMA
buses that is used to transfer data to and from memory.
The uclass interface is defined in include/dma.h.
config DMA_CHANNELS
bool "Enable DMA channels support"
depends on DMA
help
Enable channels support for DMA. Some DMA controllers have multiple
channels which can either transfer data to/from different devices.
config TI_EDMA3
bool "TI EDMA3 driver"
help

View file

@ -2,19 +2,192 @@
/*
* Direct Memory Access U-Class driver
*
* (C) Copyright 2015
* Texas Instruments Incorporated, <www.ti.com>
* Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
* Copyright (C) 2015 - 2018 Texas Instruments Incorporated <www.ti.com>
* Written by Mugunthan V N <mugunthanvnm@ti.com>
*
* Author: Mugunthan V N <mugunthanvnm@ti.com>
*/
#include <common.h>
#include <dm.h>
#include <dm/uclass-internal.h>
#include <dm/device-internal.h>
#include <dm/read.h>
#include <dma-uclass.h>
#include <dt-structs.h>
#include <errno.h>
#ifdef CONFIG_DMA_CHANNELS
static inline struct dma_ops *dma_dev_ops(struct udevice *dev)
{
return (struct dma_ops *)dev->driver->ops;
}
# if CONFIG_IS_ENABLED(OF_CONTROL)
static int dma_of_xlate_default(struct dma *dma,
struct ofnode_phandle_args *args)
{
debug("%s(dma=%p)\n", __func__, dma);
if (args->args_count > 1) {
pr_err("Invaild args_count: %d\n", args->args_count);
return -EINVAL;
}
if (args->args_count)
dma->id = args->args[0];
else
dma->id = 0;
return 0;
}
int dma_get_by_index(struct udevice *dev, int index, struct dma *dma)
{
int ret;
struct ofnode_phandle_args args;
struct udevice *dev_dma;
const struct dma_ops *ops;
debug("%s(dev=%p, index=%d, dma=%p)\n", __func__, dev, index, dma);
assert(dma);
dma->dev = NULL;
ret = dev_read_phandle_with_args(dev, "dmas", "#dma-cells", 0, index,
&args);
if (ret) {
pr_err("%s: dev_read_phandle_with_args failed: err=%d\n",
__func__, ret);
return ret;
}
ret = uclass_get_device_by_ofnode(UCLASS_DMA, args.node, &dev_dma);
if (ret) {
pr_err("%s: uclass_get_device_by_ofnode failed: err=%d\n",
__func__, ret);
return ret;
}
dma->dev = dev_dma;
ops = dma_dev_ops(dev_dma);
if (ops->of_xlate)
ret = ops->of_xlate(dma, &args);
else
ret = dma_of_xlate_default(dma, &args);
if (ret) {
pr_err("of_xlate() failed: %d\n", ret);
return ret;
}
return dma_request(dev_dma, dma);
}
int dma_get_by_name(struct udevice *dev, const char *name, struct dma *dma)
{
int index;
debug("%s(dev=%p, name=%s, dma=%p)\n", __func__, dev, name, dma);
dma->dev = NULL;
index = dev_read_stringlist_search(dev, "dma-names", name);
if (index < 0) {
pr_err("dev_read_stringlist_search() failed: %d\n", index);
return index;
}
return dma_get_by_index(dev, index, dma);
}
# endif /* OF_CONTROL */
int dma_request(struct udevice *dev, struct dma *dma)
{
struct dma_ops *ops = dma_dev_ops(dev);
debug("%s(dev=%p, dma=%p)\n", __func__, dev, dma);
dma->dev = dev;
if (!ops->request)
return 0;
return ops->request(dma);
}
int dma_free(struct dma *dma)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->free)
return 0;
return ops->free(dma);
}
int dma_enable(struct dma *dma)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->enable)
return -ENOSYS;
return ops->enable(dma);
}
int dma_disable(struct dma *dma)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->disable)
return -ENOSYS;
return ops->disable(dma);
}
int dma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->prepare_rcv_buf)
return -1;
return ops->prepare_rcv_buf(dma, dst, size);
}
int dma_receive(struct dma *dma, void **dst, void *metadata)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->receive)
return -ENOSYS;
return ops->receive(dma, dst, metadata);
}
int dma_send(struct dma *dma, void *src, size_t len, void *metadata)
{
struct dma_ops *ops = dma_dev_ops(dma->dev);
debug("%s(dma=%p)\n", __func__, dma);
if (!ops->send)
return -ENOSYS;
return ops->send(dma, src, len, metadata);
}
#endif /* CONFIG_DMA_CHANNELS */
int dma_get_device(u32 transfer_type, struct udevice **devp)
{
struct udevice *dev;

View file

@ -1,7 +1,7 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
* Copyright (C) 2015 Texas Instruments Incorporated <www.ti.com>
* Copyright (C) 2015 - 2018 Texas Instruments Incorporated <www.ti.com>
* Written by Mugunthan V N <mugunthanvnm@ti.com>
*
*/
@ -13,6 +13,8 @@
#include <dma.h>
struct ofnode_phandle_args;
/*
* struct dma_ops - Driver model DMA operations
*
@ -20,6 +22,93 @@
* driver model.
*/
struct dma_ops {
#ifdef CONFIG_DMA_CHANNELS
/**
* of_xlate - Translate a client's device-tree (OF) DMA specifier.
*
* The DMA core calls this function as the first step in implementing
* a client's dma_get_by_*() call.
*
* If this function pointer is set to NULL, the DMA core will use a
* default implementation, which assumes #dma-cells = <1>, and that
* the DT cell contains a simple integer DMA Channel.
*
* At present, the DMA API solely supports device-tree. If this
* changes, other xxx_xlate() functions may be added to support those
* other mechanisms.
*
* @dma: The dma struct to hold the translation result.
* @args: The dma specifier values from device tree.
* @return 0 if OK, or a negative error code.
*/
int (*of_xlate)(struct dma *dma,
struct ofnode_phandle_args *args);
/**
* request - Request a translated DMA.
*
* The DMA core calls this function as the second step in
* implementing a client's dma_get_by_*() call, following a successful
* xxx_xlate() call, or as the only step in implementing a client's
* dma_request() call.
*
* @dma: The DMA struct to request; this has been filled in by
* a previoux xxx_xlate() function call, or by the caller of
* dma_request().
* @return 0 if OK, or a negative error code.
*/
int (*request)(struct dma *dma);
/**
* free - Free a previously requested dma.
*
* This is the implementation of the client dma_free() API.
*
* @dma: The DMA to free.
* @return 0 if OK, or a negative error code.
*/
int (*free)(struct dma *dma);
/**
* enable() - Enable a DMA Channel.
*
* @dma: The DMA Channel to manipulate.
* @return zero on success, or -ve error code.
*/
int (*enable)(struct dma *dma);
/**
* disable() - Disable a DMA Channel.
*
* @dma: The DMA Channel to manipulate.
* @return zero on success, or -ve error code.
*/
int (*disable)(struct dma *dma);
/**
* prepare_rcv_buf() - Prepare/Add receive DMA buffer.
*
* @dma: The DMA Channel to manipulate.
* @dst: The receive buffer pointer.
* @size: The receive buffer size
* @return zero on success, or -ve error code.
*/
int (*prepare_rcv_buf)(struct dma *dma, void *dst, size_t size);
/**
* receive() - Receive a DMA transfer.
*
* @dma: The DMA Channel to manipulate.
* @dst: The destination pointer.
* @metadata: DMA driver's specific data
* @return zero on success, or -ve error code.
*/
int (*receive)(struct dma *dma, void **dst, void *metadata);
/**
* send() - Send a DMA transfer.
*
* @dma: The DMA Channel to manipulate.
* @src: The source pointer.
* @len: Length of the data to be sent (number of bytes).
* @metadata: DMA driver's specific data
* @return zero on success, or -ve error code.
*/
int (*send)(struct dma *dma, void *src, size_t len, void *metadata);
#endif /* CONFIG_DMA_CHANNELS */
/**
* transfer() - Issue a DMA transfer. The implementation must
* wait until the transfer is done.

View file

@ -1,12 +1,17 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* (C) Copyright 2015
* Texas Instruments Incorporated, <www.ti.com>
* Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
* Copyright (C) 2015 - 2018 Texas Instruments Incorporated <www.ti.com>
* Written by Mugunthan V N <mugunthanvnm@ti.com>
*
*/
#ifndef _DMA_H_
#define _DMA_H_
#include <linux/errno.h>
#include <linux/types.h>
/*
* enum dma_direction - dma transfer direction indicator
* @DMA_MEM_TO_MEM: Memcpy mode
@ -36,6 +41,257 @@ struct dma_dev_priv {
u32 supported;
};
#ifdef CONFIG_DMA_CHANNELS
/**
* A DMA is a feature of computer systems that allows certain hardware
* subsystems to access main system memory, independent of the CPU.
* DMA channels are typically generated externally to the HW module
* consuming them, by an entity this API calls a DMA provider. This API
* provides a standard means for drivers to enable and disable DMAs, and to
* copy, send and receive data using DMA.
*
* A driver that implements UCLASS_DMA is a DMA provider. A provider will
* often implement multiple separate DMAs, since the hardware it manages
* often has this capability. dma_uclass.h describes the interface which
* DMA providers must implement.
*
* DMA consumers/clients are the HW modules driven by the DMA channels. This
* header file describes the API used by drivers for those HW modules.
*
* DMA consumer DMA_MEM_TO_DEV (transmit) usage example (based on networking).
* Note. dma_send() is sync operation always - it'll start transfer and will
* poll for it to complete:
* - get/request dma channel
* struct dma dma_tx;
* ret = dma_get_by_name(common->dev, "tx0", &dma_tx);
* if (ret) ...
*
* - enable dma channel
* ret = dma_enable(&dma_tx);
* if (ret) ...
*
* - dma transmit DMA_MEM_TO_DEV.
* struct ti_drv_packet_data packet_data;
*
* packet_data.opt1 = val1;
* packet_data.opt2 = val2;
* ret = dma_send(&dma_tx, packet, length, &packet_data);
* if (ret) ..
*
* DMA consumer DMA_DEV_TO_MEM (receive) usage example (based on networking).
* Note. dma_receive() is sync operation always - it'll start transfer
* (if required) and will poll for it to complete (or for any previously
* configured dev2mem transfer to complete):
* - get/request dma channel
* struct dma dma_rx;
* ret = dma_get_by_name(common->dev, "rx0", &dma_rx);
* if (ret) ...
*
* - enable dma channel
* ret = dma_enable(&dma_rx);
* if (ret) ...
*
* - dma receive DMA_DEV_TO_MEM.
* struct ti_drv_packet_data packet_data;
*
* len = dma_receive(&dma_rx, (void **)packet, &packet_data);
* if (ret < 0) ...
*
* DMA consumer DMA_DEV_TO_MEM (receive) zero-copy usage example (based on
* networking). Networking subsystem allows to configure and use few receive
* buffers (dev2mem), as Networking RX DMA channels usually implemented
* as streaming interface
* - get/request dma channel
* struct dma dma_rx;
* ret = dma_get_by_name(common->dev, "rx0", &dma_rx);
* if (ret) ...
*
* for (i = 0; i < RX_DESC_NUM; i++) {
* ret = dma_prepare_rcv_buf(&dma_rx,
* net_rx_packets[i],
* RX_BUF_SIZE);
* if (ret) ...
* }
*
* - enable dma channel
* ret = dma_enable(&dma_rx);
* if (ret) ...
*
* - dma receive DMA_DEV_TO_MEM.
* struct ti_drv_packet_data packet_data;
*
* len = dma_receive(&dma_rx, (void **)packet, &packet_data);
* if (ret < 0) ..
*
* -- process packet --
*
* - return buffer back to DAM channel
* ret = dma_prepare_rcv_buf(&dma_rx,
* net_rx_packets[rx_next],
* RX_BUF_SIZE);
*/
struct udevice;
/**
* struct dma - A handle to (allowing control of) a single DMA.
*
* Clients provide storage for DMA handles. The content of the structure is
* managed solely by the DMA API and DMA drivers. A DMA struct is
* initialized by "get"ing the DMA struct. The DMA struct is passed to all
* other DMA APIs to identify which DMA channel to operate upon.
*
* @dev: The device which implements the DMA channel.
* @id: The DMA channel ID within the provider.
*
* Currently, the DMA API assumes that a single integer ID is enough to
* identify and configure any DMA channel for any DMA provider. If this
* assumption becomes invalid in the future, the struct could be expanded to
* either (a) add more fields to allow DMA providers to store additional
* information, or (b) replace the id field with an opaque pointer, which the
* provider would dynamically allocated during its .of_xlate op, and process
* during is .request op. This may require the addition of an extra op to clean
* up the allocation.
*/
struct dma {
struct udevice *dev;
/*
* Written by of_xlate. We assume a single id is enough for now. In the
* future, we might add more fields here.
*/
unsigned long id;
};
# if CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DMA)
/**
* dma_get_by_index - Get/request a DMA by integer index.
*
* This looks up and requests a DMA. The index is relative to the client
* device; each device is assumed to have n DMAs associated with it somehow,
* and this function finds and requests one of them. The mapping of client
* device DMA indices to provider DMAs may be via device-tree properties,
* board-provided mapping tables, or some other mechanism.
*
* @dev: The client device.
* @index: The index of the DMA to request, within the client's list of
* DMA channels.
* @dma: A pointer to a DMA struct to initialize.
* @return 0 if OK, or a negative error code.
*/
int dma_get_by_index(struct udevice *dev, int index, struct dma *dma);
/**
* dma_get_by_name - Get/request a DMA by name.
*
* This looks up and requests a DMA. The name is relative to the client
* device; each device is assumed to have n DMAs associated with it somehow,
* and this function finds and requests one of them. The mapping of client
* device DMA names to provider DMAs may be via device-tree properties,
* board-provided mapping tables, or some other mechanism.
*
* @dev: The client device.
* @name: The name of the DMA to request, within the client's list of
* DMA channels.
* @dma: A pointer to a DMA struct to initialize.
* @return 0 if OK, or a negative error code.
*/
int dma_get_by_name(struct udevice *dev, const char *name, struct dma *dma);
# else
static inline int dma_get_by_index(struct udevice *dev, int index,
struct dma *dma)
{
return -ENOSYS;
}
static inline int dma_get_by_name(struct udevice *dev, const char *name,
struct dma *dma)
{
return -ENOSYS;
}
# endif
/**
* dma_request - Request a DMA by provider-specific ID.
*
* This requests a DMA using a provider-specific ID. Generally, this function
* should not be used, since dma_get_by_index/name() provide an interface that
* better separates clients from intimate knowledge of DMA providers.
* However, this function may be useful in core SoC-specific code.
*
* @dev: The DMA provider device.
* @dma: A pointer to a DMA struct to initialize. The caller must
* have already initialized any field in this struct which the
* DMA provider uses to identify the DMA channel.
* @return 0 if OK, or a negative error code.
*/
int dma_request(struct udevice *dev, struct dma *dma);
/**
* dma_free - Free a previously requested DMA.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @return 0 if OK, or a negative error code.
*/
int dma_free(struct dma *dma);
/**
* dma_enable() - Enable (turn on) a DMA channel.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @return zero on success, or -ve error code.
*/
int dma_enable(struct dma *dma);
/**
* dma_disable() - Disable (turn off) a DMA channel.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @return zero on success, or -ve error code.
*/
int dma_disable(struct dma *dma);
/**
* dma_prepare_rcv_buf() - Prepare/add receive DMA buffer.
*
* It allows to implement zero-copy async DMA_DEV_TO_MEM (receive) transactions
* if supported by DMA providers.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @dst: The receive buffer pointer.
* @size: The receive buffer size
* @return zero on success, or -ve error code.
*/
int dma_prepare_rcv_buf(struct dma *dma, void *dst, size_t size);
/**
* dma_receive() - Receive a DMA transfer.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @dst: The destination pointer.
* @metadata: DMA driver's channel specific data
* @return length of received data on success, or zero - no data,
* or -ve error code.
*/
int dma_receive(struct dma *dma, void **dst, void *metadata);
/**
* dma_send() - Send a DMA transfer.
*
* @dma: A DMA struct that was previously successfully requested by
* dma_request/get_by_*().
* @src: The source pointer.
* @len: Length of the data to be sent (number of bytes).
* @metadata: DMA driver's channel specific data
* @return zero on success, or -ve error code.
*/
int dma_send(struct dma *dma, void *src, size_t len, void *metadata);
#endif /* CONFIG_DMA_CHANNELS */
/*
* dma_get_device - get a DMA device which supports transfer
* type of transfer_type