Unverified Commit a1daaa99 authored by Ikjoon Jang's avatar Ikjoon Jang Committed by Mark Brown
Browse files

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



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: default avatarIkjoon Jang <ikjn@chromium.org>
Link: https://lore.kernel.org/r/20201006155010.v5.2.I06cb65401ab5ad63ea30c4788d26633928d80f38@changeid


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 9935b612

drivers/spi/spi-mtk-nor.c

+52 −42
Original line number Diff line number Diff line
@@ -97,6 +97,7 @@ struct mtk_nor { 
	struct device *dev;

	void __iomem *base;

	u8 *buffer;

	dma_addr_t buffer_dma;

	struct clk *spi_clk;

	struct clk *ctlr_clk;

	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)

{

	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)

{

	struct mtk_nor *sp = spi_controller_get_devdata(mem->spi->master);



	if (!op->data.nbytes)

		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) ||

			    (op->data.nbytes < MTK_NOR_DMA_ALIGN))

				op->data.nbytes = 1;

			else if (!((ulong)(op->data.buf.in) &

				   MTK_NOR_DMA_ALIGN_MASK))

			else if (!need_bounce(sp, op))

				op->data.nbytes &= ~MTK_NOR_DMA_ALIGN_MASK;

			else if (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);

}



static int mtk_nor_read_dma(struct mtk_nor *sp, u32 from, unsigned int length,

			    u8 *buffer)

static int mtk_nor_dma_exec(struct mtk_nor *sp, u32 from, unsigned int length,

			    dma_addr_t dma_addr)

{

	int ret = 0;

	ulong delay;

	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(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);

	}



	dma_unmap_single(sp->dev, dma_addr, length, DMA_FROM_DEVICE);

	if (ret < 0)

		dev_err(sp->dev, "dma read timeout.\n");



	return ret;

}



static int mtk_nor_read_bounce(struct mtk_nor *sp, u32 from,

			       unsigned int length, u8 *buffer)

static int mtk_nor_read_bounce(struct mtk_nor *sp, const struct spi_mem_op *op)

{

	unsigned int rdlen;

	int ret;



	if (length & MTK_NOR_DMA_ALIGN_MASK)

		rdlen = (length + MTK_NOR_DMA_ALIGN) & ~MTK_NOR_DMA_ALIGN_MASK;

	if (op->data.nbytes & MTK_NOR_DMA_ALIGN_MASK)

		rdlen = (op->data.nbytes + MTK_NOR_DMA_ALIGN) & ~MTK_NOR_DMA_ALIGN_MASK;

	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;

}



	memcpy(buffer, sp->buffer, length);

	return 0;

static int mtk_nor_read_dma(struct mtk_nor *sp, const struct spi_mem_op *op)

{

	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)
@@ -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) {

			mtk_nor_set_addr(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 {

			return mtk_nor_read_dma(sp, op->addr.val,

						op->data.nbytes,

						op->data.buf.in);

			return mtk_nor_read_dma(sp, op);

		}

	}
@@ -729,7 +741,6 @@ static int mtk_nor_probe(struct platform_device *pdev) 
	struct spi_controller *ctlr;

	struct mtk_nor *sp;

	void __iomem *base;

	u8 *buffer;

	struct clk *spi_clk, *ctlr_clk;

	int ret, irq;
@@ -745,16 +756,6 @@ static int mtk_nor_probe(struct platform_device *pdev) 
	if (IS_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));

	if (!ctlr) {

		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->base = base;

	sp->buffer = buffer;

	sp->has_irq = false;

	sp->wbuf_en = false;

	sp->ctlr = ctlr;

	sp->dev = &pdev->dev;

	sp->spi_clk = spi_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);

	if (irq < 0) {

CRA Git | Maintained and supported by SUSTech CRA and CCSE