hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

dmaengine: rcar-dmac: Add support for R-Car V3U 

The DMACs (both SYS-DMAC and RT-DMAC) on R-Car V3U differ slightly from
the DMACs on R-Car Gen2 and other R-Car Gen3 SoCs:
  1. The per-channel registers are located in a second register block.
     Add support for mapping the second block, using the appropriate
     offsets and stride.
  2. The common Channel Clear Register (DMACHCLR) was replaced by a
     per-channel register.
     Update rcar_dmac_chan_clear{,_all}() to handle this.
     As rcar_dmac_init() needs to clear the status before the individual
     channels are probed, channel index and base address initialization
     are moved forward.

Inspired by a patch in the BSP by Phong Hoang
<phong.hoang.wz@renesas.com>.

Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Tested-by: Wolfram Sang <wsa+renesas@sang-engineering.com>
Tested-by: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
Reviewed-by: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
Link: https://lore.kernel.org/r/20210128084455.2237256-5-geert+renesas@glider.be
Signed-off-by: Vinod Koul <vkoul@kernel.org>
This commit is contained in:
Geert Uytterhoeven 2021-01-28 09:44:55 +01:00 committed by Vinod Koul
parent 245bbd16b7
commit e5bfbbb916
1 changed files with 58 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
drivers/dma/sh/rcar-dmac.c
View File

