2018-08-22 01:02:23 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-11-26 14:10:05 +03:00
|
|
|
/*
|
2019-02-08 12:09:09 +03:00
|
|
|
* SuperH MSIOF SPI Controller Interface
|
2009-11-26 14:10:05 +03:00
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Magnus Damm
|
2017-05-22 16:11:43 +03:00
|
|
|
* Copyright (C) 2014 Renesas Electronics Corporation
|
|
|
|
* Copyright (C) 2014-2017 Glider bvba
|
2009-11-26 14:10:05 +03:00
|
|
|
*/
|
|
|
|
|
2011-01-21 18:56:37 +03:00
|
|
|
#include <linux/bitmap.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/completion.h>
|
2009-11-26 14:10:05 +03:00
|
|
|
#include <linux/delay.h>
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dmaengine.h>
|
2011-01-21 18:56:37 +03:00
|
|
|
#include <linux/err.h>
|
2009-11-26 14:10:05 +03:00
|
|
|
#include <linux/interrupt.h>
|
2011-01-21 18:56:37 +03:00
|
|
|
#include <linux/io.h>
|
2019-04-02 17:40:22 +03:00
|
|
|
#include <linux/iopoll.h>
|
2011-01-21 18:56:37 +03:00
|
|
|
#include <linux/kernel.h>
|
2011-07-03 23:44:29 +04:00
|
|
|
#include <linux/module.h>
|
2012-12-12 15:54:48 +04:00
|
|
|
#include <linux/of.h>
|
2014-02-25 14:21:09 +04:00
|
|
|
#include <linux/of_device.h>
|
2009-11-26 14:10:05 +03:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/pm_runtime.h>
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
#include <linux/sh_dma.h>
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2011-01-21 18:56:37 +03:00
|
|
|
#include <linux/spi/sh_msiof.h>
|
2009-11-26 14:10:05 +03:00
|
|
|
#include <linux/spi/spi.h>
|
|
|
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
2014-02-25 14:21:09 +04:00
|
|
|
struct sh_msiof_chipdata {
|
2019-02-28 14:05:13 +03:00
|
|
|
u32 bits_per_word_mask;
|
2014-02-25 14:21:09 +04:00
|
|
|
u16 tx_fifo_size;
|
|
|
|
u16 rx_fifo_size;
|
2019-02-08 12:09:09 +03:00
|
|
|
u16 ctlr_flags;
|
2018-04-13 15:44:17 +03:00
|
|
|
u16 min_div_pow;
|
2014-02-25 14:21:09 +04:00
|
|
|
};
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
struct sh_msiof_spi_priv {
|
2019-02-08 12:09:09 +03:00
|
|
|
struct spi_controller *ctlr;
|
2009-11-26 14:10:05 +03:00
|
|
|
void __iomem *mapbase;
|
|
|
|
struct clk *clk;
|
|
|
|
struct platform_device *pdev;
|
|
|
|
struct sh_msiof_spi_info *info;
|
|
|
|
struct completion done;
|
2018-06-13 11:41:15 +03:00
|
|
|
struct completion done_txdma;
|
2015-06-14 20:25:05 +03:00
|
|
|
unsigned int tx_fifo_size;
|
|
|
|
unsigned int rx_fifo_size;
|
2018-04-13 15:44:17 +03:00
|
|
|
unsigned int min_div_pow;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
void *tx_dma_page;
|
|
|
|
void *rx_dma_page;
|
|
|
|
dma_addr_t tx_dma_addr;
|
|
|
|
dma_addr_t rx_dma_addr;
|
2017-12-13 22:05:10 +03:00
|
|
|
bool native_cs_inited;
|
|
|
|
bool native_cs_high;
|
2017-05-22 16:11:43 +03:00
|
|
|
bool slave_aborted;
|
2009-11-26 14:10:05 +03:00
|
|
|
};
|
|
|
|
|
2017-12-13 22:05:11 +03:00
|
|
|
#define MAX_SS 3 /* Maximum number of native chip selects */
|
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
#define SITMDR1 0x00 /* Transmit Mode Register 1 */
|
|
|
|
#define SITMDR2 0x04 /* Transmit Mode Register 2 */
|
|
|
|
#define SITMDR3 0x08 /* Transmit Mode Register 3 */
|
|
|
|
#define SIRMDR1 0x10 /* Receive Mode Register 1 */
|
|
|
|
#define SIRMDR2 0x14 /* Receive Mode Register 2 */
|
|
|
|
#define SIRMDR3 0x18 /* Receive Mode Register 3 */
|
|
|
|
#define SITSCR 0x20 /* Transmit Clock Select Register */
|
|
|
|
#define SIRSCR 0x22 /* Receive Clock Select Register (SH, A1, APE6) */
|
|
|
|
#define SICTR 0x28 /* Control Register */
|
|
|
|
#define SIFCTR 0x30 /* FIFO Control Register */
|
|
|
|
#define SISTR 0x40 /* Status Register */
|
|
|
|
#define SIIER 0x44 /* Interrupt Enable Register */
|
|
|
|
#define SITDR1 0x48 /* Transmit Control Data Register 1 (SH, A1) */
|
|
|
|
#define SITDR2 0x4c /* Transmit Control Data Register 2 (SH, A1) */
|
|
|
|
#define SITFDR 0x50 /* Transmit FIFO Data Register */
|
|
|
|
#define SIRDR1 0x58 /* Receive Control Data Register 1 (SH, A1) */
|
|
|
|
#define SIRDR2 0x5c /* Receive Control Data Register 2 (SH, A1) */
|
|
|
|
#define SIRFDR 0x60 /* Receive FIFO Data Register */
|
|
|
|
|
|
|
|
/* SITMDR1 and SIRMDR1 */
|
|
|
|
#define SIMDR1_TRMD BIT(31) /* Transfer Mode (1 = Master mode) */
|
|
|
|
#define SIMDR1_SYNCMD_MASK GENMASK(29, 28) /* SYNC Mode */
|
|
|
|
#define SIMDR1_SYNCMD_SPI (2 << 28) /* Level mode/SPI */
|
|
|
|
#define SIMDR1_SYNCMD_LR (3 << 28) /* L/R mode */
|
|
|
|
#define SIMDR1_SYNCAC_SHIFT 25 /* Sync Polarity (1 = Active-low) */
|
|
|
|
#define SIMDR1_BITLSB_SHIFT 24 /* MSB/LSB First (1 = LSB first) */
|
|
|
|
#define SIMDR1_DTDL_SHIFT 20 /* Data Pin Bit Delay for MSIOF_SYNC */
|
|
|
|
#define SIMDR1_SYNCDL_SHIFT 16 /* Frame Sync Signal Timing Delay */
|
|
|
|
#define SIMDR1_FLD_MASK GENMASK(3, 2) /* Frame Sync Signal Interval (0-3) */
|
|
|
|
#define SIMDR1_FLD_SHIFT 2
|
|
|
|
#define SIMDR1_XXSTP BIT(0) /* Transmission/Reception Stop on FIFO */
|
|
|
|
/* SITMDR1 */
|
|
|
|
#define SITMDR1_PCON BIT(30) /* Transfer Signal Connection */
|
|
|
|
#define SITMDR1_SYNCCH_MASK GENMASK(27, 26) /* Sync Signal Channel Select */
|
|
|
|
#define SITMDR1_SYNCCH_SHIFT 26 /* 0=MSIOF_SYNC, 1=MSIOF_SS1, 2=MSIOF_SS2 */
|
|
|
|
|
|
|
|
/* SITMDR2 and SIRMDR2 */
|
|
|
|
#define SIMDR2_BITLEN1(i) (((i) - 1) << 24) /* Data Size (8-32 bits) */
|
|
|
|
#define SIMDR2_WDLEN1(i) (((i) - 1) << 16) /* Word Count (1-64/256 (SH, A1))) */
|
|
|
|
#define SIMDR2_GRPMASK1 BIT(0) /* Group Output Mask 1 (SH, A1) */
|
|
|
|
|
|
|
|
/* SITSCR and SIRSCR */
|
|
|
|
#define SISCR_BRPS_MASK GENMASK(12, 8) /* Prescaler Setting (1-32) */
|
|
|
|
#define SISCR_BRPS(i) (((i) - 1) << 8)
|
|
|
|
#define SISCR_BRDV_MASK GENMASK(2, 0) /* Baud Rate Generator's Division Ratio */
|
|
|
|
#define SISCR_BRDV_DIV_2 0
|
|
|
|
#define SISCR_BRDV_DIV_4 1
|
|
|
|
#define SISCR_BRDV_DIV_8 2
|
|
|
|
#define SISCR_BRDV_DIV_16 3
|
|
|
|
#define SISCR_BRDV_DIV_32 4
|
|
|
|
#define SISCR_BRDV_DIV_1 7
|
|
|
|
|
|
|
|
/* SICTR */
|
|
|
|
#define SICTR_TSCKIZ_MASK GENMASK(31, 30) /* Transmit Clock I/O Polarity Select */
|
|
|
|
#define SICTR_TSCKIZ_SCK BIT(31) /* Disable SCK when TX disabled */
|
|
|
|
#define SICTR_TSCKIZ_POL_SHIFT 30 /* Transmit Clock Polarity */
|
|
|
|
#define SICTR_RSCKIZ_MASK GENMASK(29, 28) /* Receive Clock Polarity Select */
|
|
|
|
#define SICTR_RSCKIZ_SCK BIT(29) /* Must match CTR_TSCKIZ_SCK */
|
|
|
|
#define SICTR_RSCKIZ_POL_SHIFT 28 /* Receive Clock Polarity */
|
|
|
|
#define SICTR_TEDG_SHIFT 27 /* Transmit Timing (1 = falling edge) */
|
|
|
|
#define SICTR_REDG_SHIFT 26 /* Receive Timing (1 = falling edge) */
|
|
|
|
#define SICTR_TXDIZ_MASK GENMASK(23, 22) /* Pin Output When TX is Disabled */
|
|
|
|
#define SICTR_TXDIZ_LOW (0 << 22) /* 0 */
|
|
|
|
#define SICTR_TXDIZ_HIGH (1 << 22) /* 1 */
|
|
|
|
#define SICTR_TXDIZ_HIZ (2 << 22) /* High-impedance */
|
|
|
|
#define SICTR_TSCKE BIT(15) /* Transmit Serial Clock Output Enable */
|
|
|
|
#define SICTR_TFSE BIT(14) /* Transmit Frame Sync Signal Output Enable */
|
|
|
|
#define SICTR_TXE BIT(9) /* Transmit Enable */
|
|
|
|
#define SICTR_RXE BIT(8) /* Receive Enable */
|
|
|
|
#define SICTR_TXRST BIT(1) /* Transmit Reset */
|
|
|
|
#define SICTR_RXRST BIT(0) /* Receive Reset */
|
|
|
|
|
|
|
|
/* SIFCTR */
|
|
|
|
#define SIFCTR_TFWM_MASK GENMASK(31, 29) /* Transmit FIFO Watermark */
|
|
|
|
#define SIFCTR_TFWM_64 (0 << 29) /* Transfer Request when 64 empty stages */
|
|
|
|
#define SIFCTR_TFWM_32 (1 << 29) /* Transfer Request when 32 empty stages */
|
|
|
|
#define SIFCTR_TFWM_24 (2 << 29) /* Transfer Request when 24 empty stages */
|
|
|
|
#define SIFCTR_TFWM_16 (3 << 29) /* Transfer Request when 16 empty stages */
|
|
|
|
#define SIFCTR_TFWM_12 (4 << 29) /* Transfer Request when 12 empty stages */
|
|
|
|
#define SIFCTR_TFWM_8 (5 << 29) /* Transfer Request when 8 empty stages */
|
|
|
|
#define SIFCTR_TFWM_4 (6 << 29) /* Transfer Request when 4 empty stages */
|
|
|
|
#define SIFCTR_TFWM_1 (7 << 29) /* Transfer Request when 1 empty stage */
|
|
|
|
#define SIFCTR_TFUA_MASK GENMASK(26, 20) /* Transmit FIFO Usable Area */
|
|
|
|
#define SIFCTR_TFUA_SHIFT 20
|
|
|
|
#define SIFCTR_TFUA(i) ((i) << SIFCTR_TFUA_SHIFT)
|
|
|
|
#define SIFCTR_RFWM_MASK GENMASK(15, 13) /* Receive FIFO Watermark */
|
|
|
|
#define SIFCTR_RFWM_1 (0 << 13) /* Transfer Request when 1 valid stages */
|
|
|
|
#define SIFCTR_RFWM_4 (1 << 13) /* Transfer Request when 4 valid stages */
|
|
|
|
#define SIFCTR_RFWM_8 (2 << 13) /* Transfer Request when 8 valid stages */
|
|
|
|
#define SIFCTR_RFWM_16 (3 << 13) /* Transfer Request when 16 valid stages */
|
|
|
|
#define SIFCTR_RFWM_32 (4 << 13) /* Transfer Request when 32 valid stages */
|
|
|
|
#define SIFCTR_RFWM_64 (5 << 13) /* Transfer Request when 64 valid stages */
|
|
|
|
#define SIFCTR_RFWM_128 (6 << 13) /* Transfer Request when 128 valid stages */
|
|
|
|
#define SIFCTR_RFWM_256 (7 << 13) /* Transfer Request when 256 valid stages */
|
|
|
|
#define SIFCTR_RFUA_MASK GENMASK(12, 4) /* Receive FIFO Usable Area (0x40 = full) */
|
|
|
|
#define SIFCTR_RFUA_SHIFT 4
|
|
|
|
#define SIFCTR_RFUA(i) ((i) << SIFCTR_RFUA_SHIFT)
|
|
|
|
|
|
|
|
/* SISTR */
|
|
|
|
#define SISTR_TFEMP BIT(29) /* Transmit FIFO Empty */
|
|
|
|
#define SISTR_TDREQ BIT(28) /* Transmit Data Transfer Request */
|
|
|
|
#define SISTR_TEOF BIT(23) /* Frame Transmission End */
|
|
|
|
#define SISTR_TFSERR BIT(21) /* Transmit Frame Synchronization Error */
|
|
|
|
#define SISTR_TFOVF BIT(20) /* Transmit FIFO Overflow */
|
|
|
|
#define SISTR_TFUDF BIT(19) /* Transmit FIFO Underflow */
|
|
|
|
#define SISTR_RFFUL BIT(13) /* Receive FIFO Full */
|
|
|
|
#define SISTR_RDREQ BIT(12) /* Receive Data Transfer Request */
|
|
|
|
#define SISTR_REOF BIT(7) /* Frame Reception End */
|
|
|
|
#define SISTR_RFSERR BIT(5) /* Receive Frame Synchronization Error */
|
|
|
|
#define SISTR_RFUDF BIT(4) /* Receive FIFO Underflow */
|
|
|
|
#define SISTR_RFOVF BIT(3) /* Receive FIFO Overflow */
|
|
|
|
|
|
|
|
/* SIIER */
|
|
|
|
#define SIIER_TDMAE BIT(31) /* Transmit Data DMA Transfer Req. Enable */
|
|
|
|
#define SIIER_TFEMPE BIT(29) /* Transmit FIFO Empty Enable */
|
|
|
|
#define SIIER_TDREQE BIT(28) /* Transmit Data Transfer Request Enable */
|
|
|
|
#define SIIER_TEOFE BIT(23) /* Frame Transmission End Enable */
|
|
|
|
#define SIIER_TFSERRE BIT(21) /* Transmit Frame Sync Error Enable */
|
|
|
|
#define SIIER_TFOVFE BIT(20) /* Transmit FIFO Overflow Enable */
|
|
|
|
#define SIIER_TFUDFE BIT(19) /* Transmit FIFO Underflow Enable */
|
|
|
|
#define SIIER_RDMAE BIT(15) /* Receive Data DMA Transfer Req. Enable */
|
|
|
|
#define SIIER_RFFULE BIT(13) /* Receive FIFO Full Enable */
|
|
|
|
#define SIIER_RDREQE BIT(12) /* Receive Data Transfer Request Enable */
|
|
|
|
#define SIIER_REOFE BIT(7) /* Frame Reception End Enable */
|
|
|
|
#define SIIER_RFSERRE BIT(5) /* Receive Frame Sync Error Enable */
|
|
|
|
#define SIIER_RFUDFE BIT(4) /* Receive FIFO Underflow Enable */
|
|
|
|
#define SIIER_RFOVFE BIT(3) /* Receive FIFO Overflow Enable */
|
2014-02-20 18:43:03 +04:00
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2011-01-21 18:56:37 +03:00
|
|
|
static u32 sh_msiof_read(struct sh_msiof_spi_priv *p, int reg_offs)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
|
|
|
switch (reg_offs) {
|
2020-01-08 22:43:19 +03:00
|
|
|
case SITSCR:
|
|
|
|
case SIRSCR:
|
2009-11-26 14:10:05 +03:00
|
|
|
return ioread16(p->mapbase + reg_offs);
|
|
|
|
default:
|
|
|
|
return ioread32(p->mapbase + reg_offs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_write(struct sh_msiof_spi_priv *p, int reg_offs,
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 value)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
|
|
|
switch (reg_offs) {
|
2020-01-08 22:43:19 +03:00
|
|
|
case SITSCR:
|
|
|
|
case SIRSCR:
|
2009-11-26 14:10:05 +03:00
|
|
|
iowrite16(value, p->mapbase + reg_offs);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
iowrite32(value, p->mapbase + reg_offs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_modify_ctr_wait(struct sh_msiof_spi_priv *p,
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 clr, u32 set)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 mask = clr | set;
|
|
|
|
u32 data;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
data = sh_msiof_read(p, SICTR);
|
2009-11-26 14:10:05 +03:00
|
|
|
data &= ~clr;
|
|
|
|
data |= set;
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SICTR, data);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
return readl_poll_timeout_atomic(p->mapbase + SICTR, data,
|
2019-05-27 15:19:35 +03:00
|
|
|
(data & mask) == set, 1, 100);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t sh_msiof_spi_irq(int irq, void *data)
|
|
|
|
{
|
|
|
|
struct sh_msiof_spi_priv *p = data;
|
|
|
|
|
|
|
|
/* just disable the interrupt and wake up */
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, 0);
|
2009-11-26 14:10:05 +03:00
|
|
|
complete(&p->done);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2019-04-02 17:40:23 +03:00
|
|
|
static void sh_msiof_spi_reset_regs(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
2020-01-08 22:43:19 +03:00
|
|
|
u32 mask = SICTR_TXRST | SICTR_RXRST;
|
2019-04-02 17:40:23 +03:00
|
|
|
u32 data;
|
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
data = sh_msiof_read(p, SICTR);
|
2019-04-02 17:40:23 +03:00
|
|
|
data |= mask;
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SICTR, data);
|
2019-04-02 17:40:23 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
readl_poll_timeout_atomic(p->mapbase + SICTR, data, !(data & mask), 1,
|
2019-04-02 17:40:23 +03:00
|
|
|
100);
|
|
|
|
}
|
|
|
|
|
2018-04-13 15:44:17 +03:00
|
|
|
static const u32 sh_msiof_spi_div_array[] = {
|
2020-01-08 22:43:19 +03:00
|
|
|
SISCR_BRDV_DIV_1, SISCR_BRDV_DIV_2, SISCR_BRDV_DIV_4,
|
|
|
|
SISCR_BRDV_DIV_8, SISCR_BRDV_DIV_16, SISCR_BRDV_DIV_32,
|
2009-11-26 14:10:05 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static void sh_msiof_spi_set_clk_regs(struct sh_msiof_spi_priv *p,
|
2014-02-20 18:43:02 +04:00
|
|
|
unsigned long parent_rate, u32 spi_hz)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2018-04-13 15:44:17 +03:00
|
|
|
unsigned long div;
|
2015-01-30 09:11:54 +03:00
|
|
|
u32 brps, scr;
|
2018-04-13 15:44:17 +03:00
|
|
|
unsigned int div_pow = p->min_div_pow;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2018-04-13 15:44:17 +03:00
|
|
|
if (!spi_hz || !parent_rate) {
|
|
|
|
WARN(1, "Invalid clock rate parameters %lu and %u\n",
|
|
|
|
parent_rate, spi_hz);
|
|
|
|
return;
|
|
|
|
}
|
2017-07-12 13:26:01 +03:00
|
|
|
|
2018-04-13 15:44:17 +03:00
|
|
|
div = DIV_ROUND_UP(parent_rate, spi_hz);
|
|
|
|
if (div <= 1024) {
|
2020-01-08 22:43:19 +03:00
|
|
|
/* SISCR_BRDV_DIV_1 is valid only if BRPS is x 1/1 or x 1/2 */
|
2018-04-13 15:44:17 +03:00
|
|
|
if (!div_pow && div <= 32 && div > 2)
|
|
|
|
div_pow = 1;
|
|
|
|
|
|
|
|
if (div_pow)
|
|
|
|
brps = (div + 1) >> div_pow;
|
|
|
|
else
|
|
|
|
brps = div;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2018-04-13 15:44:17 +03:00
|
|
|
for (; brps > 32; div_pow++)
|
|
|
|
brps = (brps + 1) >> 1;
|
|
|
|
} else {
|
|
|
|
/* Set transfer rate composite divisor to 2^5 * 32 = 1024 */
|
|
|
|
dev_err(&p->pdev->dev,
|
|
|
|
"Requested SPI transfer rate %d is too low\n", spi_hz);
|
|
|
|
div_pow = 5;
|
|
|
|
brps = 32;
|
|
|
|
}
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
scr = sh_msiof_spi_div_array[div_pow] | SISCR_BRPS(brps);
|
|
|
|
sh_msiof_write(p, SITSCR, scr);
|
2019-02-08 12:09:09 +03:00
|
|
|
if (!(p->ctlr->flags & SPI_CONTROLLER_MUST_TX))
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIRSCR, scr);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2014-12-19 11:15:53 +03:00
|
|
|
static u32 sh_msiof_get_delay_bit(u32 dtdl_or_syncdl)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* DTDL/SYNCDL bit : p->info->dtdl or p->info->syncdl
|
|
|
|
* b'000 : 0
|
|
|
|
* b'001 : 100
|
|
|
|
* b'010 : 200
|
|
|
|
* b'011 (SYNCDL only) : 300
|
|
|
|
* b'101 : 50
|
|
|
|
* b'110 : 150
|
|
|
|
*/
|
|
|
|
if (dtdl_or_syncdl % 100)
|
|
|
|
return dtdl_or_syncdl / 100 + 5;
|
|
|
|
else
|
|
|
|
return dtdl_or_syncdl / 100;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 sh_msiof_spi_get_dtdl_and_syncdl(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
if (!p->info)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* check if DTDL and SYNCDL is allowed value */
|
|
|
|
if (p->info->dtdl > 200 || p->info->syncdl > 300) {
|
|
|
|
dev_warn(&p->pdev->dev, "DTDL or SYNCDL is too large\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if the sum of DTDL and SYNCDL becomes an integer value */
|
|
|
|
if ((p->info->dtdl + p->info->syncdl) % 100) {
|
|
|
|
dev_warn(&p->pdev->dev, "the sum of DTDL/SYNCDL is not good\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
val = sh_msiof_get_delay_bit(p->info->dtdl) << SIMDR1_DTDL_SHIFT;
|
|
|
|
val |= sh_msiof_get_delay_bit(p->info->syncdl) << SIMDR1_SYNCDL_SHIFT;
|
2014-12-19 11:15:53 +03:00
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2017-12-13 22:05:11 +03:00
|
|
|
static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p, u32 ss,
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 cpol, u32 cpha,
|
2013-12-01 22:19:15 +04:00
|
|
|
u32 tx_hi_z, u32 lsb_first, u32 cs_high)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 tmp;
|
2009-11-26 14:10:05 +03:00
|
|
|
int edge;
|
|
|
|
|
|
|
|
/*
|
2010-02-02 05:29:15 +03:00
|
|
|
* CPOL CPHA TSCKIZ RSCKIZ TEDG REDG
|
|
|
|
* 0 0 10 10 1 1
|
|
|
|
* 0 1 10 10 0 0
|
|
|
|
* 1 0 11 11 0 0
|
|
|
|
* 1 1 11 11 1 1
|
2009-11-26 14:10:05 +03:00
|
|
|
*/
|
2020-01-08 22:43:19 +03:00
|
|
|
tmp = SIMDR1_SYNCMD_SPI | 1 << SIMDR1_FLD_SHIFT | SIMDR1_XXSTP;
|
|
|
|
tmp |= !cs_high << SIMDR1_SYNCAC_SHIFT;
|
|
|
|
tmp |= lsb_first << SIMDR1_BITLSB_SHIFT;
|
2014-12-19 11:15:53 +03:00
|
|
|
tmp |= sh_msiof_spi_get_dtdl_and_syncdl(p);
|
2019-02-08 12:09:09 +03:00
|
|
|
if (spi_controller_is_slave(p->ctlr)) {
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITMDR1, tmp | SITMDR1_PCON);
|
2017-12-13 22:05:11 +03:00
|
|
|
} else {
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITMDR1,
|
|
|
|
tmp | SIMDR1_TRMD | SITMDR1_PCON |
|
|
|
|
(ss < MAX_SS ? ss : 0) << SITMDR1_SYNCCH_SHIFT);
|
2017-12-13 22:05:11 +03:00
|
|
|
}
|
2019-02-08 12:09:09 +03:00
|
|
|
if (p->ctlr->flags & SPI_CONTROLLER_MUST_TX) {
|
spi: sh-msiof: Add support for R-Car H2 and M2
Add support for the MSIOF variant in the R-Car H2 (r8a7790) and M2
(r8a7791) SoCs.
Binding documentation:
- Add future-proof "renesas,msiof-<soctype>" compatible values,
- The default for "renesas,rx-fifo-size" is 256 on R-Car H2 and M2,
- "renesas,tx-fifo-size" and "renesas,rx-fifo-size" are deprecated for
soctype-specific bindings,
- Add example bindings.
Implementation:
- MSIOF on R-Car H2 and M2 requires the transmission of dummy data if
data is being received only (cfr. "Set SICTR.TSCKE to 1" and "Write
dummy transmission data to SITFDR" in paragraph "Transmit and Receive
Procedures" of the Hardware User's Manual).
- As RX depends on TX, MSIOF on R-Car H2 and M2 also lacks the RSCR
register (Receive Clock Select Register), and some bits in the RMDR1
(Receive Mode Register 1) and TMDR2 (Transmit Mode Register 2)
registers.
- Use the recently introduced SPI_MASTER_MUST_TX flag to enable support
for dummy transmission in the SPI core, and to differentiate from other
MSIOF implementations in code paths that need this.
- New DT compatible values ("renesas,msiof-r8a7790" and
"renesas,msiof-r8a7791") are added, as well as new platform device
names ("spi_r8a7790_msiof" and "spi_r8a7791_msiof").
- The default RX FIFO size is 256 words on R-Car H2 and M2.
This is loosely based on a set of patches from Takashi Yoshii
<takasi-y@ops.dti.ne.jp>.
Signed-off-by: Geert Uytterhoeven <geert+renesas@linux-m68k.org>
Acked-by: Magnus Damm <damm@opensource.se>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-25 14:21:10 +04:00
|
|
|
/* These bits are reserved if RX needs TX */
|
|
|
|
tmp &= ~0x0000ffff;
|
|
|
|
}
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIRMDR1, tmp);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2014-02-20 18:43:03 +04:00
|
|
|
tmp = 0;
|
2020-01-08 22:43:19 +03:00
|
|
|
tmp |= SICTR_TSCKIZ_SCK | cpol << SICTR_TSCKIZ_POL_SHIFT;
|
|
|
|
tmp |= SICTR_RSCKIZ_SCK | cpol << SICTR_RSCKIZ_POL_SHIFT;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2011-01-21 18:56:37 +03:00
|
|
|
edge = cpol ^ !cpha;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
tmp |= edge << SICTR_TEDG_SHIFT;
|
|
|
|
tmp |= edge << SICTR_REDG_SHIFT;
|
|
|
|
tmp |= tx_hi_z ? SICTR_TXDIZ_HIZ : SICTR_TXDIZ_LOW;
|
|
|
|
sh_msiof_write(p, SICTR, tmp);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_set_mode_regs(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, void *rx_buf,
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 bits, u32 words)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2020-01-08 22:43:19 +03:00
|
|
|
u32 dr2 = SIMDR2_BITLEN1(bits) | SIMDR2_WDLEN1(words);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
if (tx_buf || (p->ctlr->flags & SPI_CONTROLLER_MUST_TX))
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITMDR2, dr2);
|
2009-11-26 14:10:05 +03:00
|
|
|
else
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITMDR2, dr2 | SIMDR2_GRPMASK1);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
|
|
|
if (rx_buf)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIRMDR2, dr2);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_reset_str(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SISTR,
|
|
|
|
sh_msiof_read(p, SISTR) & ~(SISTR_TDREQ | SISTR_RDREQ));
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_8(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
const u8 *buf_8 = tx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, buf_8[k] << fs);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_16(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
const u16 *buf_16 = tx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, buf_16[k] << fs);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_16u(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
const u16 *buf_16 = tx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, get_unaligned(&buf_16[k]) << fs);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_32(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
const u32 *buf_32 = tx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, buf_32[k] << fs);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_32u(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
const u32 *buf_32 = tx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, get_unaligned(&buf_32[k]) << fs);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2011-01-21 18:56:42 +03:00
|
|
|
static void sh_msiof_spi_write_fifo_s32(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
|
|
|
const u32 *buf_32 = tx_buf;
|
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, swab32(buf_32[k] << fs));
|
2011-01-21 18:56:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_write_fifo_s32u(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, int words, int fs)
|
|
|
|
{
|
|
|
|
const u32 *buf_32 = tx_buf;
|
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SITFDR, swab32(get_unaligned(&buf_32[k]) << fs));
|
2011-01-21 18:56:42 +03:00
|
|
|
}
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
static void sh_msiof_spi_read_fifo_8(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u8 *buf_8 = rx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
buf_8[k] = sh_msiof_read(p, SIRFDR) >> fs;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_16(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u16 *buf_16 = rx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
buf_16[k] = sh_msiof_read(p, SIRFDR) >> fs;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_16u(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u16 *buf_16 = rx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
put_unaligned(sh_msiof_read(p, SIRFDR) >> fs, &buf_16[k]);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_32(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 *buf_32 = rx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
buf_32[k] = sh_msiof_read(p, SIRFDR) >> fs;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_32u(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 18:56:37 +03:00
|
|
|
u32 *buf_32 = rx_buf;
|
2009-11-26 14:10:05 +03:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
put_unaligned(sh_msiof_read(p, SIRFDR) >> fs, &buf_32[k]);
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2011-01-21 18:56:42 +03:00
|
|
|
static void sh_msiof_spi_read_fifo_s32(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
|
|
|
u32 *buf_32 = rx_buf;
|
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
buf_32[k] = swab32(sh_msiof_read(p, SIRFDR) >> fs);
|
2011-01-21 18:56:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_s32u(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
|
|
|
u32 *buf_32 = rx_buf;
|
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
2020-01-08 22:43:19 +03:00
|
|
|
put_unaligned(swab32(sh_msiof_read(p, SIRFDR) >> fs), &buf_32[k]);
|
2011-01-21 18:56:42 +03:00
|
|
|
}
|
|
|
|
|
2014-02-20 18:43:04 +04:00
|
|
|
static int sh_msiof_spi_setup(struct spi_device *spi)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct sh_msiof_spi_priv *p =
|
|
|
|
spi_controller_get_devdata(spi->controller);
|
2017-12-13 22:05:10 +03:00
|
|
|
u32 clr, set, tmp;
|
2014-12-15 17:01:11 +03:00
|
|
|
|
2019-04-03 18:08:52 +03:00
|
|
|
if (spi->cs_gpiod || spi_controller_is_slave(p->ctlr))
|
2017-12-13 22:05:10 +03:00
|
|
|
return 0;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2017-12-13 22:05:10 +03:00
|
|
|
if (p->native_cs_inited &&
|
|
|
|
(p->native_cs_high == !!(spi->mode & SPI_CS_HIGH)))
|
|
|
|
return 0;
|
2014-12-15 17:01:11 +03:00
|
|
|
|
2017-12-13 22:05:10 +03:00
|
|
|
/* Configure native chip select mode/polarity early */
|
2020-01-08 22:43:19 +03:00
|
|
|
clr = SIMDR1_SYNCMD_MASK;
|
|
|
|
set = SIMDR1_SYNCMD_SPI;
|
2017-12-13 22:05:10 +03:00
|
|
|
if (spi->mode & SPI_CS_HIGH)
|
2020-01-08 22:43:19 +03:00
|
|
|
clr |= BIT(SIMDR1_SYNCAC_SHIFT);
|
2017-12-13 22:05:10 +03:00
|
|
|
else
|
2020-01-08 22:43:19 +03:00
|
|
|
set |= BIT(SIMDR1_SYNCAC_SHIFT);
|
2017-12-13 22:05:10 +03:00
|
|
|
pm_runtime_get_sync(&p->pdev->dev);
|
2020-01-08 22:43:19 +03:00
|
|
|
tmp = sh_msiof_read(p, SITMDR1) & ~clr;
|
|
|
|
sh_msiof_write(p, SITMDR1, tmp | set | SIMDR1_TRMD | SITMDR1_PCON);
|
|
|
|
tmp = sh_msiof_read(p, SIRMDR1) & ~clr;
|
|
|
|
sh_msiof_write(p, SIRMDR1, tmp | set);
|
2015-01-07 18:37:25 +03:00
|
|
|
pm_runtime_put(&p->pdev->dev);
|
2017-12-13 22:05:10 +03:00
|
|
|
p->native_cs_high = spi->mode & SPI_CS_HIGH;
|
|
|
|
p->native_cs_inited = true;
|
2014-02-25 14:21:13 +04:00
|
|
|
return 0;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
static int sh_msiof_prepare_message(struct spi_controller *ctlr,
|
2014-02-25 14:21:11 +04:00
|
|
|
struct spi_message *msg)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct sh_msiof_spi_priv *p = spi_controller_get_devdata(ctlr);
|
2014-02-25 14:21:11 +04:00
|
|
|
const struct spi_device *spi = msg->spi;
|
2017-12-13 22:05:12 +03:00
|
|
|
u32 ss, cs_high;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2014-02-25 14:21:11 +04:00
|
|
|
/* Configure pins before asserting CS */
|
2019-04-03 18:08:52 +03:00
|
|
|
if (spi->cs_gpiod) {
|
2020-01-02 16:38:18 +03:00
|
|
|
ss = ctlr->unused_native_cs;
|
2017-12-13 22:05:12 +03:00
|
|
|
cs_high = p->native_cs_high;
|
|
|
|
} else {
|
|
|
|
ss = spi->chip_select;
|
|
|
|
cs_high = !!(spi->mode & SPI_CS_HIGH);
|
|
|
|
}
|
|
|
|
sh_msiof_spi_set_pin_regs(p, ss, !!(spi->mode & SPI_CPOL),
|
2014-02-25 14:21:11 +04:00
|
|
|
!!(spi->mode & SPI_CPHA),
|
|
|
|
!!(spi->mode & SPI_3WIRE),
|
2017-12-13 22:05:12 +03:00
|
|
|
!!(spi->mode & SPI_LSB_FIRST), cs_high);
|
2014-02-25 14:21:11 +04:00
|
|
|
return 0;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2014-06-20 14:16:17 +04:00
|
|
|
static int sh_msiof_spi_start(struct sh_msiof_spi_priv *p, void *rx_buf)
|
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
bool slave = spi_controller_is_slave(p->ctlr);
|
2017-05-22 16:11:43 +03:00
|
|
|
int ret = 0;
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
/* setup clock and rx/tx signals */
|
2017-05-22 16:11:43 +03:00
|
|
|
if (!slave)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, SICTR_TSCKE);
|
2014-06-20 14:16:17 +04:00
|
|
|
if (rx_buf && !ret)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, SICTR_RXE);
|
2014-06-20 14:16:17 +04:00
|
|
|
if (!ret)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, SICTR_TXE);
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
/* start by setting frame bit */
|
2017-05-22 16:11:43 +03:00
|
|
|
if (!ret && !slave)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, SICTR_TFSE);
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_spi_stop(struct sh_msiof_spi_priv *p, void *rx_buf)
|
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
bool slave = spi_controller_is_slave(p->ctlr);
|
2017-05-22 16:11:43 +03:00
|
|
|
int ret = 0;
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
/* shut down frame, rx/tx and clock signals */
|
2017-05-22 16:11:43 +03:00
|
|
|
if (!slave)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, SICTR_TFSE, 0);
|
2014-06-20 14:16:17 +04:00
|
|
|
if (!ret)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, SICTR_TXE, 0);
|
2014-06-20 14:16:17 +04:00
|
|
|
if (rx_buf && !ret)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, SICTR_RXE, 0);
|
2017-05-22 16:11:43 +03:00
|
|
|
if (!ret && !slave)
|
2020-01-08 22:43:19 +03:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, SICTR_TSCKE, 0);
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
static int sh_msiof_slave_abort(struct spi_controller *ctlr)
|
2017-05-22 16:11:43 +03:00
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct sh_msiof_spi_priv *p = spi_controller_get_devdata(ctlr);
|
2017-05-22 16:11:43 +03:00
|
|
|
|
|
|
|
p->slave_aborted = true;
|
|
|
|
complete(&p->done);
|
2018-06-13 11:41:15 +03:00
|
|
|
complete(&p->done_txdma);
|
2017-05-22 16:11:43 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-06-13 11:41:15 +03:00
|
|
|
static int sh_msiof_wait_for_completion(struct sh_msiof_spi_priv *p,
|
|
|
|
struct completion *x)
|
2017-05-22 16:11:43 +03:00
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
if (spi_controller_is_slave(p->ctlr)) {
|
2018-06-13 11:41:15 +03:00
|
|
|
if (wait_for_completion_interruptible(x) ||
|
2017-05-22 16:11:43 +03:00
|
|
|
p->slave_aborted) {
|
|
|
|
dev_dbg(&p->pdev->dev, "interrupted\n");
|
|
|
|
return -EINTR;
|
|
|
|
}
|
|
|
|
} else {
|
2018-06-13 11:41:15 +03:00
|
|
|
if (!wait_for_completion_timeout(x, HZ)) {
|
2017-05-22 16:11:43 +03:00
|
|
|
dev_err(&p->pdev->dev, "timeout\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
static int sh_msiof_spi_txrx_once(struct sh_msiof_spi_priv *p,
|
|
|
|
void (*tx_fifo)(struct sh_msiof_spi_priv *,
|
|
|
|
const void *, int, int),
|
|
|
|
void (*rx_fifo)(struct sh_msiof_spi_priv *,
|
|
|
|
void *, int, int),
|
|
|
|
const void *tx_buf, void *rx_buf,
|
|
|
|
int words, int bits)
|
|
|
|
{
|
|
|
|
int fifo_shift;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* limit maximum word transfer to rx/tx fifo size */
|
|
|
|
if (tx_buf)
|
|
|
|
words = min_t(int, words, p->tx_fifo_size);
|
|
|
|
if (rx_buf)
|
|
|
|
words = min_t(int, words, p->rx_fifo_size);
|
|
|
|
|
|
|
|
/* the fifo contents need shifting */
|
|
|
|
fifo_shift = 32 - bits;
|
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
/* default FIFO watermarks for PIO */
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIFCTR, 0);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
/* setup msiof transfer mode registers */
|
|
|
|
sh_msiof_spi_set_mode_regs(p, tx_buf, rx_buf, bits, words);
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, SIIER_TEOFE | SIIER_REOFE);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
|
|
|
/* write tx fifo */
|
|
|
|
if (tx_buf)
|
|
|
|
tx_fifo(p, tx_buf, words, fifo_shift);
|
|
|
|
|
2013-11-15 02:32:02 +04:00
|
|
|
reinit_completion(&p->done);
|
2017-05-22 16:11:43 +03:00
|
|
|
p->slave_aborted = false;
|
2014-06-20 14:16:17 +04:00
|
|
|
|
|
|
|
ret = sh_msiof_spi_start(p, rx_buf);
|
2009-11-26 14:10:05 +03:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to start hardware\n");
|
2014-06-20 14:16:18 +04:00
|
|
|
goto stop_ier;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* wait for tx fifo to be emptied / rx fifo to be filled */
|
2018-06-13 11:41:15 +03:00
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done);
|
2017-05-22 16:11:43 +03:00
|
|
|
if (ret)
|
2014-06-20 14:16:18 +04:00
|
|
|
goto stop_reset;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
|
|
|
/* read rx fifo */
|
|
|
|
if (rx_buf)
|
|
|
|
rx_fifo(p, rx_buf, words, fifo_shift);
|
|
|
|
|
|
|
|
/* clear status bits */
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
|
2014-06-20 14:16:17 +04:00
|
|
|
ret = sh_msiof_spi_stop(p, rx_buf);
|
2009-11-26 14:10:05 +03:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to shut down hardware\n");
|
2014-06-20 14:16:18 +04:00
|
|
|
return ret;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return words;
|
|
|
|
|
2014-06-20 14:16:18 +04:00
|
|
|
stop_reset:
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
sh_msiof_spi_stop(p, rx_buf);
|
|
|
|
stop_ier:
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, 0);
|
2009-11-26 14:10:05 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
static void sh_msiof_dma_complete(void *arg)
|
|
|
|
{
|
2018-06-13 11:41:15 +03:00
|
|
|
complete(arg);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_dma_once(struct sh_msiof_spi_priv *p, const void *tx,
|
|
|
|
void *rx, unsigned int len)
|
|
|
|
{
|
|
|
|
u32 ier_bits = 0;
|
|
|
|
struct dma_async_tx_descriptor *desc_tx = NULL, *desc_rx = NULL;
|
|
|
|
dma_cookie_t cookie;
|
|
|
|
int ret;
|
|
|
|
|
2014-08-06 16:59:03 +04:00
|
|
|
/* First prepare and submit the DMA request(s), as this may fail */
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
if (rx) {
|
2020-01-08 22:43:19 +03:00
|
|
|
ier_bits |= SIIER_RDREQE | SIIER_RDMAE;
|
2019-02-08 12:09:09 +03:00
|
|
|
desc_rx = dmaengine_prep_slave_single(p->ctlr->dma_rx,
|
2018-03-21 11:07:23 +03:00
|
|
|
p->rx_dma_addr, len, DMA_DEV_TO_MEM,
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
|
2014-08-07 16:07:42 +04:00
|
|
|
if (!desc_rx)
|
|
|
|
return -EAGAIN;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
|
|
|
desc_rx->callback = sh_msiof_dma_complete;
|
2018-06-13 11:41:15 +03:00
|
|
|
desc_rx->callback_param = &p->done;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
cookie = dmaengine_submit(desc_rx);
|
2014-08-07 16:07:42 +04:00
|
|
|
if (dma_submit_error(cookie))
|
|
|
|
return cookie;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tx) {
|
2020-01-08 22:43:19 +03:00
|
|
|
ier_bits |= SIIER_TDREQE | SIIER_TDMAE;
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_sync_single_for_device(p->ctlr->dma_tx->device->dev,
|
2014-08-06 16:59:03 +04:00
|
|
|
p->tx_dma_addr, len, DMA_TO_DEVICE);
|
2019-02-08 12:09:09 +03:00
|
|
|
desc_tx = dmaengine_prep_slave_single(p->ctlr->dma_tx,
|
2018-03-21 11:07:23 +03:00
|
|
|
p->tx_dma_addr, len, DMA_MEM_TO_DEV,
|
2014-08-06 16:59:03 +04:00
|
|
|
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
|
|
|
|
if (!desc_tx) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto no_dma_tx;
|
|
|
|
}
|
|
|
|
|
2018-06-13 11:41:15 +03:00
|
|
|
desc_tx->callback = sh_msiof_dma_complete;
|
|
|
|
desc_tx->callback_param = &p->done_txdma;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
cookie = dmaengine_submit(desc_tx);
|
|
|
|
if (dma_submit_error(cookie)) {
|
|
|
|
ret = cookie;
|
2014-08-06 16:59:03 +04:00
|
|
|
goto no_dma_tx;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-06 16:59:03 +04:00
|
|
|
/* 1 stage FIFO watermarks for DMA */
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIFCTR, SIFCTR_TFWM_1 | SIFCTR_RFWM_1);
|
2014-08-06 16:59:03 +04:00
|
|
|
|
|
|
|
/* setup msiof transfer mode registers (32-bit words) */
|
|
|
|
sh_msiof_spi_set_mode_regs(p, tx, rx, 32, len / 4);
|
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, ier_bits);
|
2014-08-06 16:59:03 +04:00
|
|
|
|
|
|
|
reinit_completion(&p->done);
|
2018-06-13 11:41:15 +03:00
|
|
|
if (tx)
|
|
|
|
reinit_completion(&p->done_txdma);
|
2017-05-22 16:11:43 +03:00
|
|
|
p->slave_aborted = false;
|
2014-08-06 16:59:03 +04:00
|
|
|
|
|
|
|
/* Now start DMA */
|
|
|
|
if (rx)
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_async_issue_pending(p->ctlr->dma_rx);
|
2014-08-07 16:07:43 +04:00
|
|
|
if (tx)
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_async_issue_pending(p->ctlr->dma_tx);
|
2014-08-06 16:59:03 +04:00
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
ret = sh_msiof_spi_start(p, rx);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to start hardware\n");
|
2014-08-06 16:59:03 +04:00
|
|
|
goto stop_dma;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
}
|
|
|
|
|
2018-06-13 11:41:15 +03:00
|
|
|
if (tx) {
|
|
|
|
/* wait for tx DMA completion */
|
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done_txdma);
|
|
|
|
if (ret)
|
|
|
|
goto stop_reset;
|
|
|
|
}
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
2018-06-13 11:41:15 +03:00
|
|
|
if (rx) {
|
|
|
|
/* wait for rx DMA completion */
|
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done);
|
|
|
|
if (ret)
|
|
|
|
goto stop_reset;
|
2018-01-03 20:11:14 +03:00
|
|
|
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, 0);
|
2018-06-13 11:41:15 +03:00
|
|
|
} else {
|
2018-01-03 20:11:14 +03:00
|
|
|
/* wait for tx fifo to be emptied */
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, SIIER_TEOFE);
|
2018-06-13 11:41:15 +03:00
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done);
|
2018-01-03 20:11:14 +03:00
|
|
|
if (ret)
|
|
|
|
goto stop_reset;
|
|
|
|
}
|
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
/* clear status bits */
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
|
|
|
|
ret = sh_msiof_spi_stop(p, rx);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to shut down hardware\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rx)
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_sync_single_for_cpu(p->ctlr->dma_rx->device->dev,
|
|
|
|
p->rx_dma_addr, len, DMA_FROM_DEVICE);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
stop_reset:
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
sh_msiof_spi_stop(p, rx);
|
2014-08-06 16:59:03 +04:00
|
|
|
stop_dma:
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
if (tx)
|
2019-02-08 12:09:09 +03:00
|
|
|
dmaengine_terminate_all(p->ctlr->dma_tx);
|
2014-08-06 16:59:03 +04:00
|
|
|
no_dma_tx:
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
if (rx)
|
2019-02-08 12:09:09 +03:00
|
|
|
dmaengine_terminate_all(p->ctlr->dma_rx);
|
2020-01-08 22:43:19 +03:00
|
|
|
sh_msiof_write(p, SIIER, 0);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_bswap32(u32 *dst, const u32 *src, unsigned int words)
|
|
|
|
{
|
|
|
|
/* src or dst can be unaligned, but not both */
|
|
|
|
if ((unsigned long)src & 3) {
|
|
|
|
while (words--) {
|
|
|
|
*dst++ = swab32(get_unaligned(src));
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
} else if ((unsigned long)dst & 3) {
|
|
|
|
while (words--) {
|
|
|
|
put_unaligned(swab32(*src++), dst);
|
|
|
|
dst++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
while (words--)
|
|
|
|
*dst++ = swab32(*src++);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_wswap32(u32 *dst, const u32 *src, unsigned int words)
|
|
|
|
{
|
|
|
|
/* src or dst can be unaligned, but not both */
|
|
|
|
if ((unsigned long)src & 3) {
|
|
|
|
while (words--) {
|
|
|
|
*dst++ = swahw32(get_unaligned(src));
|
|
|
|
src++;
|
|
|
|
}
|
|
|
|
} else if ((unsigned long)dst & 3) {
|
|
|
|
while (words--) {
|
|
|
|
put_unaligned(swahw32(*src++), dst);
|
|
|
|
dst++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
while (words--)
|
|
|
|
*dst++ = swahw32(*src++);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_plain32(u32 *dst, const u32 *src, unsigned int words)
|
|
|
|
{
|
|
|
|
memcpy(dst, src, words * 4);
|
|
|
|
}
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
static int sh_msiof_transfer_one(struct spi_controller *ctlr,
|
2014-02-25 14:21:13 +04:00
|
|
|
struct spi_device *spi,
|
|
|
|
struct spi_transfer *t)
|
2009-11-26 14:10:05 +03:00
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct sh_msiof_spi_priv *p = spi_controller_get_devdata(ctlr);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
void (*copy32)(u32 *, const u32 *, unsigned int);
|
2009-11-26 14:10:05 +03:00
|
|
|
void (*tx_fifo)(struct sh_msiof_spi_priv *, const void *, int, int);
|
|
|
|
void (*rx_fifo)(struct sh_msiof_spi_priv *, void *, int, int);
|
2014-06-20 14:16:19 +04:00
|
|
|
const void *tx_buf = t->tx_buf;
|
|
|
|
void *rx_buf = t->rx_buf;
|
|
|
|
unsigned int len = t->len;
|
|
|
|
unsigned int bits = t->bits_per_word;
|
|
|
|
unsigned int bytes_per_word;
|
|
|
|
unsigned int words;
|
2009-11-26 14:10:05 +03:00
|
|
|
int n;
|
2011-01-21 18:56:42 +03:00
|
|
|
bool swab;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
int ret;
|
|
|
|
|
2019-04-02 17:40:23 +03:00
|
|
|
/* reset registers */
|
|
|
|
sh_msiof_spi_reset_regs(p);
|
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
/* setup clocks (clock already enabled in chipselect()) */
|
2019-02-08 12:09:09 +03:00
|
|
|
if (!spi_controller_is_slave(p->ctlr))
|
2017-05-22 16:11:43 +03:00
|
|
|
sh_msiof_spi_set_clk_regs(p, clk_get_rate(p->clk), t->speed_hz);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
while (ctlr->dma_tx && len > 15) {
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
/*
|
|
|
|
* DMA supports 32-bit words only, hence pack 8-bit and 16-bit
|
|
|
|
* words, with byte resp. word swapping.
|
|
|
|
*/
|
2015-06-14 20:25:05 +03:00
|
|
|
unsigned int l = 0;
|
|
|
|
|
|
|
|
if (tx_buf)
|
2019-01-18 12:29:31 +03:00
|
|
|
l = min(round_down(len, 4), p->tx_fifo_size * 4);
|
2015-06-14 20:25:05 +03:00
|
|
|
if (rx_buf)
|
2019-01-18 12:29:31 +03:00
|
|
|
l = min(round_down(len, 4), p->rx_fifo_size * 4);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
|
|
|
if (bits <= 8) {
|
|
|
|
copy32 = copy_bswap32;
|
|
|
|
} else if (bits <= 16) {
|
|
|
|
copy32 = copy_wswap32;
|
|
|
|
} else {
|
|
|
|
copy32 = copy_plain32;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tx_buf)
|
|
|
|
copy32(p->tx_dma_page, tx_buf, l / 4);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
ret = sh_msiof_dma_once(p, tx_buf, rx_buf, l);
|
2014-07-09 14:26:23 +04:00
|
|
|
if (ret == -EAGAIN) {
|
2017-11-30 16:38:50 +03:00
|
|
|
dev_warn_once(&p->pdev->dev,
|
|
|
|
"DMA not available, falling back to PIO\n");
|
2014-07-09 14:26:23 +04:00
|
|
|
break;
|
|
|
|
}
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (rx_buf) {
|
|
|
|
copy32(rx_buf, p->rx_dma_page, l / 4);
|
|
|
|
rx_buf += l;
|
|
|
|
}
|
|
|
|
if (tx_buf)
|
|
|
|
tx_buf += l;
|
|
|
|
|
|
|
|
len -= l;
|
|
|
|
if (!len)
|
|
|
|
return 0;
|
|
|
|
}
|
2009-11-26 14:10:05 +03:00
|
|
|
|
spi: sh-msiof: Reduce the number of times write to and perform the transmission from FIFO
The current state of the spi-sh-msiof, in master transfer mode: if t-> bits_per_word <= 8,
if the data length is divisible by 4 ((len & 3) = 0), the length of each word will be 32 bits
In case of data length can not be divisible by 4 ((len & 3) != 0), always set each word to be
8 bits, this will increase the number of times that write to FIFO, increasing the number of
times it should be transmitted. Assume that the number of bytes of data length more than 64 bytes,
each transmission will write 64 times into the TFDR then transmit, a maximum one-time
transmission will transmit 64 bytes if each word is 8 bits long.
Switch to setting if t->bits_per_word <= 8, the word length will be 32 bits although the data
length is not divisible by 4, then if leftover, will transmit the balance and the length of each
words is 1 byte. The maximum each can transmit up to 64 x 4 (Data Size = 32 bits (4 bytes)) = 256 bytes.
TMDR2 : Bits 28 to 24 BITLEN1[4:0] Data Size (8 to 32 bits)
Bits 23 to 16 WDLEN1[7:0] Word Count (1 to 64 words)
Signed-off-by: Hoan Nguyen An <na-hoan@jinso.co.jp>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-12-20 11:48:42 +03:00
|
|
|
if (bits <= 8 && len > 15) {
|
2011-01-21 18:56:42 +03:00
|
|
|
bits = 32;
|
|
|
|
swab = true;
|
|
|
|
} else {
|
|
|
|
swab = false;
|
|
|
|
}
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
/* setup bytes per word and fifo read/write functions */
|
|
|
|
if (bits <= 8) {
|
|
|
|
bytes_per_word = 1;
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_8;
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_8;
|
|
|
|
} else if (bits <= 16) {
|
|
|
|
bytes_per_word = 2;
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)tx_buf & 0x01)
|
2009-11-26 14:10:05 +03:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_16u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_16;
|
|
|
|
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)rx_buf & 0x01)
|
2009-11-26 14:10:05 +03:00
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_16u;
|
|
|
|
else
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_16;
|
2011-01-21 18:56:42 +03:00
|
|
|
} else if (swab) {
|
|
|
|
bytes_per_word = 4;
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)tx_buf & 0x03)
|
2011-01-21 18:56:42 +03:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_s32u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_s32;
|
|
|
|
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)rx_buf & 0x03)
|
2011-01-21 18:56:42 +03:00
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_s32u;
|
|
|
|
else
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_s32;
|
2009-11-26 14:10:05 +03:00
|
|
|
} else {
|
|
|
|
bytes_per_word = 4;
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)tx_buf & 0x03)
|
2009-11-26 14:10:05 +03:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_32u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_32;
|
|
|
|
|
2014-06-20 14:16:19 +04:00
|
|
|
if ((unsigned long)rx_buf & 0x03)
|
2009-11-26 14:10:05 +03:00
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_32u;
|
|
|
|
else
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_32;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* transfer in fifo sized chunks */
|
2014-06-20 14:16:19 +04:00
|
|
|
words = len / bytes_per_word;
|
|
|
|
|
|
|
|
while (words > 0) {
|
|
|
|
n = sh_msiof_spi_txrx_once(p, tx_fifo, rx_fifo, tx_buf, rx_buf,
|
2009-11-26 14:10:05 +03:00
|
|
|
words, bits);
|
|
|
|
if (n < 0)
|
2014-06-20 14:16:18 +04:00
|
|
|
return n;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2014-06-20 14:16:19 +04:00
|
|
|
if (tx_buf)
|
|
|
|
tx_buf += n * bytes_per_word;
|
|
|
|
if (rx_buf)
|
|
|
|
rx_buf += n * bytes_per_word;
|
2009-11-26 14:10:05 +03:00
|
|
|
words -= n;
|
spi: sh-msiof: Reduce the number of times write to and perform the transmission from FIFO
The current state of the spi-sh-msiof, in master transfer mode: if t-> bits_per_word <= 8,
if the data length is divisible by 4 ((len & 3) = 0), the length of each word will be 32 bits
In case of data length can not be divisible by 4 ((len & 3) != 0), always set each word to be
8 bits, this will increase the number of times that write to FIFO, increasing the number of
times it should be transmitted. Assume that the number of bytes of data length more than 64 bytes,
each transmission will write 64 times into the TFDR then transmit, a maximum one-time
transmission will transmit 64 bytes if each word is 8 bits long.
Switch to setting if t->bits_per_word <= 8, the word length will be 32 bits although the data
length is not divisible by 4, then if leftover, will transmit the balance and the length of each
words is 1 byte. The maximum each can transmit up to 64 x 4 (Data Size = 32 bits (4 bytes)) = 256 bytes.
TMDR2 : Bits 28 to 24 BITLEN1[4:0] Data Size (8 to 32 bits)
Bits 23 to 16 WDLEN1[7:0] Word Count (1 to 64 words)
Signed-off-by: Hoan Nguyen An <na-hoan@jinso.co.jp>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-12-20 11:48:42 +03:00
|
|
|
|
|
|
|
if (words == 0 && (len % bytes_per_word)) {
|
|
|
|
words = len % bytes_per_word;
|
|
|
|
bits = t->bits_per_word;
|
|
|
|
bytes_per_word = 1;
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_8;
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_8;
|
|
|
|
}
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-25 14:21:09 +04:00
|
|
|
static const struct sh_msiof_chipdata sh_data = {
|
2019-02-28 14:05:13 +03:00
|
|
|
.bits_per_word_mask = SPI_BPW_RANGE_MASK(8, 32),
|
2014-02-25 14:21:09 +04:00
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 12:09:09 +03:00
|
|
|
.ctlr_flags = 0,
|
2018-04-13 15:44:17 +03:00
|
|
|
.min_div_pow = 0,
|
2017-07-12 13:26:01 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sh_msiof_chipdata rcar_gen2_data = {
|
2019-02-28 14:05:13 +03:00
|
|
|
.bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16) |
|
|
|
|
SPI_BPW_MASK(24) | SPI_BPW_MASK(32),
|
2017-07-12 13:26:01 +03:00
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 12:09:09 +03:00
|
|
|
.ctlr_flags = SPI_CONTROLLER_MUST_TX,
|
2018-04-13 15:44:17 +03:00
|
|
|
.min_div_pow = 0,
|
spi: sh-msiof: Add support for R-Car H2 and M2
Add support for the MSIOF variant in the R-Car H2 (r8a7790) and M2
(r8a7791) SoCs.
Binding documentation:
- Add future-proof "renesas,msiof-<soctype>" compatible values,
- The default for "renesas,rx-fifo-size" is 256 on R-Car H2 and M2,
- "renesas,tx-fifo-size" and "renesas,rx-fifo-size" are deprecated for
soctype-specific bindings,
- Add example bindings.
Implementation:
- MSIOF on R-Car H2 and M2 requires the transmission of dummy data if
data is being received only (cfr. "Set SICTR.TSCKE to 1" and "Write
dummy transmission data to SITFDR" in paragraph "Transmit and Receive
Procedures" of the Hardware User's Manual).
- As RX depends on TX, MSIOF on R-Car H2 and M2 also lacks the RSCR
register (Receive Clock Select Register), and some bits in the RMDR1
(Receive Mode Register 1) and TMDR2 (Transmit Mode Register 2)
registers.
- Use the recently introduced SPI_MASTER_MUST_TX flag to enable support
for dummy transmission in the SPI core, and to differentiate from other
MSIOF implementations in code paths that need this.
- New DT compatible values ("renesas,msiof-r8a7790" and
"renesas,msiof-r8a7791") are added, as well as new platform device
names ("spi_r8a7790_msiof" and "spi_r8a7791_msiof").
- The default RX FIFO size is 256 words on R-Car H2 and M2.
This is loosely based on a set of patches from Takashi Yoshii
<takasi-y@ops.dti.ne.jp>.
Signed-off-by: Geert Uytterhoeven <geert+renesas@linux-m68k.org>
Acked-by: Magnus Damm <damm@opensource.se>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-25 14:21:10 +04:00
|
|
|
};
|
|
|
|
|
2017-07-12 13:26:01 +03:00
|
|
|
static const struct sh_msiof_chipdata rcar_gen3_data = {
|
2019-02-28 14:05:13 +03:00
|
|
|
.bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16) |
|
|
|
|
SPI_BPW_MASK(24) | SPI_BPW_MASK(32),
|
spi: sh-msiof: Add support for R-Car H2 and M2
Add support for the MSIOF variant in the R-Car H2 (r8a7790) and M2
(r8a7791) SoCs.
Binding documentation:
- Add future-proof "renesas,msiof-<soctype>" compatible values,
- The default for "renesas,rx-fifo-size" is 256 on R-Car H2 and M2,
- "renesas,tx-fifo-size" and "renesas,rx-fifo-size" are deprecated for
soctype-specific bindings,
- Add example bindings.
Implementation:
- MSIOF on R-Car H2 and M2 requires the transmission of dummy data if
data is being received only (cfr. "Set SICTR.TSCKE to 1" and "Write
dummy transmission data to SITFDR" in paragraph "Transmit and Receive
Procedures" of the Hardware User's Manual).
- As RX depends on TX, MSIOF on R-Car H2 and M2 also lacks the RSCR
register (Receive Clock Select Register), and some bits in the RMDR1
(Receive Mode Register 1) and TMDR2 (Transmit Mode Register 2)
registers.
- Use the recently introduced SPI_MASTER_MUST_TX flag to enable support
for dummy transmission in the SPI core, and to differentiate from other
MSIOF implementations in code paths that need this.
- New DT compatible values ("renesas,msiof-r8a7790" and
"renesas,msiof-r8a7791") are added, as well as new platform device
names ("spi_r8a7790_msiof" and "spi_r8a7791_msiof").
- The default RX FIFO size is 256 words on R-Car H2 and M2.
This is loosely based on a set of patches from Takashi Yoshii
<takasi-y@ops.dti.ne.jp>.
Signed-off-by: Geert Uytterhoeven <geert+renesas@linux-m68k.org>
Acked-by: Magnus Damm <damm@opensource.se>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-02-25 14:21:10 +04:00
|
|
|
.tx_fifo_size = 64,
|
2015-06-14 20:25:05 +03:00
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 12:09:09 +03:00
|
|
|
.ctlr_flags = SPI_CONTROLLER_MUST_TX,
|
2018-04-13 15:44:17 +03:00
|
|
|
.min_div_pow = 1,
|
2014-02-25 14:21:09 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id sh_msiof_match[] = {
|
|
|
|
{ .compatible = "renesas,sh-mobile-msiof", .data = &sh_data },
|
2017-09-25 11:54:19 +03:00
|
|
|
{ .compatible = "renesas,msiof-r8a7743", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7745", .data = &rcar_gen2_data },
|
2017-07-12 13:26:01 +03:00
|
|
|
{ .compatible = "renesas,msiof-r8a7790", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7791", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7792", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7793", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7794", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,rcar-gen2-msiof", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7796", .data = &rcar_gen3_data },
|
|
|
|
{ .compatible = "renesas,rcar-gen3-msiof", .data = &rcar_gen3_data },
|
2016-12-20 13:21:16 +03:00
|
|
|
{ .compatible = "renesas,sh-msiof", .data = &sh_data }, /* Deprecated */
|
2014-02-25 14:21:09 +04:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, sh_msiof_match);
|
|
|
|
|
2012-12-12 15:54:48 +04:00
|
|
|
#ifdef CONFIG_OF
|
|
|
|
static struct sh_msiof_spi_info *sh_msiof_spi_parse_dt(struct device *dev)
|
|
|
|
{
|
|
|
|
struct sh_msiof_spi_info *info;
|
|
|
|
struct device_node *np = dev->of_node;
|
2014-02-25 14:21:08 +04:00
|
|
|
u32 num_cs = 1;
|
2012-12-12 15:54:48 +04:00
|
|
|
|
|
|
|
info = devm_kzalloc(dev, sizeof(struct sh_msiof_spi_info), GFP_KERNEL);
|
2014-04-29 12:21:25 +04:00
|
|
|
if (!info)
|
2012-12-12 15:54:48 +04:00
|
|
|
return NULL;
|
|
|
|
|
2017-05-22 16:11:43 +03:00
|
|
|
info->mode = of_property_read_bool(np, "spi-slave") ? MSIOF_SPI_SLAVE
|
|
|
|
: MSIOF_SPI_MASTER;
|
|
|
|
|
2012-12-12 15:54:48 +04:00
|
|
|
/* Parse the MSIOF properties */
|
2017-05-22 16:11:43 +03:00
|
|
|
if (info->mode == MSIOF_SPI_MASTER)
|
|
|
|
of_property_read_u32(np, "num-cs", &num_cs);
|
2012-12-12 15:54:48 +04:00
|
|
|
of_property_read_u32(np, "renesas,tx-fifo-size",
|
|
|
|
&info->tx_fifo_override);
|
|
|
|
of_property_read_u32(np, "renesas,rx-fifo-size",
|
|
|
|
&info->rx_fifo_override);
|
2014-12-19 11:15:53 +03:00
|
|
|
of_property_read_u32(np, "renesas,dtdl", &info->dtdl);
|
|
|
|
of_property_read_u32(np, "renesas,syncdl", &info->syncdl);
|
2012-12-12 15:54:48 +04:00
|
|
|
|
|
|
|
info->num_chipselect = num_cs;
|
|
|
|
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static struct sh_msiof_spi_info *sh_msiof_spi_parse_dt(struct device *dev)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
static struct dma_chan *sh_msiof_request_dma_chan(struct device *dev,
|
|
|
|
enum dma_transfer_direction dir, unsigned int id, dma_addr_t port_addr)
|
|
|
|
{
|
|
|
|
dma_cap_mask_t mask;
|
|
|
|
struct dma_chan *chan;
|
|
|
|
struct dma_slave_config cfg;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dma_cap_zero(mask);
|
|
|
|
dma_cap_set(DMA_SLAVE, mask);
|
|
|
|
|
2014-08-06 16:59:05 +04:00
|
|
|
chan = dma_request_slave_channel_compat(mask, shdma_chan_filter,
|
|
|
|
(void *)(unsigned long)id, dev,
|
|
|
|
dir == DMA_MEM_TO_DEV ? "tx" : "rx");
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
if (!chan) {
|
2014-08-06 16:59:05 +04:00
|
|
|
dev_warn(dev, "dma_request_slave_channel_compat failed\n");
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&cfg, 0, sizeof(cfg));
|
|
|
|
cfg.direction = dir;
|
2014-08-06 16:59:04 +04:00
|
|
|
if (dir == DMA_MEM_TO_DEV) {
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
cfg.dst_addr = port_addr;
|
2014-08-06 16:59:04 +04:00
|
|
|
cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
|
|
|
|
} else {
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
cfg.src_addr = port_addr;
|
2014-08-06 16:59:04 +04:00
|
|
|
cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
|
|
|
|
}
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
|
|
|
ret = dmaengine_slave_config(chan, &cfg);
|
|
|
|
if (ret) {
|
|
|
|
dev_warn(dev, "dmaengine_slave_config failed %d\n", ret);
|
|
|
|
dma_release_channel(chan);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return chan;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_request_dma(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = p->pdev;
|
|
|
|
struct device *dev = &pdev->dev;
|
2019-01-18 12:29:30 +03:00
|
|
|
const struct sh_msiof_spi_info *info = p->info;
|
2014-08-06 16:59:05 +04:00
|
|
|
unsigned int dma_tx_id, dma_rx_id;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
const struct resource *res;
|
2019-02-08 12:09:09 +03:00
|
|
|
struct spi_controller *ctlr;
|
2014-07-11 19:56:22 +04:00
|
|
|
struct device *tx_dev, *rx_dev;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
2014-08-06 16:59:05 +04:00
|
|
|
if (dev->of_node) {
|
|
|
|
/* In the OF case we will get the slave IDs from the DT */
|
|
|
|
dma_tx_id = 0;
|
|
|
|
dma_rx_id = 0;
|
|
|
|
} else if (info && info->dma_tx_id && info->dma_rx_id) {
|
|
|
|
dma_tx_id = info->dma_tx_id;
|
|
|
|
dma_rx_id = info->dma_rx_id;
|
|
|
|
} else {
|
|
|
|
/* The driver assumes no error */
|
|
|
|
return 0;
|
|
|
|
}
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
|
|
|
/* The DMA engine uses the second register set, if present */
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
|
|
if (!res)
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr = p->ctlr;
|
|
|
|
ctlr->dma_tx = sh_msiof_request_dma_chan(dev, DMA_MEM_TO_DEV,
|
2020-01-08 22:43:19 +03:00
|
|
|
dma_tx_id, res->start + SITFDR);
|
2019-02-08 12:09:09 +03:00
|
|
|
if (!ctlr->dma_tx)
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
return -ENODEV;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr->dma_rx = sh_msiof_request_dma_chan(dev, DMA_DEV_TO_MEM,
|
2020-01-08 22:43:19 +03:00
|
|
|
dma_rx_id, res->start + SIRFDR);
|
2019-02-08 12:09:09 +03:00
|
|
|
if (!ctlr->dma_rx)
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
goto free_tx_chan;
|
|
|
|
|
|
|
|
p->tx_dma_page = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
|
|
|
|
if (!p->tx_dma_page)
|
|
|
|
goto free_rx_chan;
|
|
|
|
|
|
|
|
p->rx_dma_page = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
|
|
|
|
if (!p->rx_dma_page)
|
|
|
|
goto free_tx_page;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
tx_dev = ctlr->dma_tx->device->dev;
|
2014-07-11 19:56:22 +04:00
|
|
|
p->tx_dma_addr = dma_map_single(tx_dev, p->tx_dma_page, PAGE_SIZE,
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
DMA_TO_DEVICE);
|
2014-07-11 19:56:22 +04:00
|
|
|
if (dma_mapping_error(tx_dev, p->tx_dma_addr))
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
goto free_rx_page;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
rx_dev = ctlr->dma_rx->device->dev;
|
2014-07-11 19:56:22 +04:00
|
|
|
p->rx_dma_addr = dma_map_single(rx_dev, p->rx_dma_page, PAGE_SIZE,
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
DMA_FROM_DEVICE);
|
2014-07-11 19:56:22 +04:00
|
|
|
if (dma_mapping_error(rx_dev, p->rx_dma_addr))
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
goto unmap_tx_page;
|
|
|
|
|
|
|
|
dev_info(dev, "DMA available");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unmap_tx_page:
|
2014-07-11 19:56:22 +04:00
|
|
|
dma_unmap_single(tx_dev, p->tx_dma_addr, PAGE_SIZE, DMA_TO_DEVICE);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
free_rx_page:
|
|
|
|
free_page((unsigned long)p->rx_dma_page);
|
|
|
|
free_tx_page:
|
|
|
|
free_page((unsigned long)p->tx_dma_page);
|
|
|
|
free_rx_chan:
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_release_channel(ctlr->dma_rx);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
free_tx_chan:
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_release_channel(ctlr->dma_tx);
|
|
|
|
ctlr->dma_tx = NULL;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_release_dma(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct spi_controller *ctlr = p->ctlr;
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
if (!ctlr->dma_tx)
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
return;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_unmap_single(ctlr->dma_rx->device->dev, p->rx_dma_addr, PAGE_SIZE,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dma_unmap_single(ctlr->dma_tx->device->dev, p->tx_dma_addr, PAGE_SIZE,
|
|
|
|
DMA_TO_DEVICE);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
free_page((unsigned long)p->rx_dma_page);
|
|
|
|
free_page((unsigned long)p->tx_dma_page);
|
2019-02-08 12:09:09 +03:00
|
|
|
dma_release_channel(ctlr->dma_rx);
|
|
|
|
dma_release_channel(ctlr->dma_tx);
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
}
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
static int sh_msiof_spi_probe(struct platform_device *pdev)
|
|
|
|
{
|
2019-02-08 12:09:09 +03:00
|
|
|
struct spi_controller *ctlr;
|
2016-06-22 15:50:03 +03:00
|
|
|
const struct sh_msiof_chipdata *chipdata;
|
2017-05-22 16:11:43 +03:00
|
|
|
struct sh_msiof_spi_info *info;
|
2009-11-26 14:10:05 +03:00
|
|
|
struct sh_msiof_spi_priv *p;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
2017-10-04 15:20:27 +03:00
|
|
|
chipdata = of_device_get_match_data(&pdev->dev);
|
|
|
|
if (chipdata) {
|
2017-05-22 16:11:43 +03:00
|
|
|
info = sh_msiof_spi_parse_dt(&pdev->dev);
|
2014-02-25 14:21:09 +04:00
|
|
|
} else {
|
2016-06-22 15:50:03 +03:00
|
|
|
chipdata = (const void *)pdev->id_entry->driver_data;
|
2017-05-22 16:11:43 +03:00
|
|
|
info = dev_get_platdata(&pdev->dev);
|
2014-02-25 14:21:09 +04:00
|
|
|
}
|
2012-12-12 15:54:48 +04:00
|
|
|
|
2017-05-22 16:11:43 +03:00
|
|
|
if (!info) {
|
2012-12-12 15:54:48 +04:00
|
|
|
dev_err(&pdev->dev, "failed to obtain device info\n");
|
2017-05-22 16:11:43 +03:00
|
|
|
return -ENXIO;
|
2012-12-12 15:54:48 +04:00
|
|
|
}
|
|
|
|
|
2017-05-22 16:11:43 +03:00
|
|
|
if (info->mode == MSIOF_SPI_SLAVE)
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr = spi_alloc_slave(&pdev->dev,
|
|
|
|
sizeof(struct sh_msiof_spi_priv));
|
2017-05-22 16:11:43 +03:00
|
|
|
else
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr = spi_alloc_master(&pdev->dev,
|
|
|
|
sizeof(struct sh_msiof_spi_priv));
|
|
|
|
if (ctlr == NULL)
|
2017-05-22 16:11:43 +03:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
p = spi_controller_get_devdata(ctlr);
|
2017-05-22 16:11:43 +03:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, p);
|
2019-02-08 12:09:09 +03:00
|
|
|
p->ctlr = ctlr;
|
2017-05-22 16:11:43 +03:00
|
|
|
p->info = info;
|
2018-04-13 15:44:17 +03:00
|
|
|
p->min_div_pow = chipdata->min_div_pow;
|
2017-05-22 16:11:43 +03:00
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
init_completion(&p->done);
|
2018-06-13 11:41:15 +03:00
|
|
|
init_completion(&p->done_txdma);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2013-11-28 05:39:42 +04:00
|
|
|
p->clk = devm_clk_get(&pdev->dev, NULL);
|
2009-11-26 14:10:05 +03:00
|
|
|
if (IS_ERR(p->clk)) {
|
2012-11-07 15:40:04 +04:00
|
|
|
dev_err(&pdev->dev, "cannot get clock\n");
|
2009-11-26 14:10:05 +03:00
|
|
|
ret = PTR_ERR(p->clk);
|
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = platform_get_irq(pdev, 0);
|
2013-11-28 05:39:42 +04:00
|
|
|
if (i < 0) {
|
2018-10-12 22:48:22 +03:00
|
|
|
ret = i;
|
2013-11-28 05:39:42 +04:00
|
|
|
goto err1;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
2013-11-28 05:39:42 +04:00
|
|
|
|
2019-08-07 11:52:13 +03:00
|
|
|
p->mapbase = devm_platform_ioremap_resource(pdev, 0);
|
2013-11-28 05:39:42 +04:00
|
|
|
if (IS_ERR(p->mapbase)) {
|
|
|
|
ret = PTR_ERR(p->mapbase);
|
|
|
|
goto err1;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2013-11-28 05:39:42 +04:00
|
|
|
ret = devm_request_irq(&pdev->dev, i, sh_msiof_spi_irq, 0,
|
|
|
|
dev_name(&pdev->dev), p);
|
2009-11-26 14:10:05 +03:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "unable to request irq\n");
|
2013-11-28 05:39:42 +04:00
|
|
|
goto err1;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
p->pdev = pdev;
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
|
|
|
|
/* Platform data may override FIFO sizes */
|
2016-06-22 15:50:03 +03:00
|
|
|
p->tx_fifo_size = chipdata->tx_fifo_size;
|
|
|
|
p->rx_fifo_size = chipdata->rx_fifo_size;
|
2009-11-26 14:10:05 +03:00
|
|
|
if (p->info->tx_fifo_override)
|
|
|
|
p->tx_fifo_size = p->info->tx_fifo_override;
|
|
|
|
if (p->info->rx_fifo_override)
|
|
|
|
p->rx_fifo_size = p->info->rx_fifo_override;
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
/* init controller code */
|
|
|
|
ctlr->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
|
|
|
|
ctlr->mode_bits |= SPI_LSB_FIRST | SPI_3WIRE;
|
|
|
|
ctlr->flags = chipdata->ctlr_flags;
|
|
|
|
ctlr->bus_num = pdev->id;
|
2020-01-02 16:38:18 +03:00
|
|
|
ctlr->num_chipselect = p->info->num_chipselect;
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr->dev.of_node = pdev->dev.of_node;
|
|
|
|
ctlr->setup = sh_msiof_spi_setup;
|
|
|
|
ctlr->prepare_message = sh_msiof_prepare_message;
|
|
|
|
ctlr->slave_abort = sh_msiof_slave_abort;
|
2019-02-28 14:05:13 +03:00
|
|
|
ctlr->bits_per_word_mask = chipdata->bits_per_word_mask;
|
2019-02-08 12:09:09 +03:00
|
|
|
ctlr->auto_runtime_pm = true;
|
|
|
|
ctlr->transfer_one = sh_msiof_transfer_one;
|
2019-04-03 18:08:52 +03:00
|
|
|
ctlr->use_gpio_descriptors = true;
|
2020-01-02 16:38:18 +03:00
|
|
|
ctlr->max_native_cs = MAX_SS;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
ret = sh_msiof_request_dma(p);
|
|
|
|
if (ret < 0)
|
|
|
|
dev_warn(&pdev->dev, "DMA not available, using PIO\n");
|
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
ret = devm_spi_register_controller(&pdev->dev, ctlr);
|
2014-02-25 14:21:13 +04:00
|
|
|
if (ret < 0) {
|
2019-02-08 12:09:09 +03:00
|
|
|
dev_err(&pdev->dev, "devm_spi_register_controller error.\n");
|
2014-02-25 14:21:13 +04:00
|
|
|
goto err2;
|
|
|
|
}
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2014-02-25 14:21:13 +04:00
|
|
|
return 0;
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2014-02-25 14:21:13 +04:00
|
|
|
err2:
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
sh_msiof_release_dma(p);
|
2009-11-26 14:10:05 +03:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
err1:
|
2019-02-08 12:09:09 +03:00
|
|
|
spi_controller_put(ctlr);
|
2009-11-26 14:10:05 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_spi_remove(struct platform_device *pdev)
|
|
|
|
{
|
spi: sh-msiof: Add DMA support
Add DMA support to the MSIOF driver using platform data.
As MSIOF DMA is limited to 32-bit words (requiring byte/wordswapping for
smaller wordsizes), and the group length is limited to 256 words, DMA is
performed on two fixed pages, allocated and mapped at driver initialization
time.
Performance figures (in Mbps) on r8a7791/koelsch at different SPI clock
frequencies for 1024-byte and 4096-byte transfers:
1024 bytes 4096 bytes
- 3.25 MHz: PIO 2.1, DMA 2.6 | PIO 2.8, DMA 3.1
- 6.5 MHz: PIO 3.2, DMA 4.4 | PIO 5.0, DMA 5.9
- 13 MHz: PIO 4.2, DMA 6.6 | PIO 8.2, DMA 10.7
- 26 MHz: PIO 5.9, DMA 10.4 | PIO 12.4, DMA 18.4
Note that DMA is only faster than PIO for transfers that exceed the FIFO
size (typically 64 words / 256 bytes).
Also note that large transfers (larger than the group length for DMA, or
larger than the FIFO size for PIO), should use cs-gpio (with the
appropriate pinmux setup), as the hardware chipselect will be deasserted in
between chunks.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Mark Brown <broonie@linaro.org>
2014-06-30 14:10:24 +04:00
|
|
|
struct sh_msiof_spi_priv *p = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
sh_msiof_release_dma(p);
|
2014-02-25 14:21:13 +04:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
return 0;
|
2009-11-26 14:10:05 +03:00
|
|
|
}
|
|
|
|
|
2015-05-01 18:44:07 +03:00
|
|
|
static const struct platform_device_id spi_driver_ids[] = {
|
2014-02-25 14:21:09 +04:00
|
|
|
{ "spi_sh_msiof", (kernel_ulong_t)&sh_data },
|
2012-12-12 15:54:48 +04:00
|
|
|
{},
|
|
|
|
};
|
2014-02-25 14:21:09 +04:00
|
|
|
MODULE_DEVICE_TABLE(platform, spi_driver_ids);
|
2012-12-12 15:54:48 +04:00
|
|
|
|
2018-09-05 11:49:36 +03:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int sh_msiof_spi_suspend(struct device *dev)
|
|
|
|
{
|
2018-10-21 23:00:46 +03:00
|
|
|
struct sh_msiof_spi_priv *p = dev_get_drvdata(dev);
|
2018-09-05 11:49:36 +03:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
return spi_controller_suspend(p->ctlr);
|
2018-09-05 11:49:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_spi_resume(struct device *dev)
|
|
|
|
{
|
2018-10-21 23:00:46 +03:00
|
|
|
struct sh_msiof_spi_priv *p = dev_get_drvdata(dev);
|
2018-09-05 11:49:36 +03:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
return spi_controller_resume(p->ctlr);
|
2018-09-05 11:49:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static SIMPLE_DEV_PM_OPS(sh_msiof_spi_pm_ops, sh_msiof_spi_suspend,
|
|
|
|
sh_msiof_spi_resume);
|
|
|
|
#define DEV_PM_OPS &sh_msiof_spi_pm_ops
|
|
|
|
#else
|
|
|
|
#define DEV_PM_OPS NULL
|
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
|
2009-11-26 14:10:05 +03:00
|
|
|
static struct platform_driver sh_msiof_spi_drv = {
|
|
|
|
.probe = sh_msiof_spi_probe,
|
|
|
|
.remove = sh_msiof_spi_remove,
|
2014-02-25 14:21:09 +04:00
|
|
|
.id_table = spi_driver_ids,
|
2009-11-26 14:10:05 +03:00
|
|
|
.driver = {
|
|
|
|
.name = "spi_sh_msiof",
|
2018-09-05 11:49:36 +03:00
|
|
|
.pm = DEV_PM_OPS,
|
2013-03-14 14:01:51 +04:00
|
|
|
.of_match_table = of_match_ptr(sh_msiof_match),
|
2009-11-26 14:10:05 +03:00
|
|
|
},
|
|
|
|
};
|
2011-10-05 21:29:49 +04:00
|
|
|
module_platform_driver(sh_msiof_spi_drv);
|
2009-11-26 14:10:05 +03:00
|
|
|
|
2019-02-08 12:09:09 +03:00
|
|
|
MODULE_DESCRIPTION("SuperH MSIOF SPI Controller Interface Driver");
|
2009-11-26 14:10:05 +03:00
|
|
|
MODULE_AUTHOR("Magnus Damm");
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
|
|
MODULE_ALIAS("platform:spi_sh_msiof");
|