Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-09-20 22:52:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

dma: add channels support

Browse source 
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
Show stats Download patch file Download diff file Expand all files Collapse all files

7
drivers/dma/Kconfig
View file

@ -12,6 +12,13 @@ config DMA
buses that is used to transfer data to and from memory. buses that is used to transfer data to and from memory.
The uclass interface is defined in include/dma.h. 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 config TI_EDMA3
bool "TI EDMA3 driver" bool "TI EDMA3 driver"
help help

181
drivers/dma/dma-uclass.c
View file

@ -2,19 +2,192 @@
/* /*
* Direct Memory Access U-Class driver * Direct Memory Access U-Class driver
* *
* (C) Copyright 2015 * Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
* Texas Instruments Incorporated, <www.ti.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> * Author: Mugunthan V N <mugunthanvnm@ti.com>
*/ */
#include <common.h> #include <common.h>
#include <dm.h> #include <dm.h>
#include <dm/uclass-internal.h> #include <dm/read.h>
#include <dm/device-internal.h>
#include <dma-uclass.h> #include <dma-uclass.h>
#include <dt-structs.h>
#include <errno.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) int dma_get_device(u32 transfer_type, struct udevice **devp)
{ {
struct udevice *dev; struct udevice *dev;

91
include/dma-uclass.h
View file

@ -1,7 +1,7 @@
/* SPDX-License-Identifier: GPL-2.0+ */ /* SPDX-License-Identifier: GPL-2.0+ */
/* /*
* Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com> * 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> * Written by Mugunthan V N <mugunthanvnm@ti.com>
* *
*/ */
@ -13,6 +13,8 @@
#include <dma.h> #include <dma.h>
struct ofnode_phandle_args;
/* /*
* struct dma_ops - Driver model DMA operations * struct dma_ops - Driver model DMA operations
* *
@ -20,6 +22,93 @@
* driver model. * driver model.
*/ */
struct dma_ops { 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 * transfer() - Issue a DMA transfer. The implementation must
* wait until the transfer is done. * wait until the transfer is done.

260
include/dma.h
View file

@ -1,12 +1,17 @@
/* SPDX-License-Identifier: GPL-2.0+ */ /* SPDX-License-Identifier: GPL-2.0+ */
/* /*
* (C) Copyright 2015 * Copyright (C) 2018 Álvaro Fernández Rojas <noltari@gmail.com>
* Texas Instruments Incorporated, <www.ti.com> * Copyright (C) 2015 - 2018 Texas Instruments Incorporated <www.ti.com>
* Written by Mugunthan V N <mugunthanvnm@ti.com>
*
*/ */
#ifndef _DMA_H_ #ifndef _DMA_H_
#define _DMA_H_ #define _DMA_H_
#include <linux/errno.h>
#include <linux/types.h>
/* /*
* enum dma_direction - dma transfer direction indicator * enum dma_direction - dma transfer direction indicator
* @DMA_MEM_TO_MEM: Memcpy mode * @DMA_MEM_TO_MEM: Memcpy mode
@ -36,6 +41,257 @@ struct dma_dev_priv {
u32 supported; 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 * dma_get_device - get a DMA device which supports transfer
* type of transfer_type * type of transfer_type