4 * Copyright (C) 2012 Renesas Solutions Corp.
7 * Copyright (C) 2011 Renesas Solutions Corp.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/errno.h>
28 #include <linux/list.h>
29 #include <linux/workqueue.h>
30 #include <linux/interrupt.h>
31 #include <linux/platform_device.h>
33 #include <linux/clk.h>
34 #include <linux/dmaengine.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/sh_dma.h>
37 #include <linux/spi/spi.h>
38 #include <linux/spi/rspi.h>
40 #define RSPI_SPCR 0x00
41 #define RSPI_SSLP 0x01
42 #define RSPI_SPPCR 0x02
43 #define RSPI_SPSR 0x03
44 #define RSPI_SPDR 0x04
45 #define RSPI_SPSCR 0x08
46 #define RSPI_SPSSR 0x09
47 #define RSPI_SPBR 0x0a
48 #define RSPI_SPDCR 0x0b
49 #define RSPI_SPCKD 0x0c
50 #define RSPI_SSLND 0x0d
51 #define RSPI_SPND 0x0e
52 #define RSPI_SPCR2 0x0f
53 #define RSPI_SPCMD0 0x10
54 #define RSPI_SPCMD1 0x12
55 #define RSPI_SPCMD2 0x14
56 #define RSPI_SPCMD3 0x16
57 #define RSPI_SPCMD4 0x18
58 #define RSPI_SPCMD5 0x1a
59 #define RSPI_SPCMD6 0x1c
60 #define RSPI_SPCMD7 0x1e
63 #define QSPI_SPBFCR 0x18
64 #define QSPI_SPBDCR 0x1a
65 #define QSPI_SPBMUL0 0x1c
66 #define QSPI_SPBMUL1 0x20
67 #define QSPI_SPBMUL2 0x24
68 #define QSPI_SPBMUL3 0x28
71 #define SPCR_SPRIE 0x80
73 #define SPCR_SPTIE 0x20
74 #define SPCR_SPEIE 0x10
75 #define SPCR_MSTR 0x08
76 #define SPCR_MODFEN 0x04
77 #define SPCR_TXMD 0x02
78 #define SPCR_SPMS 0x01
81 #define SSLP_SSL1P 0x02
82 #define SSLP_SSL0P 0x01
85 #define SPPCR_MOIFE 0x20
86 #define SPPCR_MOIFV 0x10
87 #define SPPCR_SPOM 0x04
88 #define SPPCR_SPLP2 0x02
89 #define SPPCR_SPLP 0x01
92 #define SPSR_SPRF 0x80
93 #define SPSR_SPTEF 0x20
94 #define SPSR_PERF 0x08
95 #define SPSR_MODF 0x04
96 #define SPSR_IDLNF 0x02
97 #define SPSR_OVRF 0x01
100 #define SPSCR_SPSLN_MASK 0x07
103 #define SPSSR_SPECM_MASK 0x70
104 #define SPSSR_SPCP_MASK 0x07
107 #define SPDCR_SPLW 0x20
108 #define SPDCR_SPRDTD 0x10
109 #define SPDCR_SLSEL1 0x08
110 #define SPDCR_SLSEL0 0x04
111 #define SPDCR_SLSEL_MASK 0x0c
112 #define SPDCR_SPFC1 0x02
113 #define SPDCR_SPFC0 0x01
116 #define SPCKD_SCKDL_MASK 0x07
119 #define SSLND_SLNDL_MASK 0x07
122 #define SPND_SPNDL_MASK 0x07
125 #define SPCR2_PTE 0x08
126 #define SPCR2_SPIE 0x04
127 #define SPCR2_SPOE 0x02
128 #define SPCR2_SPPE 0x01
131 #define SPCMD_SCKDEN 0x8000
132 #define SPCMD_SLNDEN 0x4000
133 #define SPCMD_SPNDEN 0x2000
134 #define SPCMD_LSBF 0x1000
135 #define SPCMD_SPB_MASK 0x0f00
136 #define SPCMD_SPB_8_TO_16(bit) (((bit - 1) << 8) & SPCMD_SPB_MASK)
137 #define SPCMD_SPB_8BIT 0x0000 /* qspi only */
138 #define SPCMD_SPB_16BIT 0x0100
139 #define SPCMD_SPB_20BIT 0x0000
140 #define SPCMD_SPB_24BIT 0x0100
141 #define SPCMD_SPB_32BIT 0x0200
142 #define SPCMD_SSLKP 0x0080
143 #define SPCMD_SSLA_MASK 0x0030
144 #define SPCMD_BRDV_MASK 0x000c
145 #define SPCMD_CPOL 0x0002
146 #define SPCMD_CPHA 0x0001
149 #define SPBFCR_TXRST 0x80 /* qspi only */
150 #define SPBFCR_RXRST 0x40 /* qspi only */
155 struct spi_master
*master
;
156 struct list_head queue
;
157 struct work_struct ws
;
158 wait_queue_head_t wait
;
162 const struct spi_ops
*ops
;
165 struct dma_chan
*chan_tx
;
166 struct dma_chan
*chan_rx
;
169 unsigned dma_width_16bit
:1;
170 unsigned dma_callbacked
:1;
173 static void rspi_write8(const struct rspi_data
*rspi
, u8 data
, u16 offset
)
175 iowrite8(data
, rspi
->addr
+ offset
);
178 static void rspi_write16(const struct rspi_data
*rspi
, u16 data
, u16 offset
)
180 iowrite16(data
, rspi
->addr
+ offset
);
183 static void rspi_write32(const struct rspi_data
*rspi
, u32 data
, u16 offset
)
185 iowrite32(data
, rspi
->addr
+ offset
);
188 static u8
rspi_read8(const struct rspi_data
*rspi
, u16 offset
)
190 return ioread8(rspi
->addr
+ offset
);
193 static u16
rspi_read16(const struct rspi_data
*rspi
, u16 offset
)
195 return ioread16(rspi
->addr
+ offset
);
198 /* optional functions */
200 int (*set_config_register
)(const struct rspi_data
*rspi
,
202 int (*send_pio
)(struct rspi_data
*rspi
, struct spi_message
*mesg
,
203 struct spi_transfer
*t
);
204 int (*receive_pio
)(struct rspi_data
*rspi
, struct spi_message
*mesg
,
205 struct spi_transfer
*t
);
212 static int rspi_set_config_register(const struct rspi_data
*rspi
,
217 /* Sets output mode(CMOS) and MOSI signal(from previous transfer) */
218 rspi_write8(rspi
, 0x00, RSPI_SPPCR
);
220 /* Sets transfer bit rate */
221 spbr
= clk_get_rate(rspi
->clk
) / (2 * rspi
->max_speed_hz
) - 1;
222 rspi_write8(rspi
, clamp(spbr
, 0, 255), RSPI_SPBR
);
224 /* Sets number of frames to be used: 1 frame */
225 rspi_write8(rspi
, 0x00, RSPI_SPDCR
);
227 /* Sets RSPCK, SSL, next-access delay value */
228 rspi_write8(rspi
, 0x00, RSPI_SPCKD
);
229 rspi_write8(rspi
, 0x00, RSPI_SSLND
);
230 rspi_write8(rspi
, 0x00, RSPI_SPND
);
232 /* Sets parity, interrupt mask */
233 rspi_write8(rspi
, 0x00, RSPI_SPCR2
);
236 rspi_write16(rspi
, SPCMD_SPB_8_TO_16(access_size
) | SPCMD_SSLKP
,
240 rspi_write8(rspi
, SPCR_MSTR
, RSPI_SPCR
);
248 static int qspi_set_config_register(const struct rspi_data
*rspi
,
254 /* Sets output mode(CMOS) and MOSI signal(from previous transfer) */
255 rspi_write8(rspi
, 0x00, RSPI_SPPCR
);
257 /* Sets transfer bit rate */
258 spbr
= clk_get_rate(rspi
->clk
) / (2 * rspi
->max_speed_hz
);
259 rspi_write8(rspi
, clamp(spbr
, 0, 255), RSPI_SPBR
);
261 /* Sets number of frames to be used: 1 frame */
262 rspi_write8(rspi
, 0x00, RSPI_SPDCR
);
264 /* Sets RSPCK, SSL, next-access delay value */
265 rspi_write8(rspi
, 0x00, RSPI_SPCKD
);
266 rspi_write8(rspi
, 0x00, RSPI_SSLND
);
267 rspi_write8(rspi
, 0x00, RSPI_SPND
);
269 /* Data Length Setting */
270 if (access_size
== 8)
271 spcmd
= SPCMD_SPB_8BIT
;
272 else if (access_size
== 16)
273 spcmd
= SPCMD_SPB_16BIT
;
274 else if (access_size
== 32)
275 spcmd
= SPCMD_SPB_32BIT
;
277 spcmd
|= SPCMD_SCKDEN
| SPCMD_SLNDEN
| SPCMD_SSLKP
| SPCMD_SPNDEN
;
279 /* Resets transfer data length */
280 rspi_write32(rspi
, 0, QSPI_SPBMUL0
);
282 /* Resets transmit and receive buffer */
283 rspi_write8(rspi
, SPBFCR_TXRST
| SPBFCR_RXRST
, QSPI_SPBFCR
);
284 /* Sets buffer to allow normal operation */
285 rspi_write8(rspi
, 0x00, QSPI_SPBFCR
);
288 rspi_write16(rspi
, spcmd
, RSPI_SPCMD0
);
290 /* Enables SPI function in a master mode */
291 rspi_write8(rspi
, SPCR_SPE
| SPCR_MSTR
, RSPI_SPCR
);
296 #define set_config_register(spi, n) spi->ops->set_config_register(spi, n)
298 static void rspi_enable_irq(const struct rspi_data
*rspi
, u8 enable
)
300 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | enable
, RSPI_SPCR
);
303 static void rspi_disable_irq(const struct rspi_data
*rspi
, u8 disable
)
305 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~disable
, RSPI_SPCR
);
308 static int rspi_wait_for_interrupt(struct rspi_data
*rspi
, u8 wait_mask
,
313 rspi
->spsr
= rspi_read8(rspi
, RSPI_SPSR
);
314 rspi_enable_irq(rspi
, enable_bit
);
315 ret
= wait_event_timeout(rspi
->wait
, rspi
->spsr
& wait_mask
, HZ
);
316 if (ret
== 0 && !(rspi
->spsr
& wait_mask
))
322 static void rspi_assert_ssl(const struct rspi_data
*rspi
)
324 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | SPCR_SPE
, RSPI_SPCR
);
327 static void rspi_negate_ssl(const struct rspi_data
*rspi
)
329 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~SPCR_SPE
, RSPI_SPCR
);
332 static int rspi_send_pio(struct rspi_data
*rspi
, struct spi_message
*mesg
,
333 struct spi_transfer
*t
)
336 const u8
*data
= t
->tx_buf
;
338 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | SPCR_TXMD
,
341 if (rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
) < 0) {
342 dev_err(&rspi
->master
->dev
,
343 "%s: tx empty timeout\n", __func__
);
347 rspi_write16(rspi
, *data
, RSPI_SPDR
);
352 /* Waiting for the last transmition */
353 rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
);
358 static int qspi_send_pio(struct rspi_data
*rspi
, struct spi_message
*mesg
,
359 struct spi_transfer
*t
)
362 const u8
*data
= t
->tx_buf
;
364 rspi_write8(rspi
, SPBFCR_TXRST
, QSPI_SPBFCR
);
365 rspi_write8(rspi
, 0x00, QSPI_SPBFCR
);
369 if (rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
) < 0) {
370 dev_err(&rspi
->master
->dev
,
371 "%s: tx empty timeout\n", __func__
);
374 rspi_write8(rspi
, *data
++, RSPI_SPDR
);
376 if (rspi_wait_for_interrupt(rspi
, SPSR_SPRF
, SPCR_SPRIE
) < 0) {
377 dev_err(&rspi
->master
->dev
,
378 "%s: receive timeout\n", __func__
);
381 rspi_read8(rspi
, RSPI_SPDR
);
386 /* Waiting for the last transmition */
387 rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
);
392 #define send_pio(spi, mesg, t) spi->ops->send_pio(spi, mesg, t)
394 static void rspi_dma_complete(void *arg
)
396 struct rspi_data
*rspi
= arg
;
398 rspi
->dma_callbacked
= 1;
399 wake_up_interruptible(&rspi
->wait
);
402 static int rspi_dma_map_sg(struct scatterlist
*sg
, const void *buf
,
403 unsigned len
, struct dma_chan
*chan
,
404 enum dma_transfer_direction dir
)
406 sg_init_table(sg
, 1);
407 sg_set_buf(sg
, buf
, len
);
408 sg_dma_len(sg
) = len
;
409 return dma_map_sg(chan
->device
->dev
, sg
, 1, dir
);
412 static void rspi_dma_unmap_sg(struct scatterlist
*sg
, struct dma_chan
*chan
,
413 enum dma_transfer_direction dir
)
415 dma_unmap_sg(chan
->device
->dev
, sg
, 1, dir
);
418 static void rspi_memory_to_8bit(void *buf
, const void *data
, unsigned len
)
421 const u8
*src
= data
;
424 *dst
++ = (u16
)(*src
++);
429 static void rspi_memory_from_8bit(void *buf
, const void *data
, unsigned len
)
432 const u16
*src
= data
;
440 static int rspi_send_dma(struct rspi_data
*rspi
, struct spi_transfer
*t
)
442 struct scatterlist sg
;
443 const void *buf
= NULL
;
444 struct dma_async_tx_descriptor
*desc
;
448 if (rspi
->dma_width_16bit
) {
451 * If DMAC bus width is 16-bit, the driver allocates a dummy
452 * buffer. And, the driver converts original data into the
453 * DMAC data as the following format:
454 * original data: 1st byte, 2nd byte ...
455 * DMAC data: 1st byte, dummy, 2nd byte, dummy ...
458 tmp
= kmalloc(len
, GFP_KERNEL
);
461 rspi_memory_to_8bit(tmp
, t
->tx_buf
, t
->len
);
468 if (!rspi_dma_map_sg(&sg
, buf
, len
, rspi
->chan_tx
, DMA_TO_DEVICE
)) {
472 desc
= dmaengine_prep_slave_sg(rspi
->chan_tx
, &sg
, 1, DMA_TO_DEVICE
,
473 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
480 * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
481 * called. So, this driver disables the IRQ while DMA transfer.
483 disable_irq(rspi
->irq
);
485 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) | SPCR_TXMD
, RSPI_SPCR
);
486 rspi_enable_irq(rspi
, SPCR_SPTIE
);
487 rspi
->dma_callbacked
= 0;
489 desc
->callback
= rspi_dma_complete
;
490 desc
->callback_param
= rspi
;
491 dmaengine_submit(desc
);
492 dma_async_issue_pending(rspi
->chan_tx
);
494 ret
= wait_event_interruptible_timeout(rspi
->wait
,
495 rspi
->dma_callbacked
, HZ
);
496 if (ret
> 0 && rspi
->dma_callbacked
)
500 rspi_disable_irq(rspi
, SPCR_SPTIE
);
502 enable_irq(rspi
->irq
);
505 rspi_dma_unmap_sg(&sg
, rspi
->chan_tx
, DMA_TO_DEVICE
);
507 if (rspi
->dma_width_16bit
)
513 static void rspi_receive_init(const struct rspi_data
*rspi
)
517 spsr
= rspi_read8(rspi
, RSPI_SPSR
);
518 if (spsr
& SPSR_SPRF
)
519 rspi_read16(rspi
, RSPI_SPDR
); /* dummy read */
520 if (spsr
& SPSR_OVRF
)
521 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPSR
) & ~SPSR_OVRF
,
525 static int rspi_receive_pio(struct rspi_data
*rspi
, struct spi_message
*mesg
,
526 struct spi_transfer
*t
)
531 rspi_receive_init(rspi
);
535 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~SPCR_TXMD
,
538 if (rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
) < 0) {
539 dev_err(&rspi
->master
->dev
,
540 "%s: tx empty timeout\n", __func__
);
543 /* dummy write for generate clock */
544 rspi_write16(rspi
, 0x00, RSPI_SPDR
);
546 if (rspi_wait_for_interrupt(rspi
, SPSR_SPRF
, SPCR_SPRIE
) < 0) {
547 dev_err(&rspi
->master
->dev
,
548 "%s: receive timeout\n", __func__
);
551 /* SPDR allows 16 or 32-bit access only */
552 *data
= (u8
)rspi_read16(rspi
, RSPI_SPDR
);
561 static void qspi_receive_init(const struct rspi_data
*rspi
)
565 spsr
= rspi_read8(rspi
, RSPI_SPSR
);
566 if (spsr
& SPSR_SPRF
)
567 rspi_read8(rspi
, RSPI_SPDR
); /* dummy read */
568 rspi_write8(rspi
, SPBFCR_TXRST
| SPBFCR_RXRST
, QSPI_SPBFCR
);
569 rspi_write8(rspi
, 0x00, QSPI_SPBFCR
);
572 static int qspi_receive_pio(struct rspi_data
*rspi
, struct spi_message
*mesg
,
573 struct spi_transfer
*t
)
578 qspi_receive_init(rspi
);
583 if (rspi_wait_for_interrupt(rspi
, SPSR_SPTEF
, SPCR_SPTIE
) < 0) {
584 dev_err(&rspi
->master
->dev
,
585 "%s: tx empty timeout\n", __func__
);
588 /* dummy write for generate clock */
589 rspi_write8(rspi
, 0x00, RSPI_SPDR
);
591 if (rspi_wait_for_interrupt(rspi
, SPSR_SPRF
, SPCR_SPRIE
) < 0) {
592 dev_err(&rspi
->master
->dev
,
593 "%s: receive timeout\n", __func__
);
596 /* SPDR allows 8, 16 or 32-bit access */
597 *data
++ = rspi_read8(rspi
, RSPI_SPDR
);
604 #define receive_pio(spi, mesg, t) spi->ops->receive_pio(spi, mesg, t)
606 static int rspi_receive_dma(struct rspi_data
*rspi
, struct spi_transfer
*t
)
608 struct scatterlist sg
, sg_dummy
;
609 void *dummy
= NULL
, *rx_buf
= NULL
;
610 struct dma_async_tx_descriptor
*desc
, *desc_dummy
;
614 if (rspi
->dma_width_16bit
) {
616 * If DMAC bus width is 16-bit, the driver allocates a dummy
617 * buffer. And, finally the driver converts the DMAC data into
618 * actual data as the following format:
619 * DMAC data: 1st byte, dummy, 2nd byte, dummy ...
620 * actual data: 1st byte, 2nd byte ...
623 rx_buf
= kmalloc(len
, GFP_KERNEL
);
631 /* prepare dummy transfer to generate SPI clocks */
632 dummy
= kzalloc(len
, GFP_KERNEL
);
637 if (!rspi_dma_map_sg(&sg_dummy
, dummy
, len
, rspi
->chan_tx
,
642 desc_dummy
= dmaengine_prep_slave_sg(rspi
->chan_tx
, &sg_dummy
, 1,
643 DMA_TO_DEVICE
, DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
646 goto end_dummy_mapped
;
649 /* prepare receive transfer */
650 if (!rspi_dma_map_sg(&sg
, rx_buf
, len
, rspi
->chan_rx
,
653 goto end_dummy_mapped
;
656 desc
= dmaengine_prep_slave_sg(rspi
->chan_rx
, &sg
, 1, DMA_FROM_DEVICE
,
657 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
663 rspi_receive_init(rspi
);
666 * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
667 * called. So, this driver disables the IRQ while DMA transfer.
669 disable_irq(rspi
->irq
);
671 rspi_write8(rspi
, rspi_read8(rspi
, RSPI_SPCR
) & ~SPCR_TXMD
, RSPI_SPCR
);
672 rspi_enable_irq(rspi
, SPCR_SPTIE
| SPCR_SPRIE
);
673 rspi
->dma_callbacked
= 0;
675 desc
->callback
= rspi_dma_complete
;
676 desc
->callback_param
= rspi
;
677 dmaengine_submit(desc
);
678 dma_async_issue_pending(rspi
->chan_rx
);
680 desc_dummy
->callback
= NULL
; /* No callback */
681 dmaengine_submit(desc_dummy
);
682 dma_async_issue_pending(rspi
->chan_tx
);
684 ret
= wait_event_interruptible_timeout(rspi
->wait
,
685 rspi
->dma_callbacked
, HZ
);
686 if (ret
> 0 && rspi
->dma_callbacked
)
690 rspi_disable_irq(rspi
, SPCR_SPTIE
| SPCR_SPRIE
);
692 enable_irq(rspi
->irq
);
695 rspi_dma_unmap_sg(&sg
, rspi
->chan_rx
, DMA_FROM_DEVICE
);
697 rspi_dma_unmap_sg(&sg_dummy
, rspi
->chan_tx
, DMA_TO_DEVICE
);
699 if (rspi
->dma_width_16bit
) {
701 rspi_memory_from_8bit(t
->rx_buf
, rx_buf
, t
->len
);
709 static int rspi_is_dma(const struct rspi_data
*rspi
, struct spi_transfer
*t
)
711 if (t
->tx_buf
&& rspi
->chan_tx
)
713 /* If the module receives data by DMAC, it also needs TX DMAC */
714 if (t
->rx_buf
&& rspi
->chan_tx
&& rspi
->chan_rx
)
720 static void rspi_work(struct work_struct
*work
)
722 struct rspi_data
*rspi
= container_of(work
, struct rspi_data
, ws
);
723 struct spi_message
*mesg
;
724 struct spi_transfer
*t
;
729 spin_lock_irqsave(&rspi
->lock
, flags
);
730 if (list_empty(&rspi
->queue
)) {
731 spin_unlock_irqrestore(&rspi
->lock
, flags
);
734 mesg
= list_entry(rspi
->queue
.next
, struct spi_message
, queue
);
735 list_del_init(&mesg
->queue
);
736 spin_unlock_irqrestore(&rspi
->lock
, flags
);
738 rspi_assert_ssl(rspi
);
740 list_for_each_entry(t
, &mesg
->transfers
, transfer_list
) {
742 if (rspi_is_dma(rspi
, t
))
743 ret
= rspi_send_dma(rspi
, t
);
745 ret
= send_pio(rspi
, mesg
, t
);
750 if (rspi_is_dma(rspi
, t
))
751 ret
= rspi_receive_dma(rspi
, t
);
753 ret
= receive_pio(rspi
, mesg
, t
);
757 mesg
->actual_length
+= t
->len
;
759 rspi_negate_ssl(rspi
);
762 mesg
->complete(mesg
->context
);
769 mesg
->complete(mesg
->context
);
772 static int rspi_setup(struct spi_device
*spi
)
774 struct rspi_data
*rspi
= spi_master_get_devdata(spi
->master
);
776 if (!spi
->bits_per_word
)
777 spi
->bits_per_word
= 8;
778 rspi
->max_speed_hz
= spi
->max_speed_hz
;
780 set_config_register(rspi
, 8);
785 static int rspi_transfer(struct spi_device
*spi
, struct spi_message
*mesg
)
787 struct rspi_data
*rspi
= spi_master_get_devdata(spi
->master
);
790 mesg
->actual_length
= 0;
791 mesg
->status
= -EINPROGRESS
;
793 spin_lock_irqsave(&rspi
->lock
, flags
);
794 list_add_tail(&mesg
->queue
, &rspi
->queue
);
795 schedule_work(&rspi
->ws
);
796 spin_unlock_irqrestore(&rspi
->lock
, flags
);
801 static void rspi_cleanup(struct spi_device
*spi
)
805 static irqreturn_t
rspi_irq(int irq
, void *_sr
)
807 struct rspi_data
*rspi
= _sr
;
809 irqreturn_t ret
= IRQ_NONE
;
810 unsigned char disable_irq
= 0;
812 rspi
->spsr
= spsr
= rspi_read8(rspi
, RSPI_SPSR
);
813 if (spsr
& SPSR_SPRF
)
814 disable_irq
|= SPCR_SPRIE
;
815 if (spsr
& SPSR_SPTEF
)
816 disable_irq
|= SPCR_SPTIE
;
820 rspi_disable_irq(rspi
, disable_irq
);
821 wake_up(&rspi
->wait
);
827 static int rspi_request_dma(struct rspi_data
*rspi
,
828 struct platform_device
*pdev
)
830 const struct rspi_plat_data
*rspi_pd
= dev_get_platdata(&pdev
->dev
);
831 struct resource
*res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
833 struct dma_slave_config cfg
;
836 if (!res
|| !rspi_pd
)
837 return 0; /* The driver assumes no error. */
839 rspi
->dma_width_16bit
= rspi_pd
->dma_width_16bit
;
841 /* If the module receives data by DMAC, it also needs TX DMAC */
842 if (rspi_pd
->dma_rx_id
&& rspi_pd
->dma_tx_id
) {
844 dma_cap_set(DMA_SLAVE
, mask
);
845 rspi
->chan_rx
= dma_request_channel(mask
, shdma_chan_filter
,
846 (void *)rspi_pd
->dma_rx_id
);
848 cfg
.slave_id
= rspi_pd
->dma_rx_id
;
849 cfg
.direction
= DMA_DEV_TO_MEM
;
851 cfg
.src_addr
= res
->start
+ RSPI_SPDR
;
852 ret
= dmaengine_slave_config(rspi
->chan_rx
, &cfg
);
854 dev_info(&pdev
->dev
, "Use DMA when rx.\n");
859 if (rspi_pd
->dma_tx_id
) {
861 dma_cap_set(DMA_SLAVE
, mask
);
862 rspi
->chan_tx
= dma_request_channel(mask
, shdma_chan_filter
,
863 (void *)rspi_pd
->dma_tx_id
);
865 cfg
.slave_id
= rspi_pd
->dma_tx_id
;
866 cfg
.direction
= DMA_MEM_TO_DEV
;
867 cfg
.dst_addr
= res
->start
+ RSPI_SPDR
;
869 ret
= dmaengine_slave_config(rspi
->chan_tx
, &cfg
);
871 dev_info(&pdev
->dev
, "Use DMA when tx\n");
880 static void rspi_release_dma(struct rspi_data
*rspi
)
883 dma_release_channel(rspi
->chan_tx
);
885 dma_release_channel(rspi
->chan_rx
);
888 static int rspi_remove(struct platform_device
*pdev
)
890 struct rspi_data
*rspi
= spi_master_get(platform_get_drvdata(pdev
));
892 spi_unregister_master(rspi
->master
);
893 rspi_release_dma(rspi
);
894 free_irq(platform_get_irq(pdev
, 0), rspi
);
897 spi_master_put(rspi
->master
);
902 static int rspi_probe(struct platform_device
*pdev
)
904 struct resource
*res
;
905 struct spi_master
*master
;
906 struct rspi_data
*rspi
;
909 const struct rspi_plat_data
*rspi_pd
= dev_get_platdata(&pdev
->dev
);
910 const struct spi_ops
*ops
;
911 const struct platform_device_id
*id_entry
= pdev
->id_entry
;
913 ops
= (struct spi_ops
*)id_entry
->driver_data
;
914 /* ops parameter check */
915 if (!ops
->set_config_register
) {
916 dev_err(&pdev
->dev
, "there is no set_config_register\n");
920 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
921 if (unlikely(res
== NULL
)) {
922 dev_err(&pdev
->dev
, "invalid resource\n");
926 irq
= platform_get_irq(pdev
, 0);
928 dev_err(&pdev
->dev
, "platform_get_irq error\n");
932 master
= spi_alloc_master(&pdev
->dev
, sizeof(struct rspi_data
));
933 if (master
== NULL
) {
934 dev_err(&pdev
->dev
, "spi_alloc_master error.\n");
938 rspi
= spi_master_get_devdata(master
);
939 platform_set_drvdata(pdev
, rspi
);
941 rspi
->master
= master
;
942 rspi
->addr
= ioremap(res
->start
, resource_size(res
));
943 if (rspi
->addr
== NULL
) {
944 dev_err(&pdev
->dev
, "ioremap error.\n");
949 snprintf(clk_name
, sizeof(clk_name
), "%s%d", id_entry
->name
, pdev
->id
);
950 rspi
->clk
= clk_get(&pdev
->dev
, clk_name
);
951 if (IS_ERR(rspi
->clk
)) {
952 dev_err(&pdev
->dev
, "cannot get clock\n");
953 ret
= PTR_ERR(rspi
->clk
);
956 clk_enable(rspi
->clk
);
958 INIT_LIST_HEAD(&rspi
->queue
);
959 spin_lock_init(&rspi
->lock
);
960 INIT_WORK(&rspi
->ws
, rspi_work
);
961 init_waitqueue_head(&rspi
->wait
);
963 master
->num_chipselect
= rspi_pd
->num_chipselect
;
964 if (!master
->num_chipselect
)
965 master
->num_chipselect
= 2; /* default */
967 master
->bus_num
= pdev
->id
;
968 master
->setup
= rspi_setup
;
969 master
->transfer
= rspi_transfer
;
970 master
->cleanup
= rspi_cleanup
;
972 ret
= request_irq(irq
, rspi_irq
, 0, dev_name(&pdev
->dev
), rspi
);
974 dev_err(&pdev
->dev
, "request_irq error\n");
979 ret
= rspi_request_dma(rspi
, pdev
);
981 dev_err(&pdev
->dev
, "rspi_request_dma failed.\n");
985 ret
= spi_register_master(master
);
987 dev_err(&pdev
->dev
, "spi_register_master error.\n");
991 dev_info(&pdev
->dev
, "probed\n");
996 rspi_release_dma(rspi
);
1001 iounmap(rspi
->addr
);
1003 spi_master_put(master
);
1008 static struct spi_ops rspi_ops
= {
1009 .set_config_register
= rspi_set_config_register
,
1010 .send_pio
= rspi_send_pio
,
1011 .receive_pio
= rspi_receive_pio
,
1014 static struct spi_ops qspi_ops
= {
1015 .set_config_register
= qspi_set_config_register
,
1016 .send_pio
= qspi_send_pio
,
1017 .receive_pio
= qspi_receive_pio
,
1020 static struct platform_device_id spi_driver_ids
[] = {
1021 { "rspi", (kernel_ulong_t
)&rspi_ops
},
1022 { "qspi", (kernel_ulong_t
)&qspi_ops
},
1026 MODULE_DEVICE_TABLE(platform
, spi_driver_ids
);
1028 static struct platform_driver rspi_driver
= {
1029 .probe
= rspi_probe
,
1030 .remove
= rspi_remove
,
1031 .id_table
= spi_driver_ids
,
1033 .name
= "renesas_spi",
1034 .owner
= THIS_MODULE
,
1037 module_platform_driver(rspi_driver
);
1039 MODULE_DESCRIPTION("Renesas RSPI bus driver");
1040 MODULE_LICENSE("GPL v2");
1041 MODULE_AUTHOR("Yoshihiro Shimoda");
1042 MODULE_ALIAS("platform:rspi");