2009-11-26 04:10:05 -07:00
|
|
|
/*
|
|
|
|
* SuperH MSIOF SPI Master Interface
|
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Magnus Damm
|
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
|
|
|
* Copyright (C) 2014 Glider bvba
|
2009-11-26 04:10:05 -07:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
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>
|
|
|
|
#include <linux/gpio.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>
|
|
|
|
#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 {
|
|
|
|
u16 tx_fifo_size;
|
|
|
|
u16 rx_fifo_size;
|
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
|
|
|
u16 master_flags;
|
2014-02-25 03:21:09 -07:00
|
|
|
};
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
struct sh_msiof_spi_priv {
|
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 spi_master *master;
|
2009-11-26 04:10:05 -07:00
|
|
|
void __iomem *mapbase;
|
|
|
|
struct clk *clk;
|
|
|
|
struct platform_device *pdev;
|
2014-02-25 03:21:09 -07:00
|
|
|
const struct sh_msiof_chipdata *chipdata;
|
2009-11-26 04:10:05 -07:00
|
|
|
struct sh_msiof_spi_info *info;
|
|
|
|
struct completion done;
|
|
|
|
int tx_fifo_size;
|
|
|
|
int rx_fifo_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
|
|
|
void *tx_dma_page;
|
|
|
|
void *rx_dma_page;
|
|
|
|
dma_addr_t tx_dma_addr;
|
|
|
|
dma_addr_t rx_dma_addr;
|
2009-11-26 04:10:05 -07:00
|
|
|
};
|
|
|
|
|
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 */
|
|
|
|
#define MDR1_TRMD 0x80000000 /* Transfer Mode (1 = Master mode) */
|
|
|
|
#define MDR1_SYNCMD_MASK 0x30000000 /* SYNC Mode */
|
|
|
|
#define MDR1_SYNCMD_SPI 0x20000000 /* Level mode/SPI */
|
|
|
|
#define MDR1_SYNCMD_LR 0x30000000 /* L/R mode */
|
|
|
|
#define MDR1_SYNCAC_SHIFT 25 /* Sync Polarity (1 = Active-low) */
|
|
|
|
#define MDR1_BITLSB_SHIFT 24 /* MSB/LSB First (1 = LSB first) */
|
2014-12-19 01:15:53 -07:00
|
|
|
#define MDR1_DTDL_SHIFT 20 /* Data Pin Bit Delay for MSIOF_SYNC */
|
|
|
|
#define MDR1_SYNCDL_SHIFT 16 /* Frame Sync Signal Timing Delay */
|
2015-01-06 03:01:26 -07:00
|
|
|
#define MDR1_FLD_MASK 0x0000000c /* Frame Sync Signal Interval (0-3) */
|
2014-02-20 07:43:03 -07:00
|
|
|
#define MDR1_FLD_SHIFT 2
|
|
|
|
#define MDR1_XXSTP 0x00000001 /* Transmission/Reception Stop on FIFO */
|
|
|
|
/* TMDR1 */
|
|
|
|
#define TMDR1_PCON 0x40000000 /* Transfer Signal Connection */
|
|
|
|
|
|
|
|
/* 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))) */
|
|
|
|
#define MDR2_GRPMASK1 0x00000001 /* Group Output Mask 1 (SH, A1) */
|
|
|
|
|
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
|
|
|
#define MAX_WDLEN 256U
|
|
|
|
|
2014-02-20 07:43:03 -07:00
|
|
|
/* TSCR and RSCR */
|
|
|
|
#define SCR_BRPS_MASK 0x1f00 /* Prescaler Setting (1-32) */
|
|
|
|
#define SCR_BRPS(i) (((i) - 1) << 8)
|
|
|
|
#define SCR_BRDV_MASK 0x0007 /* Baud Rate Generator's Division Ratio */
|
|
|
|
#define SCR_BRDV_DIV_2 0x0000
|
|
|
|
#define SCR_BRDV_DIV_4 0x0001
|
|
|
|
#define SCR_BRDV_DIV_8 0x0002
|
|
|
|
#define SCR_BRDV_DIV_16 0x0003
|
|
|
|
#define SCR_BRDV_DIV_32 0x0004
|
|
|
|
#define SCR_BRDV_DIV_1 0x0007
|
|
|
|
|
|
|
|
/* CTR */
|
|
|
|
#define CTR_TSCKIZ_MASK 0xc0000000 /* Transmit Clock I/O Polarity Select */
|
|
|
|
#define CTR_TSCKIZ_SCK 0x80000000 /* Disable SCK when TX disabled */
|
|
|
|
#define CTR_TSCKIZ_POL_SHIFT 30 /* Transmit Clock Polarity */
|
|
|
|
#define CTR_RSCKIZ_MASK 0x30000000 /* Receive Clock Polarity Select */
|
|
|
|
#define CTR_RSCKIZ_SCK 0x20000000 /* 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 0x00c00000 /* Pin Output When TX is Disabled */
|
|
|
|
#define CTR_TXDIZ_LOW 0x00000000 /* 0 */
|
|
|
|
#define CTR_TXDIZ_HIGH 0x00400000 /* 1 */
|
|
|
|
#define CTR_TXDIZ_HIZ 0x00800000 /* High-impedance */
|
|
|
|
#define CTR_TSCKE 0x00008000 /* Transmit Serial Clock Output Enable */
|
|
|
|
#define CTR_TFSE 0x00004000 /* Transmit Frame Sync Signal Output Enable */
|
|
|
|
#define CTR_TXE 0x00000200 /* Transmit Enable */
|
|
|
|
#define CTR_RXE 0x00000100 /* Receive Enable */
|
|
|
|
|
2014-06-20 04:16:16 -06:00
|
|
|
/* FCTR */
|
|
|
|
#define FCTR_TFWM_MASK 0xe0000000 /* Transmit FIFO Watermark */
|
|
|
|
#define FCTR_TFWM_64 0x00000000 /* Transfer Request when 64 empty stages */
|
|
|
|
#define FCTR_TFWM_32 0x20000000 /* Transfer Request when 32 empty stages */
|
|
|
|
#define FCTR_TFWM_24 0x40000000 /* Transfer Request when 24 empty stages */
|
|
|
|
#define FCTR_TFWM_16 0x60000000 /* Transfer Request when 16 empty stages */
|
|
|
|
#define FCTR_TFWM_12 0x80000000 /* Transfer Request when 12 empty stages */
|
|
|
|
#define FCTR_TFWM_8 0xa0000000 /* Transfer Request when 8 empty stages */
|
|
|
|
#define FCTR_TFWM_4 0xc0000000 /* Transfer Request when 4 empty stages */
|
|
|
|
#define FCTR_TFWM_1 0xe0000000 /* Transfer Request when 1 empty stage */
|
|
|
|
#define FCTR_TFUA_MASK 0x07f00000 /* Transmit FIFO Usable Area */
|
|
|
|
#define FCTR_TFUA_SHIFT 20
|
|
|
|
#define FCTR_TFUA(i) ((i) << FCTR_TFUA_SHIFT)
|
|
|
|
#define FCTR_RFWM_MASK 0x0000e000 /* Receive FIFO Watermark */
|
|
|
|
#define FCTR_RFWM_1 0x00000000 /* Transfer Request when 1 valid stages */
|
|
|
|
#define FCTR_RFWM_4 0x00002000 /* Transfer Request when 4 valid stages */
|
|
|
|
#define FCTR_RFWM_8 0x00004000 /* Transfer Request when 8 valid stages */
|
|
|
|
#define FCTR_RFWM_16 0x00006000 /* Transfer Request when 16 valid stages */
|
|
|
|
#define FCTR_RFWM_32 0x00008000 /* Transfer Request when 32 valid stages */
|
|
|
|
#define FCTR_RFWM_64 0x0000a000 /* Transfer Request when 64 valid stages */
|
|
|
|
#define FCTR_RFWM_128 0x0000c000 /* Transfer Request when 128 valid stages */
|
|
|
|
#define FCTR_RFWM_256 0x0000e000 /* Transfer Request when 256 valid stages */
|
|
|
|
#define FCTR_RFUA_MASK 0x00001ff0 /* Receive FIFO Usable Area (0x40 = full) */
|
|
|
|
#define FCTR_RFUA_SHIFT 4
|
|
|
|
#define FCTR_RFUA(i) ((i) << FCTR_RFUA_SHIFT)
|
|
|
|
|
|
|
|
/* STR */
|
|
|
|
#define STR_TFEMP 0x20000000 /* Transmit FIFO Empty */
|
|
|
|
#define STR_TDREQ 0x10000000 /* Transmit Data Transfer Request */
|
2014-02-20 07:43:03 -07:00
|
|
|
#define STR_TEOF 0x00800000 /* Frame Transmission End */
|
2014-06-20 04:16:16 -06:00
|
|
|
#define STR_TFSERR 0x00200000 /* Transmit Frame Synchronization Error */
|
|
|
|
#define STR_TFOVF 0x00100000 /* Transmit FIFO Overflow */
|
|
|
|
#define STR_TFUDF 0x00080000 /* Transmit FIFO Underflow */
|
|
|
|
#define STR_RFFUL 0x00002000 /* Receive FIFO Full */
|
|
|
|
#define STR_RDREQ 0x00001000 /* Receive Data Transfer Request */
|
2014-02-20 07:43:03 -07:00
|
|
|
#define STR_REOF 0x00000080 /* Frame Reception End */
|
2014-06-20 04:16:16 -06:00
|
|
|
#define STR_RFSERR 0x00000020 /* Receive Frame Synchronization Error */
|
|
|
|
#define STR_RFUDF 0x00000010 /* Receive FIFO Underflow */
|
|
|
|
#define STR_RFOVF 0x00000008 /* Receive FIFO Overflow */
|
|
|
|
|
|
|
|
/* IER */
|
|
|
|
#define IER_TDMAE 0x80000000 /* Transmit Data DMA Transfer Req. Enable */
|
|
|
|
#define IER_TFEMPE 0x20000000 /* Transmit FIFO Empty Enable */
|
|
|
|
#define IER_TDREQE 0x10000000 /* Transmit Data Transfer Request Enable */
|
|
|
|
#define IER_TEOFE 0x00800000 /* Frame Transmission End Enable */
|
|
|
|
#define IER_TFSERRE 0x00200000 /* Transmit Frame Sync Error Enable */
|
|
|
|
#define IER_TFOVFE 0x00100000 /* Transmit FIFO Overflow Enable */
|
|
|
|
#define IER_TFUDFE 0x00080000 /* Transmit FIFO Underflow Enable */
|
|
|
|
#define IER_RDMAE 0x00008000 /* Receive Data DMA Transfer Req. Enable */
|
|
|
|
#define IER_RFFULE 0x00002000 /* Receive FIFO Full Enable */
|
|
|
|
#define IER_RDREQE 0x00001000 /* Receive Data Transfer Request Enable */
|
|
|
|
#define IER_REOFE 0x00000080 /* Frame Reception End Enable */
|
|
|
|
#define IER_RFSERRE 0x00000020 /* Receive Frame Sync Error Enable */
|
|
|
|
#define IER_RFUDFE 0x00000010 /* Receive FIFO Underflow Enable */
|
|
|
|
#define IER_RFOVFE 0x00000008 /* 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
|
|
|
int k;
|
|
|
|
|
|
|
|
data = sh_msiof_read(p, CTR);
|
|
|
|
data &= ~clr;
|
|
|
|
data |= set;
|
|
|
|
sh_msiof_write(p, CTR, data);
|
|
|
|
|
|
|
|
for (k = 100; k > 0; k--) {
|
|
|
|
if ((sh_msiof_read(p, CTR) & mask) == set)
|
|
|
|
break;
|
|
|
|
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
|
|
|
|
return k > 0 ? 0 : -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
unsigned short div;
|
2015-01-29 23:11:54 -07:00
|
|
|
unsigned short brdv;
|
|
|
|
} const sh_msiof_spi_div_table[] = {
|
|
|
|
{ 1, SCR_BRDV_DIV_1 },
|
|
|
|
{ 2, SCR_BRDV_DIV_2 },
|
|
|
|
{ 4, SCR_BRDV_DIV_4 },
|
|
|
|
{ 8, SCR_BRDV_DIV_8 },
|
|
|
|
{ 16, SCR_BRDV_DIV_16 },
|
|
|
|
{ 32, 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
|
|
|
{
|
|
|
|
unsigned long div = 1024;
|
2015-01-29 23:11:54 -07:00
|
|
|
u32 brps, scr;
|
2009-11-26 04:10:05 -07:00
|
|
|
size_t k;
|
|
|
|
|
|
|
|
if (!WARN_ON(!spi_hz || !parent_rate))
|
2013-12-01 11:19:13 -07:00
|
|
|
div = DIV_ROUND_UP(parent_rate, spi_hz);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2015-01-29 23:11:54 -07:00
|
|
|
for (k = 0; k < ARRAY_SIZE(sh_msiof_spi_div_table); k++) {
|
|
|
|
brps = DIV_ROUND_UP(div, sh_msiof_spi_div_table[k].div);
|
|
|
|
if (brps <= 32) /* max of brdv is 32 */
|
2009-11-26 04:10:05 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-01-29 23:11:54 -07:00
|
|
|
k = min_t(int, k, ARRAY_SIZE(sh_msiof_spi_div_table) - 1);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2015-01-29 23:11:54 -07:00
|
|
|
scr = sh_msiof_spi_div_table[k].brdv | SCR_BRPS(brps);
|
|
|
|
sh_msiof_write(p, TSCR, scr);
|
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
|
|
|
if (!(p->chipdata->master_flags & SPI_MASTER_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;
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p,
|
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);
|
2014-02-20 07:43:03 -07:00
|
|
|
sh_msiof_write(p, TMDR1, tmp | MDR1_TRMD | TMDR1_PCON);
|
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
|
|
|
if (p->chipdata->master_flags & SPI_MASTER_MUST_TX) {
|
|
|
|
/* 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
|
|
|
|
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
|
|
|
if (tx_buf || (p->chipdata->master_flags & SPI_MASTER_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)
|
|
|
|
{
|
|
|
|
sh_msiof_write(p, STR, sh_msiof_read(p, STR));
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2014-02-20 07:43:04 -07:00
|
|
|
struct device_node *np = spi->master->dev.of_node;
|
2014-02-25 03:21:11 -07:00
|
|
|
struct sh_msiof_spi_priv *p = spi_master_get_devdata(spi->master);
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-12-15 07:01:11 -07:00
|
|
|
pm_runtime_get_sync(&p->pdev->dev);
|
|
|
|
|
2014-02-20 07:43:04 -07:00
|
|
|
if (!np) {
|
|
|
|
/*
|
|
|
|
* Use spi->controller_data for CS (same strategy as spi_gpio),
|
|
|
|
* if any. otherwise let HW control CS
|
|
|
|
*/
|
|
|
|
spi->cs_gpio = (uintptr_t)spi->controller_data;
|
|
|
|
}
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:11 -07:00
|
|
|
/* Configure pins before deasserting CS */
|
|
|
|
sh_msiof_spi_set_pin_regs(p, !!(spi->mode & SPI_CPOL),
|
|
|
|
!!(spi->mode & SPI_CPHA),
|
|
|
|
!!(spi->mode & SPI_3WIRE),
|
|
|
|
!!(spi->mode & SPI_LSB_FIRST),
|
|
|
|
!!(spi->mode & SPI_CS_HIGH));
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:13 -07:00
|
|
|
if (spi->cs_gpio >= 0)
|
|
|
|
gpio_set_value(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-12-15 07:01:11 -07:00
|
|
|
|
2015-01-07 08:37:25 -07:00
|
|
|
pm_runtime_put(&p->pdev->dev);
|
2014-12-15 07:01:11 -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:11 -07:00
|
|
|
static int sh_msiof_prepare_message(struct spi_master *master,
|
|
|
|
struct spi_message *msg)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2014-02-25 03:21:11 -07:00
|
|
|
struct sh_msiof_spi_priv *p = spi_master_get_devdata(master);
|
|
|
|
const struct spi_device *spi = msg->spi;
|
2009-11-26 04:10:05 -07:00
|
|
|
|
2014-02-25 03:21:11 -07:00
|
|
|
/* Configure pins before asserting CS */
|
|
|
|
sh_msiof_spi_set_pin_regs(p, !!(spi->mode & SPI_CPOL),
|
|
|
|
!!(spi->mode & SPI_CPHA),
|
|
|
|
!!(spi->mode & SPI_3WIRE),
|
|
|
|
!!(spi->mode & SPI_LSB_FIRST),
|
|
|
|
!!(spi->mode & SPI_CS_HIGH));
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* setup clock and rx/tx signals */
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, 0, CTR_TSCKE);
|
|
|
|
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 */
|
|
|
|
if (!ret)
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* shut down frame, rx/tx and clock signals */
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_TFSE, 0);
|
|
|
|
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);
|
|
|
|
if (!ret)
|
|
|
|
ret = sh_msiof_modify_ctr_wait(p, CTR_TSCKE, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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);
|
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 */
|
2015-02-02 01:30:34 -07:00
|
|
|
if (!wait_for_completion_timeout(&p->done, HZ)) {
|
2014-06-20 04:16:18 -06:00
|
|
|
dev_err(&p->pdev->dev, "PIO timeout\n");
|
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct sh_msiof_spi_priv *p = arg;
|
|
|
|
|
|
|
|
sh_msiof_write(p, IER, 0);
|
|
|
|
complete(&p->done);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
desc_rx = dmaengine_prep_slave_single(p->master->dma_rx,
|
|
|
|
p->rx_dma_addr, len, DMA_FROM_DEVICE,
|
|
|
|
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;
|
|
|
|
desc_rx->callback_param = p;
|
|
|
|
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;
|
|
|
|
dma_sync_single_for_device(p->master->dma_tx->device->dev,
|
|
|
|
p->tx_dma_addr, len, DMA_TO_DEVICE);
|
|
|
|
desc_tx = dmaengine_prep_slave_single(p->master->dma_tx,
|
|
|
|
p->tx_dma_addr, len, DMA_TO_DEVICE,
|
|
|
|
DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
|
|
|
|
if (!desc_tx) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
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
|
|
|
if (rx) {
|
|
|
|
/* No callback */
|
|
|
|
desc_tx->callback = NULL;
|
|
|
|
} else {
|
|
|
|
desc_tx->callback = sh_msiof_dma_complete;
|
|
|
|
desc_tx->callback_param = p;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
|
|
/* Now start DMA */
|
|
|
|
if (rx)
|
2014-08-07 06:07:43 -06:00
|
|
|
dma_async_issue_pending(p->master->dma_rx);
|
|
|
|
if (tx)
|
2014-08-06 06:59:03 -06:00
|
|
|
dma_async_issue_pending(p->master->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
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
/* wait for tx fifo to be emptied / rx fifo to be filled */
|
2015-02-02 01:30:34 -07:00
|
|
|
if (!wait_for_completion_timeout(&p->done, 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
|
|
|
dev_err(&p->pdev->dev, "DMA timeout\n");
|
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto stop_reset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)
|
2014-07-11 09:56:22 -06:00
|
|
|
dma_sync_single_for_cpu(p->master->dma_rx->device->dev,
|
|
|
|
p->rx_dma_addr, len,
|
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);
|
|
|
|
|
|
|
|
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)
|
|
|
|
dmaengine_terminate_all(p->master->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)
|
|
|
|
dmaengine_terminate_all(p->master->dma_rx);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2014-02-25 03:21:13 -07:00
|
|
|
static int sh_msiof_transfer_one(struct spi_master *master,
|
|
|
|
struct spi_device *spi,
|
|
|
|
struct spi_transfer *t)
|
2009-11-26 04:10:05 -07:00
|
|
|
{
|
2014-02-25 03:21:13 -07:00
|
|
|
struct sh_msiof_spi_priv *p = spi_master_get_devdata(master);
|
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;
|
|
|
|
|
|
|
|
/* setup clocks (clock already enabled in chipselect()) */
|
|
|
|
sh_msiof_spi_set_clk_regs(p, clk_get_rate(p->clk), t->speed_hz);
|
|
|
|
|
|
|
|
while (master->dma_tx && len > 15) {
|
|
|
|
/*
|
|
|
|
* DMA supports 32-bit words only, hence pack 8-bit and 16-bit
|
|
|
|
* words, with byte resp. word swapping.
|
|
|
|
*/
|
|
|
|
unsigned int l = min(len, MAX_WDLEN * 4);
|
|
|
|
|
|
|
|
if (bits <= 8) {
|
|
|
|
if (l & 3)
|
|
|
|
break;
|
|
|
|
copy32 = copy_bswap32;
|
|
|
|
} else if (bits <= 16) {
|
|
|
|
if (l & 1)
|
|
|
|
break;
|
|
|
|
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) {
|
|
|
|
pr_warn_once("%s %s: DMA not available, falling back to PIO\n",
|
|
|
|
dev_driver_string(&p->pdev->dev),
|
|
|
|
dev_name(&p->pdev->dev));
|
|
|
|
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
|
|
|
|
2014-06-20 04:16:19 -06:00
|
|
|
if (bits <= 8 && len > 15 && !(len & 3)) {
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-25 03:21:09 -07:00
|
|
|
static const struct sh_msiof_chipdata sh_data = {
|
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 64,
|
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
|
|
|
.master_flags = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sh_msiof_chipdata r8a779x_data = {
|
|
|
|
.tx_fifo_size = 64,
|
|
|
|
.rx_fifo_size = 256,
|
|
|
|
.master_flags = SPI_MASTER_MUST_TX,
|
2014-02-25 03:21:09 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id sh_msiof_match[] = {
|
|
|
|
{ .compatible = "renesas,sh-msiof", .data = &sh_data },
|
|
|
|
{ .compatible = "renesas,sh-mobile-msiof", .data = &sh_data },
|
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
|
|
|
{ .compatible = "renesas,msiof-r8a7790", .data = &r8a779x_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7791", .data = &r8a779x_data },
|
2014-08-28 02:11:03 -06:00
|
|
|
{ .compatible = "renesas,msiof-r8a7792", .data = &r8a779x_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7793", .data = &r8a779x_data },
|
|
|
|
{ .compatible = "renesas,msiof-r8a7794", .data = &r8a779x_data },
|
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;
|
|
|
|
|
|
|
|
/* Parse the MSIOF properties */
|
|
|
|
of_property_read_u32(np, "num-cs", &num_cs);
|
|
|
|
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;
|
|
|
|
const struct sh_msiof_spi_info *info = dev_get_platdata(dev);
|
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;
|
|
|
|
struct spi_master *master;
|
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);
|
|
|
|
|
|
|
|
master = p->master;
|
|
|
|
master->dma_tx = sh_msiof_request_dma_chan(dev, DMA_MEM_TO_DEV,
|
2014-08-06 06:59:05 -06:00
|
|
|
dma_tx_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
|
|
|
res->start + TFDR);
|
|
|
|
if (!master->dma_tx)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
master->dma_rx = sh_msiof_request_dma_chan(dev, DMA_DEV_TO_MEM,
|
2014-08-06 06:59:05 -06:00
|
|
|
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
|
|
|
res->start + RFDR);
|
|
|
|
if (!master->dma_rx)
|
|
|
|
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;
|
|
|
|
|
2014-07-11 09:56:22 -06:00
|
|
|
tx_dev = master->dma_tx->device->dev;
|
|
|
|
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;
|
|
|
|
|
2014-07-11 09:56:22 -06:00
|
|
|
rx_dev = master->dma_rx->device->dev;
|
|
|
|
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:
|
|
|
|
dma_release_channel(master->dma_rx);
|
|
|
|
free_tx_chan:
|
|
|
|
dma_release_channel(master->dma_tx);
|
|
|
|
master->dma_tx = NULL;
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_msiof_release_dma(struct sh_msiof_spi_priv *p)
|
|
|
|
{
|
|
|
|
struct spi_master *master = p->master;
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
if (!master->dma_tx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = &p->pdev->dev;
|
2014-07-11 09:56:22 -06:00
|
|
|
dma_unmap_single(master->dma_rx->device->dev, p->rx_dma_addr,
|
|
|
|
PAGE_SIZE, DMA_FROM_DEVICE);
|
|
|
|
dma_unmap_single(master->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);
|
|
|
|
dma_release_channel(master->dma_rx);
|
|
|
|
dma_release_channel(master->dma_tx);
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
static int sh_msiof_spi_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct resource *r;
|
|
|
|
struct spi_master *master;
|
2014-02-25 03:21:09 -07:00
|
|
|
const struct of_device_id *of_id;
|
2009-11-26 04:10:05 -07:00
|
|
|
struct sh_msiof_spi_priv *p;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
master = spi_alloc_master(&pdev->dev, sizeof(struct sh_msiof_spi_priv));
|
|
|
|
if (master == NULL) {
|
|
|
|
dev_err(&pdev->dev, "failed to allocate spi master\n");
|
2013-11-27 18:39:42 -07:00
|
|
|
return -ENOMEM;
|
2009-11-26 04:10:05 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
p = spi_master_get_devdata(master);
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, 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
|
|
|
p->master = master;
|
2014-02-25 03:21:09 -07:00
|
|
|
|
|
|
|
of_id = of_match_device(sh_msiof_match, &pdev->dev);
|
|
|
|
if (of_id) {
|
|
|
|
p->chipdata = of_id->data;
|
2012-12-12 04:54:48 -07:00
|
|
|
p->info = sh_msiof_spi_parse_dt(&pdev->dev);
|
2014-02-25 03:21:09 -07:00
|
|
|
} else {
|
|
|
|
p->chipdata = (const void *)pdev->id_entry->driver_data;
|
2013-07-30 01:58:59 -06:00
|
|
|
p->info = dev_get_platdata(&pdev->dev);
|
2014-02-25 03:21:09 -07:00
|
|
|
}
|
2012-12-12 04:54:48 -07:00
|
|
|
|
|
|
|
if (!p->info) {
|
|
|
|
dev_err(&pdev->dev, "failed to obtain device info\n");
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
2009-11-26 04:10:05 -07:00
|
|
|
init_completion(&p->done);
|
|
|
|
|
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) {
|
|
|
|
dev_err(&pdev->dev, "cannot get platform IRQ\n");
|
2009-11-26 04:10:05 -07:00
|
|
|
ret = -ENOENT;
|
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
|
|
|
|
|
|
|
r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
p->mapbase = devm_ioremap_resource(&pdev->dev, r);
|
|
|
|
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 */
|
2014-02-25 03:21:09 -07:00
|
|
|
p->tx_fifo_size = p->chipdata->tx_fifo_size;
|
|
|
|
p->rx_fifo_size = p->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;
|
|
|
|
|
2014-02-25 03:21:13 -07:00
|
|
|
/* init master code */
|
2009-11-26 04:10:05 -07:00
|
|
|
master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
|
|
|
|
master->mode_bits |= SPI_LSB_FIRST | SPI_3WIRE;
|
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
|
|
|
master->flags = p->chipdata->master_flags;
|
2009-11-26 04:10:05 -07:00
|
|
|
master->bus_num = pdev->id;
|
2014-02-20 07:43:00 -07:00
|
|
|
master->dev.of_node = pdev->dev.of_node;
|
2009-11-26 04:10:05 -07:00
|
|
|
master->num_chipselect = p->info->num_chipselect;
|
2014-02-20 07:43:04 -07:00
|
|
|
master->setup = sh_msiof_spi_setup;
|
2014-02-25 03:21:11 -07:00
|
|
|
master->prepare_message = sh_msiof_prepare_message;
|
2014-02-25 03:21:12 -07:00
|
|
|
master->bits_per_word_mask = SPI_BPW_RANGE_MASK(8, 32);
|
2014-03-11 03:59:11 -06:00
|
|
|
master->auto_runtime_pm = true;
|
2014-02-25 03:21:13 -07:00
|
|
|
master->transfer_one = sh_msiof_transfer_one;
|
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");
|
|
|
|
|
2014-02-25 03:21:13 -07:00
|
|
|
ret = devm_spi_register_master(&pdev->dev, master);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&pdev->dev, "spi_register_master error.\n");
|
|
|
|
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:
|
|
|
|
spi_master_put(master);
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-02-25 03:21:09 -07:00
|
|
|
static struct platform_device_id spi_driver_ids[] = {
|
|
|
|
{ "spi_sh_msiof", (kernel_ulong_t)&sh_data },
|
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
|
|
|
{ "spi_r8a7790_msiof", (kernel_ulong_t)&r8a779x_data },
|
|
|
|
{ "spi_r8a7791_msiof", (kernel_ulong_t)&r8a779x_data },
|
2014-08-28 02:11:03 -06:00
|
|
|
{ "spi_r8a7792_msiof", (kernel_ulong_t)&r8a779x_data },
|
|
|
|
{ "spi_r8a7793_msiof", (kernel_ulong_t)&r8a779x_data },
|
|
|
|
{ "spi_r8a7794_msiof", (kernel_ulong_t)&r8a779x_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
|
|
|
|
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",
|
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
|
|
|
|
|
|
|
MODULE_DESCRIPTION("SuperH MSIOF SPI Master Interface Driver");
|
|
|
|
MODULE_AUTHOR("Magnus Damm");
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
|
|
MODULE_ALIAS("platform:spi_sh_msiof");
|