@ -189,7 +189,8 @@ struct rcar_dmac_chan {
* struct rcar_dmac - R-Car Gen2 DMA Controller * struct rcar_dmac - R-Car Gen2 DMA Controller
* @engine: base DMA engine object * @engine: base DMA engine object
* @dev: the hardware device * @dev: the hardware device
* @iomem: remapped I/O memory base * @dmac_base: remapped base register block
* @chan_base: remapped channel register block (optional)
* @n_channels: number of available channels * @n_channels: number of available channels
* @channels: array of DMAC channels * @channels: array of DMAC channels
* @channels_mask: bitfield of which DMA channels are managed by this driver * @channels_mask: bitfield of which DMA channels are managed by this driver
@ -198,7 +199,8 @@ struct rcar_dmac_chan {
struct rcar_dmac { struct rcar_dmac {
struct dma_device engine; struct dma_device engine;
struct device *dev; struct device *dev;
void __iomem *iomem; void __iomem *dmac_base;
void __iomem *chan_base;
unsigned int n_channels; unsigned int n_channels;
struct rcar_dmac_chan *channels; struct rcar_dmac_chan *channels;
@ -234,7 +236,7 @@ struct rcar_dmac_of_data {
#define RCAR_DMAOR_PRI_ROUND_ROBIN (3 << 8) #define RCAR_DMAOR_PRI_ROUND_ROBIN (3 << 8)
#define RCAR_DMAOR_AE (1 << 2) #define RCAR_DMAOR_AE (1 << 2)
#define RCAR_DMAOR_DME (1 << 0) #define RCAR_DMAOR_DME (1 << 0)
#define RCAR_DMACHCLR 0x0080 #define RCAR_DMACHCLR 0x0080 /* Not on R-Car V3U */
#define RCAR_DMADPSEC 0x00a0 #define RCAR_DMADPSEC 0x00a0
#define RCAR_DMASAR 0x0000 #define RCAR_DMASAR 0x0000
@ -297,6 +299,9 @@ struct rcar_dmac_of_data {
#define RCAR_DMAFIXDAR 0x0014 #define RCAR_DMAFIXDAR 0x0014
#define RCAR_DMAFIXDPBASE 0x0060 #define RCAR_DMAFIXDPBASE 0x0060
/* For R-Car V3U */
#define RCAR_V3U_DMACHCLR 0x0100
/* Hardcode the MEMCPY transfer size to 4 bytes. */ /* Hardcode the MEMCPY transfer size to 4 bytes. */
#define RCAR_DMAC_MEMCPY_XFER_SIZE 4 #define RCAR_DMAC_MEMCPY_XFER_SIZE 4
@ -307,17 +312,17 @@ struct rcar_dmac_of_data {
static void rcar_dmac_write(struct rcar_dmac *dmac, u32 reg, u32 data) static void rcar_dmac_write(struct rcar_dmac *dmac, u32 reg, u32 data)
{ {
if (reg == RCAR_DMAOR) if (reg == RCAR_DMAOR)
writew(data, dmac->iomem + reg); writew(data, dmac->dmac_base + reg);
else else
writel(data, dmac->iomem + reg); writel(data, dmac->dmac_base + reg);
} }
static u32 rcar_dmac_read(struct rcar_dmac *dmac, u32 reg) static u32 rcar_dmac_read(struct rcar_dmac *dmac, u32 reg)
{ {
if (reg == RCAR_DMAOR) if (reg == RCAR_DMAOR)
return readw(dmac->iomem + reg); return readw(dmac->dmac_base + reg);
else else
return readl(dmac->iomem + reg); return readl(dmac->dmac_base + reg);
} }
static u32 rcar_dmac_chan_read(struct rcar_dmac_chan *chan, u32 reg) static u32 rcar_dmac_chan_read(struct rcar_dmac_chan *chan, u32 reg)
@ -339,12 +344,23 @@ static void rcar_dmac_chan_write(struct rcar_dmac_chan *chan, u32 reg, u32 data)
static void rcar_dmac_chan_clear(struct rcar_dmac *dmac, static void rcar_dmac_chan_clear(struct rcar_dmac *dmac,
struct rcar_dmac_chan *chan) struct rcar_dmac_chan *chan)
{ {
rcar_dmac_write(dmac, RCAR_DMACHCLR, BIT(chan->index)); if (dmac->chan_base)
rcar_dmac_chan_write(chan, RCAR_V3U_DMACHCLR, 1);
else
rcar_dmac_write(dmac, RCAR_DMACHCLR, BIT(chan->index));
} }
static void rcar_dmac_chan_clear_all(struct rcar_dmac *dmac) static void rcar_dmac_chan_clear_all(struct rcar_dmac *dmac)
{ {
rcar_dmac_write(dmac, RCAR_DMACHCLR, dmac->channels_mask); struct rcar_dmac_chan *chan;
unsigned int i;
if (dmac->chan_base) {
for_each_rcar_dmac_chan(i, dmac, chan)
rcar_dmac_chan_write(chan, RCAR_V3U_DMACHCLR, 1);
} else {
rcar_dmac_write(dmac, RCAR_DMACHCLR, dmac->channels_mask);
}
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
@ -1743,9 +1759,7 @@ static const struct dev_pm_ops rcar_dmac_pm = {
*/ */
static int rcar_dmac_chan_probe(struct rcar_dmac *dmac, static int rcar_dmac_chan_probe(struct rcar_dmac *dmac,
struct rcar_dmac_chan *rchan, struct rcar_dmac_chan *rchan)
const struct rcar_dmac_of_data *data,
unsigned int index)
{ {
struct platform_device *pdev = to_platform_device(dmac->dev); struct platform_device *pdev = to_platform_device(dmac->dev);
struct dma_chan *chan = &rchan->chan; struct dma_chan *chan = &rchan->chan;
@ -1753,9 +1767,6 @@ static int rcar_dmac_chan_probe(struct rcar_dmac *dmac,
char *irqname; char *irqname;
int ret; int ret;
rchan->index = index;
rchan->iomem = dmac->iomem + data->chan_offset_base +
data->chan_offset_stride * index;
rchan->mid_rid = -EINVAL; rchan->mid_rid = -EINVAL;
spin_lock_init(&rchan->lock); spin_lock_init(&rchan->lock);
@ -1767,13 +1778,13 @@ static int rcar_dmac_chan_probe(struct rcar_dmac *dmac,
INIT_LIST_HEAD(&rchan->desc.wait); INIT_LIST_HEAD(&rchan->desc.wait);
/* Request the channel interrupt. */ /* Request the channel interrupt. */
sprintf(pdev_irqname, "ch%u", index); sprintf(pdev_irqname, "ch%u", rchan->index);
rchan->irq = platform_get_irq_byname(pdev, pdev_irqname); rchan->irq = platform_get_irq_byname(pdev, pdev_irqname);
if (rchan->irq < 0) if (rchan->irq < 0)
return -ENODEV; return -ENODEV;
irqname = devm_kasprintf(dmac->dev, GFP_KERNEL, "%s:%u", irqname = devm_kasprintf(dmac->dev, GFP_KERNEL, "%s:%u",
dev_name(dmac->dev), index); dev_name(dmac->dev), rchan->index);
if (!irqname) if (!irqname)
return -ENOMEM; return -ENOMEM;
@ -1842,6 +1853,7 @@ static int rcar_dmac_probe(struct platform_device *pdev)
const struct rcar_dmac_of_data *data; const struct rcar_dmac_of_data *data;
struct rcar_dmac_chan *chan; struct rcar_dmac_chan *chan;
struct dma_device *engine; struct dma_device *engine;
void __iomem *chan_base;
struct rcar_dmac *dmac; struct rcar_dmac *dmac;
unsigned int i; unsigned int i;
int ret; int ret;
@ -1880,9 +1892,24 @@ static int rcar_dmac_probe(struct platform_device *pdev)
return -ENOMEM; return -ENOMEM;
/* Request resources. */ /* Request resources. */
dmac->iomem = devm_platform_ioremap_resource(pdev, 0); dmac->dmac_base = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(dmac->iomem)) if (IS_ERR(dmac->dmac_base))
return PTR_ERR(dmac->iomem); return PTR_ERR(dmac->dmac_base);
if (!data->chan_offset_base) {
dmac->chan_base = devm_platform_ioremap_resource(pdev, 1);
if (IS_ERR(dmac->chan_base))
return PTR_ERR(dmac->chan_base);
chan_base = dmac->chan_base;
} else {
chan_base = dmac->dmac_base + data->chan_offset_base;
}
for_each_rcar_dmac_chan(i, dmac, chan) {
chan->index = i;
chan->iomem = chan_base + i * data->chan_offset_stride;
}
/* Enable runtime PM and initialize the device. */ /* Enable runtime PM and initialize the device. */
pm_runtime_enable(&pdev->dev); pm_runtime_enable(&pdev->dev);
@ -1929,7 +1956,7 @@ static int rcar_dmac_probe(struct platform_device *pdev)
INIT_LIST_HEAD(&engine->channels); INIT_LIST_HEAD(&engine->channels);
for_each_rcar_dmac_chan(i, dmac, chan) { for_each_rcar_dmac_chan(i, dmac, chan) {
ret = rcar_dmac_chan_probe(dmac, chan, data, i); ret = rcar_dmac_chan_probe(dmac, chan);
if (ret < 0) if (ret < 0)
goto error; goto error;
} }
@ -1977,14 +2004,22 @@ static void rcar_dmac_shutdown(struct platform_device *pdev)
} }
static const struct rcar_dmac_of_data rcar_dmac_data = { static const struct rcar_dmac_of_data rcar_dmac_data = {
.chan_offset_base = 0x8000, .chan_offset_base = 0x8000,
.chan_offset_stride = 0x80, .chan_offset_stride = 0x80,
};
static const struct rcar_dmac_of_data rcar_v3u_dmac_data = {
.chan_offset_base = 0x0,
.chan_offset_stride = 0x1000,
}; };
static const struct of_device_id rcar_dmac_of_ids[] = { static const struct of_device_id rcar_dmac_of_ids[] = {
{ {
.compatible = "renesas,rcar-dmac", .compatible = "renesas,rcar-dmac",
.data = &rcar_dmac_data, .data = &rcar_dmac_data,
}, {
.compatible = "renesas,dmac-r8a779a0",
.data = &rcar_v3u_dmac_data,
}, },
{ /* Sentinel */ } { /* Sentinel */ }
}; };