4 * Copyright (C) 2012, 2013 Renesas Solutions Corp.
5 * Copyright (C) 2014 Glider bvba
8 * Copyright (C) 2011 Renesas Solutions Corp.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/sched.h>
28 #include <linux/errno.h>
29 #include <linux/interrupt.h>
30 #include <linux/platform_device.h>
32 #include <linux/clk.h>
33 #include <linux/dmaengine.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/of_device.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/sh_dma.h>
38 #include <linux/spi/spi.h>
39 #include <linux/spi/rspi.h>
41 #define RSPI_SPCR 0x00 /* Control Register */
42 #define RSPI_SSLP 0x01 /* Slave Select Polarity Register */
43 #define RSPI_SPPCR 0x02 /* Pin Control Register */
44 #define RSPI_SPSR 0x03 /* Status Register */
45 #define RSPI_SPDR 0x04 /* Data Register */
46 #define RSPI_SPSCR 0x08 /* Sequence Control Register */
47 #define RSPI_SPSSR 0x09 /* Sequence Status Register */
48 #define RSPI_SPBR 0x0a /* Bit Rate Register */
49 #define RSPI_SPDCR 0x0b /* Data Control Register */
50 #define RSPI_SPCKD 0x0c /* Clock Delay Register */
51 #define RSPI_SSLND 0x0d /* Slave Select Negation Delay Register */
52 #define RSPI_SPND 0x0e /* Next-Access Delay Register */
53 #define RSPI_SPCR2 0x0f /* Control Register 2 (SH only) */
54 #define RSPI_SPCMD0 0x10 /* Command Register 0 */
55 #define RSPI_SPCMD1 0x12 /* Command Register 1 */
56 #define RSPI_SPCMD2 0x14 /* Command Register 2 */
57 #define RSPI_SPCMD3 0x16 /* Command Register 3 */
58 #define RSPI_SPCMD4 0x18 /* Command Register 4 */
59 #define RSPI_SPCMD5 0x1a /* Command Register 5 */
60 #define RSPI_SPCMD6 0x1c /* Command Register 6 */
61 #define RSPI_SPCMD7 0x1e /* Command Register 7 */
62 #define RSPI_SPCMD(i) (RSPI_SPCMD0 + (i) * 2)
63 #define RSPI_NUM_SPCMD 8
64 #define RSPI_RZ_NUM_SPCMD 4
65 #define QSPI_NUM_SPCMD 4
68 #define RSPI_SPBFCR 0x20 /* Buffer Control Register */
69 #define RSPI_SPBFDR 0x22 /* Buffer Data Count Setting Register */
72 #define QSPI_SPBFCR 0x18 /* Buffer Control Register */
73 #define QSPI_SPBDCR 0x1a /* Buffer Data Count Register */
74 #define QSPI_SPBMUL0 0x1c /* Transfer Data Length Multiplier Setting Register 0 */
75 #define QSPI_SPBMUL1 0x20 /* Transfer Data Length Multiplier Setting Register 1 */
76 #define QSPI_SPBMUL2 0x24 /* Transfer Data Length Multiplier Setting Register 2 */
77 #define QSPI_SPBMUL3 0x28 /* Transfer Data Length Multiplier Setting Register 3 */
78 #define QSPI_SPBMUL(i) (QSPI_SPBMUL0 + (i) * 4)
80 /* SPCR - Control Register */
81 #define SPCR_SPRIE 0x80 /* Receive Interrupt Enable */
82 #define SPCR_SPE 0x40 /* Function Enable */
83 #define SPCR_SPTIE 0x20 /* Transmit Interrupt Enable */
84 #define SPCR_SPEIE 0x10 /* Error Interrupt Enable */
85 #define SPCR_MSTR 0x08 /* Master/Slave Mode Select */
86 #define SPCR_MODFEN 0x04 /* Mode Fault Error Detection Enable */
88 #define SPCR_TXMD 0x02 /* TX Only Mode (vs. Full Duplex) */
89 #define SPCR_SPMS 0x01 /* 3-wire Mode (vs. 4-wire) */
90 /* QSPI on R-Car M2 only */
91 #define SPCR_WSWAP 0x02 /* Word Swap of read-data for DMAC */
92 #define SPCR_BSWAP 0x01 /* Byte Swap of read-data for DMAC */
94 /* SSLP - Slave Select Polarity Register */
95 #define SSLP_SSL1P 0x02 /* SSL1 Signal Polarity Setting */
96 #define SSLP_SSL0P 0x01 /* SSL0 Signal Polarity Setting */
98 /* SPPCR - Pin Control Register */
99 #define SPPCR_MOIFE 0x20 /* MOSI Idle Value Fixing Enable */
100 #define SPPCR_MOIFV 0x10 /* MOSI Idle Fixed Value */
101 #define SPPCR_SPOM 0x04
102 #define SPPCR_SPLP2 0x02 /* Loopback Mode 2 (non-inverting) */
103 #define SPPCR_SPLP 0x01 /* Loopback Mode (inverting) */
105 #define SPPCR_IO3FV 0x04 /* Single-/Dual-SPI Mode IO3 Output Fixed Value */
106 #define SPPCR_IO2FV 0x04 /* Single-/Dual-SPI Mode IO2 Output Fixed Value */
108 /* SPSR - Status Register */
109 #define SPSR_SPRF 0x80 /* Receive Buffer Full Flag */
110 #define SPSR_TEND 0x40 /* Transmit End */
111 #define SPSR_SPTEF 0x20 /* Transmit Buffer Empty Flag */
112 #define SPSR_PERF 0x08 /* Parity Error Flag */
113 #define SPSR_MODF 0x04 /* Mode Fault Error Flag */
114 #define SPSR_IDLNF 0x02 /* RSPI Idle Flag */
115 #define SPSR_OVRF 0x01 /* Overrun Error Flag (RSPI only) */
117 /* SPSCR - Sequence Control Register */
118 #define SPSCR_SPSLN_MASK 0x07 /* Sequence Length Specification */
120 /* SPSSR - Sequence Status Register */
121 #define SPSSR_SPECM_MASK 0x70 /* Command Error Mask */
122 #define SPSSR_SPCP_MASK 0x07 /* Command Pointer Mask */
124 /* SPDCR - Data Control Register */
125 #define SPDCR_TXDMY 0x80 /* Dummy Data Transmission Enable */
126 #define SPDCR_SPLW1 0x40 /* Access Width Specification (RZ) */
127 #define SPDCR_SPLW0 0x20 /* Access Width Specification (RZ) */
128 #define SPDCR_SPLLWORD (SPDCR_SPLW1 | SPDCR_SPLW0)
129 #define SPDCR_SPLWORD SPDCR_SPLW1
130 #define SPDCR_SPLBYTE SPDCR_SPLW0
131 #define SPDCR_SPLW 0x20 /* Access Width Specification (SH) */
132 #define SPDCR_SPRDTD 0x10 /* Receive Transmit Data Select (SH) */
133 #define SPDCR_SLSEL1 0x08
134 #define SPDCR_SLSEL0 0x04
135 #define SPDCR_SLSEL_MASK 0x0c /* SSL1 Output Select (SH) */
136 #define SPDCR_SPFC1 0x02
137 #define SPDCR_SPFC0 0x01
138 #define SPDCR_SPFC_MASK 0x03 /* Frame Count Setting (1-4) (SH) */
140 /* SPCKD - Clock Delay Register */
141 #define SPCKD_SCKDL_MASK 0x07 /* Clock Delay Setting (1-8) */
143 /* SSLND - Slave Select Negation Delay Register */
144 #define SSLND_SLNDL_MASK 0x07 /* SSL Negation Delay Setting (1-8) */
146 /* SPND - Next-Access Delay Register */
147 #define SPND_SPNDL_MASK 0x07 /* Next-Access Delay Setting (1-8) */
149 /* SPCR2 - Control Register 2 */
150 #define SPCR2_PTE 0x08 /* Parity Self-Test Enable */
151 #define SPCR2_SPIE 0x04 /* Idle Interrupt Enable */
152 #define SPCR2_SPOE 0x02 /* Odd Parity Enable (vs. Even) */
153 #define SPCR2_SPPE 0x01 /* Parity Enable */
155 /* SPCMDn - Command Registers */
156 #define SPCMD_SCKDEN 0x8000 /* Clock Delay Setting Enable */
157 #define SPCMD_SLNDEN 0x4000 /* SSL Negation Delay Setting Enable */
158 #define SPCMD_SPNDEN 0x2000 /* Next-Access Delay Enable */
159 #define SPCMD_LSBF 0x1000 /* LSB First */
160 #define SPCMD_SPB_MASK 0x0f00 /* Data Length Setting */
161 #define SPCMD_SPB_8_TO_16(bit) (((bit - 1) << 8) & SPCMD_SPB_MASK)
162 #define SPCMD_SPB_8BIT 0x0000 /* QSPI only */
163 #define SPCMD_SPB_16BIT 0x0100
164 #define SPCMD_SPB_20BIT 0x0000
165 #define SPCMD_SPB_24BIT 0x0100
166 #define SPCMD_SPB_32BIT 0x0200
167 #define SPCMD_SSLKP 0x0080 /* SSL Signal Level Keeping */
168 #define SPCMD_SPIMOD_MASK 0x0060 /* SPI Operating Mode (QSPI only) */
169 #define SPCMD_SPIMOD1 0x0040
170 #define SPCMD_SPIMOD0 0x0020
171 #define SPCMD_SPIMOD_SINGLE 0
172 #define SPCMD_SPIMOD_DUAL SPCMD_SPIMOD0
173 #define SPCMD_SPIMOD_QUAD SPCMD_SPIMOD1
174 #define SPCMD_SPRW 0x0010 /* SPI Read/Write Access (Dual/Quad) */
175 #define SPCMD_SSLA_MASK 0x0030 /* SSL Assert Signal Setting (RSPI) */
176 #define SPCMD_BRDV_MASK 0x000c /* Bit Rate Division Setting */
177 #define SPCMD_CPOL 0x0002 /* Clock Polarity Setting */
178 #define SPCMD_CPHA 0x0001 /* Clock Phase Setting */
180 /* SPBFCR - Buffer Control Register */
181 #define SPBFCR_TXRST 0x80 /* Transmit Buffer Data Reset */
182 #define SPBFCR_RXRST 0x40 /* Receive Buffer Data Reset */
183 #define SPBFCR_TXTRG_MASK 0x30 /* Transmit Buffer Data Triggering Number */
184 #define SPBFCR_RXTRG_MASK 0x07 /* Receive Buffer Data Triggering Number */
189 struct spi_master
*master
;
190 wait_queue_head_t wait
;
196 const struct spi_ops
*ops
;
199 struct dma_chan
*chan_tx
;
200 struct dma_chan
*chan_rx
;
202 unsigned dma_callbacked
:1;
203 unsigned byte_access
:1;
206 static void rspi_write8(const struct rspi_data
*rspi
, u8 data
, u16 offset
)
208 iowrite8(data
, rspi
->addr
+ offset
);
211 static void rspi_write16(const struct rspi_data
*rspi
, u16 data
, u16 offset
)
213 iowrite16(data
, rspi
->addr
+ offset
);
216 static void rspi_write32(const struct rspi_data
*rspi
, u32 data
, u16 offset
)
218 iowrite32(data
, rspi
->addr
+ offset
);
221 static u8
rspi_read8(const struct rspi_data
*rspi
, u16 offset
)
223 return ioread8(rspi
->addr
+ offset
);
226 static u16
rspi_read16(const struct rspi_data
*rspi
, u16 offset
)
228 return ioread16(rspi
->addr
+ offset
);
231 static void rspi_write_data(const struct rspi_data
*rspi
, u16 data
)
233 if (rspi
->byte_access
)
234 rspi_write8(rspi
, data
, RSPI_SPDR
);
236 rspi_write16(rspi
, data
, RSPI_SPDR
);
239 static u16
rspi_read_data(const struct rspi_data
*rspi
)
241 if (rspi
->byte_access
)
242 return rspi_read8(rspi
, RSPI_SPDR
);
244 return rspi_read16(rspi
, RSPI_SPDR
);
247 /* optional functions */
249 int (*set_config_register
)(struct rspi_data
*rspi
, int access_size
);
250 int (*transfer_one
)(struct spi_master
*master
, struct spi_device
*spi
,
251 struct spi_transfer
*xfer
);
257 * functions for RSPI on legacy SH
259 static int rspi_set_config_register(struct rspi_data
*rspi
, int access_size
)
263 /* Sets output mode, MOSI signal, and (optionally) loopback */
264 rspi_write8(rspi
, rspi
->sppcr
, RSPI_SPPCR
);
266 /* Sets transfer bit rate */
267 spbr
= DIV_ROUND_UP(clk_get_rate(rspi
->clk
),
268 2 * rspi
->max_speed_hz
) - 1;
269 rspi_write8(rspi
, clamp(spbr
, 0, 255), RSPI_SPBR
);
271 /* Disable dummy transmission, set 16-bit word access, 1 frame */
272 rspi_write8(rspi
, 0, RSPI_SPDCR
);
273 rspi
->byte_access
= 0;
275 /* Sets RSPCK, SSL, next-access delay value */
276 rspi_write8(rspi
, 0x00, RSPI_SPCKD
);
277 rspi_write8(rspi
, 0x00, RSPI_SSLND
);
278 rspi_write8(rspi
, 0x00, RSPI_SPND
);
280 /* Sets parity, interrupt mask */
281 rspi_write8(rspi
, 0x00, RSPI_SPCR2
);
284 rspi
->spcmd
|= SPCMD_SPB_8_TO_16(access_size
);
285 rspi_write16(rspi
, rspi
->spcmd
, RSPI_SPCMD0
);
288 rspi_write8(rspi
, SPCR_MSTR
, RSPI_SPCR
);
294 * functions for RSPI on RZ
296 static int rspi_rz_set_config_register(struct rspi_data
*rspi
, int access_size
)
300 /* Sets output mode, MOSI signal, and (optionally) loopback */
301 rspi_write8(rspi
, rspi
->sppcr
, RSPI_SPPCR
);
303 /* Sets transfer bit rate */
304 spbr
= DIV_ROUND_UP(clk_get_rate(rspi
->clk
),
305 2 * rspi
->max_speed_hz
) - 1;
306 rspi_write8(rspi
, clamp(spbr
, 0, 255), RSPI_SPBR
);
308 /* Disable dummy transmission, set byte access */
309 rspi_write8(rspi
, SPDCR_SPLBYTE
, RSPI_SPDCR
);
310 rspi
->byte_access
= 1;
312 /* Sets RSPCK, SSL, next-access delay value */
313 rspi_write8(rspi
, 0x00, RSPI_SPCKD
);
314 rspi_write8(rspi
, 0x00, RSPI_SSLND
);
315 rspi_write8(rspi
, 0x00, RSPI_SPND
);
318 rspi
->spcmd
|= SPCMD_SPB_8_TO_16(access_size
);
319 rspi_write16(rspi
, rspi
->spcmd
, RSPI_SPCMD0
);
322 rspi_write8(rspi
, SPCR_MSTR
, RSPI_SPCR
);
330 static int qspi_set_config_register(struct rspi_data
*rspi
, int access_size
)
334 /* Sets output mode, MOSI signal, and (optionally) loopback */
335 rspi_write8(rspi
, rspi
->sppcr
, RSPI_SPPCR
);
337 /* Sets transfer bit rate */
338 spbr
= DIV_ROUND_UP(clk_get_rate(rspi
->clk
), 2 * rspi
->max_speed_hz
);
339 rspi_write8(rspi
, clamp(spbr
, 0, 255), RSPI_SPBR
);
341 /* Disable dummy transmission, set byte access */
342 rspi_write8(rspi
, 0, RSPI_SPDCR
);
343 rspi
->byte_access
= 1;
345 /* Sets RSPCK, SSL, next-access delay value */
346 rspi_write8(rspi
, 0x00, RSPI_SPCKD
);
347 rspi_write8(rspi
, 0x00, RSPI_SSLND
);
348 rspi_write8(rspi
, 0x00, RSPI_SPND
);
350 /* Data Length Setting */
351 if (access_size
== 8)
352 rspi
->spcmd
|= SPCMD_SPB_8BIT
;
353 else if (access_size
== 16)
354 rspi
->spcmd
|= SPCMD_SPB_16BIT
;
356 rspi
->spcmd
|= SPCMD_SPB_32BIT
;
358 rspi
->spcmd
|= SPCMD_SCKDEN
| SPCMD_SLNDEN
| SPCMD_SPNDEN
;
360 /* Resets transfer data length */
361 rspi_write32(rspi
, 0, QSPI_SPBMUL0
);
363 /* Resets transmit and receive buffer */
364 rspi_write8(rspi
, SPBFCR_TXRST
| SPBFCR_RXRST
, QSPI_SPBFCR
);
365 /* Sets buffer to allow normal operation */
366 rspi_write8(rspi
, 0x00, QSPI_SPBFCR
);
369 rspi_write16(rspi
, rspi
->spcmd
, RSPI_SPCMD0
);
371 /* Enables SPI function in master mode */
372 rspi_write8(rspi
, SPCR_SPE
| SPCR_MSTR
, RSPI_SPCR
);
377 #define set_config_register(spi, n) spi->ops->set_config_register(spi, n)
379 static void rspi_enable_irq(const struct rspi_data
*rspi
, u8 enable
)
381 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | enable
, RSPI_SPCR
);
384 static void rspi_disable_irq(const struct rspi_data
*rspi
, u8 disable
)
386 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~disable
, RSPI_SPCR
);
389 static int rspi_wait_for_interrupt(struct rspi_data
*rspi
, u8 wait_mask
,
394 rspi
->spsr
= rspi_read8(rspi
, RSPI_SPSR
);
395 if (rspi
->spsr
& wait_mask
)
398 rspi_enable_irq(rspi
, enable_bit
);
399 ret
= wait_event_timeout(rspi
->wait
, rspi
->spsr
& wait_mask
, HZ
);
400 if (ret
== 0 && !(rspi
->spsr
& wait_mask
))
406 static inline int rspi_wait_for_tx_empty(struct rspi_data
*rspi
)
408 return rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
);
411 static inline int rspi_wait_for_rx_full(struct rspi_data
*rspi
)
413 return rspi_wait_for_interrupt(rspi
, SPSR_SPRF
, SPCR_SPRIE
);
416 static int rspi_data_out(struct rspi_data
*rspi
, u8 data
)
418 int error
= rspi_wait_for_tx_empty(rspi
);
420 dev_err(&rspi
->master
->dev
, "transmit timeout\n");
423 rspi_write_data(rspi
, data
);
427 static int rspi_data_in(struct rspi_data
*rspi
)
432 error
= rspi_wait_for_rx_full(rspi
);
434 dev_err(&rspi
->master
->dev
, "receive timeout\n");
437 data
= rspi_read_data(rspi
);
441 static int rspi_pio_transfer(struct rspi_data
*rspi
, const u8
*tx
, u8
*rx
,
446 int ret
= rspi_data_out(rspi
, *tx
++);
451 int ret
= rspi_data_in(rspi
);
461 static void rspi_dma_complete(void *arg
)
463 struct rspi_data
*rspi
= arg
;
465 rspi
->dma_callbacked
= 1;
466 wake_up_interruptible(&rspi
->wait
);
469 static int rspi_dma_map_sg(struct scatterlist
*sg
, const void *buf
,
470 unsigned len
, struct dma_chan
*chan
,
471 enum dma_transfer_direction dir
)
473 sg_init_table(sg
, 1);
474 sg_set_buf(sg
, buf
, len
);
475 sg_dma_len(sg
) = len
;
476 return dma_map_sg(chan
->device
->dev
, sg
, 1, dir
);
479 static void rspi_dma_unmap_sg(struct scatterlist
*sg
, struct dma_chan
*chan
,
480 enum dma_transfer_direction dir
)
482 dma_unmap_sg(chan
->device
->dev
, sg
, 1, dir
);
485 static int rspi_send_dma(struct rspi_data
*rspi
, struct spi_transfer
*t
)
487 struct scatterlist sg
;
488 const void *buf
= t
->tx_buf
;
489 struct dma_async_tx_descriptor
*desc
;
490 unsigned int len
= t
->len
;
493 if (!rspi_dma_map_sg(&sg
, buf
, len
, rspi
->chan_tx
, DMA_TO_DEVICE
))
496 desc
= dmaengine_prep_slave_sg(rspi
->chan_tx
, &sg
, 1, DMA_TO_DEVICE
,
497 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
504 * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
505 * called. So, this driver disables the IRQ while DMA transfer.
507 disable_irq(rspi
->tx_irq
);
509 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | SPCR_TXMD
, RSPI_SPCR
);
510 rspi_enable_irq(rspi
, SPCR_SPTIE
);
511 rspi
->dma_callbacked
= 0;
513 desc
->callback
= rspi_dma_complete
;
514 desc
->callback_param
= rspi
;
515 dmaengine_submit(desc
);
516 dma_async_issue_pending(rspi
->chan_tx
);
518 ret
= wait_event_interruptible_timeout(rspi
->wait
,
519 rspi
->dma_callbacked
, HZ
);
520 if (ret
> 0 && rspi
->dma_callbacked
)
524 rspi_disable_irq(rspi
, SPCR_SPTIE
);
526 enable_irq(rspi
->tx_irq
);
529 rspi_dma_unmap_sg(&sg
, rspi
->chan_tx
, DMA_TO_DEVICE
);
533 static void rspi_receive_init(const struct rspi_data
*rspi
)
537 spsr
= rspi_read8(rspi
, RSPI_SPSR
);
538 if (spsr
& SPSR_SPRF
)
539 rspi_read_data(rspi
); /* dummy read */
540 if (spsr
& SPSR_OVRF
)
541 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPSR
) & ~SPSR_OVRF
,
545 static void rspi_rz_receive_init(const struct rspi_data
*rspi
)
547 rspi_receive_init(rspi
);
548 rspi_write8(rspi
, SPBFCR_TXRST
| SPBFCR_RXRST
, RSPI_SPBFCR
);
549 rspi_write8(rspi
, 0, RSPI_SPBFCR
);
552 static void qspi_receive_init(const struct rspi_data
*rspi
)
556 spsr
= rspi_read8(rspi
, RSPI_SPSR
);
557 if (spsr
& SPSR_SPRF
)
558 rspi_read_data(rspi
); /* dummy read */
559 rspi_write8(rspi
, SPBFCR_TXRST
| SPBFCR_RXRST
, QSPI_SPBFCR
);
560 rspi_write8(rspi
, 0, QSPI_SPBFCR
);
563 static int rspi_send_receive_dma(struct rspi_data
*rspi
, struct spi_transfer
*t
)
565 struct scatterlist sg_rx
, sg_tx
;
566 const void *tx_buf
= t
->tx_buf
;
567 void *rx_buf
= t
->rx_buf
;
568 struct dma_async_tx_descriptor
*desc_tx
, *desc_rx
;
569 unsigned int len
= t
->len
;
572 /* prepare transmit transfer */
573 if (!rspi_dma_map_sg(&sg_tx
, tx_buf
, len
, rspi
->chan_tx
,
577 desc_tx
= dmaengine_prep_slave_sg(rspi
->chan_tx
, &sg_tx
, 1,
578 DMA_TO_DEVICE
, DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
584 /* prepare receive transfer */
585 if (!rspi_dma_map_sg(&sg_rx
, rx_buf
, len
, rspi
->chan_rx
,
591 desc_rx
= dmaengine_prep_slave_sg(rspi
->chan_rx
, &sg_rx
, 1,
593 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
599 rspi_receive_init(rspi
);
602 * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
603 * called. So, this driver disables the IRQ while DMA transfer.
605 disable_irq(rspi
->tx_irq
);
606 if (rspi
->rx_irq
!= rspi
->tx_irq
)
607 disable_irq(rspi
->rx_irq
);
609 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~SPCR_TXMD
, RSPI_SPCR
);
610 rspi_enable_irq(rspi
, SPCR_SPTIE
| SPCR_SPRIE
);
611 rspi
->dma_callbacked
= 0;
613 desc_rx
->callback
= rspi_dma_complete
;
614 desc_rx
->callback_param
= rspi
;
615 dmaengine_submit(desc_rx
);
616 dma_async_issue_pending(rspi
->chan_rx
);
618 desc_tx
->callback
= NULL
; /* No callback */
619 dmaengine_submit(desc_tx
);
620 dma_async_issue_pending(rspi
->chan_tx
);
622 ret
= wait_event_interruptible_timeout(rspi
->wait
,
623 rspi
->dma_callbacked
, HZ
);
624 if (ret
> 0 && rspi
->dma_callbacked
)
628 rspi_disable_irq(rspi
, SPCR_SPTIE
| SPCR_SPRIE
);
630 enable_irq(rspi
->tx_irq
);
631 if (rspi
->rx_irq
!= rspi
->tx_irq
)
632 enable_irq(rspi
->rx_irq
);
635 rspi_dma_unmap_sg(&sg_rx
, rspi
->chan_rx
, DMA_FROM_DEVICE
);
637 rspi_dma_unmap_sg(&sg_tx
, rspi
->chan_tx
, DMA_TO_DEVICE
);
641 static int rspi_is_dma(const struct rspi_data
*rspi
, struct spi_transfer
*t
)
643 /* If the module receives data by DMAC, it also needs TX DMAC */
645 return rspi
->chan_tx
&& rspi
->chan_rx
;
653 static int rspi_transfer_out_in(struct rspi_data
*rspi
,
654 struct spi_transfer
*xfer
)
659 spcr
= rspi_read8(rspi
, RSPI_SPCR
);
661 rspi_receive_init(rspi
);
666 rspi_write8(rspi
, spcr
, RSPI_SPCR
);
668 ret
= rspi_pio_transfer(rspi
, xfer
->tx_buf
, xfer
->rx_buf
, xfer
->len
);
672 /* Wait for the last transmission */
673 rspi_wait_for_tx_empty(rspi
);
678 static int rspi_transfer_one(struct spi_master
*master
, struct spi_device
*spi
,
679 struct spi_transfer
*xfer
)
681 struct rspi_data
*rspi
= spi_master_get_devdata(master
);
683 if (!rspi_is_dma(rspi
, xfer
))
684 return rspi_transfer_out_in(rspi
, xfer
);
687 return rspi_send_receive_dma(rspi
, xfer
);
689 return rspi_send_dma(rspi
, xfer
);
692 static int rspi_rz_transfer_out_in(struct rspi_data
*rspi
,
693 struct spi_transfer
*xfer
)
697 rspi_rz_receive_init(rspi
);
699 ret
= rspi_pio_transfer(rspi
, xfer
->tx_buf
, xfer
->rx_buf
, xfer
->len
);
703 /* Wait for the last transmission */
704 rspi_wait_for_tx_empty(rspi
);
709 static int rspi_rz_transfer_one(struct spi_master
*master
,
710 struct spi_device
*spi
,
711 struct spi_transfer
*xfer
)
713 struct rspi_data
*rspi
= spi_master_get_devdata(master
);
715 return rspi_rz_transfer_out_in(rspi
, xfer
);
718 static int qspi_transfer_out_in(struct rspi_data
*rspi
,
719 struct spi_transfer
*xfer
)
723 qspi_receive_init(rspi
);
725 ret
= rspi_pio_transfer(rspi
, xfer
->tx_buf
, xfer
->rx_buf
, xfer
->len
);
729 /* Wait for the last transmission */
730 rspi_wait_for_tx_empty(rspi
);
735 static int qspi_transfer_out(struct rspi_data
*rspi
, struct spi_transfer
*xfer
)
739 ret
= rspi_pio_transfer(rspi
, xfer
->tx_buf
, NULL
, xfer
->len
);
743 /* Wait for the last transmission */
744 rspi_wait_for_tx_empty(rspi
);
749 static int qspi_transfer_in(struct rspi_data
*rspi
, struct spi_transfer
*xfer
)
751 return rspi_pio_transfer(rspi
, NULL
, xfer
->rx_buf
, xfer
->len
);
754 static int qspi_transfer_one(struct spi_master
*master
, struct spi_device
*spi
,
755 struct spi_transfer
*xfer
)
757 struct rspi_data
*rspi
= spi_master_get_devdata(master
);
759 if (spi
->mode
& SPI_LOOP
) {
760 return qspi_transfer_out_in(rspi
, xfer
);
761 } else if (xfer
->tx_nbits
> SPI_NBITS_SINGLE
) {
762 /* Quad or Dual SPI Write */
763 return qspi_transfer_out(rspi
, xfer
);
764 } else if (xfer
->rx_nbits
> SPI_NBITS_SINGLE
) {
765 /* Quad or Dual SPI Read */
766 return qspi_transfer_in(rspi
, xfer
);
768 /* Single SPI Transfer */
769 return qspi_transfer_out_in(rspi
, xfer
);
773 static int rspi_setup(struct spi_device
*spi
)
775 struct rspi_data
*rspi
= spi_master_get_devdata(spi
->master
);
777 rspi
->max_speed_hz
= spi
->max_speed_hz
;
779 rspi
->spcmd
= SPCMD_SSLKP
;
780 if (spi
->mode
& SPI_CPOL
)
781 rspi
->spcmd
|= SPCMD_CPOL
;
782 if (spi
->mode
& SPI_CPHA
)
783 rspi
->spcmd
|= SPCMD_CPHA
;
785 /* CMOS output mode and MOSI signal from previous transfer */
787 if (spi
->mode
& SPI_LOOP
)
788 rspi
->sppcr
|= SPPCR_SPLP
;
790 set_config_register(rspi
, 8);
795 static u16
qspi_transfer_mode(const struct spi_transfer
*xfer
)
798 switch (xfer
->tx_nbits
) {
800 return SPCMD_SPIMOD_QUAD
;
802 return SPCMD_SPIMOD_DUAL
;
807 switch (xfer
->rx_nbits
) {
809 return SPCMD_SPIMOD_QUAD
| SPCMD_SPRW
;
811 return SPCMD_SPIMOD_DUAL
| SPCMD_SPRW
;
819 static int qspi_setup_sequencer(struct rspi_data
*rspi
,
820 const struct spi_message
*msg
)
822 const struct spi_transfer
*xfer
;
823 unsigned int i
= 0, len
= 0;
824 u16 current_mode
= 0xffff, mode
;
826 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
827 mode
= qspi_transfer_mode(xfer
);
828 if (mode
== current_mode
) {
833 /* Transfer mode change */
835 /* Set transfer data length of previous transfer */
836 rspi_write32(rspi
, len
, QSPI_SPBMUL(i
- 1));
839 if (i
>= QSPI_NUM_SPCMD
) {
840 dev_err(&msg
->spi
->dev
,
841 "Too many different transfer modes");
845 /* Program transfer mode for this transfer */
846 rspi_write16(rspi
, rspi
->spcmd
| mode
, RSPI_SPCMD(i
));
852 /* Set final transfer data length and sequence length */
853 rspi_write32(rspi
, len
, QSPI_SPBMUL(i
- 1));
854 rspi_write8(rspi
, i
- 1, RSPI_SPSCR
);
860 static int rspi_prepare_message(struct spi_master
*master
,
861 struct spi_message
*msg
)
863 struct rspi_data
*rspi
= spi_master_get_devdata(master
);
867 (SPI_TX_DUAL
| SPI_TX_QUAD
| SPI_RX_DUAL
| SPI_RX_QUAD
)) {
868 /* Setup sequencer for messages with multiple transfer modes */
869 ret
= qspi_setup_sequencer(rspi
, msg
);
874 /* Enable SPI function in master mode */
875 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | SPCR_SPE
, RSPI_SPCR
);
879 static int rspi_unprepare_message(struct spi_master
*master
,
880 struct spi_message
*msg
)
882 struct rspi_data
*rspi
= spi_master_get_devdata(master
);
884 /* Disable SPI function */
885 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~SPCR_SPE
, RSPI_SPCR
);
887 /* Reset sequencer for Single SPI Transfers */
888 rspi_write16(rspi
, rspi
->spcmd
, RSPI_SPCMD0
);
889 rspi_write8(rspi
, 0, RSPI_SPSCR
);
893 static irqreturn_t
rspi_irq_mux(int irq
, void *_sr
)
895 struct rspi_data
*rspi
= _sr
;
897 irqreturn_t ret
= IRQ_NONE
;
900 rspi
->spsr
= spsr
= rspi_read8(rspi
, RSPI_SPSR
);
901 if (spsr
& SPSR_SPRF
)
902 disable_irq
|= SPCR_SPRIE
;
903 if (spsr
& SPSR_SPTEF
)
904 disable_irq
|= SPCR_SPTIE
;
908 rspi_disable_irq(rspi
, disable_irq
);
909 wake_up(&rspi
->wait
);
915 static irqreturn_t
rspi_irq_rx(int irq
, void *_sr
)
917 struct rspi_data
*rspi
= _sr
;
920 rspi
->spsr
= spsr
= rspi_read8(rspi
, RSPI_SPSR
);
921 if (spsr
& SPSR_SPRF
) {
922 rspi_disable_irq(rspi
, SPCR_SPRIE
);
923 wake_up(&rspi
->wait
);
930 static irqreturn_t
rspi_irq_tx(int irq
, void *_sr
)
932 struct rspi_data
*rspi
= _sr
;
935 rspi
->spsr
= spsr
= rspi_read8(rspi
, RSPI_SPSR
);
936 if (spsr
& SPSR_SPTEF
) {
937 rspi_disable_irq(rspi
, SPCR_SPTIE
);
938 wake_up(&rspi
->wait
);
945 static struct dma_chan
*rspi_request_dma_chan(struct device
*dev
,
946 enum dma_transfer_direction dir
,
948 dma_addr_t port_addr
)
951 struct dma_chan
*chan
;
952 struct dma_slave_config cfg
;
956 dma_cap_set(DMA_SLAVE
, mask
);
958 chan
= dma_request_channel(mask
, shdma_chan_filter
,
959 (void *)(unsigned long)id
);
961 dev_warn(dev
, "dma_request_channel failed\n");
965 memset(&cfg
, 0, sizeof(cfg
));
968 if (dir
== DMA_MEM_TO_DEV
)
969 cfg
.dst_addr
= port_addr
;
971 cfg
.src_addr
= port_addr
;
973 ret
= dmaengine_slave_config(chan
, &cfg
);
975 dev_warn(dev
, "dmaengine_slave_config failed %d\n", ret
);
976 dma_release_channel(chan
);
983 static int rspi_request_dma(struct rspi_data
*rspi
,
984 struct platform_device
*pdev
)
986 const struct rspi_plat_data
*rspi_pd
= dev_get_platdata(&pdev
->dev
);
987 struct resource
*res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
989 if (!res
|| !rspi_pd
)
990 return 0; /* The driver assumes no error. */
992 /* If the module receives data by DMAC, it also needs TX DMAC */
993 if (rspi_pd
->dma_rx_id
&& rspi_pd
->dma_tx_id
) {
994 rspi
->chan_rx
= rspi_request_dma_chan(&pdev
->dev
,
997 res
->start
+ RSPI_SPDR
);
1001 dev_info(&pdev
->dev
, "Use DMA when rx.\n");
1003 if (rspi_pd
->dma_tx_id
) {
1004 rspi
->chan_tx
= rspi_request_dma_chan(&pdev
->dev
,
1007 res
->start
+ RSPI_SPDR
);
1011 dev_info(&pdev
->dev
, "Use DMA when tx\n");
1017 static void rspi_release_dma(struct rspi_data
*rspi
)
1020 dma_release_channel(rspi
->chan_tx
);
1022 dma_release_channel(rspi
->chan_rx
);
1025 static int rspi_remove(struct platform_device
*pdev
)
1027 struct rspi_data
*rspi
= platform_get_drvdata(pdev
);
1029 rspi_release_dma(rspi
);
1030 pm_runtime_disable(&pdev
->dev
);
1035 static const struct spi_ops rspi_ops
= {
1036 .set_config_register
= rspi_set_config_register
,
1037 .transfer_one
= rspi_transfer_one
,
1038 .mode_bits
= SPI_CPHA
| SPI_CPOL
| SPI_LOOP
,
1039 .flags
= SPI_MASTER_MUST_TX
,
1042 static const struct spi_ops rspi_rz_ops
= {
1043 .set_config_register
= rspi_rz_set_config_register
,
1044 .transfer_one
= rspi_rz_transfer_one
,
1045 .mode_bits
= SPI_CPHA
| SPI_CPOL
| SPI_LOOP
,
1046 .flags
= SPI_MASTER_MUST_RX
| SPI_MASTER_MUST_TX
,
1049 static const struct spi_ops qspi_ops
= {
1050 .set_config_register
= qspi_set_config_register
,
1051 .transfer_one
= qspi_transfer_one
,
1052 .mode_bits
= SPI_CPHA
| SPI_CPOL
| SPI_LOOP
|
1053 SPI_TX_DUAL
| SPI_TX_QUAD
|
1054 SPI_RX_DUAL
| SPI_RX_QUAD
,
1055 .flags
= SPI_MASTER_MUST_RX
| SPI_MASTER_MUST_TX
,
1059 static const struct of_device_id rspi_of_match
[] = {
1060 /* RSPI on legacy SH */
1061 { .compatible
= "renesas,rspi", .data
= &rspi_ops
},
1062 /* RSPI on RZ/A1H */
1063 { .compatible
= "renesas,rspi-rz", .data
= &rspi_rz_ops
},
1064 /* QSPI on R-Car Gen2 */
1065 { .compatible
= "renesas,qspi", .data
= &qspi_ops
},
1069 MODULE_DEVICE_TABLE(of
, rspi_of_match
);
1071 static int rspi_parse_dt(struct device
*dev
, struct spi_master
*master
)
1076 /* Parse DT properties */
1077 error
= of_property_read_u32(dev
->of_node
, "num-cs", &num_cs
);
1079 dev_err(dev
, "of_property_read_u32 num-cs failed %d\n", error
);
1083 master
->num_chipselect
= num_cs
;
1087 #define rspi_of_match NULL
1088 static inline int rspi_parse_dt(struct device
*dev
, struct spi_master
*master
)
1092 #endif /* CONFIG_OF */
1094 static int rspi_request_irq(struct device
*dev
, unsigned int irq
,
1095 irq_handler_t handler
, const char *suffix
,
1098 const char *base
= dev_name(dev
);
1099 size_t len
= strlen(base
) + strlen(suffix
) + 2;
1100 char *name
= devm_kzalloc(dev
, len
, GFP_KERNEL
);
1103 snprintf(name
, len
, "%s:%s", base
, suffix
);
1104 return devm_request_irq(dev
, irq
, handler
, 0, name
, dev_id
);
1107 static int rspi_probe(struct platform_device
*pdev
)
1109 struct resource
*res
;
1110 struct spi_master
*master
;
1111 struct rspi_data
*rspi
;
1113 const struct of_device_id
*of_id
;
1114 const struct rspi_plat_data
*rspi_pd
;
1115 const struct spi_ops
*ops
;
1117 master
= spi_alloc_master(&pdev
->dev
, sizeof(struct rspi_data
));
1118 if (master
== NULL
) {
1119 dev_err(&pdev
->dev
, "spi_alloc_master error.\n");
1123 of_id
= of_match_device(rspi_of_match
, &pdev
->dev
);
1126 ret
= rspi_parse_dt(&pdev
->dev
, master
);
1130 ops
= (struct spi_ops
*)pdev
->id_entry
->driver_data
;
1131 rspi_pd
= dev_get_platdata(&pdev
->dev
);
1132 if (rspi_pd
&& rspi_pd
->num_chipselect
)
1133 master
->num_chipselect
= rspi_pd
->num_chipselect
;
1135 master
->num_chipselect
= 2; /* default */
1138 /* ops parameter check */
1139 if (!ops
->set_config_register
) {
1140 dev_err(&pdev
->dev
, "there is no set_config_register\n");
1145 rspi
= spi_master_get_devdata(master
);
1146 platform_set_drvdata(pdev
, rspi
);
1148 rspi
->master
= master
;
1150 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1151 rspi
->addr
= devm_ioremap_resource(&pdev
->dev
, res
);
1152 if (IS_ERR(rspi
->addr
)) {
1153 ret
= PTR_ERR(rspi
->addr
);
1157 rspi
->clk
= devm_clk_get(&pdev
->dev
, NULL
);
1158 if (IS_ERR(rspi
->clk
)) {
1159 dev_err(&pdev
->dev
, "cannot get clock\n");
1160 ret
= PTR_ERR(rspi
->clk
);
1164 pm_runtime_enable(&pdev
->dev
);
1166 init_waitqueue_head(&rspi
->wait
);
1168 master
->bus_num
= pdev
->id
;
1169 master
->setup
= rspi_setup
;
1170 master
->auto_runtime_pm
= true;
1171 master
->transfer_one
= ops
->transfer_one
;
1172 master
->prepare_message
= rspi_prepare_message
;
1173 master
->unprepare_message
= rspi_unprepare_message
;
1174 master
->mode_bits
= ops
->mode_bits
;
1175 master
->flags
= ops
->flags
;
1176 master
->dev
.of_node
= pdev
->dev
.of_node
;
1178 ret
= platform_get_irq_byname(pdev
, "rx");
1180 ret
= platform_get_irq_byname(pdev
, "mux");
1182 ret
= platform_get_irq(pdev
, 0);
1184 rspi
->rx_irq
= rspi
->tx_irq
= ret
;
1187 ret
= platform_get_irq_byname(pdev
, "tx");
1192 dev_err(&pdev
->dev
, "platform_get_irq error\n");
1196 if (rspi
->rx_irq
== rspi
->tx_irq
) {
1197 /* Single multiplexed interrupt */
1198 ret
= rspi_request_irq(&pdev
->dev
, rspi
->rx_irq
, rspi_irq_mux
,
1201 /* Multi-interrupt mode, only SPRI and SPTI are used */
1202 ret
= rspi_request_irq(&pdev
->dev
, rspi
->rx_irq
, rspi_irq_rx
,
1205 ret
= rspi_request_irq(&pdev
->dev
, rspi
->tx_irq
,
1206 rspi_irq_tx
, "tx", rspi
);
1209 dev_err(&pdev
->dev
, "request_irq error\n");
1213 ret
= rspi_request_dma(rspi
, pdev
);
1215 dev_warn(&pdev
->dev
, "DMA not available, using PIO\n");
1217 ret
= devm_spi_register_master(&pdev
->dev
, master
);
1219 dev_err(&pdev
->dev
, "spi_register_master error.\n");
1223 dev_info(&pdev
->dev
, "probed\n");
1228 rspi_release_dma(rspi
);
1230 pm_runtime_disable(&pdev
->dev
);
1232 spi_master_put(master
);
1237 static struct platform_device_id spi_driver_ids
[] = {
1238 { "rspi", (kernel_ulong_t
)&rspi_ops
},
1239 { "rspi-rz", (kernel_ulong_t
)&rspi_rz_ops
},
1240 { "qspi", (kernel_ulong_t
)&qspi_ops
},
1244 MODULE_DEVICE_TABLE(platform
, spi_driver_ids
);
1246 static struct platform_driver rspi_driver
= {
1247 .probe
= rspi_probe
,
1248 .remove
= rspi_remove
,
1249 .id_table
= spi_driver_ids
,
1251 .name
= "renesas_spi",
1252 .owner
= THIS_MODULE
,
1253 .of_match_table
= of_match_ptr(rspi_of_match
),
1256 module_platform_driver(rspi_driver
);
1258 MODULE_DESCRIPTION("Renesas RSPI bus driver");
1259 MODULE_LICENSE("GPL v2");
1260 MODULE_AUTHOR("Yoshihiro Shimoda");
1261 MODULE_ALIAS("platform:rspi");