linux/drivers/dma/dw-edma/dw-edma-core.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2018-2019 Synopsys, Inc. and/or its affiliates.
 * Synopsys DesignWare eDMA core driver
 *
 * Author: Gustavo Pimentel <[email protected]>
 */

#include <linux/module.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/dmaengine.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/dma/edma.h>
#include <linux/dma-mapping.h>

#include "dw-edma-core.h"
#include "dw-edma-v0-core.h"
#include "dw-hdma-v0-core.h"
#include "../dmaengine.h"
#include "../virt-dma.h"

static inline
struct device *dchan2dev(struct dma_chan *dchan)
{ … }

static inline
struct device *chan2dev(struct dw_edma_chan *chan)
{ … }

static inline
struct dw_edma_desc *vd2dw_edma_desc(struct virt_dma_desc *vd)
{ … }

static inline
u64 dw_edma_get_pci_address(struct dw_edma_chan *chan, phys_addr_t cpu_addr)
{ … }

static struct dw_edma_burst *dw_edma_alloc_burst(struct dw_edma_chunk *chunk)
{ … }

static struct dw_edma_chunk *dw_edma_alloc_chunk(struct dw_edma_desc *desc)
{ … }

static struct dw_edma_desc *dw_edma_alloc_desc(struct dw_edma_chan *chan)
{ … }

static void dw_edma_free_burst(struct dw_edma_chunk *chunk)
{ … }

static void dw_edma_free_chunk(struct dw_edma_desc *desc)
{ … }

static void dw_edma_free_desc(struct dw_edma_desc *desc)
{ … }

static void vchan_free_desc(struct virt_dma_desc *vdesc)
{ … }

static int dw_edma_start_transfer(struct dw_edma_chan *chan)
{ … }

static void dw_edma_device_caps(struct dma_chan *dchan,
				struct dma_slave_caps *caps)
{ … }

static int dw_edma_device_config(struct dma_chan *dchan,
				 struct dma_slave_config *config)
{ … }

static int dw_edma_device_pause(struct dma_chan *dchan)
{ … }

static int dw_edma_device_resume(struct dma_chan *dchan)
{ … }

static int dw_edma_device_terminate_all(struct dma_chan *dchan)
{ … }

static void dw_edma_device_issue_pending(struct dma_chan *dchan)
{ … }

static enum dma_status
dw_edma_device_tx_status(struct dma_chan *dchan, dma_cookie_t cookie,
			 struct dma_tx_state *txstate)
{ … }

static struct dma_async_tx_descriptor *
dw_edma_device_transfer(struct dw_edma_transfer *xfer)
{ … }

static struct dma_async_tx_descriptor *
dw_edma_device_prep_slave_sg(struct dma_chan *dchan, struct scatterlist *sgl,
			     unsigned int len,
			     enum dma_transfer_direction direction,
			     unsigned long flags, void *context)
{ … }

static struct dma_async_tx_descriptor *
dw_edma_device_prep_dma_cyclic(struct dma_chan *dchan, dma_addr_t paddr,
			       size_t len, size_t count,
			       enum dma_transfer_direction direction,
			       unsigned long flags)
{ … }

static struct dma_async_tx_descriptor *
dw_edma_device_prep_interleaved_dma(struct dma_chan *dchan,
				    struct dma_interleaved_template *ilt,
				    unsigned long flags)
{ … }

static void dw_edma_done_interrupt(struct dw_edma_chan *chan)
{ … }

static void dw_edma_abort_interrupt(struct dw_edma_chan *chan)
{ … }

static inline irqreturn_t dw_edma_interrupt_write(int irq, void *data)
{ … }

static inline irqreturn_t dw_edma_interrupt_read(int irq, void *data)
{ … }

static irqreturn_t dw_edma_interrupt_common(int irq, void *data)
{ … }

static int dw_edma_alloc_chan_resources(struct dma_chan *dchan)
{ … }

static void dw_edma_free_chan_resources(struct dma_chan *dchan)
{ … }

static int dw_edma_channel_setup(struct dw_edma *dw, u32 wr_alloc, u32 rd_alloc)
{ … }

static inline void dw_edma_dec_irq_alloc(int *nr_irqs, u32 *alloc, u16 cnt)
{ … }

static inline void dw_edma_add_irq_mask(u32 *mask, u32 alloc, u16 cnt)
{ … }

static int dw_edma_irq_request(struct dw_edma *dw,
			       u32 *wr_alloc, u32 *rd_alloc)
{ … }

int dw_edma_probe(struct dw_edma_chip *chip)
{ … }
EXPORT_SYMBOL_GPL(…);

int dw_edma_remove(struct dw_edma_chip *chip)
{ … }
EXPORT_SYMBOL_GPL(…);

MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;