2018-08-21 16:02:23 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-11-26 04:10:05 -07:00
|
|
|
/*
|
2019-02-08 02:09:09 -07:00
|
|
|
* SuperH MSIOF SPI Controller Interface
|
2009-11-26 04:10:05 -07:00
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Magnus Damm
|
2017-05-22 07:11:43 -06:00
|
|
|
* Copyright (C) 2014 Renesas Electronics Corporation
|
|
|
|
* Copyright (C) 2014-2017 Glider bvba
|
2009-11-26 04:10:05 -07:00
|
|
|
*/
|
|
|
|
|
2011-01-21 08:56:37 -07:00
|
|
|
#include <linux/bitmap.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/completion.h>
|
2009-11-26 04:10:05 -07: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 04:10:24 -06:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/dmaengine.h>
|
2011-01-21 08:56:37 -07:00
|
|
|
#include <linux/err.h>
|
2009-11-26 04:10:05 -07:00
|
|
|
#include <linux/interrupt.h>
|
2011-01-21 08:56:37 -07:00
|
|
|
#include <linux/io.h>
|
2019-04-02 08:40:22 -06:00
|
|
|
#include <linux/iopoll.h>
|
2011-01-21 08:56:37 -07:00
|
|
|
#include <linux/kernel.h>
|
2011-07-03 13:44:29 -06:00
|
|
|
#include <linux/module.h>
|
2012-12-12 04:54:48 -07:00
|
|
|
#include <linux/of.h>
|
2014-02-25 03:21:09 -07:00
|
|
|
#include <linux/of_device.h>
|
2009-11-26 04:10:05 -07: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 04:10:24 -06:00
|
|
|
#include <linux/sh_dma.h>
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2011-01-21 08:56:37 -07:00
|
|
|
#include <linux/spi/sh_msiof.h>
|
2009-11-26 04:10:05 -07:00
|
|
|
#include <linux/spi/spi.h>
|
|
|
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
2014-02-25 03:21:09 -07:00
|
|
|
struct sh_msiof_chipdata {
|
2019-02-28 04:05:13 -07:00
|
|
|
u32 bits_per_word_mask;
|
2014-02-25 03:21:09 -07:00
|
|
|
u16 tx_fifo_size;
|
|
|
|
u16 rx_fifo_size;
|
2019-02-08 02:09:09 -07:00
|
|
|
u16 ctlr_flags;
|
2018-04-13 06:44:17 -06:00
|
|
|
u16 min_div_pow;
|
2014-02-25 03:21:09 -07:00
|
|
|
};
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
struct sh_msiof_spi_priv {
|
2019-02-08 02:09:09 -07:00
|
|
|
struct spi_controller *ctlr;
|
2009-11-26 04:10:05 -07:00
|
|
|
void __iomem *mapbase;
|
|
|
|
struct clk *clk;
|
|
|
|
struct platform_device *pdev;
|
|
|
|
struct sh_msiof_spi_info *info;
|
|
|
|
struct completion done;
|
2018-06-13 02:41:15 -06:00
|
|
|
struct completion done_txdma;
|
2015-06-14 11:25:05 -06:00
|
|
|
unsigned int tx_fifo_size;
|
|
|
|
unsigned int rx_fifo_size;
|
2018-04-13 06:44:17 -06: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 04:10:24 -06:00
|
|
|
void *tx_dma_page;
|
|
|
|
void *rx_dma_page;
|
|
|
|
dma_addr_t tx_dma_addr;
|
|
|
|
dma_addr_t rx_dma_addr;
|
2017-12-13 12:05:10 -07:00
|
|
|
bool native_cs_inited;
|
|
|
|
bool native_cs_high;
|
2017-05-22 07:11:43 -06:00
|
|
|
bool slave_aborted;
|
2009-11-26 04:10:05 -07:00
|
|
|
};
|
|
|
|
|
2017-12-13 12:05:11 -07:00
|
|
|
#define MAX_SS 3 /* Maximum number of native chip selects */
|
|
|
|
|
2014-02-20 07:43:03 -07:00
|
|
|
#define TMDR1 0x00 /* Transmit Mode Register 1 */
|
|
|
|
#define TMDR2 0x04 /* Transmit Mode Register 2 */
|
|
|
|
#define TMDR3 0x08 /* Transmit Mode Register 3 */
|
|
|
|
#define RMDR1 0x10 /* Receive Mode Register 1 */
|
|
|
|
#define RMDR2 0x14 /* Receive Mode Register 2 */
|
|
|
|
#define RMDR3 0x18 /* Receive Mode Register 3 */
|
|
|
|
#define TSCR 0x20 /* Transmit Clock Select Register */
|
|
|
|
#define RSCR 0x22 /* Receive Clock Select Register (SH, A1, APE6) */
|
|
|
|
#define CTR 0x28 /* Control Register */
|
|
|
|
#define FCTR 0x30 /* FIFO Control Register */
|
|
|
|
#define STR 0x40 /* Status Register */
|
|
|
|
#define IER 0x44 /* Interrupt Enable Register */
|
|
|
|
#define TDR1 0x48 /* Transmit Control Data Register 1 (SH, A1) */
|
|
|
|
#define TDR2 0x4c /* Transmit Control Data Register 2 (SH, A1) */
|
|
|
|
#define TFDR 0x50 /* Transmit FIFO Data Register */
|
|
|
|
#define RDR1 0x58 /* Receive Control Data Register 1 (SH, A1) */
|
|
|
|
#define RDR2 0x5c /* Receive Control Data Register 2 (SH, A1) */
|
|
|
|
#define RFDR 0x60 /* Receive FIFO Data Register */
|
|
|
|
|
|
|
|
/* TMDR1 and RMDR1 */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define MDR1_TRMD BIT(31) /* Transfer Mode (1 = Master mode) */
|
|
|
|
#define MDR1_SYNCMD_MASK GENMASK(29, 28) /* SYNC Mode */
|
|
|
|
#define MDR1_SYNCMD_SPI (2 << 28)/* Level mode/SPI */
|
|
|
|
#define MDR1_SYNCMD_LR (3 << 28)/* L/R mode */
|
|
|
|
#define MDR1_SYNCAC_SHIFT 25 /* Sync Polarity (1 = Active-low) */
|
|
|
|
#define MDR1_BITLSB_SHIFT 24 /* MSB/LSB First (1 = LSB first) */
|
|
|
|
#define MDR1_DTDL_SHIFT 20 /* Data Pin Bit Delay for MSIOF_SYNC */
|
|
|
|
#define MDR1_SYNCDL_SHIFT 16 /* Frame Sync Signal Timing Delay */
|
|
|
|
#define MDR1_FLD_MASK GENMASK(3, 2) /* Frame Sync Signal Interval (0-3) */
|
|
|
|
#define MDR1_FLD_SHIFT 2
|
|
|
|
#define MDR1_XXSTP BIT(0) /* Transmission/Reception Stop on FIFO */
|
2014-02-20 07:43:03 -07:00
|
|
|
/* TMDR1 */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define TMDR1_PCON BIT(30) /* Transfer Signal Connection */
|
|
|
|
#define TMDR1_SYNCCH_MASK GENMASK(27, 26) /* Sync Signal Channel Select */
|
|
|
|
#define TMDR1_SYNCCH_SHIFT 26 /* 0=MSIOF_SYNC, 1=MSIOF_SS1, 2=MSIOF_SS2 */
|
2014-02-20 07:43:03 -07:00
|
|
|
|
|
|
|
/* TMDR2 and RMDR2 */
|
|
|
|
#define MDR2_BITLEN1(i) (((i) - 1) << 24) /* Data Size (8-32 bits) */
|
|
|
|
#define MDR2_WDLEN1(i) (((i) - 1) << 16) /* Word Count (1-64/256 (SH, A1))) */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define MDR2_GRPMASK1 BIT(0) /* Group Output Mask 1 (SH, A1) */
|
2014-02-20 07:43:03 -07:00
|
|
|
|
|
|
|
/* TSCR and RSCR */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define SCR_BRPS_MASK GENMASK(12, 8) /* Prescaler Setting (1-32) */
|
2014-02-20 07:43:03 -07:00
|
|
|
#define SCR_BRPS(i) (((i) - 1) << 8)
|
2019-04-02 08:40:21 -06:00
|
|
|
#define SCR_BRDV_MASK GENMASK(2, 0) /* Baud Rate Generator's Division Ratio */
|
|
|
|
#define SCR_BRDV_DIV_2 0
|
|
|
|
#define SCR_BRDV_DIV_4 1
|
|
|
|
#define SCR_BRDV_DIV_8 2
|
|
|
|
#define SCR_BRDV_DIV_16 3
|
|
|
|
#define SCR_BRDV_DIV_32 4
|
|
|
|
#define SCR_BRDV_DIV_1 7
|
2014-02-20 07:43:03 -07:00
|
|
|
|
|
|
|
/* CTR */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define CTR_TSCKIZ_MASK GENMASK(31, 30) /* Transmit Clock I/O Polarity Select */
|
|
|
|
#define CTR_TSCKIZ_SCK BIT(31) /* Disable SCK when TX disabled */
|
|
|
|
#define CTR_TSCKIZ_POL_SHIFT 30 /* Transmit Clock Polarity */
|
|
|
|
#define CTR_RSCKIZ_MASK GENMASK(29, 28) /* Receive Clock Polarity Select */
|
|
|
|
#define CTR_RSCKIZ_SCK BIT(29) /* Must match CTR_TSCKIZ_SCK */
|
|
|
|
#define CTR_RSCKIZ_POL_SHIFT 28 /* Receive Clock Polarity */
|
|
|
|
#define CTR_TEDG_SHIFT 27 /* Transmit Timing (1 = falling edge) */
|
|
|
|
#define CTR_REDG_SHIFT 26 /* Receive Timing (1 = falling edge) */
|
|
|
|
#define CTR_TXDIZ_MASK GENMASK(23, 22) /* Pin Output When TX is Disabled */
|
|
|
|
#define CTR_TXDIZ_LOW (0 << 22) /* 0 */
|
|
|
|
#define CTR_TXDIZ_HIGH (1 << 22) /* 1 */
|
|
|
|
#define CTR_TXDIZ_HIZ (2 << 22) /* High-impedance */
|
|
|
|
#define CTR_TSCKE BIT(15) /* Transmit Serial Clock Output Enable */
|
|
|
|
#define CTR_TFSE BIT(14) /* Transmit Frame Sync Signal Output Enable */
|
|
|
|
#define CTR_TXE BIT(9) /* Transmit Enable */
|
|
|
|
#define CTR_RXE BIT(8) /* Receive Enable */
|
2019-04-02 08:40:23 -06:00
|
|
|
#define CTR_TXRST BIT(1) /* Transmit Reset */
|
|
|
|
#define CTR_RXRST BIT(0) /* Receive Reset */
|
2014-02-20 07:43:03 -07:00
|
|
|
|
2014-06-20 04:16:16 -06:00
|
|
|
/* FCTR */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define FCTR_TFWM_MASK GENMASK(31, 29) /* Transmit FIFO Watermark */
|
|
|
|
#define FCTR_TFWM_64 (0 << 29) /* Transfer Request when 64 empty stages */
|
|
|
|
#define FCTR_TFWM_32 (1 << 29) /* Transfer Request when 32 empty stages */
|
|
|
|
#define FCTR_TFWM_24 (2 << 29) /* Transfer Request when 24 empty stages */
|
|
|
|
#define FCTR_TFWM_16 (3 << 29) /* Transfer Request when 16 empty stages */
|
|
|
|
#define FCTR_TFWM_12 (4 << 29) /* Transfer Request when 12 empty stages */
|
|
|
|
#define FCTR_TFWM_8 (5 << 29) /* Transfer Request when 8 empty stages */
|
|
|
|
#define FCTR_TFWM_4 (6 << 29) /* Transfer Request when 4 empty stages */
|
|
|
|
#define FCTR_TFWM_1 (7 << 29) /* Transfer Request when 1 empty stage */
|
|
|
|
#define FCTR_TFUA_MASK GENMASK(26, 20) /* Transmit FIFO Usable Area */
|
|
|
|
#define FCTR_TFUA_SHIFT 20
|
2014-06-20 04:16:16 -06:00
|
|
|
#define FCTR_TFUA(i) ((i) << FCTR_TFUA_SHIFT)
|
2019-04-02 08:40:21 -06:00
|
|
|
#define FCTR_RFWM_MASK GENMASK(15, 13) /* Receive FIFO Watermark */
|
|
|
|
#define FCTR_RFWM_1 (0 << 13) /* Transfer Request when 1 valid stages */
|
|
|
|
#define FCTR_RFWM_4 (1 << 13) /* Transfer Request when 4 valid stages */
|
|
|
|
#define FCTR_RFWM_8 (2 << 13) /* Transfer Request when 8 valid stages */
|
|
|
|
#define FCTR_RFWM_16 (3 << 13) /* Transfer Request when 16 valid stages */
|
|
|
|
#define FCTR_RFWM_32 (4 << 13) /* Transfer Request when 32 valid stages */
|
|
|
|
#define FCTR_RFWM_64 (5 << 13) /* Transfer Request when 64 valid stages */
|
|
|
|
#define FCTR_RFWM_128 (6 << 13) /* Transfer Request when 128 valid stages */
|
|
|
|
#define FCTR_RFWM_256 (7 << 13) /* Transfer Request when 256 valid stages */
|
|
|
|
#define FCTR_RFUA_MASK GENMASK(12, 4) /* Receive FIFO Usable Area (0x40 = full) */
|
|
|
|
#define FCTR_RFUA_SHIFT 4
|
2014-06-20 04:16:16 -06:00
|
|
|
#define FCTR_RFUA(i) ((i) << FCTR_RFUA_SHIFT)
|
|
|
|
|
|
|
|
/* STR */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define STR_TFEMP BIT(29) /* Transmit FIFO Empty */
|
|
|
|
#define STR_TDREQ BIT(28) /* Transmit Data Transfer Request */
|
|
|
|
#define STR_TEOF BIT(23) /* Frame Transmission End */
|
|
|
|
#define STR_TFSERR BIT(21) /* Transmit Frame Synchronization Error */
|
|
|
|
#define STR_TFOVF BIT(20) /* Transmit FIFO Overflow */
|
|
|
|
#define STR_TFUDF BIT(19) /* Transmit FIFO Underflow */
|
|
|
|
#define STR_RFFUL BIT(13) /* Receive FIFO Full */
|
|
|
|
#define STR_RDREQ BIT(12) /* Receive Data Transfer Request */
|
|
|
|
#define STR_REOF BIT(7) /* Frame Reception End */
|
|
|
|
#define STR_RFSERR BIT(5) /* Receive Frame Synchronization Error */
|
|
|
|
#define STR_RFUDF BIT(4) /* Receive FIFO Underflow */
|
|
|
|
#define STR_RFOVF BIT(3) /* Receive FIFO Overflow */
|
2014-06-20 04:16:16 -06:00
|
|
|
|
|
|
|
/* IER */
|
2019-04-02 08:40:21 -06:00
|
|
|
#define IER_TDMAE BIT(31) /* Transmit Data DMA Transfer Req. Enable */
|
|
|
|
#define IER_TFEMPE BIT(29) /* Transmit FIFO Empty Enable */
|
|
|
|
#define IER_TDREQE BIT(28) /* Transmit Data Transfer Request Enable */
|
|
|
|
#define IER_TEOFE BIT(23) /* Frame Transmission End Enable */
|
|
|
|
#define IER_TFSERRE BIT(21) /* Transmit Frame Sync Error Enable */
|
|
|
|
#define IER_TFOVFE BIT(20) /* Transmit FIFO Overflow Enable */
|
|
|
|
#define IER_TFUDFE BIT(19) /* Transmit FIFO Underflow Enable */
|
|
|
|
#define IER_RDMAE BIT(15) /* Receive Data DMA Transfer Req. Enable */
|
|
|
|
#define IER_RFFULE BIT(13) /* Receive FIFO Full Enable */
|
|
|
|
#define IER_RDREQE BIT(12) /* Receive Data Transfer Request Enable */
|
|
|
|
#define IER_REOFE BIT(7) /* Frame Reception End Enable */
|
|
|
|
#define IER_RFSERRE BIT(5) /* Receive Frame Sync Error Enable */
|
|
|
|
#define IER_RFUDFE BIT(4) /* Receive FIFO Underflow Enable */
|
|
|
|
#define IER_RFOVFE BIT(3) /* Receive FIFO Overflow Enable */
|
2014-02-20 07:43:03 -07:00
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2011-01-21 08:56:37 -07:00
|
|
|
static u32 sh_msiof_read(struct sh_msiof_spi_priv *p, int reg_offs)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
|
|
|
switch (reg_offs) {
|
|
|
|
case TSCR:
|
|
|
|
case RSCR:
|
|
|
|
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 08:56:37 -07:00
|
|
|
u32 value)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
|
|
|
switch (reg_offs) {
|
|
|
|
case TSCR:
|
|
|
|
case RSCR:
|
|
|
|
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 08:56:37 -07:00
|
|
|
u32 clr, u32 set)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 mask = clr | set;
|
|
|
|
u32 data;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
|
|
|
data = sh_msiof_read(p, CTR);
|
|
|
|
data &= ~clr;
|
|
|
|
data |= set;
|
|
|
|
sh_msiof_write(p, CTR, data);
|
|
|
|
|
2019-04-02 08:40:22 -06:00
|
|
|
return readl_poll_timeout_atomic(p->mapbase + CTR, data,
|
2019-05-27 06:19:35 -06:00
|
|
|
(data & mask) == set, 1, 100);
|
2009-11-26 04:10:05 -07: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 */
|
|
|
|
sh_msiof_write(p, IER, 0);
|
|
|
|
complete(&p->done);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2019-04-02 08:40:23 -06:00
|
|
|
static void sh_msiof_spi_reset_regs(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
|
|
|
u32 mask = CTR_TXRST | CTR_RXRST;
|
|
|
|
u32 data;
|
|
|
|
|
|
|
|
data = sh_msiof_read(p, CTR);
|
|
|
|
data |= mask;
|
|
|
|
sh_msiof_write(p, CTR, data);
|
|
|
|
|
|
|
|
readl_poll_timeout_atomic(p->mapbase + CTR, data, !(data & mask), 1,
|
|
|
|
100);
|
|
|
|
}
|
|
|
|
|
2018-04-13 06:44:17 -06:00
|
|
|
static const u32 sh_msiof_spi_div_array[] = {
|
|
|
|
SCR_BRDV_DIV_1, SCR_BRDV_DIV_2, SCR_BRDV_DIV_4,
|
|
|
|
SCR_BRDV_DIV_8, SCR_BRDV_DIV_16, SCR_BRDV_DIV_32,
|
2009-11-26 04:10:05 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static void sh_msiof_spi_set_clk_regs(struct sh_msiof_spi_priv *p,
|
2014-02-20 07:43:02 -07:00
|
|
|
unsigned long parent_rate, u32 spi_hz)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2018-04-13 06:44:17 -06:00
|
|
|
unsigned long div;
|
2015-01-29 23:11:54 -07:00
|
|
|
u32 brps, scr;
|
2018-04-13 06:44:17 -06:00
|
|
|
unsigned int div_pow = p->min_div_pow;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2018-04-13 06:44:17 -06:00
|
|
|
if (!spi_hz || !parent_rate) {
|
|
|
|
WARN(1, "Invalid clock rate parameters %lu and %u\n",
|
|
|
|
parent_rate, spi_hz);
|
|
|
|
return;
|
|
|
|
}
|
2017-07-12 04:26:01 -06:00
|
|
|
|
2018-04-13 06:44:17 -06:00
|
|
|
div = DIV_ROUND_UP(parent_rate, spi_hz);
|
|
|
|
if (div <= 1024) {
|
2016-08-05 02:17:52 -06:00
|
|
|
/* SCR_BRDV_DIV_1 is valid only if BRPS is x 1/1 or x 1/2 */
|
2018-04-13 06:44:17 -06: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 04:10:05 -07:00
|
|
|
|
2018-04-13 06:44:17 -06: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 04:10:05 -07:00
|
|
|
|
2018-04-13 06:44:17 -06:00
|
|
|
scr = sh_msiof_spi_div_array[div_pow] | SCR_BRPS(brps);
|
2015-01-29 23:11:54 -07:00
|
|
|
sh_msiof_write(p, TSCR, scr);
|
2019-02-08 02:09:09 -07:00
|
|
|
if (!(p->ctlr->flags & SPI_CONTROLLER_MUST_TX))
|
2015-01-29 23:11:54 -07:00
|
|
|
sh_msiof_write(p, RSCR, scr);
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
2014-12-19 01:15:53 -07: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = sh_msiof_get_delay_bit(p->info->dtdl) << MDR1_DTDL_SHIFT;
|
|
|
|
val |= sh_msiof_get_delay_bit(p->info->syncdl) << MDR1_SYNCDL_SHIFT;
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2017-12-13 12:05:11 -07:00
|
|
|
static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p, u32 ss,
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 cpol, u32 cpha,
|
2013-12-01 11:19:15 -07:00
|
|
|
u32 tx_hi_z, u32 lsb_first, u32 cs_high)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 tmp;
|
2009-11-26 04:10:05 -07:00
|
|
|
int edge;
|
|
|
|
|
|
|
|
/*
|
2010-02-01 19:29:15 -07: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 04:10:05 -07:00
|
|
|
*/
|
2014-02-20 07:43:03 -07:00
|
|
|
tmp = MDR1_SYNCMD_SPI | 1 << MDR1_FLD_SHIFT | MDR1_XXSTP;
|
|
|
|
tmp |= !cs_high << MDR1_SYNCAC_SHIFT;
|
|
|
|
tmp |= lsb_first << MDR1_BITLSB_SHIFT;
|
2014-12-19 01:15:53 -07:00
|
|
|
tmp |= sh_msiof_spi_get_dtdl_and_syncdl(p);
|
2019-02-08 02:09:09 -07:00
|
|
|
if (spi_controller_is_slave(p->ctlr)) {
|
2017-05-22 07:11:43 -06:00
|
|
|
sh_msiof_write(p, TMDR1, tmp | TMDR1_PCON);
|
2017-12-13 12:05:11 -07:00
|
|
|
} else {
|
|
|
|
sh_msiof_write(p, TMDR1,
|
|
|
|
tmp | MDR1_TRMD | TMDR1_PCON |
|
|
|
|
(ss < MAX_SS ? ss : 0) << TMDR1_SYNCCH_SHIFT);
|
|
|
|
}
|
2019-02-08 02:09:09 -07: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 03:21:10 -07:00
|
|
|
/* These bits are reserved if RX needs TX */
|
|
|
|
tmp &= ~0x0000ffff;
|
|
|
|
}
|
2014-02-20 07:43:03 -07:00
|
|
|
sh_msiof_write(p, RMDR1, tmp);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-20 07:43:03 -07:00
|
|
|
tmp = 0;
|
|
|
|
tmp |= CTR_TSCKIZ_SCK | cpol << CTR_TSCKIZ_POL_SHIFT;
|
|
|
|
tmp |= CTR_RSCKIZ_SCK | cpol << CTR_RSCKIZ_POL_SHIFT;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2011-01-21 08:56:37 -07:00
|
|
|
edge = cpol ^ !cpha;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-20 07:43:03 -07:00
|
|
|
tmp |= edge << CTR_TEDG_SHIFT;
|
|
|
|
tmp |= edge << CTR_REDG_SHIFT;
|
|
|
|
tmp |= tx_hi_z ? CTR_TXDIZ_HIZ : CTR_TXDIZ_LOW;
|
2009-11-26 04:10:05 -07:00
|
|
|
sh_msiof_write(p, CTR, tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_set_mode_regs(struct sh_msiof_spi_priv *p,
|
|
|
|
const void *tx_buf, void *rx_buf,
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 bits, u32 words)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2014-02-20 07:43:03 -07:00
|
|
|
u32 dr2 = MDR2_BITLEN1(bits) | MDR2_WDLEN1(words);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
if (tx_buf || (p->ctlr->flags & SPI_CONTROLLER_MUST_TX))
|
2009-11-26 04:10:05 -07:00
|
|
|
sh_msiof_write(p, TMDR2, dr2);
|
|
|
|
else
|
2014-02-20 07:43:03 -07:00
|
|
|
sh_msiof_write(p, TMDR2, dr2 | MDR2_GRPMASK1);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
|
|
|
if (rx_buf)
|
|
|
|
sh_msiof_write(p, RMDR2, dr2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_reset_str(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
2018-09-05 02:49:37 -06:00
|
|
|
sh_msiof_write(p, STR,
|
|
|
|
sh_msiof_read(p, STR) & ~(STR_TDREQ | STR_RDREQ));
|
2009-11-26 04:10:05 -07: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 08:56:37 -07:00
|
|
|
const u8 *buf_8 = tx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
sh_msiof_write(p, TFDR, buf_8[k] << fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 08:56:37 -07:00
|
|
|
const u16 *buf_16 = tx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
sh_msiof_write(p, TFDR, buf_16[k] << fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 08:56:37 -07:00
|
|
|
const u16 *buf_16 = tx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
sh_msiof_write(p, TFDR, get_unaligned(&buf_16[k]) << fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 08:56:37 -07:00
|
|
|
const u32 *buf_32 = tx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
sh_msiof_write(p, TFDR, buf_32[k] << fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 08:56:37 -07:00
|
|
|
const u32 *buf_32 = tx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
sh_msiof_write(p, TFDR, get_unaligned(&buf_32[k]) << fs);
|
|
|
|
}
|
|
|
|
|
2011-01-21 08:56:42 -07: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++)
|
|
|
|
sh_msiof_write(p, TFDR, swab32(buf_32[k] << fs));
|
|
|
|
}
|
|
|
|
|
|
|
|
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++)
|
|
|
|
sh_msiof_write(p, TFDR, swab32(get_unaligned(&buf_32[k]) << fs));
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07: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 08:56:37 -07:00
|
|
|
u8 *buf_8 = rx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
buf_8[k] = sh_msiof_read(p, RFDR) >> fs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_16(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u16 *buf_16 = rx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
buf_16[k] = sh_msiof_read(p, RFDR) >> fs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_16u(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u16 *buf_16 = rx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
put_unaligned(sh_msiof_read(p, RFDR) >> fs, &buf_16[k]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_32(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 *buf_32 = rx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
buf_32[k] = sh_msiof_read(p, RFDR) >> fs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_spi_read_fifo_32u(struct sh_msiof_spi_priv *p,
|
|
|
|
void *rx_buf, int words, int fs)
|
|
|
|
{
|
2011-01-21 08:56:37 -07:00
|
|
|
u32 *buf_32 = rx_buf;
|
2009-11-26 04:10:05 -07:00
|
|
|
int k;
|
|
|
|
|
|
|
|
for (k = 0; k < words; k++)
|
|
|
|
put_unaligned(sh_msiof_read(p, RFDR) >> fs, &buf_32[k]);
|
|
|
|
}
|
|
|
|
|
2011-01-21 08:56:42 -07: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++)
|
|
|
|
buf_32[k] = swab32(sh_msiof_read(p, RFDR) >> fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
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++)
|
|
|
|
put_unaligned(swab32(sh_msiof_read(p, RFDR) >> fs), &buf_32[k]);
|
|
|
|
}
|
|
|
|
|
2014-02-20 07:43:04 -07:00
|
|
|
static int sh_msiof_spi_setup(struct spi_device *spi)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
struct sh_msiof_spi_priv *p =
|
|
|
|
spi_controller_get_devdata(spi->controller);
|
2017-12-13 12:05:10 -07:00
|
|
|
u32 clr, set, tmp;
|
2014-12-15 07:01:11 -07:00
|
|
|
|
2019-04-03 09:08:52 -06:00
|
|
|
if (spi->cs_gpiod || spi_controller_is_slave(p->ctlr))
|
2017-12-13 12:05:10 -07:00
|
|
|
return 0;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2017-12-13 12:05:10 -07:00
|
|
|
if (p->native_cs_inited &&
|
|
|
|
(p->native_cs_high == !!(spi->mode & SPI_CS_HIGH)))
|
|
|
|
return 0;
|
2014-12-15 07:01:11 -07:00
|
|
|
|
2017-12-13 12:05:10 -07:00
|
|
|
/* Configure native chip select mode/polarity early */
|
|
|
|
clr = MDR1_SYNCMD_MASK;
|
2018-05-23 03:02:04 -06:00
|
|
|
set = MDR1_SYNCMD_SPI;
|
2017-12-13 12:05:10 -07:00
|
|
|
if (spi->mode & SPI_CS_HIGH)
|
|
|
|
clr |= BIT(MDR1_SYNCAC_SHIFT);
|
|
|
|
else
|
|
|
|
set |= BIT(MDR1_SYNCAC_SHIFT);
|
|
|
|
pm_runtime_get_sync(&p->pdev->dev);
|
|
|
|
tmp = sh_msiof_read(p, TMDR1) & ~clr;
|
2018-05-23 03:02:04 -06:00
|
|
|
sh_msiof_write(p, TMDR1, tmp | set | MDR1_TRMD | TMDR1_PCON);
|
|
|
|
tmp = sh_msiof_read(p, RMDR1) & ~clr;
|
|
|
|
sh_msiof_write(p, RMDR1, tmp | set);
|
2015-01-07 08:37:25 -07:00
|
|
|
pm_runtime_put(&p->pdev->dev);
|
2017-12-13 12:05:10 -07:00
|
|
|
p->native_cs_high = spi->mode & SPI_CS_HIGH;
|
|
|
|
p->native_cs_inited = true;
|
2014-02-25 03:21:13 -07:00
|
|
|
return 0;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
static int sh_msiof_prepare_message(struct spi_controller *ctlr,
|
2014-02-25 03:21:11 -07:00
|
|
|
struct spi_message *msg)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
struct sh_msiof_spi_priv *p = spi_controller_get_devdata(ctlr);
|
2014-02-25 03:21:11 -07:00
|
|
|
const struct spi_device *spi = msg->spi;
|
2017-12-13 12:05:12 -07:00
|
|
|
u32 ss, cs_high;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:11 -07:00
|
|
|
/* Configure pins before asserting CS */
|
2019-04-03 09:08:52 -06:00
|
|
|
if (spi->cs_gpiod) {
|
2020-01-02 06:38:18 -07:00
|
|
|
ss = ctlr->unused_native_cs;
|
2017-12-13 12:05:12 -07: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 03:21:11 -07:00
|
|
|
!!(spi->mode & SPI_CPHA),
|
|
|
|
!!(spi->mode & SPI_3WIRE),
|
2017-12-13 12:05:12 -07:00
|
|
|
!!(spi->mode & SPI_LSB_FIRST), cs_high);
|
2014-02-25 03:21:11 -07:00
|
|
|
return 0;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
2014-06-20 04:16:17 -06:00
|
|
|
static int sh_msiof_spi_start(struct sh_msiof_spi_priv *p, void *rx_buf)
|
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
bool slave = spi_controller_is_slave(p->ctlr);
|
2017-05-22 07:11:43 -06:00
|
|
|
int ret = 0;
|
2014-06-20 04:16:17 -06:00
|
|
|
|
|
|
|
/* setup clock and rx/tx signals */
|
2017-05-22 07:11:43 -06:00
|
|
|
if (!slave)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, CTR_TSCKE);
|
2014-06-20 04:16:17 -06:00
|
|
|
if (rx_buf && !ret)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, CTR_RXE);
|
|
|
|
if (!ret)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, CTR_TXE);
|
|
|
|
|
|
|
|
/* start by setting frame bit */
|
2017-05-22 07:11:43 -06:00
|
|
|
if (!ret && !slave)
|
2014-06-20 04:16:17 -06:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, CTR_TFSE);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_spi_stop(struct sh_msiof_spi_priv *p, void *rx_buf)
|
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
bool slave = spi_controller_is_slave(p->ctlr);
|
2017-05-22 07:11:43 -06:00
|
|
|
int ret = 0;
|
2014-06-20 04:16:17 -06:00
|
|
|
|
|
|
|
/* shut down frame, rx/tx and clock signals */
|
2017-05-22 07:11:43 -06:00
|
|
|
if (!slave)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_TFSE, 0);
|
2014-06-20 04:16:17 -06:00
|
|
|
if (!ret)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_TXE, 0);
|
|
|
|
if (rx_buf && !ret)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_RXE, 0);
|
2017-05-22 07:11:43 -06:00
|
|
|
if (!ret && !slave)
|
2014-06-20 04:16:17 -06:00
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_TSCKE, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
static int sh_msiof_slave_abort(struct spi_controller *ctlr)
|
2017-05-22 07:11:43 -06:00
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
struct sh_msiof_spi_priv *p = spi_controller_get_devdata(ctlr);
|
2017-05-22 07:11:43 -06:00
|
|
|
|
|
|
|
p->slave_aborted = true;
|
|
|
|
complete(&p->done);
|
2018-06-13 02:41:15 -06:00
|
|
|
complete(&p->done_txdma);
|
2017-05-22 07:11:43 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-06-13 02:41:15 -06:00
|
|
|
static int sh_msiof_wait_for_completion(struct sh_msiof_spi_priv *p,
|
|
|
|
struct completion *x)
|
2017-05-22 07:11:43 -06:00
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
if (spi_controller_is_slave(p->ctlr)) {
|
2018-06-13 02:41:15 -06:00
|
|
|
if (wait_for_completion_interruptible(x) ||
|
2017-05-22 07:11:43 -06:00
|
|
|
p->slave_aborted) {
|
|
|
|
dev_dbg(&p->pdev->dev, "interrupted\n");
|
|
|
|
return -EINTR;
|
|
|
|
}
|
|
|
|
} else {
|
2018-06-13 02:41:15 -06:00
|
|
|
if (!wait_for_completion_timeout(x, HZ)) {
|
2017-05-22 07:11:43 -06:00
|
|
|
dev_err(&p->pdev->dev, "timeout\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07: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 04:10:24 -06:00
|
|
|
/* default FIFO watermarks for PIO */
|
|
|
|
sh_msiof_write(p, FCTR, 0);
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
/* setup msiof transfer mode registers */
|
|
|
|
sh_msiof_spi_set_mode_regs(p, tx_buf, rx_buf, bits, words);
|
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 04:10:24 -06:00
|
|
|
sh_msiof_write(p, IER, IER_TEOFE | IER_REOFE);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
|
|
|
/* write tx fifo */
|
|
|
|
if (tx_buf)
|
|
|
|
tx_fifo(p, tx_buf, words, fifo_shift);
|
|
|
|
|
2013-11-14 15:32:02 -07:00
|
|
|
reinit_completion(&p->done);
|
2017-05-22 07:11:43 -06:00
|
|
|
p->slave_aborted = false;
|
2014-06-20 04:16:17 -06:00
|
|
|
|
|
|
|
ret = sh_msiof_spi_start(p, rx_buf);
|
2009-11-26 04:10:05 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to start hardware\n");
|
2014-06-20 04:16:18 -06:00
|
|
|
goto stop_ier;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* wait for tx fifo to be emptied / rx fifo to be filled */
|
2018-06-13 02:41:15 -06:00
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done);
|
2017-05-22 07:11:43 -06:00
|
|
|
if (ret)
|
2014-06-20 04:16:18 -06:00
|
|
|
goto stop_reset;
|
2009-11-26 04:10:05 -07: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 04:16:17 -06:00
|
|
|
ret = sh_msiof_spi_stop(p, rx_buf);
|
2009-11-26 04:10:05 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to shut down hardware\n");
|
2014-06-20 04:16:18 -06:00
|
|
|
return ret;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return words;
|
|
|
|
|
2014-06-20 04:16:18 -06:00
|
|
|
stop_reset:
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
sh_msiof_spi_stop(p, rx_buf);
|
|
|
|
stop_ier:
|
2009-11-26 04:10:05 -07:00
|
|
|
sh_msiof_write(p, IER, 0);
|
|
|
|
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 04:10:24 -06:00
|
|
|
static void sh_msiof_dma_complete(void *arg)
|
|
|
|
{
|
2018-06-13 02:41:15 -06: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 04:10:24 -06: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 06:59:03 -06: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 04:10:24 -06:00
|
|
|
if (rx) {
|
|
|
|
ier_bits |= IER_RDREQE | IER_RDMAE;
|
2019-02-08 02:09:09 -07:00
|
|
|
desc_rx = dmaengine_prep_slave_single(p->ctlr->dma_rx,
|
2018-03-21 02:07:23 -06: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 04:10:24 -06:00
|
|
|
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
|
2014-08-07 06:07:42 -06: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 04:10:24 -06:00
|
|
|
|
|
|
|
desc_rx->callback = sh_msiof_dma_complete;
|
2018-06-13 02:41:15 -06: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 04:10:24 -06:00
|
|
|
cookie = dmaengine_submit(desc_rx);
|
2014-08-07 06:07:42 -06: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 04:10:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tx) {
|
2014-08-06 06:59:03 -06:00
|
|
|
ier_bits |= IER_TDREQE | IER_TDMAE;
|
2019-02-08 02:09:09 -07:00
|
|
|
dma_sync_single_for_device(p->ctlr->dma_tx->device->dev,
|
2014-08-06 06:59:03 -06:00
|
|
|
p->tx_dma_addr, len, DMA_TO_DEVICE);
|
2019-02-08 02:09:09 -07:00
|
|
|
desc_tx = dmaengine_prep_slave_single(p->ctlr->dma_tx,
|
2018-03-21 02:07:23 -06:00
|
|
|
p->tx_dma_addr, len, DMA_MEM_TO_DEV,
|
2014-08-06 06:59:03 -06:00
|
|
|
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
|
|
|
|
if (!desc_tx) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto no_dma_tx;
|
|
|
|
}
|
|
|
|
|
2018-06-13 02:41:15 -06: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 04:10:24 -06:00
|
|
|
cookie = dmaengine_submit(desc_tx);
|
|
|
|
if (dma_submit_error(cookie)) {
|
|
|
|
ret = cookie;
|
2014-08-06 06:59:03 -06: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 04:10:24 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-06 06:59:03 -06:00
|
|
|
/* 1 stage FIFO watermarks for DMA */
|
|
|
|
sh_msiof_write(p, FCTR, FCTR_TFWM_1 | FCTR_RFWM_1);
|
|
|
|
|
|
|
|
/* setup msiof transfer mode registers (32-bit words) */
|
|
|
|
sh_msiof_spi_set_mode_regs(p, tx, rx, 32, len / 4);
|
|
|
|
|
|
|
|
sh_msiof_write(p, IER, ier_bits);
|
|
|
|
|
|
|
|
reinit_completion(&p->done);
|
2018-06-13 02:41:15 -06:00
|
|
|
if (tx)
|
|
|
|
reinit_completion(&p->done_txdma);
|
2017-05-22 07:11:43 -06:00
|
|
|
p->slave_aborted = false;
|
2014-08-06 06:59:03 -06:00
|
|
|
|
|
|
|
/* Now start DMA */
|
|
|
|
if (rx)
|
2019-02-08 02:09:09 -07:00
|
|
|
dma_async_issue_pending(p->ctlr->dma_rx);
|
2014-08-07 06:07:43 -06:00
|
|
|
if (tx)
|
2019-02-08 02:09:09 -07:00
|
|
|
dma_async_issue_pending(p->ctlr->dma_tx);
|
2014-08-06 06:59:03 -06: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 04:10:24 -06:00
|
|
|
ret = sh_msiof_spi_start(p, rx);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&p->pdev->dev, "failed to start hardware\n");
|
2014-08-06 06:59:03 -06: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 04:10:24 -06:00
|
|
|
}
|
|
|
|
|
2018-06-13 02:41:15 -06: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 04:10:24 -06:00
|
|
|
|
2018-06-13 02:41:15 -06: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 10:11:14 -07:00
|
|
|
|
2018-06-13 02:41:15 -06:00
|
|
|
sh_msiof_write(p, IER, 0);
|
|
|
|
} else {
|
2018-01-03 10:11:14 -07:00
|
|
|
/* wait for tx fifo to be emptied */
|
2018-06-13 02:41:15 -06:00
|
|
|
sh_msiof_write(p, IER, IER_TEOFE);
|
|
|
|
ret = sh_msiof_wait_for_completion(p, &p->done);
|
2018-01-03 10:11:14 -07: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 04:10:24 -06: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 02:09:09 -07: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 04:10:24 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
stop_reset:
|
|
|
|
sh_msiof_reset_str(p);
|
|
|
|
sh_msiof_spi_stop(p, rx);
|
2014-08-06 06:59:03 -06: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 04:10:24 -06:00
|
|
|
if (tx)
|
2019-02-08 02:09:09 -07:00
|
|
|
dmaengine_terminate_all(p->ctlr->dma_tx);
|
2014-08-06 06:59:03 -06: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 04:10:24 -06:00
|
|
|
if (rx)
|
2019-02-08 02:09:09 -07:00
|
|
|
dmaengine_terminate_all(p->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 04:10:24 -06:00
|
|
|
sh_msiof_write(p, IER, 0);
|
|
|
|
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 02:09:09 -07:00
|
|
|
static int sh_msiof_transfer_one(struct spi_controller *ctlr,
|
2014-02-25 03:21:13 -07:00
|
|
|
struct spi_device *spi,
|
|
|
|
struct spi_transfer *t)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
void (*copy32)(u32 *, const u32 *, unsigned int);
|
2009-11-26 04:10:05 -07: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 04:16:19 -06: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 04:10:05 -07:00
|
|
|
int n;
|
2011-01-21 08:56:42 -07: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 04:10:24 -06:00
|
|
|
int ret;
|
|
|
|
|
2019-04-02 08:40:23 -06: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 04:10:24 -06:00
|
|
|
/* setup clocks (clock already enabled in chipselect()) */
|
2019-02-08 02:09:09 -07:00
|
|
|
if (!spi_controller_is_slave(p->ctlr))
|
2017-05-22 07:11:43 -06: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 04:10:24 -06:00
|
|
|
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
/*
|
|
|
|
* DMA supports 32-bit words only, hence pack 8-bit and 16-bit
|
|
|
|
* words, with byte resp. word swapping.
|
|
|
|
*/
|
2015-06-14 11:25:05 -06:00
|
|
|
unsigned int l = 0;
|
|
|
|
|
|
|
|
if (tx_buf)
|
2019-01-18 02:29:31 -07:00
|
|
|
l = min(round_down(len, 4), p->tx_fifo_size * 4);
|
2015-06-14 11:25:05 -06:00
|
|
|
if (rx_buf)
|
2019-01-18 02:29:31 -07: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 04:10:24 -06: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 04:10:05 -07: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 04:10:24 -06:00
|
|
|
ret = sh_msiof_dma_once(p, tx_buf, rx_buf, l);
|
2014-07-09 04:26:23 -06:00
|
|
|
if (ret == -EAGAIN) {
|
2017-11-30 06:38:50 -07:00
|
|
|
dev_warn_once(&p->pdev->dev,
|
|
|
|
"DMA not available, falling back to PIO\n");
|
2014-07-09 04:26:23 -06: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 04:10:24 -06: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 04:10:05 -07: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 01:48:42 -07:00
|
|
|
if (bits <= 8 && len > 15) {
|
2011-01-21 08:56:42 -07:00
|
|
|
bits = 32;
|
|
|
|
swab = true;
|
|
|
|
} else {
|
|
|
|
swab = false;
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07: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 04:16:19 -06:00
|
|
|
if ((unsigned long)tx_buf & 0x01)
|
2009-11-26 04:10:05 -07:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_16u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_16;
|
|
|
|
|
2014-06-20 04:16:19 -06:00
|
|
|
if ((unsigned long)rx_buf & 0x01)
|
2009-11-26 04:10:05 -07:00
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_16u;
|
|
|
|
else
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_16;
|
2011-01-21 08:56:42 -07:00
|
|
|
} else if (swab) {
|
|
|
|
bytes_per_word = 4;
|
2014-06-20 04:16:19 -06:00
|
|
|
if ((unsigned long)tx_buf & 0x03)
|
2011-01-21 08:56:42 -07:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_s32u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_s32;
|
|
|
|
|
2014-06-20 04:16:19 -06:00
|
|
|
if ((unsigned long)rx_buf & 0x03)
|
2011-01-21 08:56:42 -07:00
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_s32u;
|
|
|
|
else
|
|
|
|
rx_fifo = sh_msiof_spi_read_fifo_s32;
|
2009-11-26 04:10:05 -07:00
|
|
|
} else {
|
|
|
|
bytes_per_word = 4;
|
2014-06-20 04:16:19 -06:00
|
|
|
if ((unsigned long)tx_buf & 0x03)
|
2009-11-26 04:10:05 -07:00
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_32u;
|
|
|
|
else
|
|
|
|
tx_fifo = sh_msiof_spi_write_fifo_32;
|
|
|
|
|
2014-06-20 04:16:19 -06:00
|
|
|
if ((unsigned long)rx_buf & 0x03)
|
2009-11-26 04:10:05 -07: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 04:16:19 -06: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 04:10:05 -07:00
|
|
|
words, bits);
|
|
|
|
if (n < 0)
|
2014-06-20 04:16:18 -06:00
|
|
|
return n;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-06-20 04:16:19 -06:00
|
|
|
if (tx_buf)
|
|
|
|
tx_buf += n * bytes_per_word;
|
|
|
|
if (rx_buf)
|
|
|
|
rx_buf += n * bytes_per_word;
|
2009-11-26 04:10:05 -07: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 01:48:42 -07: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 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-25 03:21:09 -07:00
|
|
|
static const struct sh_msiof_chipdata sh_data = {
|
2019-02-28 04:05:13 -07:00
|
|
|
.bits_per_word_mask = SPI_BPW_RANGE_MASK(8, 32),
|
2014-02-25 03:21:09 -07:00
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 02:09:09 -07:00
|
|
|
.ctlr_flags = 0,
|
2018-04-13 06:44:17 -06:00
|
|
|
.min_div_pow = 0,
|
2017-07-12 04:26:01 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sh_msiof_chipdata rcar_gen2_data = {
|
2019-02-28 04:05:13 -07:00
|
|
|
.bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16) |
|
|
|
|
SPI_BPW_MASK(24) | SPI_BPW_MASK(32),
|
2017-07-12 04:26:01 -06:00
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 02:09:09 -07:00
|
|
|
.ctlr_flags = SPI_CONTROLLER_MUST_TX,
|
2018-04-13 06:44:17 -06: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 03:21:10 -07:00
|
|
|
};
|
|
|
|
|
2017-07-12 04:26:01 -06:00
|
|
|
static const struct sh_msiof_chipdata rcar_gen3_data = {
|
2019-02-28 04:05:13 -07: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 03:21:10 -07:00
|
|
|
.tx_fifo_size = 64,
|
2015-06-14 11:25:05 -06:00
|
|
|
.rx_fifo_size = 64,
|
2019-02-08 02:09:09 -07:00
|
|
|
.ctlr_flags = SPI_CONTROLLER_MUST_TX,
|
2018-04-13 06:44:17 -06:00
|
|
|
.min_div_pow = 1,
|
2014-02-25 03:21:09 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id sh_msiof_match[] = {
|
|
|
|
{ .compatible = "renesas,sh-mobile-msiof", .data = &sh_data },
|
2017-09-25 02:54:19 -06:00
|
|
|
{ .compatible = "renesas,msiof-r8a7743", .data = &rcar_gen2_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7745", .data = &rcar_gen2_data },
|
2017-07-12 04:26:01 -06: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 03:21:16 -07:00
|
|
|
{ .compatible = "renesas,sh-msiof", .data = &sh_data }, /* Deprecated */
|
2014-02-25 03:21:09 -07:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, sh_msiof_match);
|
|
|
|
|
2012-12-12 04:54:48 -07: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 03:21:08 -07:00
|
|
|
u32 num_cs = 1;
|
2012-12-12 04:54:48 -07:00
|
|
|
|
|
|
|
info = devm_kzalloc(dev, sizeof(struct sh_msiof_spi_info), GFP_KERNEL);
|
2014-04-29 02:21:25 -06:00
|
|
|
if (!info)
|
2012-12-12 04:54:48 -07:00
|
|
|
return NULL;
|
|
|
|
|
2017-05-22 07:11:43 -06:00
|
|
|
info->mode = of_property_read_bool(np, "spi-slave") ? MSIOF_SPI_SLAVE
|
|
|
|
: MSIOF_SPI_MASTER;
|
|
|
|
|
2012-12-12 04:54:48 -07:00
|
|
|
/* Parse the MSIOF properties */
|
2017-05-22 07:11:43 -06:00
|
|
|
if (info->mode == MSIOF_SPI_MASTER)
|
|
|
|
of_property_read_u32(np, "num-cs", &num_cs);
|
2012-12-12 04:54:48 -07: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 01:15:53 -07:00
|
|
|
of_property_read_u32(np, "renesas,dtdl", &info->dtdl);
|
|
|
|
of_property_read_u32(np, "renesas,syncdl", &info->syncdl);
|
2012-12-12 04:54:48 -07: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 04:10:24 -06: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 06:59:05 -06: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 04:10:24 -06:00
|
|
|
if (!chan) {
|
2014-08-06 06:59:05 -06: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 04:10:24 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&cfg, 0, sizeof(cfg));
|
|
|
|
cfg.direction = dir;
|
2014-08-06 06:59:04 -06: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 04:10:24 -06:00
|
|
|
cfg.dst_addr = port_addr;
|
2014-08-06 06:59:04 -06: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 04:10:24 -06:00
|
|
|
cfg.src_addr = port_addr;
|
2014-08-06 06:59:04 -06: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 04:10:24 -06: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 02:29:30 -07:00
|
|
|
const struct sh_msiof_spi_info *info = p->info;
|
2014-08-06 06:59:05 -06: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 04:10:24 -06:00
|
|
|
const struct resource *res;
|
2019-02-08 02:09:09 -07:00
|
|
|
struct spi_controller *ctlr;
|
2014-07-11 09:56:22 -06: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 04:10:24 -06:00
|
|
|
|
2014-08-06 06:59:05 -06: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 04:10:24 -06: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 02:09:09 -07:00
|
|
|
ctlr = p->ctlr;
|
|
|
|
ctlr->dma_tx = sh_msiof_request_dma_chan(dev, DMA_MEM_TO_DEV,
|
|
|
|
dma_tx_id, res->start + TFDR);
|
|
|
|
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 04:10:24 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
ctlr->dma_rx = sh_msiof_request_dma_chan(dev, DMA_DEV_TO_MEM,
|
|
|
|
dma_rx_id, res->start + RFDR);
|
|
|
|
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 04:10:24 -06: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 02:09:09 -07:00
|
|
|
tx_dev = ctlr->dma_tx->device->dev;
|
2014-07-11 09:56:22 -06: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 04:10:24 -06:00
|
|
|
DMA_TO_DEVICE);
|
2014-07-11 09:56:22 -06: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 04:10:24 -06:00
|
|
|
goto free_rx_page;
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
rx_dev = ctlr->dma_rx->device->dev;
|
2014-07-11 09:56:22 -06: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 04:10:24 -06:00
|
|
|
DMA_FROM_DEVICE);
|
2014-07-11 09:56:22 -06: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 04:10:24 -06:00
|
|
|
goto unmap_tx_page;
|
|
|
|
|
|
|
|
dev_info(dev, "DMA available");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unmap_tx_page:
|
2014-07-11 09:56:22 -06: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 04:10:24 -06: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 02:09:09 -07: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 04:10:24 -06:00
|
|
|
free_tx_chan:
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_release_dma(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
return;
|
|
|
|
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
free_page((unsigned long)p->rx_dma_page);
|
|
|
|
free_page((unsigned long)p->tx_dma_page);
|
2019-02-08 02:09:09 -07: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 04:10:24 -06:00
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
static int sh_msiof_spi_probe(struct platform_device *pdev)
|
|
|
|
{
|
2019-02-08 02:09:09 -07:00
|
|
|
struct spi_controller *ctlr;
|
2016-06-22 06:50:03 -06:00
|
|
|
const struct sh_msiof_chipdata *chipdata;
|
2017-05-22 07:11:43 -06:00
|
|
|
struct sh_msiof_spi_info *info;
|
2009-11-26 04:10:05 -07:00
|
|
|
struct sh_msiof_spi_priv *p;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
2017-10-04 06:20:27 -06:00
|
|
|
chipdata = of_device_get_match_data(&pdev->dev);
|
|
|
|
if (chipdata) {
|
2017-05-22 07:11:43 -06:00
|
|
|
info = sh_msiof_spi_parse_dt(&pdev->dev);
|
2014-02-25 03:21:09 -07:00
|
|
|
} else {
|
2016-06-22 06:50:03 -06:00
|
|
|
chipdata = (const void *)pdev->id_entry->driver_data;
|
2017-05-22 07:11:43 -06:00
|
|
|
info = dev_get_platdata(&pdev->dev);
|
2014-02-25 03:21:09 -07:00
|
|
|
}
|
2012-12-12 04:54:48 -07:00
|
|
|
|
2017-05-22 07:11:43 -06:00
|
|
|
if (!info) {
|
2012-12-12 04:54:48 -07:00
|
|
|
dev_err(&pdev->dev, "failed to obtain device info\n");
|
2017-05-22 07:11:43 -06:00
|
|
|
return -ENXIO;
|
2012-12-12 04:54:48 -07:00
|
|
|
}
|
|
|
|
|
2017-05-22 07:11:43 -06:00
|
|
|
if (info->mode == MSIOF_SPI_SLAVE)
|
2019-02-08 02:09:09 -07:00
|
|
|
ctlr = spi_alloc_slave(&pdev->dev,
|
|
|
|
sizeof(struct sh_msiof_spi_priv));
|
2017-05-22 07:11:43 -06:00
|
|
|
else
|
2019-02-08 02:09:09 -07:00
|
|
|
ctlr = spi_alloc_master(&pdev->dev,
|
|
|
|
sizeof(struct sh_msiof_spi_priv));
|
|
|
|
if (ctlr == NULL)
|
2017-05-22 07:11:43 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
p = spi_controller_get_devdata(ctlr);
|
2017-05-22 07:11:43 -06:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, p);
|
2019-02-08 02:09:09 -07:00
|
|
|
p->ctlr = ctlr;
|
2017-05-22 07:11:43 -06:00
|
|
|
p->info = info;
|
2018-04-13 06:44:17 -06:00
|
|
|
p->min_div_pow = chipdata->min_div_pow;
|
2017-05-22 07:11:43 -06:00
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
init_completion(&p->done);
|
2018-06-13 02:41:15 -06:00
|
|
|
init_completion(&p->done_txdma);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2013-11-27 18:39:42 -07:00
|
|
|
p->clk = devm_clk_get(&pdev->dev, NULL);
|
2009-11-26 04:10:05 -07:00
|
|
|
if (IS_ERR(p->clk)) {
|
2012-11-07 04:40:04 -07:00
|
|
|
dev_err(&pdev->dev, "cannot get clock\n");
|
2009-11-26 04:10:05 -07:00
|
|
|
ret = PTR_ERR(p->clk);
|
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = platform_get_irq(pdev, 0);
|
2013-11-27 18:39:42 -07:00
|
|
|
if (i < 0) {
|
2018-10-12 13:48:22 -06:00
|
|
|
ret = i;
|
2013-11-27 18:39:42 -07:00
|
|
|
goto err1;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
2013-11-27 18:39:42 -07:00
|
|
|
|
2019-08-07 02:52:13 -06:00
|
|
|
p->mapbase = devm_platform_ioremap_resource(pdev, 0);
|
2013-11-27 18:39:42 -07:00
|
|
|
if (IS_ERR(p->mapbase)) {
|
|
|
|
ret = PTR_ERR(p->mapbase);
|
|
|
|
goto err1;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
2013-11-27 18:39:42 -07:00
|
|
|
ret = devm_request_irq(&pdev->dev, i, sh_msiof_spi_irq, 0,
|
|
|
|
dev_name(&pdev->dev), p);
|
2009-11-26 04:10:05 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "unable to request irq\n");
|
2013-11-27 18:39:42 -07:00
|
|
|
goto err1;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
p->pdev = pdev;
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
|
|
|
|
/* Platform data may override FIFO sizes */
|
2016-06-22 06:50:03 -06:00
|
|
|
p->tx_fifo_size = chipdata->tx_fifo_size;
|
|
|
|
p->rx_fifo_size = chipdata->rx_fifo_size;
|
2009-11-26 04:10:05 -07: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 02:09:09 -07: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 06:38:18 -07:00
|
|
|
ctlr->num_chipselect = p->info->num_chipselect;
|
2019-02-08 02:09:09 -07: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 04:05:13 -07:00
|
|
|
ctlr->bits_per_word_mask = chipdata->bits_per_word_mask;
|
2019-02-08 02:09:09 -07:00
|
|
|
ctlr->auto_runtime_pm = true;
|
|
|
|
ctlr->transfer_one = sh_msiof_transfer_one;
|
2019-04-03 09:08:52 -06:00
|
|
|
ctlr->use_gpio_descriptors = true;
|
2020-01-02 06:38:18 -07:00
|
|
|
ctlr->max_native_cs = MAX_SS;
|
2009-11-26 04:10:05 -07: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 04:10:24 -06:00
|
|
|
ret = sh_msiof_request_dma(p);
|
|
|
|
if (ret < 0)
|
|
|
|
dev_warn(&pdev->dev, "DMA not available, using PIO\n");
|
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
ret = devm_spi_register_controller(&pdev->dev, ctlr);
|
2014-02-25 03:21:13 -07:00
|
|
|
if (ret < 0) {
|
2019-02-08 02:09:09 -07:00
|
|
|
dev_err(&pdev->dev, "devm_spi_register_controller error.\n");
|
2014-02-25 03:21:13 -07:00
|
|
|
goto err2;
|
|
|
|
}
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:13 -07:00
|
|
|
return 0;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:13 -07: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 04:10:24 -06:00
|
|
|
sh_msiof_release_dma(p);
|
2009-11-26 04:10:05 -07:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
err1:
|
2019-02-08 02:09:09 -07:00
|
|
|
spi_controller_put(ctlr);
|
2009-11-26 04:10:05 -07: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 04:10:24 -06:00
|
|
|
struct sh_msiof_spi_priv *p = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
sh_msiof_release_dma(p);
|
2014-02-25 03:21:13 -07:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
return 0;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
2015-05-01 09:44:07 -06:00
|
|
|
static const struct platform_device_id spi_driver_ids[] = {
|
2014-02-25 03:21:09 -07:00
|
|
|
{ "spi_sh_msiof", (kernel_ulong_t)&sh_data },
|
2012-12-12 04:54:48 -07:00
|
|
|
{},
|
|
|
|
};
|
2014-02-25 03:21:09 -07:00
|
|
|
MODULE_DEVICE_TABLE(platform, spi_driver_ids);
|
2012-12-12 04:54:48 -07:00
|
|
|
|
2018-09-05 02:49:36 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
static int sh_msiof_spi_suspend(struct device *dev)
|
|
|
|
{
|
2018-10-21 14:00:46 -06:00
|
|
|
struct sh_msiof_spi_priv *p = dev_get_drvdata(dev);
|
2018-09-05 02:49:36 -06:00
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
return spi_controller_suspend(p->ctlr);
|
2018-09-05 02:49:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_msiof_spi_resume(struct device *dev)
|
|
|
|
{
|
2018-10-21 14:00:46 -06:00
|
|
|
struct sh_msiof_spi_priv *p = dev_get_drvdata(dev);
|
2018-09-05 02:49:36 -06:00
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
return spi_controller_resume(p->ctlr);
|
2018-09-05 02:49:36 -06: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 04:10:05 -07:00
|
|
|
static struct platform_driver sh_msiof_spi_drv = {
|
|
|
|
.probe = sh_msiof_spi_probe,
|
|
|
|
.remove = sh_msiof_spi_remove,
|
2014-02-25 03:21:09 -07:00
|
|
|
.id_table = spi_driver_ids,
|
2009-11-26 04:10:05 -07:00
|
|
|
.driver = {
|
|
|
|
.name = "spi_sh_msiof",
|
2018-09-05 02:49:36 -06:00
|
|
|
.pm = DEV_PM_OPS,
|
2013-03-14 04:01:51 -06:00
|
|
|
.of_match_table = of_match_ptr(sh_msiof_match),
|
2009-11-26 04:10:05 -07:00
|
|
|
},
|
|
|
|
};
|
2011-10-05 11:29:49 -06:00
|
|
|
module_platform_driver(sh_msiof_spi_drv);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2019-02-08 02:09:09 -07:00
|
|
|
MODULE_DESCRIPTION("SuperH MSIOF SPI Controller Interface Driver");
|
2009-11-26 04:10:05 -07:00
|
|
|
MODULE_AUTHOR("Magnus Damm");
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
|
|
MODULE_ALIAS("platform:spi_sh_msiof");
|