mirror of
https://github.com/torvalds/linux.git
synced 2024-12-24 20:01:55 +00:00
dmaengine updates for v6.7
Updates: - Big pile of __counted_by attribute annotations to several structures for bounds checking of flexible arrays at run-time - Another big pile platform remove callback returning void changes - Device tree device_get_match_data() usage and dropping of_match_device() calls - Minor driver updates to pxa, idxd fsl, hisi etc drivers -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEE+vs47OPLdNbVcHzyfBQHDyUjg0cFAmVE43oACgkQfBQHDyUj g0clYg/9Fxm042/2teLU1z3kggXSsCzLYg3NIDEdU/8AGQyJtb8van2mBnnUW8Rh LoOf+b0HZEAyBQUjIYCPCMXovOYKEIjMLRJeZGYUZH3yzi2RImvIAA4FLfKHUTzj JKbbKHYSc226JixKv0td5+Tdd2G+Zpxrr+77HatgU5a43FYlfXgi294rc3uQxSvl moz+0xq/muVTmT5Brva32Ezk2YkmzAmQ+Ek2YK1TI8pQgjqupUtO5/66bzPMYK/Z AsJqGhQ+JXp54cSqRssWzDi6OCrtn1Xh4sAlUhZNC078o+QdOeQu7AN3W9nrYyd7 Kf6kFR8p/c7Q8LxTFKdp1QHam27cbUWJ+WV3olDrHgrAI2LKUYv3KIoD9Q3XvEBt rTRbEjWu6i7G3SOWH+JedoAKLMFtWph5EEIIbCSMbd8jkLidz1/R2cgSn+3m4BF/ t7al3dUyqERq4terM7q+04J8x9W2/Wtg53xizcurzryw+PiWnA0y35vw5JQ1fBpG JXIY6iBx5xWm+jbDRznvkeFhr7dHPXbS3eOJGbUkDumzLafruXd0NlRZcTkA25aR dJt+8e8434T/hVqaMRw+XGpIIS27mfFeJenqQWuj6j9AbFcnmhl72ecXqmD7khRb SfBrkGdtjQSNO5oAVJyVEPZ8Eu+VPF+IKF6PTkWsJqVPBo4RS2o= =DeMU -----END PGP SIGNATURE----- Merge tag 'dmaengine-6.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/dmaengine Pull dmaengine updates from Vinod Koul: - Big pile of __counted_by attribute annotations to several structures for bounds checking of flexible arrays at run-time - Another big pile platform remove callback returning void changes - Device tree device_get_match_data() usage and dropping of_match_device() calls - Minor driver updates to pxa, idxd fsl, hisi etc drivers * tag 'dmaengine-6.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/dmaengine: (106 commits) dmaengine: stm32-mdma: correct desc prep when channel running dmaengine: dw-axi-dmac: Add support DMAX_NUM_CHANNELS > 16 dmaengine: xilinx: xilinx_dma: Fix kernel doc about xilinx_dma_remove() dmaengine: mmp_tdma: drop unused variable 'of_id' MAINTAINERS: Add entries for NXP(Freescale) eDMA drivers dmaengine: xilinx: xdma: Support cyclic transfers dmaengine: xilinx: xdma: Prepare the introduction of cyclic transfers dmaengine: Drop unnecessary of_match_device() calls dmaengine: Use device_get_match_data() dmaengine: pxa_dma: Annotate struct pxad_desc_sw with __counted_by dmaengine: pxa_dma: Remove an erroneous BUG_ON() in pxad_free_desc() dmaengine: xilinx: xdma: Use resource_size() in xdma_probe() dmaengine: fsl-dpaa2-qdma: Remove redundant initialization owner in dpaa2_qdma_driver dmaengine: Remove unused declaration dma_chan_cleanup() dmaengine: mmp: fix Wvoid-pointer-to-enum-cast warning dmaengine: qcom: fix Wvoid-pointer-to-enum-cast warning dmaengine: fsl-edma: Remove redundant dev_err() for platform_get_irq() dmaengine: ep93xx_dma: Annotate struct ep93xx_dma_engine with __counted_by dmaengine: idxd: add wq driver name support for accel-config user tool dmaengine: fsl-edma: Annotate struct struct fsl_edma_engine with __counted_by ...
This commit is contained in:
commit
d934aef6bb
@ -270,6 +270,12 @@ Description: Shows the operation capability bits displayed in bitmap format
|
||||
correlates to the operations allowed. It's visible only
|
||||
on platforms that support the capability.
|
||||
|
||||
What: /sys/bus/dsa/devices/wq<m>.<n>/driver_name
|
||||
Date: Sept 8, 2023
|
||||
KernelVersion: 6.7.0
|
||||
Contact: dmaengine@vger.kernel.org
|
||||
Description: Name of driver to be bounded to the wq.
|
||||
|
||||
What: /sys/bus/dsa/devices/engine<m>.<n>/group_id
|
||||
Date: Oct 25, 2019
|
||||
KernelVersion: 5.6.0
|
||||
|
@ -69,6 +69,8 @@ properties:
|
||||
dma-channel-mask:
|
||||
maxItems: 1
|
||||
|
||||
dma-coherent: true
|
||||
|
||||
required:
|
||||
- compatible
|
||||
- reg
|
||||
|
@ -8338,6 +8338,14 @@ F: Documentation/devicetree/bindings/spi/spi-fsl-dspi.txt
|
||||
F: drivers/spi/spi-fsl-dspi.c
|
||||
F: include/linux/spi/spi-fsl-dspi.h
|
||||
|
||||
FREESCALE eDMA DRIVER
|
||||
M: Frank Li <Frank.Li@nxp.com>
|
||||
L: imx@lists.linux.dev
|
||||
L: dmaengine@vger.kernel.org
|
||||
S: Maintained
|
||||
F: Documentation/devicetree/bindings/dma/fsl,edma.yaml
|
||||
F: drivers/dma/fsl-edma*.*
|
||||
|
||||
FREESCALE ENETC ETHERNET DRIVERS
|
||||
M: Claudiu Manoil <claudiu.manoil@nxp.com>
|
||||
M: Vladimir Oltean <vladimir.oltean@nxp.com>
|
||||
|
@ -362,7 +362,7 @@ config INTEL_IOATDMA
|
||||
|
||||
config K3_DMA
|
||||
tristate "Hisilicon K3 DMA support"
|
||||
depends on ARCH_HI3xxx || ARCH_HISI || COMPILE_TEST
|
||||
depends on ARCH_HISI || COMPILE_TEST
|
||||
select DMA_ENGINE
|
||||
select DMA_VIRTUAL_CHANNELS
|
||||
help
|
||||
|
@ -923,7 +923,7 @@ fail:
|
||||
*
|
||||
* Return: Always '0'
|
||||
*/
|
||||
static int msgdma_remove(struct platform_device *pdev)
|
||||
static void msgdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct msgdma_device *mdev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -933,8 +933,6 @@ static int msgdma_remove(struct platform_device *pdev)
|
||||
msgdma_dev_remove(mdev);
|
||||
|
||||
dev_notice(&pdev->dev, "Altera mSGDMA driver removed\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
@ -952,7 +950,7 @@ static struct platform_driver msgdma_driver = {
|
||||
.of_match_table = of_match_ptr(msgdma_match),
|
||||
},
|
||||
.probe = msgdma_probe,
|
||||
.remove = msgdma_remove,
|
||||
.remove_new = msgdma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(msgdma_driver);
|
||||
|
@ -128,7 +128,7 @@ struct admac_data {
|
||||
int irq;
|
||||
int irq_index;
|
||||
int nchannels;
|
||||
struct admac_chan channels[];
|
||||
struct admac_chan channels[] __counted_by(nchannels);
|
||||
};
|
||||
|
||||
struct admac_tx {
|
||||
@ -925,7 +925,7 @@ free_reset:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int admac_remove(struct platform_device *pdev)
|
||||
static void admac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct admac_data *ad = platform_get_drvdata(pdev);
|
||||
|
||||
@ -933,8 +933,6 @@ static int admac_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&ad->dma);
|
||||
free_irq(ad->irq, ad);
|
||||
reset_control_rearm(ad->rstc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id admac_of_match[] = {
|
||||
@ -949,7 +947,7 @@ static struct platform_driver apple_admac_driver = {
|
||||
.of_match_table = admac_of_match,
|
||||
},
|
||||
.probe = admac_probe,
|
||||
.remove = admac_remove,
|
||||
.remove_new = admac_remove,
|
||||
};
|
||||
module_platform_driver(apple_admac_driver);
|
||||
|
||||
|
@ -239,7 +239,7 @@ struct at_desc {
|
||||
bool memset_buffer;
|
||||
dma_addr_t memset_paddr;
|
||||
int *memset_vaddr;
|
||||
struct atdma_sg sg[];
|
||||
struct atdma_sg sg[] __counted_by(sglen);
|
||||
};
|
||||
|
||||
/*-- Channels --------------------------------------------------------*/
|
||||
@ -2100,7 +2100,7 @@ err_irq:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int at_dma_remove(struct platform_device *pdev)
|
||||
static void at_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct at_dma *atdma = platform_get_drvdata(pdev);
|
||||
struct dma_chan *chan, *_chan;
|
||||
@ -2122,8 +2122,6 @@ static int at_dma_remove(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
clk_disable_unprepare(atdma->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void at_dma_shutdown(struct platform_device *pdev)
|
||||
@ -2242,7 +2240,7 @@ static const struct dev_pm_ops __maybe_unused at_dma_dev_pm_ops = {
|
||||
};
|
||||
|
||||
static struct platform_driver at_dma_driver = {
|
||||
.remove = at_dma_remove,
|
||||
.remove_new = at_dma_remove,
|
||||
.shutdown = at_dma_shutdown,
|
||||
.id_table = atdma_devtypes,
|
||||
.driver = {
|
||||
|
@ -2431,7 +2431,7 @@ err_free_irq:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int at_xdmac_remove(struct platform_device *pdev)
|
||||
static void at_xdmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct at_xdmac *atxdmac = (struct at_xdmac *)platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -2452,8 +2452,6 @@ static int at_xdmac_remove(struct platform_device *pdev)
|
||||
tasklet_kill(&atchan->tasklet);
|
||||
at_xdmac_free_chan_resources(&atchan->chan);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops __maybe_unused atmel_xdmac_dev_pm_ops = {
|
||||
@ -2478,7 +2476,7 @@ MODULE_DEVICE_TABLE(of, atmel_xdmac_dt_ids);
|
||||
|
||||
static struct platform_driver at_xdmac_driver = {
|
||||
.probe = at_xdmac_probe,
|
||||
.remove = at_xdmac_remove,
|
||||
.remove_new = at_xdmac_remove,
|
||||
.driver = {
|
||||
.name = "at_xdmac",
|
||||
.of_match_table = of_match_ptr(atmel_xdmac_dt_ids),
|
||||
|
@ -1734,7 +1734,7 @@ fail_free_mchan:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sba_remove(struct platform_device *pdev)
|
||||
static void sba_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sba_device *sba = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1745,8 +1745,6 @@ static int sba_remove(struct platform_device *pdev)
|
||||
sba_freeup_channel_resources(sba);
|
||||
|
||||
mbox_free_channel(sba->mchan);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id sba_of_match[] = {
|
||||
@ -1758,7 +1756,7 @@ MODULE_DEVICE_TABLE(of, sba_of_match);
|
||||
|
||||
static struct platform_driver sba_driver = {
|
||||
.probe = sba_probe,
|
||||
.remove = sba_remove,
|
||||
.remove_new = sba_remove,
|
||||
.driver = {
|
||||
.name = "bcm-sba-raid",
|
||||
.of_match_table = sba_of_match,
|
||||
|
@ -1019,19 +1019,17 @@ err_no_dma:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int bcm2835_dma_remove(struct platform_device *pdev)
|
||||
static void bcm2835_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct bcm2835_dmadev *od = platform_get_drvdata(pdev);
|
||||
|
||||
dma_async_device_unregister(&od->ddev);
|
||||
bcm2835_dma_free(od);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver bcm2835_dma_driver = {
|
||||
.probe = bcm2835_dma_probe,
|
||||
.remove = bcm2835_dma_remove,
|
||||
.remove_new = bcm2835_dma_remove,
|
||||
.driver = {
|
||||
.name = "bcm2835-dma",
|
||||
.of_match_table = of_match_ptr(bcm2835_dma_of_match),
|
||||
|
@ -455,7 +455,7 @@ error_ofput:
|
||||
}
|
||||
|
||||
|
||||
static int mpc52xx_bcom_remove(struct platform_device *op)
|
||||
static void mpc52xx_bcom_remove(struct platform_device *op)
|
||||
{
|
||||
/* Clean up the engine */
|
||||
bcom_engine_cleanup();
|
||||
@ -473,8 +473,6 @@ static int mpc52xx_bcom_remove(struct platform_device *op)
|
||||
/* Release memory */
|
||||
kfree(bcom_eng);
|
||||
bcom_eng = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id mpc52xx_bcom_of_match[] = {
|
||||
@ -488,7 +486,7 @@ MODULE_DEVICE_TABLE(of, mpc52xx_bcom_of_match);
|
||||
|
||||
static struct platform_driver mpc52xx_bcom_of_platform_driver = {
|
||||
.probe = mpc52xx_bcom_probe,
|
||||
.remove = mpc52xx_bcom_remove,
|
||||
.remove_new = mpc52xx_bcom_remove,
|
||||
.driver = {
|
||||
.name = DRIVER_NAME,
|
||||
.of_match_table = mpc52xx_bcom_of_match,
|
||||
|
@ -117,7 +117,7 @@ struct axi_dmac_desc {
|
||||
unsigned int num_submitted;
|
||||
unsigned int num_completed;
|
||||
unsigned int num_sgs;
|
||||
struct axi_dmac_sg sg[];
|
||||
struct axi_dmac_sg sg[] __counted_by(num_sgs);
|
||||
};
|
||||
|
||||
struct axi_dmac_chan {
|
||||
@ -484,12 +484,11 @@ static struct axi_dmac_desc *axi_dmac_alloc_desc(unsigned int num_sgs)
|
||||
desc = kzalloc(struct_size(desc, sg, num_sgs), GFP_NOWAIT);
|
||||
if (!desc)
|
||||
return NULL;
|
||||
desc->num_sgs = num_sgs;
|
||||
|
||||
for (i = 0; i < num_sgs; i++)
|
||||
desc->sg[i].id = AXI_DMAC_SG_UNUSED;
|
||||
|
||||
desc->num_sgs = num_sgs;
|
||||
|
||||
return desc;
|
||||
}
|
||||
|
||||
@ -1029,7 +1028,7 @@ err_clk_disable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int axi_dmac_remove(struct platform_device *pdev)
|
||||
static void axi_dmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct axi_dmac *dmac = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1038,8 +1037,6 @@ static int axi_dmac_remove(struct platform_device *pdev)
|
||||
tasklet_kill(&dmac->chan.vchan.task);
|
||||
dma_async_device_unregister(&dmac->dma_dev);
|
||||
clk_disable_unprepare(dmac->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id axi_dmac_of_match_table[] = {
|
||||
@ -1054,7 +1051,7 @@ static struct platform_driver axi_dmac_driver = {
|
||||
.of_match_table = axi_dmac_of_match_table,
|
||||
},
|
||||
.probe = axi_dmac_probe,
|
||||
.remove = axi_dmac_remove,
|
||||
.remove_new = axi_dmac_remove,
|
||||
};
|
||||
module_platform_driver(axi_dmac_driver);
|
||||
|
||||
|
@ -1008,7 +1008,7 @@ err_disable_clk:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int jz4780_dma_remove(struct platform_device *pdev)
|
||||
static void jz4780_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct jz4780_dma_dev *jzdma = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -1020,8 +1020,6 @@ static int jz4780_dma_remove(struct platform_device *pdev)
|
||||
|
||||
for (i = 0; i < jzdma->soc_data->nb_channels; i++)
|
||||
tasklet_kill(&jzdma->chan[i].vchan.task);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct jz4780_dma_soc_data jz4740_dma_soc_data = {
|
||||
@ -1124,7 +1122,7 @@ MODULE_DEVICE_TABLE(of, jz4780_dma_dt_match);
|
||||
|
||||
static struct platform_driver jz4780_dma_driver = {
|
||||
.probe = jz4780_dma_probe,
|
||||
.remove = jz4780_dma_remove,
|
||||
.remove_new = jz4780_dma_remove,
|
||||
.driver = {
|
||||
.name = "jz4780-dma",
|
||||
.of_match_table = jz4780_dma_dt_match,
|
||||
|
@ -62,6 +62,17 @@ static inline u32 axi_dma_ioread32(struct axi_dma_chip *chip, u32 reg)
|
||||
return ioread32(chip->regs + reg);
|
||||
}
|
||||
|
||||
static inline void
|
||||
axi_dma_iowrite64(struct axi_dma_chip *chip, u32 reg, u64 val)
|
||||
{
|
||||
iowrite64(val, chip->regs + reg);
|
||||
}
|
||||
|
||||
static inline u64 axi_dma_ioread64(struct axi_dma_chip *chip, u32 reg)
|
||||
{
|
||||
return ioread64(chip->regs + reg);
|
||||
}
|
||||
|
||||
static inline void
|
||||
axi_chan_iowrite32(struct axi_dma_chan *chan, u32 reg, u32 val)
|
||||
{
|
||||
@ -182,38 +193,73 @@ static inline u32 axi_chan_irq_read(struct axi_dma_chan *chan)
|
||||
|
||||
static inline void axi_chan_disable(struct axi_dma_chan *chan)
|
||||
{
|
||||
u32 val;
|
||||
u64 val;
|
||||
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_EN_SHIFT);
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels)
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_WE_SHIFT;
|
||||
else
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN2_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, val);
|
||||
if (chan->chip->dw->hdata->nr_channels >= DMAC_CHAN_16) {
|
||||
val = axi_dma_ioread64(chan->chip, DMAC_CHEN);
|
||||
if (chan->id >= DMAC_CHAN_16) {
|
||||
val &= ~((u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_EN_SHIFT + DMAC_CHAN_BLOCK_SHIFT));
|
||||
val |= (u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_EN2_WE_SHIFT + DMAC_CHAN_BLOCK_SHIFT);
|
||||
} else {
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_EN_SHIFT);
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN2_WE_SHIFT;
|
||||
}
|
||||
axi_dma_iowrite64(chan->chip, DMAC_CHEN, val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_EN_SHIFT);
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels)
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_WE_SHIFT;
|
||||
else
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN2_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, (u32)val);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void axi_chan_enable(struct axi_dma_chan *chan)
|
||||
{
|
||||
u32 val;
|
||||
u64 val;
|
||||
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels)
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_EN_WE_SHIFT;
|
||||
else
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_SHIFT |
|
||||
if (chan->chip->dw->hdata->nr_channels >= DMAC_CHAN_16) {
|
||||
val = axi_dma_ioread64(chan->chip, DMAC_CHEN);
|
||||
if (chan->id >= DMAC_CHAN_16) {
|
||||
val |= (u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_EN_SHIFT + DMAC_CHAN_BLOCK_SHIFT) |
|
||||
(u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_EN2_WE_SHIFT + DMAC_CHAN_BLOCK_SHIFT);
|
||||
} else {
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_EN2_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, val);
|
||||
}
|
||||
axi_dma_iowrite64(chan->chip, DMAC_CHEN, val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels) {
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_EN_WE_SHIFT;
|
||||
} else {
|
||||
val |= BIT(chan->id) << DMAC_CHAN_EN_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_EN2_WE_SHIFT;
|
||||
}
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, (u32)val);
|
||||
}
|
||||
}
|
||||
|
||||
static inline bool axi_chan_is_hw_enable(struct axi_dma_chan *chan)
|
||||
{
|
||||
u32 val;
|
||||
u64 val;
|
||||
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
if (chan->chip->dw->hdata->nr_channels >= DMAC_CHAN_16)
|
||||
val = axi_dma_ioread64(chan->chip, DMAC_CHEN);
|
||||
else
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
|
||||
return !!(val & (BIT(chan->id) << DMAC_CHAN_EN_SHIFT));
|
||||
if (chan->id >= DMAC_CHAN_16)
|
||||
return !!(val & ((u64)(BIT(chan->id) >> DMAC_CHAN_16) << DMAC_CHAN_BLOCK_SHIFT));
|
||||
else
|
||||
return !!(val & (BIT(chan->id) << DMAC_CHAN_EN_SHIFT));
|
||||
}
|
||||
|
||||
static void axi_dma_hw_init(struct axi_dma_chip *chip)
|
||||
@ -1175,20 +1221,34 @@ static int dma_chan_pause(struct dma_chan *dchan)
|
||||
struct axi_dma_chan *chan = dchan_to_axi_dma_chan(dchan);
|
||||
unsigned long flags;
|
||||
unsigned int timeout = 20; /* timeout iterations */
|
||||
u32 val;
|
||||
u64 val;
|
||||
|
||||
spin_lock_irqsave(&chan->vc.lock, flags);
|
||||
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels) {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val |= BIT(chan->id) << DMAC_CHAN_SUSP_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, val);
|
||||
if (chan->chip->dw->hdata->nr_channels >= DMAC_CHAN_16) {
|
||||
val = axi_dma_ioread64(chan->chip, DMAC_CHSUSPREG);
|
||||
if (chan->id >= DMAC_CHAN_16) {
|
||||
val |= (u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_SUSP2_SHIFT + DMAC_CHAN_BLOCK_SHIFT) |
|
||||
(u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_SUSP2_WE_SHIFT + DMAC_CHAN_BLOCK_SHIFT);
|
||||
} else {
|
||||
val |= BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT;
|
||||
}
|
||||
axi_dma_iowrite64(chan->chip, DMAC_CHSUSPREG, val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG);
|
||||
val |= BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT |
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels) {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val |= BIT(chan->id) << DMAC_CHAN_SUSP_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, (u32)val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG);
|
||||
val |= BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT |
|
||||
BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT;
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, val);
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, (u32)val);
|
||||
}
|
||||
}
|
||||
|
||||
do {
|
||||
@ -1210,18 +1270,32 @@ static int dma_chan_pause(struct dma_chan *dchan)
|
||||
/* Called in chan locked context */
|
||||
static inline void axi_chan_resume(struct axi_dma_chan *chan)
|
||||
{
|
||||
u32 val;
|
||||
u64 val;
|
||||
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels) {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP_SHIFT);
|
||||
val |= (BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT);
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, val);
|
||||
if (chan->chip->dw->hdata->nr_channels >= DMAC_CHAN_16) {
|
||||
val = axi_dma_ioread64(chan->chip, DMAC_CHSUSPREG);
|
||||
if (chan->id >= DMAC_CHAN_16) {
|
||||
val &= ~((u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_SUSP2_SHIFT + DMAC_CHAN_BLOCK_SHIFT));
|
||||
val |= ((u64)(BIT(chan->id) >> DMAC_CHAN_16)
|
||||
<< (DMAC_CHAN_SUSP2_WE_SHIFT + DMAC_CHAN_BLOCK_SHIFT));
|
||||
} else {
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT);
|
||||
val |= (BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT);
|
||||
}
|
||||
axi_dma_iowrite64(chan->chip, DMAC_CHSUSPREG, val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT);
|
||||
val |= (BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT);
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, val);
|
||||
if (chan->chip->dw->hdata->reg_map_8_channels) {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHEN);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP_SHIFT);
|
||||
val |= (BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT);
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHEN, (u32)val);
|
||||
} else {
|
||||
val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG);
|
||||
val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT);
|
||||
val |= (BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT);
|
||||
axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, (u32)val);
|
||||
}
|
||||
}
|
||||
|
||||
chan->is_paused = false;
|
||||
@ -1535,7 +1609,7 @@ err_pm_disable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int dw_remove(struct platform_device *pdev)
|
||||
static void dw_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct axi_dma_chip *chip = platform_get_drvdata(pdev);
|
||||
struct dw_axi_dma *dw = chip->dw;
|
||||
@ -1564,8 +1638,6 @@ static int dw_remove(struct platform_device *pdev)
|
||||
list_del(&chan->vc.chan.device_node);
|
||||
tasklet_kill(&chan->vc.task);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops dw_axi_dma_pm_ops = {
|
||||
@ -1588,7 +1660,7 @@ MODULE_DEVICE_TABLE(of, dw_dma_of_id_table);
|
||||
|
||||
static struct platform_driver dw_driver = {
|
||||
.probe = dw_probe,
|
||||
.remove = dw_remove,
|
||||
.remove_new = dw_remove,
|
||||
.driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
.of_match_table = dw_dma_of_id_table,
|
||||
|
@ -18,7 +18,7 @@
|
||||
|
||||
#include "../virt-dma.h"
|
||||
|
||||
#define DMAC_MAX_CHANNELS 16
|
||||
#define DMAC_MAX_CHANNELS 32
|
||||
#define DMAC_MAX_MASTERS 2
|
||||
#define DMAC_MAX_BLK_SIZE 0x200000
|
||||
|
||||
@ -222,6 +222,10 @@ static inline struct axi_dma_chan *dchan_to_axi_dma_chan(struct dma_chan *dchan)
|
||||
/* DMAC_CHEN2 */
|
||||
#define DMAC_CHAN_EN2_WE_SHIFT 16
|
||||
|
||||
/* DMAC CHAN BLOCKS */
|
||||
#define DMAC_CHAN_BLOCK_SHIFT 32
|
||||
#define DMAC_CHAN_16 16
|
||||
|
||||
/* DMAC_CHSUSP */
|
||||
#define DMAC_CHAN_SUSP2_SHIFT 0
|
||||
#define DMAC_CHAN_SUSP2_WE_SHIFT 16
|
||||
|
@ -93,7 +93,7 @@ err_dw_dma_probe:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int dw_remove(struct platform_device *pdev)
|
||||
static void dw_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct dw_dma_chip_pdata *data = platform_get_drvdata(pdev);
|
||||
struct dw_dma_chip *chip = data->chip;
|
||||
@ -109,8 +109,6 @@ static int dw_remove(struct platform_device *pdev)
|
||||
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
clk_disable_unprepare(chip->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void dw_shutdown(struct platform_device *pdev)
|
||||
@ -193,7 +191,7 @@ static const struct dev_pm_ops dw_dev_pm_ops = {
|
||||
|
||||
static struct platform_driver dw_driver = {
|
||||
.probe = dw_probe,
|
||||
.remove = dw_remove,
|
||||
.remove_new = dw_remove,
|
||||
.shutdown = dw_shutdown,
|
||||
.driver = {
|
||||
.name = DRV_NAME,
|
||||
|
@ -213,7 +213,7 @@ struct ep93xx_dma_engine {
|
||||
#define INTERRUPT_NEXT_BUFFER 2
|
||||
|
||||
size_t num_channels;
|
||||
struct ep93xx_dma_chan channels[];
|
||||
struct ep93xx_dma_chan channels[] __counted_by(num_channels);
|
||||
};
|
||||
|
||||
static inline struct device *chan2dev(struct ep93xx_dma_chan *edmac)
|
||||
|
@ -814,7 +814,6 @@ static const struct fsl_mc_device_id dpaa2_qdma_id_table[] = {
|
||||
static struct fsl_mc_driver dpaa2_qdma_driver = {
|
||||
.driver = {
|
||||
.name = "dpaa2-qdma",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.probe = dpaa2_qdma_probe,
|
||||
.remove = dpaa2_qdma_remove,
|
||||
|
@ -225,7 +225,7 @@ struct fsl_edma_engine {
|
||||
bool big_endian;
|
||||
struct edma_regs regs;
|
||||
u64 chan_masked;
|
||||
struct fsl_edma_chan chans[];
|
||||
struct fsl_edma_chan chans[] __counted_by(n_chans);
|
||||
};
|
||||
|
||||
#define edma_read_tcdreg(chan, __name) \
|
||||
|
@ -13,13 +13,11 @@
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of_address.h>
|
||||
#include <linux/of_irq.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/pm_domain.h>
|
||||
#include <linux/property.h>
|
||||
|
||||
#include "fsl-edma-common.h"
|
||||
|
||||
@ -232,10 +230,8 @@ static int fsl_edma3_irq_init(struct platform_device *pdev, struct fsl_edma_engi
|
||||
|
||||
/* request channel irq */
|
||||
fsl_chan->txirq = platform_get_irq(pdev, i);
|
||||
if (fsl_chan->txirq < 0) {
|
||||
dev_err(&pdev->dev, "Can't get chan %d's irq.\n", i);
|
||||
if (fsl_chan->txirq < 0)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = devm_request_irq(&pdev->dev, fsl_chan->txirq,
|
||||
fsl_edma3_tx_handler, IRQF_SHARED,
|
||||
@ -418,8 +414,6 @@ static int fsl_edma3_attach_pd(struct platform_device *pdev, struct fsl_edma_eng
|
||||
|
||||
static int fsl_edma_probe(struct platform_device *pdev)
|
||||
{
|
||||
const struct of_device_id *of_id =
|
||||
of_match_device(fsl_edma_dt_ids, &pdev->dev);
|
||||
struct device_node *np = pdev->dev.of_node;
|
||||
struct fsl_edma_engine *fsl_edma;
|
||||
const struct fsl_edma_drvdata *drvdata = NULL;
|
||||
@ -428,8 +422,7 @@ static int fsl_edma_probe(struct platform_device *pdev)
|
||||
int chans;
|
||||
int ret, i;
|
||||
|
||||
if (of_id)
|
||||
drvdata = of_id->data;
|
||||
drvdata = device_get_match_data(&pdev->dev);
|
||||
if (!drvdata) {
|
||||
dev_err(&pdev->dev, "unable to find driver data\n");
|
||||
return -EINVAL;
|
||||
@ -617,7 +610,7 @@ static int fsl_edma_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fsl_edma_remove(struct platform_device *pdev)
|
||||
static void fsl_edma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct device_node *np = pdev->dev.of_node;
|
||||
struct fsl_edma_engine *fsl_edma = platform_get_drvdata(pdev);
|
||||
@ -627,8 +620,6 @@ static int fsl_edma_remove(struct platform_device *pdev)
|
||||
of_dma_controller_free(np);
|
||||
dma_async_device_unregister(&fsl_edma->dma_dev);
|
||||
fsl_disable_clocks(fsl_edma, fsl_edma->drvdata->dmamuxs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fsl_edma_suspend_late(struct device *dev)
|
||||
@ -692,7 +683,7 @@ static struct platform_driver fsl_edma_driver = {
|
||||
.pm = &fsl_edma_pm_ops,
|
||||
},
|
||||
.probe = fsl_edma_probe,
|
||||
.remove = fsl_edma_remove,
|
||||
.remove_new = fsl_edma_remove,
|
||||
};
|
||||
|
||||
static int __init fsl_edma_init(void)
|
||||
|
@ -1266,7 +1266,7 @@ static void fsl_qdma_cleanup_vchan(struct dma_device *dmadev)
|
||||
}
|
||||
}
|
||||
|
||||
static int fsl_qdma_remove(struct platform_device *pdev)
|
||||
static void fsl_qdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
int i;
|
||||
struct fsl_qdma_queue *status;
|
||||
@ -1283,7 +1283,6 @@ static int fsl_qdma_remove(struct platform_device *pdev)
|
||||
dma_free_coherent(&pdev->dev, sizeof(struct fsl_qdma_format) *
|
||||
status->n_cq, status->cq, status->bus_addr);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsl_qdma_dt_ids[] = {
|
||||
@ -1298,7 +1297,7 @@ static struct platform_driver fsl_qdma_driver = {
|
||||
.of_match_table = fsl_qdma_dt_ids,
|
||||
},
|
||||
.probe = fsl_qdma_probe,
|
||||
.remove = fsl_qdma_remove,
|
||||
.remove_new = fsl_qdma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(fsl_qdma_driver);
|
||||
|
@ -857,7 +857,7 @@ static void fsl_re_remove_chan(struct fsl_re_chan *chan)
|
||||
chan->oub_phys_addr);
|
||||
}
|
||||
|
||||
static int fsl_re_remove(struct platform_device *ofdev)
|
||||
static void fsl_re_remove(struct platform_device *ofdev)
|
||||
{
|
||||
struct fsl_re_drv_private *re_priv;
|
||||
struct device *dev;
|
||||
@ -872,8 +872,6 @@ static int fsl_re_remove(struct platform_device *ofdev)
|
||||
|
||||
/* Unregister the driver */
|
||||
dma_async_device_unregister(&re_priv->dma_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsl_re_ids[] = {
|
||||
@ -888,7 +886,7 @@ static struct platform_driver fsl_re_driver = {
|
||||
.of_match_table = fsl_re_ids,
|
||||
},
|
||||
.probe = fsl_re_probe,
|
||||
.remove = fsl_re_remove,
|
||||
.remove_new = fsl_re_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(fsl_re_driver);
|
||||
|
@ -1306,7 +1306,7 @@ out_return:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int fsldma_of_remove(struct platform_device *op)
|
||||
static void fsldma_of_remove(struct platform_device *op)
|
||||
{
|
||||
struct fsldma_device *fdev;
|
||||
unsigned int i;
|
||||
@ -1324,8 +1324,6 @@ static int fsldma_of_remove(struct platform_device *op)
|
||||
|
||||
iounmap(fdev->regs);
|
||||
kfree(fdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
@ -1406,7 +1404,7 @@ static struct platform_driver fsldma_of_driver = {
|
||||
#endif
|
||||
},
|
||||
.probe = fsldma_of_probe,
|
||||
.remove = fsldma_of_remove,
|
||||
.remove_new = fsldma_of_remove,
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
@ -163,7 +163,7 @@ struct hisi_dma_dev {
|
||||
u32 chan_depth;
|
||||
enum hisi_dma_reg_layout reg_layout;
|
||||
void __iomem *queue_base; /* queue region start of register */
|
||||
struct hisi_dma_chan chan[];
|
||||
struct hisi_dma_chan chan[] __counted_by(chan_num);
|
||||
};
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
|
@ -660,13 +660,11 @@ static int idma64_platform_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int idma64_platform_remove(struct platform_device *pdev)
|
||||
static void idma64_platform_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct idma64_chip *chip = platform_get_drvdata(pdev);
|
||||
|
||||
idma64_remove(chip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused idma64_pm_suspend(struct device *dev)
|
||||
@ -691,7 +689,7 @@ static const struct dev_pm_ops idma64_dev_pm_ops = {
|
||||
|
||||
static struct platform_driver idma64_platform_driver = {
|
||||
.probe = idma64_platform_probe,
|
||||
.remove = idma64_platform_remove,
|
||||
.remove_new = idma64_platform_remove,
|
||||
.driver = {
|
||||
.name = LPSS_IDMA64_DRIVER_NAME,
|
||||
.pm = &idma64_dev_pm_ops,
|
||||
|
@ -1,12 +1,12 @@
|
||||
ccflags-y += -DDEFAULT_SYMBOL_NAMESPACE=IDXD
|
||||
|
||||
obj-$(CONFIG_INTEL_IDXD_BUS) += idxd_bus.o
|
||||
idxd_bus-y := bus.o
|
||||
|
||||
obj-$(CONFIG_INTEL_IDXD) += idxd.o
|
||||
idxd-y := init.o irq.o device.o sysfs.o submit.o dma.o cdev.o debugfs.o
|
||||
|
||||
idxd-$(CONFIG_INTEL_IDXD_PERFMON) += perfmon.o
|
||||
|
||||
obj-$(CONFIG_INTEL_IDXD_BUS) += idxd_bus.o
|
||||
idxd_bus-y := bus.o
|
||||
|
||||
obj-$(CONFIG_INTEL_IDXD_COMPAT) += idxd_compat.o
|
||||
idxd_compat-y := compat.o
|
||||
|
@ -509,6 +509,7 @@ void idxd_wq_del_cdev(struct idxd_wq *wq)
|
||||
|
||||
static int idxd_user_drv_probe(struct idxd_dev *idxd_dev)
|
||||
{
|
||||
struct device *dev = &idxd_dev->conf_dev;
|
||||
struct idxd_wq *wq = idxd_dev_to_wq(idxd_dev);
|
||||
struct idxd_device *idxd = wq->idxd;
|
||||
int rc;
|
||||
@ -536,6 +537,12 @@ static int idxd_user_drv_probe(struct idxd_dev *idxd_dev)
|
||||
|
||||
mutex_lock(&wq->wq_lock);
|
||||
|
||||
if (!idxd_wq_driver_name_match(wq, dev)) {
|
||||
idxd->cmd_status = IDXD_SCMD_WQ_NO_DRV_NAME;
|
||||
rc = -ENODEV;
|
||||
goto wq_err;
|
||||
}
|
||||
|
||||
wq->wq = create_workqueue(dev_name(wq_confdev(wq)));
|
||||
if (!wq->wq) {
|
||||
rc = -ENOMEM;
|
||||
|
@ -306,6 +306,12 @@ static int idxd_dmaengine_drv_probe(struct idxd_dev *idxd_dev)
|
||||
return -ENXIO;
|
||||
|
||||
mutex_lock(&wq->wq_lock);
|
||||
if (!idxd_wq_driver_name_match(wq, dev)) {
|
||||
idxd->cmd_status = IDXD_SCMD_WQ_NO_DRV_NAME;
|
||||
rc = -ENODEV;
|
||||
goto err;
|
||||
}
|
||||
|
||||
wq->type = IDXD_WQT_KERNEL;
|
||||
|
||||
rc = drv_enable_wq(wq);
|
||||
|
@ -159,6 +159,8 @@ struct idxd_cdev {
|
||||
int minor;
|
||||
};
|
||||
|
||||
#define DRIVER_NAME_SIZE 128
|
||||
|
||||
#define IDXD_ALLOCATED_BATCH_SIZE 128U
|
||||
#define WQ_NAME_SIZE 1024
|
||||
#define WQ_TYPE_SIZE 10
|
||||
@ -227,6 +229,8 @@ struct idxd_wq {
|
||||
/* Lock to protect upasid_xa access. */
|
||||
struct mutex uc_lock;
|
||||
struct xarray upasid_xa;
|
||||
|
||||
char driver_name[DRIVER_NAME_SIZE + 1];
|
||||
};
|
||||
|
||||
struct idxd_engine {
|
||||
@ -646,6 +650,11 @@ static inline void idxd_wqcfg_set_max_batch_shift(int idxd_type, union wqcfg *wq
|
||||
wqcfg->max_batch_shift = max_batch_shift;
|
||||
}
|
||||
|
||||
static inline int idxd_wq_driver_name_match(struct idxd_wq *wq, struct device *dev)
|
||||
{
|
||||
return (strncmp(wq->driver_name, dev->driver->name, strlen(dev->driver->name)) == 0);
|
||||
}
|
||||
|
||||
int __must_check __idxd_driver_register(struct idxd_device_driver *idxd_drv,
|
||||
struct module *module, const char *mod_name);
|
||||
#define idxd_driver_register(driver) \
|
||||
|
@ -434,8 +434,8 @@ irqreturn_t idxd_misc_thread(int vec, void *data)
|
||||
val |= IDXD_INTC_ERR;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
dev_warn(dev, "err[%d]: %#16.16llx\n",
|
||||
i, idxd->sw_err.bits[i]);
|
||||
dev_warn_ratelimited(dev, "err[%d]: %#16.16llx\n",
|
||||
i, idxd->sw_err.bits[i]);
|
||||
err = true;
|
||||
}
|
||||
|
||||
|
@ -1259,6 +1259,39 @@ err:
|
||||
static struct device_attribute dev_attr_wq_op_config =
|
||||
__ATTR(op_config, 0644, wq_op_config_show, wq_op_config_store);
|
||||
|
||||
static ssize_t wq_driver_name_show(struct device *dev, struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct idxd_wq *wq = confdev_to_wq(dev);
|
||||
|
||||
return sysfs_emit(buf, "%s\n", wq->driver_name);
|
||||
}
|
||||
|
||||
static ssize_t wq_driver_name_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
struct idxd_wq *wq = confdev_to_wq(dev);
|
||||
char *input, *pos;
|
||||
|
||||
if (wq->state != IDXD_WQ_DISABLED)
|
||||
return -EPERM;
|
||||
|
||||
if (strlen(buf) > DRIVER_NAME_SIZE || strlen(buf) == 0)
|
||||
return -EINVAL;
|
||||
|
||||
input = kstrndup(buf, count, GFP_KERNEL);
|
||||
if (!input)
|
||||
return -ENOMEM;
|
||||
|
||||
pos = strim(input);
|
||||
memset(wq->driver_name, 0, DRIVER_NAME_SIZE + 1);
|
||||
sprintf(wq->driver_name, "%s", pos);
|
||||
kfree(input);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct device_attribute dev_attr_wq_driver_name =
|
||||
__ATTR(driver_name, 0644, wq_driver_name_show, wq_driver_name_store);
|
||||
|
||||
static struct attribute *idxd_wq_attributes[] = {
|
||||
&dev_attr_wq_clients.attr,
|
||||
&dev_attr_wq_state.attr,
|
||||
@ -1278,6 +1311,7 @@ static struct attribute *idxd_wq_attributes[] = {
|
||||
&dev_attr_wq_occupancy.attr,
|
||||
&dev_attr_wq_enqcmds_retries.attr,
|
||||
&dev_attr_wq_op_config.attr,
|
||||
&dev_attr_wq_driver_name.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
|
@ -1017,7 +1017,7 @@ suspend:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int mdc_dma_remove(struct platform_device *pdev)
|
||||
static void mdc_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct mdc_dma *mdma = platform_get_drvdata(pdev);
|
||||
struct mdc_chan *mchan, *next;
|
||||
@ -1037,8 +1037,6 @@ static int mdc_dma_remove(struct platform_device *pdev)
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
if (!pm_runtime_status_suspended(&pdev->dev))
|
||||
img_mdc_runtime_suspend(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
@ -1078,7 +1076,7 @@ static struct platform_driver mdc_dma_driver = {
|
||||
.of_match_table = of_match_ptr(mdc_dma_of_match),
|
||||
},
|
||||
.probe = mdc_dma_probe,
|
||||
.remove = mdc_dma_remove,
|
||||
.remove_new = mdc_dma_remove,
|
||||
};
|
||||
module_platform_driver(mdc_dma_driver);
|
||||
|
||||
|
@ -1216,7 +1216,7 @@ static void imxdma_free_irq(struct platform_device *pdev, struct imxdma_engine *
|
||||
}
|
||||
}
|
||||
|
||||
static int imxdma_remove(struct platform_device *pdev)
|
||||
static void imxdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct imxdma_engine *imxdma = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1229,8 +1229,6 @@ static int imxdma_remove(struct platform_device *pdev)
|
||||
|
||||
clk_disable_unprepare(imxdma->dma_ipg);
|
||||
clk_disable_unprepare(imxdma->dma_ahb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver imxdma_driver = {
|
||||
@ -1238,7 +1236,7 @@ static struct platform_driver imxdma_driver = {
|
||||
.name = "imx-dma",
|
||||
.of_match_table = imx_dma_of_dev_id,
|
||||
},
|
||||
.remove = imxdma_remove,
|
||||
.remove_new = imxdma_remove,
|
||||
};
|
||||
|
||||
static int __init imxdma_module_init(void)
|
||||
|
@ -2358,7 +2358,7 @@ err_clk:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sdma_remove(struct platform_device *pdev)
|
||||
static void sdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sdma_engine *sdma = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -2377,7 +2377,6 @@ static int sdma_remove(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver sdma_driver = {
|
||||
@ -2385,7 +2384,7 @@ static struct platform_driver sdma_driver = {
|
||||
.name = "imx-sdma",
|
||||
.of_match_table = sdma_dt_ids,
|
||||
},
|
||||
.remove = sdma_remove,
|
||||
.remove_new = sdma_remove,
|
||||
.probe = sdma_probe,
|
||||
};
|
||||
|
||||
|
@ -15,7 +15,6 @@
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/of_dma.h>
|
||||
@ -839,7 +838,6 @@ static int k3_dma_probe(struct platform_device *op)
|
||||
{
|
||||
const struct k3dma_soc_data *soc_data;
|
||||
struct k3_dma_dev *d;
|
||||
const struct of_device_id *of_id;
|
||||
int i, ret, irq = 0;
|
||||
|
||||
d = devm_kzalloc(&op->dev, sizeof(*d), GFP_KERNEL);
|
||||
@ -854,19 +852,16 @@ static int k3_dma_probe(struct platform_device *op)
|
||||
if (IS_ERR(d->base))
|
||||
return PTR_ERR(d->base);
|
||||
|
||||
of_id = of_match_device(k3_pdma_dt_ids, &op->dev);
|
||||
if (of_id) {
|
||||
of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-channels", &d->dma_channels);
|
||||
of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-requests", &d->dma_requests);
|
||||
ret = of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-channel-mask", &d->dma_channel_mask);
|
||||
if (ret) {
|
||||
dev_warn(&op->dev,
|
||||
"dma-channel-mask doesn't exist, considering all as available.\n");
|
||||
d->dma_channel_mask = (u32)~0UL;
|
||||
}
|
||||
of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-channels", &d->dma_channels);
|
||||
of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-requests", &d->dma_requests);
|
||||
ret = of_property_read_u32((&op->dev)->of_node,
|
||||
"dma-channel-mask", &d->dma_channel_mask);
|
||||
if (ret) {
|
||||
dev_warn(&op->dev,
|
||||
"dma-channel-mask doesn't exist, considering all as available.\n");
|
||||
d->dma_channel_mask = (u32)~0UL;
|
||||
}
|
||||
|
||||
if (!(soc_data->flags & K3_FLAG_NOCLK)) {
|
||||
@ -974,7 +969,7 @@ dma_async_register_fail:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int k3_dma_remove(struct platform_device *op)
|
||||
static void k3_dma_remove(struct platform_device *op)
|
||||
{
|
||||
struct k3_dma_chan *c, *cn;
|
||||
struct k3_dma_dev *d = platform_get_drvdata(op);
|
||||
@ -990,7 +985,6 @@ static int k3_dma_remove(struct platform_device *op)
|
||||
}
|
||||
tasklet_kill(&d->task);
|
||||
clk_disable_unprepare(d->clk);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
@ -1034,7 +1028,7 @@ static struct platform_driver k3_pdma_driver = {
|
||||
.of_match_table = k3_pdma_dt_ids,
|
||||
},
|
||||
.probe = k3_dma_probe,
|
||||
.remove = k3_dma_remove,
|
||||
.remove_new = k3_dma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(k3_pdma_driver);
|
||||
|
@ -255,15 +255,13 @@ static int mcf_edma_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mcf_edma_remove(struct platform_device *pdev)
|
||||
static void mcf_edma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct fsl_edma_engine *mcf_edma = platform_get_drvdata(pdev);
|
||||
|
||||
mcf_edma_irq_free(pdev, mcf_edma);
|
||||
fsl_edma_cleanup_vchan(&mcf_edma->dma_dev);
|
||||
dma_async_device_unregister(&mcf_edma->dma_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver mcf_edma_driver = {
|
||||
@ -271,7 +269,7 @@ static struct platform_driver mcf_edma_driver = {
|
||||
.name = "mcf-edma",
|
||||
},
|
||||
.probe = mcf_edma_probe,
|
||||
.remove = mcf_edma_remove,
|
||||
.remove_new = mcf_edma_remove,
|
||||
};
|
||||
|
||||
bool mcf_edma_filter_fn(struct dma_chan *chan, void *param)
|
||||
|
@ -885,7 +885,7 @@ err_unregister:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int mtk_cqdma_remove(struct platform_device *pdev)
|
||||
static void mtk_cqdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct mtk_cqdma_device *cqdma = platform_get_drvdata(pdev);
|
||||
struct mtk_cqdma_vchan *vc;
|
||||
@ -918,13 +918,11 @@ static int mtk_cqdma_remove(struct platform_device *pdev)
|
||||
|
||||
dma_async_device_unregister(&cqdma->ddev);
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver mtk_cqdma_driver = {
|
||||
.probe = mtk_cqdma_probe,
|
||||
.remove = mtk_cqdma_remove,
|
||||
.remove_new = mtk_cqdma_remove,
|
||||
.driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
.of_match_table = mtk_cqdma_match,
|
||||
|
@ -1009,7 +1009,7 @@ err_unregister:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int mtk_hsdma_remove(struct platform_device *pdev)
|
||||
static void mtk_hsdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct mtk_hsdma_device *hsdma = platform_get_drvdata(pdev);
|
||||
struct mtk_hsdma_vchan *vc;
|
||||
@ -1034,13 +1034,11 @@ static int mtk_hsdma_remove(struct platform_device *pdev)
|
||||
|
||||
dma_async_device_unregister(&hsdma->ddev);
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver mtk_hsdma_driver = {
|
||||
.probe = mtk_hsdma_probe,
|
||||
.remove = mtk_hsdma_remove,
|
||||
.remove_new = mtk_hsdma_remove,
|
||||
.driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
.of_match_table = mtk_hsdma_match,
|
||||
|
@ -572,7 +572,7 @@ err_no_dma:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int mtk_uart_apdma_remove(struct platform_device *pdev)
|
||||
static void mtk_uart_apdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct mtk_uart_apdmadev *mtkd = platform_get_drvdata(pdev);
|
||||
|
||||
@ -583,8 +583,6 @@ static int mtk_uart_apdma_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&mtkd->ddev);
|
||||
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
@ -639,7 +637,7 @@ static const struct dev_pm_ops mtk_uart_apdma_pm_ops = {
|
||||
|
||||
static struct platform_driver mtk_uart_apdma_driver = {
|
||||
.probe = mtk_uart_apdma_probe,
|
||||
.remove = mtk_uart_apdma_remove,
|
||||
.remove_new = mtk_uart_apdma_remove,
|
||||
.driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
.pm = &mtk_uart_apdma_pm_ops,
|
||||
|
@ -15,7 +15,6 @@
|
||||
#include <linux/device.h>
|
||||
#include <linux/platform_data/mmp_dma.h>
|
||||
#include <linux/dmapool.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/of.h>
|
||||
|
||||
@ -932,7 +931,7 @@ static void dma_do_tasklet(struct tasklet_struct *t)
|
||||
}
|
||||
}
|
||||
|
||||
static int mmp_pdma_remove(struct platform_device *op)
|
||||
static void mmp_pdma_remove(struct platform_device *op)
|
||||
{
|
||||
struct mmp_pdma_device *pdev = platform_get_drvdata(op);
|
||||
struct mmp_pdma_phy *phy;
|
||||
@ -958,7 +957,6 @@ static int mmp_pdma_remove(struct platform_device *op)
|
||||
}
|
||||
|
||||
dma_async_device_unregister(&pdev->device);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mmp_pdma_chan_init(struct mmp_pdma_device *pdev, int idx, int irq)
|
||||
@ -1020,7 +1018,6 @@ static struct dma_chan *mmp_pdma_dma_xlate(struct of_phandle_args *dma_spec,
|
||||
static int mmp_pdma_probe(struct platform_device *op)
|
||||
{
|
||||
struct mmp_pdma_device *pdev;
|
||||
const struct of_device_id *of_id;
|
||||
struct mmp_dma_platdata *pdata = dev_get_platdata(&op->dev);
|
||||
int i, ret, irq = 0;
|
||||
int dma_channels = 0, irq_num = 0;
|
||||
@ -1040,8 +1037,7 @@ static int mmp_pdma_probe(struct platform_device *op)
|
||||
if (IS_ERR(pdev->base))
|
||||
return PTR_ERR(pdev->base);
|
||||
|
||||
of_id = of_match_device(mmp_pdma_dt_ids, pdev->dev);
|
||||
if (of_id) {
|
||||
if (pdev->dev->of_node) {
|
||||
/* Parse new and deprecated dma-channels properties */
|
||||
if (of_property_read_u32(pdev->dev->of_node, "dma-channels",
|
||||
&dma_channels))
|
||||
@ -1141,7 +1137,7 @@ static struct platform_driver mmp_pdma_driver = {
|
||||
},
|
||||
.id_table = mmp_pdma_id_table,
|
||||
.probe = mmp_pdma_probe,
|
||||
.remove = mmp_pdma_remove,
|
||||
.remove_new = mmp_pdma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(mmp_pdma_driver);
|
||||
|
@ -14,9 +14,9 @@
|
||||
#include <linux/slab.h>
|
||||
#include <linux/dmaengine.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/property.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/genalloc.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of_dma.h>
|
||||
|
||||
#include "dmaengine.h"
|
||||
@ -552,12 +552,10 @@ static void mmp_tdma_issue_pending(struct dma_chan *chan)
|
||||
mmp_tdma_enable_chan(tdmac);
|
||||
}
|
||||
|
||||
static int mmp_tdma_remove(struct platform_device *pdev)
|
||||
static void mmp_tdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
if (pdev->dev.of_node)
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mmp_tdma_chan_init(struct mmp_tdma_device *tdev,
|
||||
@ -637,18 +635,13 @@ MODULE_DEVICE_TABLE(of, mmp_tdma_dt_ids);
|
||||
static int mmp_tdma_probe(struct platform_device *pdev)
|
||||
{
|
||||
enum mmp_tdma_type type;
|
||||
const struct of_device_id *of_id;
|
||||
struct mmp_tdma_device *tdev;
|
||||
int i, ret;
|
||||
int irq = 0, irq_num = 0;
|
||||
int chan_num = TDMA_CHANNEL_NUM;
|
||||
struct gen_pool *pool = NULL;
|
||||
|
||||
of_id = of_match_device(mmp_tdma_dt_ids, &pdev->dev);
|
||||
if (of_id)
|
||||
type = (enum mmp_tdma_type) of_id->data;
|
||||
else
|
||||
type = platform_get_device_id(pdev)->driver_data;
|
||||
type = (enum mmp_tdma_type)device_get_match_data(&pdev->dev);
|
||||
|
||||
/* always have couple channels */
|
||||
tdev = devm_kzalloc(&pdev->dev, sizeof(*tdev), GFP_KERNEL);
|
||||
@ -726,34 +719,24 @@ static int mmp_tdma_probe(struct platform_device *pdev)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (pdev->dev.of_node) {
|
||||
ret = of_dma_controller_register(pdev->dev.of_node,
|
||||
mmp_tdma_xlate, tdev);
|
||||
if (ret) {
|
||||
dev_err(tdev->device.dev,
|
||||
"failed to register controller\n");
|
||||
return ret;
|
||||
}
|
||||
ret = of_dma_controller_register(pdev->dev.of_node,
|
||||
mmp_tdma_xlate, tdev);
|
||||
if (ret) {
|
||||
dev_err(tdev->device.dev, "failed to register controller\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
dev_info(tdev->device.dev, "initialized\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct platform_device_id mmp_tdma_id_table[] = {
|
||||
{ "mmp-adma", MMP_AUD_TDMA },
|
||||
{ "pxa910-squ", PXA910_SQU },
|
||||
{ },
|
||||
};
|
||||
|
||||
static struct platform_driver mmp_tdma_driver = {
|
||||
.driver = {
|
||||
.name = "mmp-tdma",
|
||||
.of_match_table = mmp_tdma_dt_ids,
|
||||
},
|
||||
.id_table = mmp_tdma_id_table,
|
||||
.probe = mmp_tdma_probe,
|
||||
.remove = mmp_tdma_remove,
|
||||
.remove_new = mmp_tdma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(mmp_tdma_driver);
|
||||
|
@ -124,7 +124,7 @@ struct moxart_desc {
|
||||
unsigned int dma_cycles;
|
||||
struct virt_dma_desc vd;
|
||||
uint8_t es;
|
||||
struct moxart_sg sg[];
|
||||
struct moxart_sg sg[] __counted_by(sglen);
|
||||
};
|
||||
|
||||
struct moxart_chan {
|
||||
@ -309,6 +309,7 @@ static struct dma_async_tx_descriptor *moxart_prep_slave_sg(
|
||||
d = kzalloc(struct_size(d, sg, sg_len), GFP_ATOMIC);
|
||||
if (!d)
|
||||
return NULL;
|
||||
d->sglen = sg_len;
|
||||
|
||||
d->dma_dir = dir;
|
||||
d->dev_addr = dev_addr;
|
||||
@ -319,8 +320,6 @@ static struct dma_async_tx_descriptor *moxart_prep_slave_sg(
|
||||
d->sg[i].len = sg_dma_len(sgent);
|
||||
}
|
||||
|
||||
d->sglen = sg_len;
|
||||
|
||||
ch->error = 0;
|
||||
|
||||
return vchan_tx_prep(&ch->vc, &d->vd, tx_flags);
|
||||
@ -630,7 +629,7 @@ static int moxart_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int moxart_remove(struct platform_device *pdev)
|
||||
static void moxart_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct moxart_dmadev *m = platform_get_drvdata(pdev);
|
||||
|
||||
@ -640,8 +639,6 @@ static int moxart_remove(struct platform_device *pdev)
|
||||
|
||||
if (pdev->dev.of_node)
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id moxart_dma_match[] = {
|
||||
@ -652,7 +649,7 @@ MODULE_DEVICE_TABLE(of, moxart_dma_match);
|
||||
|
||||
static struct platform_driver moxart_driver = {
|
||||
.probe = moxart_probe,
|
||||
.remove = moxart_remove,
|
||||
.remove_new = moxart_remove,
|
||||
.driver = {
|
||||
.name = "moxart-dma-engine",
|
||||
.of_match_table = moxart_dma_match,
|
||||
|
@ -1084,7 +1084,7 @@ err:
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int mpc_dma_remove(struct platform_device *op)
|
||||
static void mpc_dma_remove(struct platform_device *op)
|
||||
{
|
||||
struct device *dev = &op->dev;
|
||||
struct mpc_dma *mdma = dev_get_drvdata(dev);
|
||||
@ -1099,8 +1099,6 @@ static int mpc_dma_remove(struct platform_device *op)
|
||||
free_irq(mdma->irq, mdma);
|
||||
irq_dispose_mapping(mdma->irq);
|
||||
tasklet_kill(&mdma->tasklet);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id mpc_dma_match[] = {
|
||||
@ -1112,7 +1110,7 @@ MODULE_DEVICE_TABLE(of, mpc_dma_match);
|
||||
|
||||
static struct platform_driver mpc_dma_driver = {
|
||||
.probe = mpc_dma_probe,
|
||||
.remove = mpc_dma_remove,
|
||||
.remove_new = mpc_dma_remove,
|
||||
.driver = {
|
||||
.name = DRV_NAME,
|
||||
.of_match_table = mpc_dma_match,
|
||||
|
@ -10,8 +10,8 @@
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/property.h>
|
||||
#include <linux/memory.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/of.h>
|
||||
@ -1328,13 +1328,8 @@ static int mv_xor_probe(struct platform_device *pdev)
|
||||
* setting up. In non-dt case it can only be the legacy one.
|
||||
*/
|
||||
xordev->xor_type = XOR_ORION;
|
||||
if (pdev->dev.of_node) {
|
||||
const struct of_device_id *of_id =
|
||||
of_match_device(mv_xor_dt_ids,
|
||||
&pdev->dev);
|
||||
|
||||
xordev->xor_type = (uintptr_t)of_id->data;
|
||||
}
|
||||
if (pdev->dev.of_node)
|
||||
xordev->xor_type = (uintptr_t)device_get_match_data(&pdev->dev);
|
||||
|
||||
/*
|
||||
* (Re-)program MBUS remapping windows if we are asked to.
|
||||
|
@ -855,7 +855,7 @@ free_msi_irqs:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int mv_xor_v2_remove(struct platform_device *pdev)
|
||||
static void mv_xor_v2_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct mv_xor_v2_device *xor_dev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -870,8 +870,6 @@ static int mv_xor_v2_remove(struct platform_device *pdev)
|
||||
platform_msi_domain_free_irqs(&pdev->dev);
|
||||
|
||||
tasklet_kill(&xor_dev->irq_tasklet);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
@ -886,7 +884,7 @@ static struct platform_driver mv_xor_v2_driver = {
|
||||
.probe = mv_xor_v2_probe,
|
||||
.suspend = mv_xor_v2_suspend,
|
||||
.resume = mv_xor_v2_resume,
|
||||
.remove = mv_xor_v2_remove,
|
||||
.remove_new = mv_xor_v2_remove,
|
||||
.driver = {
|
||||
.name = "mv_xor_v2",
|
||||
.of_match_table = of_match_ptr(mv_xor_v2_dt_ids),
|
||||
|
@ -1454,7 +1454,7 @@ e_clk_off:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int nbpf_remove(struct platform_device *pdev)
|
||||
static void nbpf_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct nbpf_device *nbpf = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -1472,8 +1472,6 @@ static int nbpf_remove(struct platform_device *pdev)
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
dma_async_device_unregister(&nbpf->dma_dev);
|
||||
clk_disable_unprepare(nbpf->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct platform_device_id nbpf_ids[] = {
|
||||
@ -1517,7 +1515,7 @@ static struct platform_driver nbpf_driver = {
|
||||
},
|
||||
.id_table = nbpf_ids,
|
||||
.probe = nbpf_probe,
|
||||
.remove = nbpf_remove,
|
||||
.remove_new = nbpf_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(nbpf_driver);
|
||||
|
@ -1231,7 +1231,7 @@ err_pool_free:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int owl_dma_remove(struct platform_device *pdev)
|
||||
static void owl_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct owl_dma *od = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1248,13 +1248,11 @@ static int owl_dma_remove(struct platform_device *pdev)
|
||||
|
||||
clk_disable_unprepare(od->clk);
|
||||
dma_pool_destroy(od->lli_pool);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver owl_dma_driver = {
|
||||
.probe = owl_dma_probe,
|
||||
.remove = owl_dma_remove,
|
||||
.remove_new = owl_dma_remove,
|
||||
.driver = {
|
||||
.name = "dma-owl",
|
||||
.of_match_table = of_match_ptr(owl_dma_match),
|
||||
|
@ -4230,7 +4230,7 @@ out:
|
||||
/**
|
||||
* ppc440spe_adma_remove - remove the asynch device
|
||||
*/
|
||||
static int ppc440spe_adma_remove(struct platform_device *ofdev)
|
||||
static void ppc440spe_adma_remove(struct platform_device *ofdev)
|
||||
{
|
||||
struct ppc440spe_adma_device *adev = platform_get_drvdata(ofdev);
|
||||
struct device_node *np = ofdev->dev.of_node;
|
||||
@ -4278,7 +4278,6 @@ static int ppc440spe_adma_remove(struct platform_device *ofdev)
|
||||
of_address_to_resource(np, 0, &res);
|
||||
release_mem_region(res.start, resource_size(&res));
|
||||
kfree(adev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -4550,7 +4549,7 @@ MODULE_DEVICE_TABLE(of, ppc440spe_adma_of_match);
|
||||
|
||||
static struct platform_driver ppc440spe_adma_driver = {
|
||||
.probe = ppc440spe_adma_probe,
|
||||
.remove = ppc440spe_adma_remove,
|
||||
.remove_new = ppc440spe_adma_remove,
|
||||
.driver = {
|
||||
.name = "PPC440SP(E)-ADMA",
|
||||
.of_match_table = ppc440spe_adma_of_match,
|
||||
|
@ -15,9 +15,8 @@
|
||||
#include <linux/device.h>
|
||||
#include <linux/platform_data/mmp_dma.h>
|
||||
#include <linux/dmapool.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/dma/pxa-dma.h>
|
||||
|
||||
@ -91,7 +90,8 @@ struct pxad_desc_sw {
|
||||
bool cyclic;
|
||||
struct dma_pool *desc_pool; /* Channel's used allocator */
|
||||
|
||||
struct pxad_desc_hw *hw_desc[]; /* DMA coherent descriptors */
|
||||
struct pxad_desc_hw *hw_desc[] __counted_by(nb_desc);
|
||||
/* DMA coherent descriptors */
|
||||
};
|
||||
|
||||
struct pxad_phy {
|
||||
@ -722,7 +722,6 @@ static void pxad_free_desc(struct virt_dma_desc *vd)
|
||||
dma_addr_t dma;
|
||||
struct pxad_desc_sw *sw_desc = to_pxad_sw_desc(vd);
|
||||
|
||||
BUG_ON(sw_desc->nb_desc == 0);
|
||||
for (i = sw_desc->nb_desc - 1; i >= 0; i--) {
|
||||
if (i > 0)
|
||||
dma = sw_desc->hw_desc[i - 1]->ddadr;
|
||||
@ -740,6 +739,7 @@ pxad_alloc_desc(struct pxad_chan *chan, unsigned int nb_hw_desc)
|
||||
{
|
||||
struct pxad_desc_sw *sw_desc;
|
||||
dma_addr_t dma;
|
||||
void *desc;
|
||||
int i;
|
||||
|
||||
sw_desc = kzalloc(struct_size(sw_desc, hw_desc, nb_hw_desc),
|
||||
@ -749,20 +749,21 @@ pxad_alloc_desc(struct pxad_chan *chan, unsigned int nb_hw_desc)
|
||||
sw_desc->desc_pool = chan->desc_pool;
|
||||
|
||||
for (i = 0; i < nb_hw_desc; i++) {
|
||||
sw_desc->hw_desc[i] = dma_pool_alloc(sw_desc->desc_pool,
|
||||
GFP_NOWAIT, &dma);
|
||||
if (!sw_desc->hw_desc[i]) {
|
||||
desc = dma_pool_alloc(sw_desc->desc_pool, GFP_NOWAIT, &dma);
|
||||
if (!desc) {
|
||||
dev_err(&chan->vc.chan.dev->device,
|
||||
"%s(): Couldn't allocate the %dth hw_desc from dma_pool %p\n",
|
||||
__func__, i, sw_desc->desc_pool);
|
||||
goto err;
|
||||
}
|
||||
|
||||
sw_desc->nb_desc++;
|
||||
sw_desc->hw_desc[i] = desc;
|
||||
|
||||
if (i == 0)
|
||||
sw_desc->first = dma;
|
||||
else
|
||||
sw_desc->hw_desc[i - 1]->ddadr = dma;
|
||||
sw_desc->nb_desc++;
|
||||
}
|
||||
|
||||
return sw_desc;
|
||||
@ -1221,13 +1222,12 @@ static void pxad_free_channels(struct dma_device *dmadev)
|
||||
}
|
||||
}
|
||||
|
||||
static int pxad_remove(struct platform_device *op)
|
||||
static void pxad_remove(struct platform_device *op)
|
||||
{
|
||||
struct pxad_device *pdev = platform_get_drvdata(op);
|
||||
|
||||
pxad_cleanup_debugfs(pdev);
|
||||
pxad_free_channels(&pdev->slave);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pxad_init_phys(struct platform_device *op,
|
||||
@ -1343,7 +1343,6 @@ static int pxad_init_dmadev(struct platform_device *op,
|
||||
static int pxad_probe(struct platform_device *op)
|
||||
{
|
||||
struct pxad_device *pdev;
|
||||
const struct of_device_id *of_id;
|
||||
const struct dma_slave_map *slave_map = NULL;
|
||||
struct mmp_dma_platdata *pdata = dev_get_platdata(&op->dev);
|
||||
int ret, dma_channels = 0, nb_requestors = 0, slave_map_cnt = 0;
|
||||
@ -1361,8 +1360,7 @@ static int pxad_probe(struct platform_device *op)
|
||||
if (IS_ERR(pdev->base))
|
||||
return PTR_ERR(pdev->base);
|
||||
|
||||
of_id = of_match_device(pxad_dt_ids, &op->dev);
|
||||
if (of_id) {
|
||||
if (op->dev.of_node) {
|
||||
/* Parse new and deprecated dma-channels properties */
|
||||
if (of_property_read_u32(op->dev.of_node, "dma-channels",
|
||||
&dma_channels))
|
||||
@ -1444,7 +1442,7 @@ static struct platform_driver pxad_driver = {
|
||||
},
|
||||
.id_table = pxad_id_table,
|
||||
.probe = pxad_probe,
|
||||
.remove = pxad_remove,
|
||||
.remove_new = pxad_remove,
|
||||
};
|
||||
|
||||
static bool pxad_filter_fn(struct dma_chan *chan, void *param)
|
||||
|
@ -74,7 +74,7 @@ struct bam_async_desc {
|
||||
struct list_head desc_node;
|
||||
enum dma_transfer_direction dir;
|
||||
size_t length;
|
||||
struct bam_desc_hw desc[];
|
||||
struct bam_desc_hw desc[] __counted_by(num_desc);
|
||||
};
|
||||
|
||||
enum bam_reg {
|
||||
@ -1386,7 +1386,7 @@ err_disable_clk:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int bam_dma_remove(struct platform_device *pdev)
|
||||
static void bam_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct bam_device *bdev = platform_get_drvdata(pdev);
|
||||
u32 i;
|
||||
@ -1416,8 +1416,6 @@ static int bam_dma_remove(struct platform_device *pdev)
|
||||
tasklet_kill(&bdev->task);
|
||||
|
||||
clk_disable_unprepare(bdev->bamclk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused bam_dma_runtime_suspend(struct device *dev)
|
||||
@ -1475,7 +1473,7 @@ static const struct dev_pm_ops bam_dma_pm_ops = {
|
||||
|
||||
static struct platform_driver bam_dma_driver = {
|
||||
.probe = bam_dma_probe,
|
||||
.remove = bam_dma_remove,
|
||||
.remove_new = bam_dma_remove,
|
||||
.driver = {
|
||||
.name = "bam-dma-engine",
|
||||
.pm = &bam_dma_pm_ops,
|
||||
|
@ -745,7 +745,7 @@ static bool hidma_test_capability(struct device *dev, enum hidma_cap test_cap)
|
||||
{
|
||||
enum hidma_cap cap;
|
||||
|
||||
cap = (enum hidma_cap) device_get_match_data(dev);
|
||||
cap = (uintptr_t) device_get_match_data(dev);
|
||||
return cap ? ((cap & test_cap) > 0) : 0;
|
||||
}
|
||||
|
||||
@ -915,7 +915,7 @@ static void hidma_shutdown(struct platform_device *pdev)
|
||||
|
||||
}
|
||||
|
||||
static int hidma_remove(struct platform_device *pdev)
|
||||
static void hidma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct hidma_dev *dmadev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -935,8 +935,6 @@ static int hidma_remove(struct platform_device *pdev)
|
||||
dev_info(&pdev->dev, "HI-DMA engine removed\n");
|
||||
pm_runtime_put_sync_suspend(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if IS_ENABLED(CONFIG_ACPI)
|
||||
@ -960,7 +958,7 @@ MODULE_DEVICE_TABLE(of, hidma_match);
|
||||
|
||||
static struct platform_driver hidma_driver = {
|
||||
.probe = hidma_probe,
|
||||
.remove = hidma_remove,
|
||||
.remove_new = hidma_remove,
|
||||
.shutdown = hidma_shutdown,
|
||||
.driver = {
|
||||
.name = "hidma",
|
||||
|
@ -904,7 +904,7 @@ err_disable_core_clk:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int adm_dma_remove(struct platform_device *pdev)
|
||||
static void adm_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct adm_device *adev = platform_get_drvdata(pdev);
|
||||
struct adm_chan *achan;
|
||||
@ -927,8 +927,6 @@ static int adm_dma_remove(struct platform_device *pdev)
|
||||
|
||||
clk_disable_unprepare(adev->core_clk);
|
||||
clk_disable_unprepare(adev->iface_clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id adm_of_match[] = {
|
||||
@ -939,7 +937,7 @@ MODULE_DEVICE_TABLE(of, adm_of_match);
|
||||
|
||||
static struct platform_driver adm_dma_driver = {
|
||||
.probe = adm_dma_probe,
|
||||
.remove = adm_dma_remove,
|
||||
.remove_new = adm_dma_remove,
|
||||
.driver = {
|
||||
.name = "adm-dma-engine",
|
||||
.of_match_table = adm_of_match,
|
||||
|
@ -78,7 +78,7 @@ struct sa11x0_dma_desc {
|
||||
bool cyclic;
|
||||
|
||||
unsigned sglen;
|
||||
struct sa11x0_dma_sg sg[];
|
||||
struct sa11x0_dma_sg sg[] __counted_by(sglen);
|
||||
};
|
||||
|
||||
struct sa11x0_dma_phy;
|
||||
@ -558,6 +558,7 @@ static struct dma_async_tx_descriptor *sa11x0_dma_prep_slave_sg(
|
||||
dev_dbg(chan->device->dev, "vchan %p: kzalloc failed\n", &c->vc);
|
||||
return NULL;
|
||||
}
|
||||
txd->sglen = j;
|
||||
|
||||
j = 0;
|
||||
for_each_sg(sg, sgent, sglen, i) {
|
||||
@ -593,7 +594,6 @@ static struct dma_async_tx_descriptor *sa11x0_dma_prep_slave_sg(
|
||||
|
||||
txd->ddar = c->ddar;
|
||||
txd->size = size;
|
||||
txd->sglen = j;
|
||||
|
||||
dev_dbg(chan->device->dev, "vchan %p: txd %p: size %zu nr %u\n",
|
||||
&c->vc, &txd->vd, txd->size, txd->sglen);
|
||||
@ -628,6 +628,7 @@ static struct dma_async_tx_descriptor *sa11x0_dma_prep_dma_cyclic(
|
||||
dev_dbg(chan->device->dev, "vchan %p: kzalloc failed\n", &c->vc);
|
||||
return NULL;
|
||||
}
|
||||
txd->sglen = sglen;
|
||||
|
||||
for (i = k = 0; i < size / period; i++) {
|
||||
size_t tlen, len = period;
|
||||
@ -653,7 +654,6 @@ static struct dma_async_tx_descriptor *sa11x0_dma_prep_dma_cyclic(
|
||||
|
||||
txd->ddar = c->ddar;
|
||||
txd->size = size;
|
||||
txd->sglen = sglen;
|
||||
txd->cyclic = 1;
|
||||
txd->period = sgperiod;
|
||||
|
||||
@ -984,7 +984,7 @@ static int sa11x0_dma_probe(struct platform_device *pdev)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sa11x0_dma_remove(struct platform_device *pdev)
|
||||
static void sa11x0_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sa11x0_dma_dev *d = platform_get_drvdata(pdev);
|
||||
unsigned pch;
|
||||
@ -997,8 +997,6 @@ static int sa11x0_dma_remove(struct platform_device *pdev)
|
||||
tasklet_kill(&d->task);
|
||||
iounmap(d->base);
|
||||
kfree(d);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __maybe_unused int sa11x0_dma_suspend(struct device *dev)
|
||||
@ -1081,7 +1079,7 @@ static struct platform_driver sa11x0_dma_driver = {
|
||||
.pm = &sa11x0_dma_pm_ops,
|
||||
},
|
||||
.probe = sa11x0_dma_probe,
|
||||
.remove = sa11x0_dma_remove,
|
||||
.remove_new = sa11x0_dma_remove,
|
||||
};
|
||||
|
||||
static int __init sa11x0_dma_init(void)
|
||||
|
@ -566,7 +566,7 @@ static int sf_pdma_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sf_pdma_remove(struct platform_device *pdev)
|
||||
static void sf_pdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sf_pdma *pdma = platform_get_drvdata(pdev);
|
||||
struct sf_pdma_chan *ch;
|
||||
@ -584,8 +584,6 @@ static int sf_pdma_remove(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
dma_async_device_unregister(&pdma->dma_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id sf_pdma_dt_ids[] = {
|
||||
@ -597,7 +595,7 @@ MODULE_DEVICE_TABLE(of, sf_pdma_dt_ids);
|
||||
|
||||
static struct platform_driver sf_pdma_driver = {
|
||||
.probe = sf_pdma_probe,
|
||||
.remove = sf_pdma_remove,
|
||||
.remove_new = sf_pdma_remove,
|
||||
.driver = {
|
||||
.name = "sf-pdma",
|
||||
.of_match_table = sf_pdma_dt_ids,
|
||||
|
@ -113,7 +113,7 @@ struct sf_pdma {
|
||||
void __iomem *membase;
|
||||
void __iomem *mappedbase;
|
||||
u32 n_chans;
|
||||
struct sf_pdma_chan chans[];
|
||||
struct sf_pdma_chan chans[] __counted_by(n_chans);
|
||||
};
|
||||
|
||||
#endif /* _SF_PDMA_H */
|
||||
|
@ -1990,7 +1990,7 @@ err_pm_disable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int rcar_dmac_remove(struct platform_device *pdev)
|
||||
static void rcar_dmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rcar_dmac *dmac = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1998,8 +1998,6 @@ static int rcar_dmac_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&dmac->engine);
|
||||
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void rcar_dmac_shutdown(struct platform_device *pdev)
|
||||
@ -2041,7 +2039,7 @@ static struct platform_driver rcar_dmac_driver = {
|
||||
.of_match_table = rcar_dmac_of_ids,
|
||||
},
|
||||
.probe = rcar_dmac_probe,
|
||||
.remove = rcar_dmac_remove,
|
||||
.remove_new = rcar_dmac_remove,
|
||||
.shutdown = rcar_dmac_shutdown,
|
||||
};
|
||||
|
||||
|
@ -969,7 +969,7 @@ err_pm_disable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int rz_dmac_remove(struct platform_device *pdev)
|
||||
static void rz_dmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rz_dmac *dmac = platform_get_drvdata(pdev);
|
||||
unsigned int i;
|
||||
@ -987,8 +987,6 @@ static int rz_dmac_remove(struct platform_device *pdev)
|
||||
reset_control_assert(dmac->rstc);
|
||||
pm_runtime_put(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id of_rz_dmac_match[] = {
|
||||
@ -1003,7 +1001,7 @@ static struct platform_driver rz_dmac_driver = {
|
||||
.of_match_table = of_rz_dmac_match,
|
||||
},
|
||||
.probe = rz_dmac_probe,
|
||||
.remove = rz_dmac_remove,
|
||||
.remove_new = rz_dmac_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(rz_dmac_driver);
|
||||
|
@ -882,7 +882,7 @@ eshdma:
|
||||
return err;
|
||||
}
|
||||
|
||||
static int sh_dmae_remove(struct platform_device *pdev)
|
||||
static void sh_dmae_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sh_dmae_device *shdev = platform_get_drvdata(pdev);
|
||||
struct dma_device *dma_dev = &shdev->shdma_dev.dma_dev;
|
||||
@ -899,8 +899,6 @@ static int sh_dmae_remove(struct platform_device *pdev)
|
||||
shdma_cleanup(&shdev->shdma_dev);
|
||||
|
||||
synchronize_rcu();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver sh_dmae_driver = {
|
||||
@ -908,7 +906,7 @@ static struct platform_driver sh_dmae_driver = {
|
||||
.pm = &sh_dmae_pm,
|
||||
.name = SH_DMAE_DRV_NAME,
|
||||
},
|
||||
.remove = sh_dmae_remove,
|
||||
.remove_new = sh_dmae_remove,
|
||||
};
|
||||
|
||||
static int __init sh_dmae_init(void)
|
||||
|
@ -57,7 +57,7 @@ struct usb_dmac_desc {
|
||||
u32 residue;
|
||||
struct list_head node;
|
||||
dma_cookie_t done_cookie;
|
||||
struct usb_dmac_sg sg[];
|
||||
struct usb_dmac_sg sg[] __counted_by(sg_allocated_len);
|
||||
};
|
||||
|
||||
#define to_usb_dmac_desc(vd) container_of(vd, struct usb_dmac_desc, vd)
|
||||
@ -866,7 +866,7 @@ static void usb_dmac_chan_remove(struct usb_dmac *dmac,
|
||||
devm_free_irq(dmac->dev, uchan->irq, uchan);
|
||||
}
|
||||
|
||||
static int usb_dmac_remove(struct platform_device *pdev)
|
||||
static void usb_dmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct usb_dmac *dmac = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -877,8 +877,6 @@ static int usb_dmac_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&dmac->engine);
|
||||
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void usb_dmac_shutdown(struct platform_device *pdev)
|
||||
@ -901,7 +899,7 @@ static struct platform_driver usb_dmac_driver = {
|
||||
.of_match_table = usb_dmac_of_ids,
|
||||
},
|
||||
.probe = usb_dmac_probe,
|
||||
.remove = usb_dmac_remove,
|
||||
.remove_new = usb_dmac_remove,
|
||||
.shutdown = usb_dmac_shutdown,
|
||||
};
|
||||
|
||||
|
@ -212,7 +212,7 @@ struct sprd_dma_dev {
|
||||
struct clk *ashb_clk;
|
||||
int irq;
|
||||
u32 total_chns;
|
||||
struct sprd_dma_chn channels[];
|
||||
struct sprd_dma_chn channels[] __counted_by(total_chns);
|
||||
};
|
||||
|
||||
static void sprd_dma_free_desc(struct virt_dma_desc *vd);
|
||||
@ -572,8 +572,7 @@ static void sprd_dma_stop(struct sprd_dma_chn *schan)
|
||||
schan->cur_desc = NULL;
|
||||
}
|
||||
|
||||
static bool sprd_dma_check_trans_done(struct sprd_dma_desc *sdesc,
|
||||
enum sprd_dma_int_type int_type,
|
||||
static bool sprd_dma_check_trans_done(enum sprd_dma_int_type int_type,
|
||||
enum sprd_dma_req_mode req_mode)
|
||||
{
|
||||
if (int_type == SPRD_DMA_NO_INT)
|
||||
@ -619,8 +618,7 @@ static irqreturn_t dma_irq_handle(int irq, void *dev_id)
|
||||
vchan_cyclic_callback(&sdesc->vd);
|
||||
} else {
|
||||
/* Check if the dma request descriptor is done. */
|
||||
trans_done = sprd_dma_check_trans_done(sdesc, int_type,
|
||||
req_type);
|
||||
trans_done = sprd_dma_check_trans_done(int_type, req_type);
|
||||
if (trans_done == true) {
|
||||
vchan_cookie_complete(&sdesc->vd);
|
||||
schan->cur_desc = NULL;
|
||||
@ -1117,6 +1115,15 @@ static int sprd_dma_probe(struct platform_device *pdev)
|
||||
u32 chn_count;
|
||||
int ret, i;
|
||||
|
||||
ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(36));
|
||||
if (ret) {
|
||||
ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "unable to set coherent mask to 32\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse new and deprecated dma-channels properties */
|
||||
ret = device_property_read_u32(&pdev->dev, "dma-channels", &chn_count);
|
||||
if (ret)
|
||||
@ -1232,7 +1239,7 @@ err_rpm:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sprd_dma_remove(struct platform_device *pdev)
|
||||
static void sprd_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sprd_dma_dev *sdev = platform_get_drvdata(pdev);
|
||||
struct sprd_dma_chn *c, *cn;
|
||||
@ -1255,7 +1262,6 @@ static int sprd_dma_remove(struct platform_device *pdev)
|
||||
|
||||
pm_runtime_put_noidle(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id sprd_dma_match[] = {
|
||||
@ -1292,7 +1298,7 @@ static const struct dev_pm_ops sprd_dma_pm_ops = {
|
||||
|
||||
static struct platform_driver sprd_dma_driver = {
|
||||
.probe = sprd_dma_probe,
|
||||
.remove = sprd_dma_remove,
|
||||
.remove_new = sprd_dma_remove,
|
||||
.driver = {
|
||||
.name = "sprd-dma",
|
||||
.of_match_table = sprd_dma_match,
|
||||
|
@ -10,9 +10,10 @@
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/property.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/remoteproc.h>
|
||||
#include <linux/slab.h>
|
||||
@ -739,18 +740,11 @@ static void st_fdma_free(struct st_fdma_dev *fdev)
|
||||
static int st_fdma_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct st_fdma_dev *fdev;
|
||||
const struct of_device_id *match;
|
||||
struct device_node *np = pdev->dev.of_node;
|
||||
const struct st_fdma_driverdata *drvdata;
|
||||
int ret, i;
|
||||
|
||||
match = of_match_device((st_fdma_match), &pdev->dev);
|
||||
if (!match || !match->data) {
|
||||
dev_err(&pdev->dev, "No device match found\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
drvdata = match->data;
|
||||
drvdata = device_get_match_data(&pdev->dev);
|
||||
|
||||
fdev = devm_kzalloc(&pdev->dev, sizeof(*fdev), GFP_KERNEL);
|
||||
if (!fdev)
|
||||
@ -849,15 +843,13 @@ err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int st_fdma_remove(struct platform_device *pdev)
|
||||
static void st_fdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct st_fdma_dev *fdev = platform_get_drvdata(pdev);
|
||||
|
||||
devm_free_irq(&pdev->dev, fdev->irq, fdev);
|
||||
st_slim_rproc_put(fdev->slim_rproc);
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver st_fdma_platform_driver = {
|
||||
@ -866,7 +858,7 @@ static struct platform_driver st_fdma_platform_driver = {
|
||||
.of_match_table = st_fdma_match,
|
||||
},
|
||||
.probe = st_fdma_probe,
|
||||
.remove = st_fdma_remove,
|
||||
.remove_new = st_fdma_remove,
|
||||
};
|
||||
module_platform_driver(st_fdma_platform_driver);
|
||||
|
||||
|
@ -97,7 +97,7 @@ struct st_fdma_desc {
|
||||
struct st_fdma_chan *fchan;
|
||||
bool iscyclic;
|
||||
unsigned int n_nodes;
|
||||
struct st_fdma_sw_node node[];
|
||||
struct st_fdma_sw_node node[] __counted_by(n_nodes);
|
||||
};
|
||||
|
||||
enum st_fdma_type {
|
||||
|
@ -21,7 +21,6 @@
|
||||
#include <linux/list.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/of_dma.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
@ -191,7 +190,7 @@ struct stm32_dma_desc {
|
||||
struct virt_dma_desc vdesc;
|
||||
bool cyclic;
|
||||
u32 num_sgs;
|
||||
struct stm32_dma_sg_req sg_req[];
|
||||
struct stm32_dma_sg_req sg_req[] __counted_by(num_sgs);
|
||||
};
|
||||
|
||||
/**
|
||||
@ -1105,6 +1104,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_slave_sg(
|
||||
desc = kzalloc(struct_size(desc, sg_req, sg_len), GFP_NOWAIT);
|
||||
if (!desc)
|
||||
return NULL;
|
||||
desc->num_sgs = sg_len;
|
||||
|
||||
/* Set peripheral flow controller */
|
||||
if (chan->dma_sconfig.device_fc)
|
||||
@ -1143,8 +1143,6 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_slave_sg(
|
||||
desc->sg_req[i].chan_reg.dma_sm1ar += sg_dma_len(sg);
|
||||
desc->sg_req[i].chan_reg.dma_sndtr = nb_data_items;
|
||||
}
|
||||
|
||||
desc->num_sgs = sg_len;
|
||||
desc->cyclic = false;
|
||||
|
||||
return vchan_tx_prep(&chan->vchan, &desc->vdesc, flags);
|
||||
@ -1218,6 +1216,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_dma_cyclic(
|
||||
desc = kzalloc(struct_size(desc, sg_req, num_periods), GFP_NOWAIT);
|
||||
if (!desc)
|
||||
return NULL;
|
||||
desc->num_sgs = num_periods;
|
||||
|
||||
for (i = 0; i < num_periods; i++) {
|
||||
desc->sg_req[i].len = period_len;
|
||||
@ -1234,8 +1233,6 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_dma_cyclic(
|
||||
if (!chan->trig_mdma)
|
||||
buf_addr += period_len;
|
||||
}
|
||||
|
||||
desc->num_sgs = num_periods;
|
||||
desc->cyclic = true;
|
||||
|
||||
return vchan_tx_prep(&chan->vchan, &desc->vdesc, flags);
|
||||
@ -1256,6 +1253,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_dma_memcpy(
|
||||
desc = kzalloc(struct_size(desc, sg_req, num_sgs), GFP_NOWAIT);
|
||||
if (!desc)
|
||||
return NULL;
|
||||
desc->num_sgs = num_sgs;
|
||||
|
||||
threshold = chan->threshold;
|
||||
|
||||
@ -1285,8 +1283,6 @@ static struct dma_async_tx_descriptor *stm32_dma_prep_dma_memcpy(
|
||||
desc->sg_req[i].chan_reg.dma_sndtr = xfer_count;
|
||||
desc->sg_req[i].len = xfer_count;
|
||||
}
|
||||
|
||||
desc->num_sgs = num_sgs;
|
||||
desc->cyclic = false;
|
||||
|
||||
return vchan_tx_prep(&chan->vchan, &desc->vdesc, flags);
|
||||
@ -1567,17 +1563,10 @@ static int stm32_dma_probe(struct platform_device *pdev)
|
||||
struct stm32_dma_chan *chan;
|
||||
struct stm32_dma_device *dmadev;
|
||||
struct dma_device *dd;
|
||||
const struct of_device_id *match;
|
||||
struct resource *res;
|
||||
struct reset_control *rst;
|
||||
int i, ret;
|
||||
|
||||
match = of_match_device(stm32_dma_of_match, &pdev->dev);
|
||||
if (!match) {
|
||||
dev_err(&pdev->dev, "Error: No device match found\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
dmadev = devm_kzalloc(&pdev->dev, sizeof(*dmadev), GFP_KERNEL);
|
||||
if (!dmadev)
|
||||
return -ENOMEM;
|
||||
|
@ -224,7 +224,7 @@ struct stm32_mdma_desc {
|
||||
u32 ccr;
|
||||
bool cyclic;
|
||||
u32 count;
|
||||
struct stm32_mdma_desc_node node[];
|
||||
struct stm32_mdma_desc_node node[] __counted_by(count);
|
||||
};
|
||||
|
||||
struct stm32_mdma_dma_config {
|
||||
@ -256,7 +256,7 @@ struct stm32_mdma_device {
|
||||
u32 nr_ahb_addr_masks;
|
||||
u32 chan_reserved;
|
||||
struct stm32_mdma_chan chan[STM32_MDMA_MAX_CHANNELS];
|
||||
u32 ahb_addr_masks[];
|
||||
u32 ahb_addr_masks[] __counted_by(nr_ahb_addr_masks);
|
||||
};
|
||||
|
||||
static struct stm32_mdma_device *stm32_mdma_get_dev(
|
||||
@ -321,6 +321,7 @@ static struct stm32_mdma_desc *stm32_mdma_alloc_desc(
|
||||
desc = kzalloc(struct_size(desc, node, count), GFP_NOWAIT);
|
||||
if (!desc)
|
||||
return NULL;
|
||||
desc->count = count;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
desc->node[i].hwdesc =
|
||||
@ -330,8 +331,6 @@ static struct stm32_mdma_desc *stm32_mdma_alloc_desc(
|
||||
goto err;
|
||||
}
|
||||
|
||||
desc->count = count;
|
||||
|
||||
return desc;
|
||||
|
||||
err:
|
||||
@ -489,7 +488,7 @@ static int stm32_mdma_set_xfer_param(struct stm32_mdma_chan *chan,
|
||||
src_maxburst = chan->dma_config.src_maxburst;
|
||||
dst_maxburst = chan->dma_config.dst_maxburst;
|
||||
|
||||
ccr = stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id));
|
||||
ccr = stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id)) & ~STM32_MDMA_CCR_EN;
|
||||
ctcr = stm32_mdma_read(dmadev, STM32_MDMA_CTCR(chan->id));
|
||||
ctbr = stm32_mdma_read(dmadev, STM32_MDMA_CTBR(chan->id));
|
||||
|
||||
@ -965,7 +964,7 @@ stm32_mdma_prep_dma_memcpy(struct dma_chan *c, dma_addr_t dest, dma_addr_t src,
|
||||
if (!desc)
|
||||
return NULL;
|
||||
|
||||
ccr = stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id));
|
||||
ccr = stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id)) & ~STM32_MDMA_CCR_EN;
|
||||
ctcr = stm32_mdma_read(dmadev, STM32_MDMA_CTCR(chan->id));
|
||||
ctbr = stm32_mdma_read(dmadev, STM32_MDMA_CTBR(chan->id));
|
||||
cbndtr = stm32_mdma_read(dmadev, STM32_MDMA_CBNDTR(chan->id));
|
||||
@ -1627,13 +1626,13 @@ static int stm32_mdma_probe(struct platform_device *pdev)
|
||||
GFP_KERNEL);
|
||||
if (!dmadev)
|
||||
return -ENOMEM;
|
||||
dmadev->nr_ahb_addr_masks = count;
|
||||
|
||||
dmadev->nr_channels = nr_channels;
|
||||
dmadev->nr_requests = nr_requests;
|
||||
device_property_read_u32_array(&pdev->dev, "st,ahb-addr-masks",
|
||||
dmadev->ahb_addr_masks,
|
||||
count);
|
||||
dmadev->nr_ahb_addr_masks = count;
|
||||
|
||||
dmadev->base = devm_platform_ioremap_resource(pdev, 0);
|
||||
if (IS_ERR(dmadev->base))
|
||||
|
@ -1271,7 +1271,7 @@ err_clk_disable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sun4i_dma_remove(struct platform_device *pdev)
|
||||
static void sun4i_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sun4i_dma_dev *priv = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1282,8 +1282,6 @@ static int sun4i_dma_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&priv->slave);
|
||||
|
||||
clk_disable_unprepare(priv->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id sun4i_dma_match[] = {
|
||||
@ -1294,7 +1292,7 @@ MODULE_DEVICE_TABLE(of, sun4i_dma_match);
|
||||
|
||||
static struct platform_driver sun4i_dma_driver = {
|
||||
.probe = sun4i_dma_probe,
|
||||
.remove = sun4i_dma_remove,
|
||||
.remove_new = sun4i_dma_remove,
|
||||
.driver = {
|
||||
.name = "sun4i-dma",
|
||||
.of_match_table = sun4i_dma_match,
|
||||
|
@ -1470,7 +1470,7 @@ err_chan_free:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sun6i_dma_remove(struct platform_device *pdev)
|
||||
static void sun6i_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sun6i_dma_dev *sdc = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1484,13 +1484,11 @@ static int sun6i_dma_remove(struct platform_device *pdev)
|
||||
reset_control_assert(sdc->rstc);
|
||||
|
||||
sun6i_dma_free(sdc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver sun6i_dma_driver = {
|
||||
.probe = sun6i_dma_probe,
|
||||
.remove = sun6i_dma_remove,
|
||||
.remove_new = sun6i_dma_remove,
|
||||
.driver = {
|
||||
.name = "sun6i-dma",
|
||||
.of_match_table = sun6i_dma_match,
|
||||
|
@ -221,7 +221,7 @@ struct tegra_dma_desc {
|
||||
unsigned int sg_count;
|
||||
struct virt_dma_desc vd;
|
||||
struct tegra_dma_channel *tdc;
|
||||
struct tegra_dma_sg_req sg_req[];
|
||||
struct tegra_dma_sg_req sg_req[] __counted_by(sg_count);
|
||||
};
|
||||
|
||||
/*
|
||||
@ -1473,14 +1473,12 @@ static int tegra_dma_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra_dma_remove(struct platform_device *pdev)
|
||||
static void tegra_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct tegra_dma *tdma = platform_get_drvdata(pdev);
|
||||
|
||||
of_dma_controller_free(pdev->dev.of_node);
|
||||
dma_async_device_unregister(&tdma->dma_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused tegra_dma_pm_suspend(struct device *dev)
|
||||
@ -1533,7 +1531,7 @@ static struct platform_driver tegra_dma_driver = {
|
||||
.of_match_table = tegra_dma_of_match,
|
||||
},
|
||||
.probe = tegra_dma_probe,
|
||||
.remove = tegra_dma_remove,
|
||||
.remove_new = tegra_dma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(tegra_dma_driver);
|
||||
|
@ -1581,7 +1581,7 @@ err_clk_unprepare:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int tegra_dma_remove(struct platform_device *pdev)
|
||||
static void tegra_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct tegra_dma *tdma = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1589,8 +1589,6 @@ static int tegra_dma_remove(struct platform_device *pdev)
|
||||
dma_async_device_unregister(&tdma->dma_dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
clk_unprepare(tdma->dma_clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused tegra_dma_runtime_suspend(struct device *dev)
|
||||
@ -1677,7 +1675,7 @@ static struct platform_driver tegra_dmac_driver = {
|
||||
.of_match_table = tegra_dma_of_match,
|
||||
},
|
||||
.probe = tegra_dma_probe,
|
||||
.remove = tegra_dma_remove,
|
||||
.remove_new = tegra_dma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(tegra_dmac_driver);
|
||||
|
@ -162,7 +162,7 @@ struct tegra_adma {
|
||||
const struct tegra_adma_chip_data *cdata;
|
||||
|
||||
/* Last member of the structure */
|
||||
struct tegra_adma_chan channels[];
|
||||
struct tegra_adma_chan channels[] __counted_by(nr_channels);
|
||||
};
|
||||
|
||||
static inline void tdma_write(struct tegra_adma *tdma, u32 reg, u32 val)
|
||||
@ -949,7 +949,7 @@ irq_dispose:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int tegra_adma_remove(struct platform_device *pdev)
|
||||
static void tegra_adma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct tegra_adma *tdma = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -961,8 +961,6 @@ static int tegra_adma_remove(struct platform_device *pdev)
|
||||
irq_dispose_mapping(tdma->channels[i].irq);
|
||||
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops tegra_adma_dev_pm_ops = {
|
||||
@ -979,7 +977,7 @@ static struct platform_driver tegra_admac_driver = {
|
||||
.of_match_table = tegra_adma_of_match,
|
||||
},
|
||||
.probe = tegra_adma_probe,
|
||||
.remove = tegra_adma_remove,
|
||||
.remove_new = tegra_adma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(tegra_admac_driver);
|
||||
|
@ -1156,7 +1156,7 @@ err_get_sync:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int cppi41_dma_remove(struct platform_device *pdev)
|
||||
static void cppi41_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct cppi41_dd *cdd = platform_get_drvdata(pdev);
|
||||
int error;
|
||||
@ -1173,7 +1173,6 @@ static int cppi41_dma_remove(struct platform_device *pdev)
|
||||
pm_runtime_dont_use_autosuspend(&pdev->dev);
|
||||
pm_runtime_put_sync(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __maybe_unused cppi41_suspend(struct device *dev)
|
||||
@ -1244,7 +1243,7 @@ static const struct dev_pm_ops cppi41_pm_ops = {
|
||||
|
||||
static struct platform_driver cpp41_dma_driver = {
|
||||
.probe = cppi41_dma_probe,
|
||||
.remove = cppi41_dma_remove,
|
||||
.remove_new = cppi41_dma_remove,
|
||||
.driver = {
|
||||
.name = "cppi41-dma-engine",
|
||||
.pm = &cppi41_pm_ops,
|
||||
|
@ -202,7 +202,7 @@ struct edma_desc {
|
||||
u32 residue;
|
||||
u32 residue_stat;
|
||||
|
||||
struct edma_pset pset[];
|
||||
struct edma_pset pset[] __counted_by(pset_nr);
|
||||
};
|
||||
|
||||
struct edma_cc;
|
||||
@ -2401,7 +2401,7 @@ static int edma_probe(struct platform_device *pdev)
|
||||
if (irq < 0 && node)
|
||||
irq = irq_of_parse_and_map(node, 0);
|
||||
|
||||
if (irq >= 0) {
|
||||
if (irq > 0) {
|
||||
irq_name = devm_kasprintf(dev, GFP_KERNEL, "%s_ccint",
|
||||
dev_name(dev));
|
||||
ret = devm_request_irq(dev, irq, dma_irq_handler, 0, irq_name,
|
||||
@ -2417,7 +2417,7 @@ static int edma_probe(struct platform_device *pdev)
|
||||
if (irq < 0 && node)
|
||||
irq = irq_of_parse_and_map(node, 2);
|
||||
|
||||
if (irq >= 0) {
|
||||
if (irq > 0) {
|
||||
irq_name = devm_kasprintf(dev, GFP_KERNEL, "%s_ccerrint",
|
||||
dev_name(dev));
|
||||
ret = devm_request_irq(dev, irq, dma_ccerr_handler, 0, irq_name,
|
||||
@ -2550,7 +2550,7 @@ static void edma_cleanupp_vchan(struct dma_device *dmadev)
|
||||
}
|
||||
}
|
||||
|
||||
static int edma_remove(struct platform_device *pdev)
|
||||
static void edma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
struct edma_cc *ecc = dev_get_drvdata(dev);
|
||||
@ -2568,8 +2568,6 @@ static int edma_remove(struct platform_device *pdev)
|
||||
edma_free_slot(ecc, ecc->dummy_slot);
|
||||
pm_runtime_put_sync(dev);
|
||||
pm_runtime_disable(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
@ -2628,7 +2626,7 @@ static const struct dev_pm_ops edma_pm_ops = {
|
||||
|
||||
static struct platform_driver edma_driver = {
|
||||
.probe = edma_probe,
|
||||
.remove = edma_remove,
|
||||
.remove_new = edma_remove,
|
||||
.driver = {
|
||||
.name = "edma",
|
||||
.pm = &edma_pm_ops,
|
||||
|
@ -124,7 +124,7 @@ struct omap_desc {
|
||||
uint32_t csdp; /* CSDP value */
|
||||
|
||||
unsigned sglen;
|
||||
struct omap_sg sg[];
|
||||
struct omap_sg sg[] __counted_by(sglen);
|
||||
};
|
||||
|
||||
enum {
|
||||
@ -1005,6 +1005,7 @@ static struct dma_async_tx_descriptor *omap_dma_prep_slave_sg(
|
||||
d = kzalloc(struct_size(d, sg, sglen), GFP_ATOMIC);
|
||||
if (!d)
|
||||
return NULL;
|
||||
d->sglen = sglen;
|
||||
|
||||
d->dir = dir;
|
||||
d->dev_addr = dev_addr;
|
||||
@ -1120,8 +1121,6 @@ static struct dma_async_tx_descriptor *omap_dma_prep_slave_sg(
|
||||
}
|
||||
}
|
||||
|
||||
d->sglen = sglen;
|
||||
|
||||
/* Release the dma_pool entries if one allocation failed */
|
||||
if (ll_failed) {
|
||||
for (i = 0; i < d->sglen; i++) {
|
||||
@ -1844,7 +1843,7 @@ static int omap_dma_probe(struct platform_device *pdev)
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int omap_dma_remove(struct platform_device *pdev)
|
||||
static void omap_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct omap_dmadev *od = platform_get_drvdata(pdev);
|
||||
int irq;
|
||||
@ -1869,8 +1868,6 @@ static int omap_dma_remove(struct platform_device *pdev)
|
||||
dma_pool_destroy(od->desc_pool);
|
||||
|
||||
omap_dma_free(od);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct omap_dma_config omap2420_data = {
|
||||
@ -1918,7 +1915,7 @@ MODULE_DEVICE_TABLE(of, omap_dma_match);
|
||||
|
||||
static struct platform_driver omap_dma_driver = {
|
||||
.probe = omap_dma_probe,
|
||||
.remove = omap_dma_remove,
|
||||
.remove_new = omap_dma_remove,
|
||||
.driver = {
|
||||
.name = "omap-dma-engine",
|
||||
.of_match_table = omap_dma_match,
|
||||
|
@ -740,7 +740,7 @@ err_release_region:
|
||||
|
||||
}
|
||||
|
||||
static int td_remove(struct platform_device *pdev)
|
||||
static void td_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct timb_dma *td = platform_get_drvdata(pdev);
|
||||
struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
@ -754,7 +754,6 @@ static int td_remove(struct platform_device *pdev)
|
||||
release_mem_region(iomem->start, resource_size(iomem));
|
||||
|
||||
dev_dbg(&pdev->dev, "Removed...\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver td_driver = {
|
||||
@ -762,7 +761,7 @@ static struct platform_driver td_driver = {
|
||||
.name = DRIVER_NAME,
|
||||
},
|
||||
.probe = td_probe,
|
||||
.remove = td_remove,
|
||||
.remove_new = td_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(td_driver);
|
||||
|
@ -1151,7 +1151,7 @@ static int __init txx9dmac_chan_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int txx9dmac_chan_remove(struct platform_device *pdev)
|
||||
static void txx9dmac_chan_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct txx9dmac_chan *dc = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1162,7 +1162,6 @@ static int txx9dmac_chan_remove(struct platform_device *pdev)
|
||||
tasklet_kill(&dc->tasklet);
|
||||
}
|
||||
dc->ddev->chan[pdev->id % TXX9_DMA_MAX_NR_CHANNELS] = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init txx9dmac_probe(struct platform_device *pdev)
|
||||
@ -1215,7 +1214,7 @@ static int __init txx9dmac_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int txx9dmac_remove(struct platform_device *pdev)
|
||||
static void txx9dmac_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct txx9dmac_dev *ddev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1224,7 +1223,6 @@ static int txx9dmac_remove(struct platform_device *pdev)
|
||||
devm_free_irq(&pdev->dev, ddev->irq, ddev);
|
||||
tasklet_kill(&ddev->tasklet);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void txx9dmac_shutdown(struct platform_device *pdev)
|
||||
@ -1262,14 +1260,14 @@ static const struct dev_pm_ops txx9dmac_dev_pm_ops = {
|
||||
};
|
||||
|
||||
static struct platform_driver txx9dmac_chan_driver = {
|
||||
.remove = txx9dmac_chan_remove,
|
||||
.remove_new = txx9dmac_chan_remove,
|
||||
.driver = {
|
||||
.name = "txx9dmac-chan",
|
||||
},
|
||||
};
|
||||
|
||||
static struct platform_driver txx9dmac_driver = {
|
||||
.remove = txx9dmac_remove,
|
||||
.remove_new = txx9dmac_remove,
|
||||
.shutdown = txx9dmac_shutdown,
|
||||
.driver = {
|
||||
.name = "txx9dmac",
|
||||
|
@ -80,7 +80,7 @@ struct uniphier_xdmac_desc {
|
||||
unsigned int nr_node;
|
||||
unsigned int cur_node;
|
||||
enum dma_transfer_direction dir;
|
||||
struct uniphier_xdmac_desc_node nodes[];
|
||||
struct uniphier_xdmac_desc_node nodes[] __counted_by(nr_node);
|
||||
};
|
||||
|
||||
struct uniphier_xdmac_chan {
|
||||
@ -97,7 +97,7 @@ struct uniphier_xdmac_device {
|
||||
struct dma_device ddev;
|
||||
void __iomem *reg_base;
|
||||
int nr_chans;
|
||||
struct uniphier_xdmac_chan channels[];
|
||||
struct uniphier_xdmac_chan channels[] __counted_by(nr_chans);
|
||||
};
|
||||
|
||||
static struct uniphier_xdmac_chan *
|
||||
@ -295,6 +295,7 @@ uniphier_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,
|
||||
xd = kzalloc(struct_size(xd, nodes, nr), GFP_NOWAIT);
|
||||
if (!xd)
|
||||
return NULL;
|
||||
xd->nr_node = nr;
|
||||
|
||||
for (i = 0; i < nr; i++) {
|
||||
burst_size = min_t(size_t, len, XDMAC_MAX_WORD_SIZE);
|
||||
@ -309,7 +310,6 @@ uniphier_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,
|
||||
}
|
||||
|
||||
xd->dir = DMA_MEM_TO_MEM;
|
||||
xd->nr_node = nr;
|
||||
xd->cur_node = 0;
|
||||
|
||||
return vchan_tx_prep(vc, &xd->vd, flags);
|
||||
@ -351,6 +351,7 @@ uniphier_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
|
||||
xd = kzalloc(struct_size(xd, nodes, sg_len), GFP_NOWAIT);
|
||||
if (!xd)
|
||||
return NULL;
|
||||
xd->nr_node = sg_len;
|
||||
|
||||
for_each_sg(sgl, sg, sg_len, i) {
|
||||
xd->nodes[i].src = (direction == DMA_DEV_TO_MEM)
|
||||
@ -385,7 +386,6 @@ uniphier_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
|
||||
}
|
||||
|
||||
xd->dir = direction;
|
||||
xd->nr_node = sg_len;
|
||||
xd->cur_node = 0;
|
||||
|
||||
return vchan_tx_prep(vc, &xd->vd, flags);
|
||||
|
@ -1776,7 +1776,7 @@ err_clk_enable:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int xgene_dma_remove(struct platform_device *pdev)
|
||||
static void xgene_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct xgene_dma *pdma = platform_get_drvdata(pdev);
|
||||
struct xgene_dma_chan *chan;
|
||||
@ -1797,8 +1797,6 @@ static int xgene_dma_remove(struct platform_device *pdev)
|
||||
|
||||
if (!IS_ERR(pdma->clk))
|
||||
clk_disable_unprepare(pdma->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
@ -1817,7 +1815,7 @@ MODULE_DEVICE_TABLE(of, xgene_dma_of_match_ptr);
|
||||
|
||||
static struct platform_driver xgene_dma_driver = {
|
||||
.probe = xgene_dma_probe,
|
||||
.remove = xgene_dma_remove,
|
||||
.remove_new = xgene_dma_remove,
|
||||
.driver = {
|
||||
.name = "X-Gene-DMA",
|
||||
.of_match_table = xgene_dma_of_match_ptr,
|
||||
|
@ -44,6 +44,8 @@
|
||||
FIELD_PREP(XDMA_DESC_FLAGS_BITS, (flag)))
|
||||
#define XDMA_DESC_CONTROL_LAST \
|
||||
XDMA_DESC_CONTROL(1, XDMA_DESC_STOPPED | XDMA_DESC_COMPLETED)
|
||||
#define XDMA_DESC_CONTROL_CYCLIC \
|
||||
XDMA_DESC_CONTROL(1, XDMA_DESC_COMPLETED)
|
||||
|
||||
/*
|
||||
* Descriptor for a single contiguous memory block transfer.
|
||||
|
@ -83,6 +83,9 @@ struct xdma_chan {
|
||||
* @dblk_num: Number of hardware descriptor blocks
|
||||
* @desc_num: Number of hardware descriptors
|
||||
* @completed_desc_num: Completed hardware descriptors
|
||||
* @cyclic: Cyclic transfer vs. scatter-gather
|
||||
* @periods: Number of periods in the cyclic transfer
|
||||
* @period_size: Size of a period in bytes in cyclic transfers
|
||||
*/
|
||||
struct xdma_desc {
|
||||
struct virt_dma_desc vdesc;
|
||||
@ -93,6 +96,9 @@ struct xdma_desc {
|
||||
u32 dblk_num;
|
||||
u32 desc_num;
|
||||
u32 completed_desc_num;
|
||||
bool cyclic;
|
||||
u32 periods;
|
||||
u32 period_size;
|
||||
};
|
||||
|
||||
#define XDMA_DEV_STATUS_REG_DMA BIT(0)
|
||||
@ -137,10 +143,10 @@ static inline void *xdma_blk_last_desc(struct xdma_desc_block *block)
|
||||
}
|
||||
|
||||
/**
|
||||
* xdma_link_desc_blocks - Link descriptor blocks for DMA transfer
|
||||
* xdma_link_sg_desc_blocks - Link SG descriptor blocks for DMA transfer
|
||||
* @sw_desc: Tx descriptor pointer
|
||||
*/
|
||||
static void xdma_link_desc_blocks(struct xdma_desc *sw_desc)
|
||||
static void xdma_link_sg_desc_blocks(struct xdma_desc *sw_desc)
|
||||
{
|
||||
struct xdma_desc_block *block;
|
||||
u32 last_blk_desc, desc_control;
|
||||
@ -174,6 +180,25 @@ static void xdma_link_desc_blocks(struct xdma_desc *sw_desc)
|
||||
desc->control = cpu_to_le32(XDMA_DESC_CONTROL_LAST);
|
||||
}
|
||||
|
||||
/**
|
||||
* xdma_link_cyclic_desc_blocks - Link cyclic descriptor blocks for DMA transfer
|
||||
* @sw_desc: Tx descriptor pointer
|
||||
*/
|
||||
static void xdma_link_cyclic_desc_blocks(struct xdma_desc *sw_desc)
|
||||
{
|
||||
struct xdma_desc_block *block;
|
||||
struct xdma_hw_desc *desc;
|
||||
int i;
|
||||
|
||||
block = sw_desc->desc_blocks;
|
||||
for (i = 0; i < sw_desc->desc_num - 1; i++) {
|
||||
desc = block->virt_addr + i * XDMA_DESC_SIZE;
|
||||
desc->next_desc = cpu_to_le64(block->dma_addr + ((i + 1) * XDMA_DESC_SIZE));
|
||||
}
|
||||
desc = block->virt_addr + i * XDMA_DESC_SIZE;
|
||||
desc->next_desc = cpu_to_le64(block->dma_addr);
|
||||
}
|
||||
|
||||
static inline struct xdma_chan *to_xdma_chan(struct dma_chan *chan)
|
||||
{
|
||||
return container_of(chan, struct xdma_chan, vchan.chan);
|
||||
@ -231,14 +256,16 @@ static void xdma_free_desc(struct virt_dma_desc *vdesc)
|
||||
* xdma_alloc_desc - Allocate descriptor
|
||||
* @chan: DMA channel pointer
|
||||
* @desc_num: Number of hardware descriptors
|
||||
* @cyclic: Whether this is a cyclic transfer
|
||||
*/
|
||||
static struct xdma_desc *
|
||||
xdma_alloc_desc(struct xdma_chan *chan, u32 desc_num)
|
||||
xdma_alloc_desc(struct xdma_chan *chan, u32 desc_num, bool cyclic)
|
||||
{
|
||||
struct xdma_desc *sw_desc;
|
||||
struct xdma_hw_desc *desc;
|
||||
dma_addr_t dma_addr;
|
||||
u32 dblk_num;
|
||||
u32 control;
|
||||
void *addr;
|
||||
int i, j;
|
||||
|
||||
@ -248,12 +275,18 @@ xdma_alloc_desc(struct xdma_chan *chan, u32 desc_num)
|
||||
|
||||
sw_desc->chan = chan;
|
||||
sw_desc->desc_num = desc_num;
|
||||
sw_desc->cyclic = cyclic;
|
||||
dblk_num = DIV_ROUND_UP(desc_num, XDMA_DESC_ADJACENT);
|
||||
sw_desc->desc_blocks = kcalloc(dblk_num, sizeof(*sw_desc->desc_blocks),
|
||||
GFP_NOWAIT);
|
||||
if (!sw_desc->desc_blocks)
|
||||
goto failed;
|
||||
|
||||
if (cyclic)
|
||||
control = XDMA_DESC_CONTROL_CYCLIC;
|
||||
else
|
||||
control = XDMA_DESC_CONTROL(1, 0);
|
||||
|
||||
sw_desc->dblk_num = dblk_num;
|
||||
for (i = 0; i < sw_desc->dblk_num; i++) {
|
||||
addr = dma_pool_alloc(chan->desc_pool, GFP_NOWAIT, &dma_addr);
|
||||
@ -263,10 +296,13 @@ xdma_alloc_desc(struct xdma_chan *chan, u32 desc_num)
|
||||
sw_desc->desc_blocks[i].virt_addr = addr;
|
||||
sw_desc->desc_blocks[i].dma_addr = dma_addr;
|
||||
for (j = 0, desc = addr; j < XDMA_DESC_ADJACENT; j++)
|
||||
desc[j].control = cpu_to_le32(XDMA_DESC_CONTROL(1, 0));
|
||||
desc[j].control = cpu_to_le32(control);
|
||||
}
|
||||
|
||||
xdma_link_desc_blocks(sw_desc);
|
||||
if (cyclic)
|
||||
xdma_link_cyclic_desc_blocks(sw_desc);
|
||||
else
|
||||
xdma_link_sg_desc_blocks(sw_desc);
|
||||
|
||||
return sw_desc;
|
||||
|
||||
@ -466,7 +502,7 @@ xdma_prep_device_sg(struct dma_chan *chan, struct scatterlist *sgl,
|
||||
for_each_sg(sgl, sg, sg_len, i)
|
||||
desc_num += DIV_ROUND_UP(sg_dma_len(sg), XDMA_DESC_BLEN_MAX);
|
||||
|
||||
sw_desc = xdma_alloc_desc(xdma_chan, desc_num);
|
||||
sw_desc = xdma_alloc_desc(xdma_chan, desc_num, false);
|
||||
if (!sw_desc)
|
||||
return NULL;
|
||||
sw_desc->dir = dir;
|
||||
@ -521,6 +557,81 @@ failed:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* xdma_prep_dma_cyclic - prepare for cyclic DMA transactions
|
||||
* @chan: DMA channel pointer
|
||||
* @address: Device DMA address to access
|
||||
* @size: Total length to transfer
|
||||
* @period_size: Period size to use for each transfer
|
||||
* @dir: Transfer direction
|
||||
* @flags: Transfer ack flags
|
||||
*/
|
||||
static struct dma_async_tx_descriptor *
|
||||
xdma_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t address,
|
||||
size_t size, size_t period_size,
|
||||
enum dma_transfer_direction dir,
|
||||
unsigned long flags)
|
||||
{
|
||||
struct xdma_chan *xdma_chan = to_xdma_chan(chan);
|
||||
struct xdma_device *xdev = xdma_chan->xdev_hdl;
|
||||
unsigned int periods = size / period_size;
|
||||
struct dma_async_tx_descriptor *tx_desc;
|
||||
struct xdma_desc_block *dblk;
|
||||
struct xdma_hw_desc *desc;
|
||||
struct xdma_desc *sw_desc;
|
||||
unsigned int i;
|
||||
|
||||
/*
|
||||
* Simplify the whole logic by preventing an abnormally high number of
|
||||
* periods and periods size.
|
||||
*/
|
||||
if (period_size > XDMA_DESC_BLEN_MAX) {
|
||||
xdma_err(xdev, "period size limited to %lu bytes\n", XDMA_DESC_BLEN_MAX);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (periods > XDMA_DESC_ADJACENT) {
|
||||
xdma_err(xdev, "number of periods limited to %u\n", XDMA_DESC_ADJACENT);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
sw_desc = xdma_alloc_desc(xdma_chan, periods, true);
|
||||
if (!sw_desc)
|
||||
return NULL;
|
||||
|
||||
sw_desc->periods = periods;
|
||||
sw_desc->period_size = period_size;
|
||||
sw_desc->dir = dir;
|
||||
|
||||
dblk = sw_desc->desc_blocks;
|
||||
desc = dblk->virt_addr;
|
||||
|
||||
/* fill hardware descriptor */
|
||||
for (i = 0; i < periods; i++) {
|
||||
desc->bytes = cpu_to_le32(period_size);
|
||||
if (dir == DMA_MEM_TO_DEV) {
|
||||
desc->src_addr = cpu_to_le64(address + i * period_size);
|
||||
desc->dst_addr = cpu_to_le64(xdma_chan->cfg.dst_addr);
|
||||
} else {
|
||||
desc->src_addr = cpu_to_le64(xdma_chan->cfg.src_addr);
|
||||
desc->dst_addr = cpu_to_le64(address + i * period_size);
|
||||
}
|
||||
|
||||
desc++;
|
||||
}
|
||||
|
||||
tx_desc = vchan_tx_prep(&xdma_chan->vchan, &sw_desc->vdesc, flags);
|
||||
if (!tx_desc)
|
||||
goto failed;
|
||||
|
||||
return tx_desc;
|
||||
|
||||
failed:
|
||||
xdma_free_desc(&sw_desc->vdesc);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* xdma_device_config - Configure the DMA channel
|
||||
* @chan: DMA channel
|
||||
@ -577,6 +688,41 @@ static int xdma_alloc_chan_resources(struct dma_chan *chan)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static enum dma_status xdma_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
|
||||
struct dma_tx_state *state)
|
||||
{
|
||||
struct xdma_chan *xdma_chan = to_xdma_chan(chan);
|
||||
struct xdma_desc *desc = NULL;
|
||||
struct virt_dma_desc *vd;
|
||||
enum dma_status ret;
|
||||
unsigned long flags;
|
||||
unsigned int period_idx;
|
||||
u32 residue = 0;
|
||||
|
||||
ret = dma_cookie_status(chan, cookie, state);
|
||||
if (ret == DMA_COMPLETE)
|
||||
return ret;
|
||||
|
||||
spin_lock_irqsave(&xdma_chan->vchan.lock, flags);
|
||||
|
||||
vd = vchan_find_desc(&xdma_chan->vchan, cookie);
|
||||
if (vd)
|
||||
desc = to_xdma_desc(vd);
|
||||
if (!desc || !desc->cyclic) {
|
||||
spin_unlock_irqrestore(&xdma_chan->vchan.lock, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
period_idx = desc->completed_desc_num % desc->periods;
|
||||
residue = (desc->periods - period_idx) * desc->period_size;
|
||||
|
||||
spin_unlock_irqrestore(&xdma_chan->vchan.lock, flags);
|
||||
|
||||
dma_set_residue(state, residue);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* xdma_channel_isr - XDMA channel interrupt handler
|
||||
* @irq: IRQ number
|
||||
@ -590,6 +736,7 @@ static irqreturn_t xdma_channel_isr(int irq, void *dev_id)
|
||||
struct virt_dma_desc *vd;
|
||||
struct xdma_desc *desc;
|
||||
int ret;
|
||||
u32 st;
|
||||
|
||||
spin_lock(&xchan->vchan.lock);
|
||||
|
||||
@ -608,6 +755,19 @@ static irqreturn_t xdma_channel_isr(int irq, void *dev_id)
|
||||
goto out;
|
||||
|
||||
desc->completed_desc_num += complete_desc_num;
|
||||
|
||||
if (desc->cyclic) {
|
||||
ret = regmap_read(xdev->rmap, xchan->base + XDMA_CHAN_STATUS,
|
||||
&st);
|
||||
if (ret)
|
||||
goto out;
|
||||
|
||||
regmap_write(xdev->rmap, xchan->base + XDMA_CHAN_STATUS, st);
|
||||
|
||||
vchan_cyclic_callback(vd);
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* if all data blocks are transferred, remove and complete the request
|
||||
*/
|
||||
@ -621,7 +781,7 @@ static irqreturn_t xdma_channel_isr(int irq, void *dev_id)
|
||||
complete_desc_num != XDMA_DESC_BLOCK_NUM * XDMA_DESC_ADJACENT)
|
||||
goto out;
|
||||
|
||||
/* transfer the rest of data */
|
||||
/* transfer the rest of data (SG only) */
|
||||
xdma_xfer_start(xchan);
|
||||
|
||||
out:
|
||||
@ -841,7 +1001,7 @@ EXPORT_SYMBOL(xdma_get_user_irq);
|
||||
* xdma_remove - Driver remove function
|
||||
* @pdev: Pointer to the platform_device structure
|
||||
*/
|
||||
static int xdma_remove(struct platform_device *pdev)
|
||||
static void xdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct xdma_device *xdev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -850,8 +1010,6 @@ static int xdma_remove(struct platform_device *pdev)
|
||||
|
||||
if (xdev->status & XDMA_DEV_STATUS_REG_DMA)
|
||||
dma_async_device_unregister(&xdev->dma_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -885,7 +1043,7 @@ static int xdma_probe(struct platform_device *pdev)
|
||||
goto failed;
|
||||
}
|
||||
xdev->irq_start = res->start;
|
||||
xdev->irq_num = res->end - res->start + 1;
|
||||
xdev->irq_num = resource_size(res);
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res) {
|
||||
@ -921,17 +1079,20 @@ static int xdma_probe(struct platform_device *pdev)
|
||||
|
||||
dma_cap_set(DMA_SLAVE, xdev->dma_dev.cap_mask);
|
||||
dma_cap_set(DMA_PRIVATE, xdev->dma_dev.cap_mask);
|
||||
dma_cap_set(DMA_CYCLIC, xdev->dma_dev.cap_mask);
|
||||
|
||||
xdev->dma_dev.dev = &pdev->dev;
|
||||
xdev->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;
|
||||
xdev->dma_dev.device_free_chan_resources = xdma_free_chan_resources;
|
||||
xdev->dma_dev.device_alloc_chan_resources = xdma_alloc_chan_resources;
|
||||
xdev->dma_dev.device_tx_status = dma_cookie_status;
|
||||
xdev->dma_dev.device_tx_status = xdma_tx_status;
|
||||
xdev->dma_dev.device_prep_slave_sg = xdma_prep_device_sg;
|
||||
xdev->dma_dev.device_config = xdma_device_config;
|
||||
xdev->dma_dev.device_issue_pending = xdma_issue_pending;
|
||||
xdev->dma_dev.filter.map = pdata->device_map;
|
||||
xdev->dma_dev.filter.mapcnt = pdata->device_map_cnt;
|
||||
xdev->dma_dev.filter.fn = xdma_filter_fn;
|
||||
xdev->dma_dev.device_prep_dma_cyclic = xdma_prep_dma_cyclic;
|
||||
|
||||
ret = dma_async_device_register(&xdev->dma_dev);
|
||||
if (ret) {
|
||||
@ -966,7 +1127,7 @@ static struct platform_driver xdma_driver = {
|
||||
},
|
||||
.id_table = xdma_id_table,
|
||||
.probe = xdma_probe,
|
||||
.remove = xdma_remove,
|
||||
.remove_new = xdma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(xdma_driver);
|
||||
|
@ -3242,10 +3242,8 @@ disable_clks:
|
||||
/**
|
||||
* xilinx_dma_remove - Driver remove function
|
||||
* @pdev: Pointer to the platform_device structure
|
||||
*
|
||||
* Return: Always '0'
|
||||
*/
|
||||
static int xilinx_dma_remove(struct platform_device *pdev)
|
||||
static void xilinx_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct xilinx_dma_device *xdev = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
@ -3259,8 +3257,6 @@ static int xilinx_dma_remove(struct platform_device *pdev)
|
||||
xilinx_dma_chan_remove(xdev->chan[i]);
|
||||
|
||||
xdma_disable_allclks(xdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver xilinx_vdma_driver = {
|
||||
@ -3269,7 +3265,7 @@ static struct platform_driver xilinx_vdma_driver = {
|
||||
.of_match_table = xilinx_dma_of_ids,
|
||||
},
|
||||
.probe = xilinx_dma_probe,
|
||||
.remove = xilinx_dma_remove,
|
||||
.remove_new = xilinx_dma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(xilinx_vdma_driver);
|
||||
|
@ -1736,7 +1736,7 @@ error:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int xilinx_dpdma_remove(struct platform_device *pdev)
|
||||
static void xilinx_dpdma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct xilinx_dpdma_device *xdev = platform_get_drvdata(pdev);
|
||||
unsigned int i;
|
||||
@ -1751,8 +1751,6 @@ static int xilinx_dpdma_remove(struct platform_device *pdev)
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(xdev->chan); i++)
|
||||
xilinx_dpdma_chan_remove(xdev->chan[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id xilinx_dpdma_of_match[] = {
|
||||
@ -1763,7 +1761,7 @@ MODULE_DEVICE_TABLE(of, xilinx_dpdma_of_match);
|
||||
|
||||
static struct platform_driver xilinx_dpdma_driver = {
|
||||
.probe = xilinx_dpdma_probe,
|
||||
.remove = xilinx_dpdma_remove,
|
||||
.remove_new = xilinx_dpdma_remove,
|
||||
.driver = {
|
||||
.name = "xilinx-zynqmp-dpdma",
|
||||
.of_match_table = xilinx_dpdma_of_match,
|
||||
|
@ -1147,7 +1147,7 @@ err_disable_pm:
|
||||
*
|
||||
* Return: Always '0'
|
||||
*/
|
||||
static int zynqmp_dma_remove(struct platform_device *pdev)
|
||||
static void zynqmp_dma_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct zynqmp_dma_device *zdev = platform_get_drvdata(pdev);
|
||||
|
||||
@ -1158,8 +1158,6 @@ static int zynqmp_dma_remove(struct platform_device *pdev)
|
||||
pm_runtime_disable(zdev->dev);
|
||||
if (!pm_runtime_enabled(zdev->dev))
|
||||
zynqmp_dma_runtime_suspend(zdev->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct of_device_id zynqmp_dma_of_match[] = {
|
||||
@ -1175,7 +1173,7 @@ static struct platform_driver zynqmp_dma_driver = {
|
||||
.pm = &zynqmp_dma_dev_pm_ops,
|
||||
},
|
||||
.probe = zynqmp_dma_probe,
|
||||
.remove = zynqmp_dma_remove,
|
||||
.remove_new = zynqmp_dma_remove,
|
||||
};
|
||||
|
||||
module_platform_driver(zynqmp_dma_driver);
|
||||
|
@ -517,8 +517,6 @@ static inline const char *dma_chan_name(struct dma_chan *chan)
|
||||
return dev_name(&chan->dev->device);
|
||||
}
|
||||
|
||||
void dma_chan_cleanup(struct kref *kref);
|
||||
|
||||
/**
|
||||
* typedef dma_filter_fn - callback filter for dma_request_channel
|
||||
* @chan: channel to be reviewed
|
||||
|
@ -31,6 +31,7 @@ enum idxd_scmd_stat {
|
||||
IDXD_SCMD_WQ_IRQ_ERR = 0x80100000,
|
||||
IDXD_SCMD_WQ_USER_NO_IOMMU = 0x80110000,
|
||||
IDXD_SCMD_DEV_EVL_ERR = 0x80120000,
|
||||
IDXD_SCMD_WQ_NO_DRV_NAME = 0x80200000,
|
||||
};
|
||||
|
||||
#define IDXD_SCMD_SOFTERR_MASK 0x80000000
|
||||
|
Loading…
Reference in New Issue
Block a user