mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-04 10:40:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

spi: spi-mtk-nor: use dma_alloc_coherent() for bounce buffer

Browse source 
Use dma_alloc_coherent() for bounce buffer instead of kmalloc() to
make sure the bounce buffer to be allocated within its DMAable range.

Signed-off-by: Ikjoon Jang <ikjn@chromium.org>
Link: https://lore.kernel.org/r/20201006155010.v5.2.I06cb65401ab5ad63ea30c4788d26633928d80f38@changeid
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Ikjoon Jang 2020-10-06 15:54:03 +08:00 committed by Mark Brown
parent 9935b612a5
commit a1daaa991e
No known key found for this signature in database
GPG key ID: 24D68B725D5487D0
1 changed files with 52 additions and 42 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

92
drivers/spi/spi-mtk-nor.c
View file

@ -97,6 +97,7 @@ struct mtk_nor {
struct device *dev; struct device *dev;
void __iomem *base; void __iomem *base;
u8 *buffer; u8 *buffer;
dma_addr_t buffer_dma;
struct clk *spi_clk; struct clk *spi_clk;
struct clk *ctlr_clk; struct clk *ctlr_clk;
unsigned int spi_freq; unsigned int spi_freq;
@ -145,6 +146,11 @@ static void mtk_nor_set_addr(struct mtk_nor *sp, const struct spi_mem_op *op)
} }
} }
static bool need_bounce(struct mtk_nor *sp, const struct spi_mem_op *op)
{
return ((uintptr_t)op->data.buf.in & MTK_NOR_DMA_ALIGN_MASK);
}
static bool mtk_nor_match_read(const struct spi_mem_op *op) static bool mtk_nor_match_read(const struct spi_mem_op *op)
{ {
int dummy = 0; int dummy = 0;
@ -238,6 +244,8 @@ static void mtk_nor_adj_prg_size(struct spi_mem_op *op)
static int mtk_nor_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op) static int mtk_nor_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
{ {
struct mtk_nor *sp = spi_controller_get_devdata(mem->spi->master);
if (!op->data.nbytes) if (!op->data.nbytes)
return 0; return 0;
@ -251,8 +259,7 @@ static int mtk_nor_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
if ((op->addr.val & MTK_NOR_DMA_ALIGN_MASK) || if ((op->addr.val & MTK_NOR_DMA_ALIGN_MASK) ||
(op->data.nbytes < MTK_NOR_DMA_ALIGN)) (op->data.nbytes < MTK_NOR_DMA_ALIGN))
op->data.nbytes = 1; op->data.nbytes = 1;
else if (!((ulong)(op->data.buf.in) & else if (!need_bounce(sp, op))
MTK_NOR_DMA_ALIGN_MASK))
op->data.nbytes &= ~MTK_NOR_DMA_ALIGN_MASK; op->data.nbytes &= ~MTK_NOR_DMA_ALIGN_MASK;
else if (op->data.nbytes > MTK_NOR_BOUNCE_BUF_SIZE) else if (op->data.nbytes > MTK_NOR_BOUNCE_BUF_SIZE)
op->data.nbytes = MTK_NOR_BOUNCE_BUF_SIZE; op->data.nbytes = MTK_NOR_BOUNCE_BUF_SIZE;
@ -325,19 +332,12 @@ static void mtk_nor_setup_bus(struct mtk_nor *sp, const struct spi_mem_op *op)
mtk_nor_rmw(sp, MTK_NOR_REG_BUSCFG, reg, MTK_NOR_BUS_MODE_MASK); mtk_nor_rmw(sp, MTK_NOR_REG_BUSCFG, reg, MTK_NOR_BUS_MODE_MASK);
} }
static int mtk_nor_read_dma(struct mtk_nor *sp, u32 from, unsigned int length, static int mtk_nor_dma_exec(struct mtk_nor *sp, u32 from, unsigned int length,
u8 *buffer) dma_addr_t dma_addr)
{ {
int ret = 0; int ret = 0;
ulong delay; ulong delay;
u32 reg; u32 reg;
dma_addr_t dma_addr;
dma_addr = dma_map_single(sp->dev, buffer, length, DMA_FROM_DEVICE);
if (dma_mapping_error(sp->dev, dma_addr)) {
dev_err(sp->dev, "failed to map dma buffer.\n");
return -EINVAL;
}
writel(from, sp->base + MTK_NOR_REG_DMA_FADR); writel(from, sp->base + MTK_NOR_REG_DMA_FADR);
writel(dma_addr, sp->base + MTK_NOR_REG_DMA_DADR); writel(dma_addr, sp->base + MTK_NOR_REG_DMA_DADR);
@ -362,30 +362,49 @@ static int mtk_nor_read_dma(struct mtk_nor *sp, u32 from, unsigned int length,
(delay + 1) * 100); (delay + 1) * 100);
} }
dma_unmap_single(sp->dev, dma_addr, length, DMA_FROM_DEVICE);
if (ret < 0) if (ret < 0)
dev_err(sp->dev, "dma read timeout.\n"); dev_err(sp->dev, "dma read timeout.\n");
return ret; return ret;
} }
static int mtk_nor_read_bounce(struct mtk_nor *sp, u32 from, static int mtk_nor_read_bounce(struct mtk_nor *sp, const struct spi_mem_op *op)
unsigned int length, u8 *buffer)
{ {
unsigned int rdlen; unsigned int rdlen;
int ret; int ret;
if (length & MTK_NOR_DMA_ALIGN_MASK) if (op->data.nbytes & MTK_NOR_DMA_ALIGN_MASK)
rdlen = (length + MTK_NOR_DMA_ALIGN) & ~MTK_NOR_DMA_ALIGN_MASK; rdlen = (op->data.nbytes + MTK_NOR_DMA_ALIGN) & ~MTK_NOR_DMA_ALIGN_MASK;
else else
rdlen = length; rdlen = op->data.nbytes;
ret = mtk_nor_dma_exec(sp, op->addr.val, rdlen, sp->buffer_dma);
if (!ret)
memcpy(op->data.buf.in, sp->buffer, op->data.nbytes);
ret = mtk_nor_read_dma(sp, from, rdlen, sp->buffer);
if (ret)
return ret; return ret;
}
memcpy(buffer, sp->buffer, length); static int mtk_nor_read_dma(struct mtk_nor *sp, const struct spi_mem_op *op)
return 0; {
int ret;
dma_addr_t dma_addr;
if (need_bounce(sp, op))
return mtk_nor_read_bounce(sp, op);
dma_addr = dma_map_single(sp->dev, op->data.buf.in,
op->data.nbytes, DMA_FROM_DEVICE);
if (dma_mapping_error(sp->dev, dma_addr))
return -EINVAL;
ret = mtk_nor_dma_exec(sp, op->addr.val, op->data.nbytes, dma_addr);
dma_unmap_single(sp->dev, dma_addr, op->data.nbytes, DMA_FROM_DEVICE);
return ret;
} }
static int mtk_nor_read_pio(struct mtk_nor *sp, const struct spi_mem_op *op) static int mtk_nor_read_pio(struct mtk_nor *sp, const struct spi_mem_op *op)
@ -566,15 +585,8 @@ static int mtk_nor_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
if (op->data.nbytes == 1) { if (op->data.nbytes == 1) {
mtk_nor_set_addr(sp, op); mtk_nor_set_addr(sp, op);
return mtk_nor_read_pio(sp, op); return mtk_nor_read_pio(sp, op);
} else if (((ulong)(op->data.buf.in) &
MTK_NOR_DMA_ALIGN_MASK)) {
return mtk_nor_read_bounce(sp, op->addr.val,
op->data.nbytes,
op->data.buf.in);
} else { } else {
return mtk_nor_read_dma(sp, op->addr.val, return mtk_nor_read_dma(sp, op);
op->data.nbytes,
op->data.buf.in);
} }
} }
@ -729,7 +741,6 @@ static int mtk_nor_probe(struct platform_device *pdev)
struct spi_controller *ctlr; struct spi_controller *ctlr;
struct mtk_nor *sp; struct mtk_nor *sp;
void __iomem *base; void __iomem *base;
u8 *buffer;
struct clk *spi_clk, *ctlr_clk; struct clk *spi_clk, *ctlr_clk;
int ret, irq; int ret, irq;
@ -745,16 +756,6 @@ static int mtk_nor_probe(struct platform_device *pdev)
if (IS_ERR(ctlr_clk)) if (IS_ERR(ctlr_clk))
return PTR_ERR(ctlr_clk); return PTR_ERR(ctlr_clk);
buffer = devm_kmalloc(&pdev->dev,
MTK_NOR_BOUNCE_BUF_SIZE + MTK_NOR_DMA_ALIGN,
GFP_KERNEL);
if (!buffer)
return -ENOMEM;
if ((ulong)buffer & MTK_NOR_DMA_ALIGN_MASK)
buffer = (u8 *)(((ulong)buffer + MTK_NOR_DMA_ALIGN) &
~MTK_NOR_DMA_ALIGN_MASK);
ctlr = spi_alloc_master(&pdev->dev, sizeof(*sp)); ctlr = spi_alloc_master(&pdev->dev, sizeof(*sp));
if (!ctlr) { if (!ctlr) {
dev_err(&pdev->dev, "failed to allocate spi controller\n"); dev_err(&pdev->dev, "failed to allocate spi controller\n");
@ -774,13 +775,22 @@ static int mtk_nor_probe(struct platform_device *pdev)
sp = spi_controller_get_devdata(ctlr); sp = spi_controller_get_devdata(ctlr);
sp->base = base; sp->base = base;
sp->buffer = buffer;
sp->has_irq = false; sp->has_irq = false;
sp->wbuf_en = false; sp->wbuf_en = false;
sp->ctlr = ctlr; sp->ctlr = ctlr;
sp->dev = &pdev->dev; sp->dev = &pdev->dev;
sp->spi_clk = spi_clk; sp->spi_clk = spi_clk;
sp->ctlr_clk = ctlr_clk; sp->ctlr_clk = ctlr_clk;
sp->buffer = dmam_alloc_coherent(&pdev->dev,
MTK_NOR_BOUNCE_BUF_SIZE + MTK_NOR_DMA_ALIGN,
&sp->buffer_dma, GFP_KERNEL);
if (!sp->buffer)
return -ENOMEM;
if ((uintptr_t)sp->buffer & MTK_NOR_DMA_ALIGN_MASK) {
dev_err(sp->dev, "misaligned allocation of internal buffer.\n");
return -ENOMEM;
}
irq = platform_get_irq_optional(pdev, 0); irq = platform_get_irq_optional(pdev, 0);
if (irq < 0) { if (irq < 0) {