2 * Marvell Armada-3700 SPI controller driver
4 * Copyright (C) 2016 Marvell Ltd.
6 * Author: Wilson Ding <dingwei@marvell.com>
7 * Author: Romain Perier <romain.perier@free-electrons.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/clk.h>
15 #include <linux/completion.h>
16 #include <linux/delay.h>
17 #include <linux/err.h>
18 #include <linux/interrupt.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
23 #include <linux/of_irq.h>
24 #include <linux/of_device.h>
25 #include <linux/pinctrl/consumer.h>
26 #include <linux/spi/spi.h>
28 #define DRIVER_NAME "armada_3700_spi"
30 #define A3700_SPI_TIMEOUT 10
32 /* SPI Register Offest */
33 #define A3700_SPI_IF_CTRL_REG 0x00
34 #define A3700_SPI_IF_CFG_REG 0x04
35 #define A3700_SPI_DATA_OUT_REG 0x08
36 #define A3700_SPI_DATA_IN_REG 0x0C
37 #define A3700_SPI_IF_INST_REG 0x10
38 #define A3700_SPI_IF_ADDR_REG 0x14
39 #define A3700_SPI_IF_RMODE_REG 0x18
40 #define A3700_SPI_IF_HDR_CNT_REG 0x1C
41 #define A3700_SPI_IF_DIN_CNT_REG 0x20
42 #define A3700_SPI_IF_TIME_REG 0x24
43 #define A3700_SPI_INT_STAT_REG 0x28
44 #define A3700_SPI_INT_MASK_REG 0x2C
46 /* A3700_SPI_IF_CTRL_REG */
47 #define A3700_SPI_EN BIT(16)
48 #define A3700_SPI_ADDR_NOT_CONFIG BIT(12)
49 #define A3700_SPI_WFIFO_OVERFLOW BIT(11)
50 #define A3700_SPI_WFIFO_UNDERFLOW BIT(10)
51 #define A3700_SPI_RFIFO_OVERFLOW BIT(9)
52 #define A3700_SPI_RFIFO_UNDERFLOW BIT(8)
53 #define A3700_SPI_WFIFO_FULL BIT(7)
54 #define A3700_SPI_WFIFO_EMPTY BIT(6)
55 #define A3700_SPI_RFIFO_FULL BIT(5)
56 #define A3700_SPI_RFIFO_EMPTY BIT(4)
57 #define A3700_SPI_WFIFO_RDY BIT(3)
58 #define A3700_SPI_RFIFO_RDY BIT(2)
59 #define A3700_SPI_XFER_RDY BIT(1)
60 #define A3700_SPI_XFER_DONE BIT(0)
62 /* A3700_SPI_IF_CFG_REG */
63 #define A3700_SPI_WFIFO_THRS BIT(28)
64 #define A3700_SPI_RFIFO_THRS BIT(24)
65 #define A3700_SPI_AUTO_CS BIT(20)
66 #define A3700_SPI_DMA_RD_EN BIT(18)
67 #define A3700_SPI_FIFO_MODE BIT(17)
68 #define A3700_SPI_SRST BIT(16)
69 #define A3700_SPI_XFER_START BIT(15)
70 #define A3700_SPI_XFER_STOP BIT(14)
71 #define A3700_SPI_INST_PIN BIT(13)
72 #define A3700_SPI_ADDR_PIN BIT(12)
73 #define A3700_SPI_DATA_PIN1 BIT(11)
74 #define A3700_SPI_DATA_PIN0 BIT(10)
75 #define A3700_SPI_FIFO_FLUSH BIT(9)
76 #define A3700_SPI_RW_EN BIT(8)
77 #define A3700_SPI_CLK_POL BIT(7)
78 #define A3700_SPI_CLK_PHA BIT(6)
79 #define A3700_SPI_BYTE_LEN BIT(5)
80 #define A3700_SPI_CLK_PRESCALE BIT(0)
81 #define A3700_SPI_CLK_PRESCALE_MASK (0x1f)
82 #define A3700_SPI_CLK_EVEN_OFFS (0x10)
84 #define A3700_SPI_WFIFO_THRS_BIT 28
85 #define A3700_SPI_RFIFO_THRS_BIT 24
86 #define A3700_SPI_FIFO_THRS_MASK 0x7
88 #define A3700_SPI_DATA_PIN_MASK 0x3
90 /* A3700_SPI_IF_HDR_CNT_REG */
91 #define A3700_SPI_DUMMY_CNT_BIT 12
92 #define A3700_SPI_DUMMY_CNT_MASK 0x7
93 #define A3700_SPI_RMODE_CNT_BIT 8
94 #define A3700_SPI_RMODE_CNT_MASK 0x3
95 #define A3700_SPI_ADDR_CNT_BIT 4
96 #define A3700_SPI_ADDR_CNT_MASK 0x7
97 #define A3700_SPI_INSTR_CNT_BIT 0
98 #define A3700_SPI_INSTR_CNT_MASK 0x3
100 /* A3700_SPI_IF_TIME_REG */
101 #define A3700_SPI_CLK_CAPT_EDGE BIT(7)
104 struct spi_master
*master
;
115 struct completion done
;
118 static u32
spireg_read(struct a3700_spi
*a3700_spi
, u32 offset
)
120 return readl(a3700_spi
->base
+ offset
);
123 static void spireg_write(struct a3700_spi
*a3700_spi
, u32 offset
, u32 data
)
125 writel(data
, a3700_spi
->base
+ offset
);
128 static void a3700_spi_auto_cs_unset(struct a3700_spi
*a3700_spi
)
132 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
133 val
&= ~A3700_SPI_AUTO_CS
;
134 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
137 static void a3700_spi_activate_cs(struct a3700_spi
*a3700_spi
, unsigned int cs
)
141 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
142 val
|= (A3700_SPI_EN
<< cs
);
143 spireg_write(a3700_spi
, A3700_SPI_IF_CTRL_REG
, val
);
146 static void a3700_spi_deactivate_cs(struct a3700_spi
*a3700_spi
,
151 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
152 val
&= ~(A3700_SPI_EN
<< cs
);
153 spireg_write(a3700_spi
, A3700_SPI_IF_CTRL_REG
, val
);
156 static int a3700_spi_pin_mode_set(struct a3700_spi
*a3700_spi
,
157 unsigned int pin_mode
, bool receiving
)
161 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
162 val
&= ~(A3700_SPI_INST_PIN
| A3700_SPI_ADDR_PIN
);
163 val
&= ~(A3700_SPI_DATA_PIN0
| A3700_SPI_DATA_PIN1
);
166 case SPI_NBITS_SINGLE
:
169 val
|= A3700_SPI_DATA_PIN0
;
172 val
|= A3700_SPI_DATA_PIN1
;
173 /* RX during address reception uses 4-pin */
175 val
|= A3700_SPI_ADDR_PIN
;
178 dev_err(&a3700_spi
->master
->dev
, "wrong pin mode %u", pin_mode
);
182 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
187 static void a3700_spi_fifo_mode_set(struct a3700_spi
*a3700_spi
)
191 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
192 val
|= A3700_SPI_FIFO_MODE
;
193 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
196 static void a3700_spi_mode_set(struct a3700_spi
*a3700_spi
,
197 unsigned int mode_bits
)
201 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
203 if (mode_bits
& SPI_CPOL
)
204 val
|= A3700_SPI_CLK_POL
;
206 val
&= ~A3700_SPI_CLK_POL
;
208 if (mode_bits
& SPI_CPHA
)
209 val
|= A3700_SPI_CLK_PHA
;
211 val
&= ~A3700_SPI_CLK_PHA
;
213 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
216 static void a3700_spi_clock_set(struct a3700_spi
*a3700_spi
,
217 unsigned int speed_hz
, u16 mode
)
222 prescale
= DIV_ROUND_UP(clk_get_rate(a3700_spi
->clk
), speed_hz
);
224 /* For prescaler values over 15, we can only set it by steps of 2.
225 * Starting from A3700_SPI_CLK_EVEN_OFFS, we set values from 0 up to
226 * 30. We only use this range from 16 to 30.
229 prescale
= A3700_SPI_CLK_EVEN_OFFS
+ DIV_ROUND_UP(prescale
, 2);
231 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
232 val
= val
& ~A3700_SPI_CLK_PRESCALE_MASK
;
234 val
= val
| (prescale
& A3700_SPI_CLK_PRESCALE_MASK
);
235 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
238 val
= spireg_read(a3700_spi
, A3700_SPI_IF_TIME_REG
);
239 val
|= A3700_SPI_CLK_CAPT_EDGE
;
240 spireg_write(a3700_spi
, A3700_SPI_IF_TIME_REG
, val
);
243 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
244 val
&= ~(A3700_SPI_CLK_POL
| A3700_SPI_CLK_PHA
);
247 val
|= A3700_SPI_CLK_POL
;
250 val
|= A3700_SPI_CLK_PHA
;
252 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
255 static void a3700_spi_bytelen_set(struct a3700_spi
*a3700_spi
, unsigned int len
)
259 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
261 val
|= A3700_SPI_BYTE_LEN
;
263 val
&= ~A3700_SPI_BYTE_LEN
;
264 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
266 a3700_spi
->byte_len
= len
;
269 static int a3700_spi_fifo_flush(struct a3700_spi
*a3700_spi
)
271 int timeout
= A3700_SPI_TIMEOUT
;
274 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
275 val
|= A3700_SPI_FIFO_FLUSH
;
276 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
279 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
280 if (!(val
& A3700_SPI_FIFO_FLUSH
))
288 static int a3700_spi_init(struct a3700_spi
*a3700_spi
)
290 struct spi_master
*master
= a3700_spi
->master
;
295 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
296 val
|= A3700_SPI_SRST
;
297 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
299 udelay(A3700_SPI_TIMEOUT
);
301 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
302 val
&= ~A3700_SPI_SRST
;
303 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
305 /* Disable AUTO_CS and deactivate all chip-selects */
306 a3700_spi_auto_cs_unset(a3700_spi
);
307 for (i
= 0; i
< master
->num_chipselect
; i
++)
308 a3700_spi_deactivate_cs(a3700_spi
, i
);
310 /* Enable FIFO mode */
311 a3700_spi_fifo_mode_set(a3700_spi
);
314 a3700_spi_mode_set(a3700_spi
, master
->mode_bits
);
317 spireg_write(a3700_spi
, A3700_SPI_IF_HDR_CNT_REG
, 0);
318 spireg_write(a3700_spi
, A3700_SPI_IF_DIN_CNT_REG
, 0);
320 /* Mask the interrupts and clear cause bits */
321 spireg_write(a3700_spi
, A3700_SPI_INT_MASK_REG
, 0);
322 spireg_write(a3700_spi
, A3700_SPI_INT_STAT_REG
, ~0U);
327 static irqreturn_t
a3700_spi_interrupt(int irq
, void *dev_id
)
329 struct spi_master
*master
= dev_id
;
330 struct a3700_spi
*a3700_spi
;
333 a3700_spi
= spi_master_get_devdata(master
);
335 /* Get interrupt causes */
336 cause
= spireg_read(a3700_spi
, A3700_SPI_INT_STAT_REG
);
338 if (!cause
|| !(a3700_spi
->wait_mask
& cause
))
341 /* mask and acknowledge the SPI interrupts */
342 spireg_write(a3700_spi
, A3700_SPI_INT_MASK_REG
, 0);
343 spireg_write(a3700_spi
, A3700_SPI_INT_STAT_REG
, cause
);
345 /* Wake up the transfer */
346 complete(&a3700_spi
->done
);
351 static bool a3700_spi_wait_completion(struct spi_device
*spi
)
353 struct a3700_spi
*a3700_spi
;
354 unsigned int timeout
;
355 unsigned int ctrl_reg
;
356 unsigned long timeout_jiffies
;
358 a3700_spi
= spi_master_get_devdata(spi
->master
);
360 /* SPI interrupt is edge-triggered, which means an interrupt will
361 * be generated only when detecting a specific status bit changed
362 * from '0' to '1'. So when we start waiting for a interrupt, we
363 * need to check status bit in control reg first, if it is already 1,
364 * then we do not need to wait for interrupt
366 ctrl_reg
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
367 if (a3700_spi
->wait_mask
& ctrl_reg
)
370 reinit_completion(&a3700_spi
->done
);
372 spireg_write(a3700_spi
, A3700_SPI_INT_MASK_REG
,
373 a3700_spi
->wait_mask
);
375 timeout_jiffies
= msecs_to_jiffies(A3700_SPI_TIMEOUT
);
376 timeout
= wait_for_completion_timeout(&a3700_spi
->done
,
379 a3700_spi
->wait_mask
= 0;
384 /* there might be the case that right after we checked the
385 * status bits in this routine and before start to wait for
386 * interrupt by wait_for_completion_timeout, the interrupt
387 * happens, to avoid missing it we need to double check
388 * status bits in control reg, if it is already 1, then
389 * consider that we have the interrupt successfully and
392 ctrl_reg
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
393 if (a3700_spi
->wait_mask
& ctrl_reg
)
396 spireg_write(a3700_spi
, A3700_SPI_INT_MASK_REG
, 0);
398 /* Timeout was reached */
402 static bool a3700_spi_transfer_wait(struct spi_device
*spi
,
403 unsigned int bit_mask
)
405 struct a3700_spi
*a3700_spi
;
407 a3700_spi
= spi_master_get_devdata(spi
->master
);
408 a3700_spi
->wait_mask
= bit_mask
;
410 return a3700_spi_wait_completion(spi
);
413 static void a3700_spi_fifo_thres_set(struct a3700_spi
*a3700_spi
,
418 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
419 val
&= ~(A3700_SPI_FIFO_THRS_MASK
<< A3700_SPI_RFIFO_THRS_BIT
);
420 val
|= (bytes
- 1) << A3700_SPI_RFIFO_THRS_BIT
;
421 val
&= ~(A3700_SPI_FIFO_THRS_MASK
<< A3700_SPI_WFIFO_THRS_BIT
);
422 val
|= (7 - bytes
) << A3700_SPI_WFIFO_THRS_BIT
;
423 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
426 static void a3700_spi_transfer_setup(struct spi_device
*spi
,
427 struct spi_transfer
*xfer
)
429 struct a3700_spi
*a3700_spi
;
430 unsigned int byte_len
;
432 a3700_spi
= spi_master_get_devdata(spi
->master
);
434 a3700_spi_clock_set(a3700_spi
, xfer
->speed_hz
, spi
->mode
);
436 byte_len
= xfer
->bits_per_word
>> 3;
438 a3700_spi_fifo_thres_set(a3700_spi
, byte_len
);
441 static void a3700_spi_set_cs(struct spi_device
*spi
, bool enable
)
443 struct a3700_spi
*a3700_spi
= spi_master_get_devdata(spi
->master
);
446 a3700_spi_activate_cs(a3700_spi
, spi
->chip_select
);
448 a3700_spi_deactivate_cs(a3700_spi
, spi
->chip_select
);
451 static void a3700_spi_header_set(struct a3700_spi
*a3700_spi
)
453 unsigned int addr_cnt
;
456 /* Clear the header registers */
457 spireg_write(a3700_spi
, A3700_SPI_IF_INST_REG
, 0);
458 spireg_write(a3700_spi
, A3700_SPI_IF_ADDR_REG
, 0);
459 spireg_write(a3700_spi
, A3700_SPI_IF_RMODE_REG
, 0);
460 spireg_write(a3700_spi
, A3700_SPI_IF_HDR_CNT_REG
, 0);
462 /* Set header counters */
463 if (a3700_spi
->tx_buf
) {
465 * when tx data is not 4 bytes aligned, there will be unexpected
466 * bytes out of SPI output register, since it always shifts out
467 * as whole 4 bytes. This might cause incorrect transaction with
468 * some devices. To avoid that, use SPI header count feature to
469 * transfer up to 3 bytes of data first, and then make the rest
470 * of data 4-byte aligned.
472 addr_cnt
= a3700_spi
->buf_len
% 4;
474 val
= (addr_cnt
& A3700_SPI_ADDR_CNT_MASK
)
475 << A3700_SPI_ADDR_CNT_BIT
;
476 spireg_write(a3700_spi
, A3700_SPI_IF_HDR_CNT_REG
, val
);
478 /* Update the buffer length to be transferred */
479 a3700_spi
->buf_len
-= addr_cnt
;
481 /* transfer 1~3 bytes through address count */
484 val
= (val
<< 8) | a3700_spi
->tx_buf
[0];
487 spireg_write(a3700_spi
, A3700_SPI_IF_ADDR_REG
, val
);
492 static int a3700_is_wfifo_full(struct a3700_spi
*a3700_spi
)
496 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
497 return (val
& A3700_SPI_WFIFO_FULL
);
500 static int a3700_spi_fifo_write(struct a3700_spi
*a3700_spi
)
504 while (!a3700_is_wfifo_full(a3700_spi
) && a3700_spi
->buf_len
) {
505 val
= cpu_to_le32(*(u32
*)a3700_spi
->tx_buf
);
506 spireg_write(a3700_spi
, A3700_SPI_DATA_OUT_REG
, val
);
507 a3700_spi
->buf_len
-= 4;
508 a3700_spi
->tx_buf
+= 4;
514 static int a3700_is_rfifo_empty(struct a3700_spi
*a3700_spi
)
516 u32 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CTRL_REG
);
518 return (val
& A3700_SPI_RFIFO_EMPTY
);
521 static int a3700_spi_fifo_read(struct a3700_spi
*a3700_spi
)
525 while (!a3700_is_rfifo_empty(a3700_spi
) && a3700_spi
->buf_len
) {
526 val
= spireg_read(a3700_spi
, A3700_SPI_DATA_IN_REG
);
527 if (a3700_spi
->buf_len
>= 4) {
528 u32 data
= le32_to_cpu(val
);
530 memcpy(a3700_spi
->rx_buf
, &data
, 4);
532 a3700_spi
->buf_len
-= 4;
533 a3700_spi
->rx_buf
+= 4;
536 * When remain bytes is not larger than 4, we should
537 * avoid memory overwriting and just write the left rx
540 while (a3700_spi
->buf_len
) {
541 *a3700_spi
->rx_buf
= val
& 0xff;
544 a3700_spi
->buf_len
--;
553 static void a3700_spi_transfer_abort_fifo(struct a3700_spi
*a3700_spi
)
555 int timeout
= A3700_SPI_TIMEOUT
;
558 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
559 val
|= A3700_SPI_XFER_STOP
;
560 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
563 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
564 if (!(val
& A3700_SPI_XFER_START
))
569 a3700_spi_fifo_flush(a3700_spi
);
571 val
&= ~A3700_SPI_XFER_STOP
;
572 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
575 static int a3700_spi_prepare_message(struct spi_master
*master
,
576 struct spi_message
*message
)
578 struct a3700_spi
*a3700_spi
= spi_master_get_devdata(master
);
579 struct spi_device
*spi
= message
->spi
;
582 ret
= clk_enable(a3700_spi
->clk
);
584 dev_err(&spi
->dev
, "failed to enable clk with error %d\n", ret
);
588 /* Flush the FIFOs */
589 ret
= a3700_spi_fifo_flush(a3700_spi
);
593 a3700_spi_bytelen_set(a3700_spi
, 4);
598 static int a3700_spi_transfer_one(struct spi_master
*master
,
599 struct spi_device
*spi
,
600 struct spi_transfer
*xfer
)
602 struct a3700_spi
*a3700_spi
= spi_master_get_devdata(master
);
603 int ret
= 0, timeout
= A3700_SPI_TIMEOUT
;
604 unsigned int nbits
= 0;
607 a3700_spi_transfer_setup(spi
, xfer
);
609 a3700_spi
->tx_buf
= xfer
->tx_buf
;
610 a3700_spi
->rx_buf
= xfer
->rx_buf
;
611 a3700_spi
->buf_len
= xfer
->len
;
614 nbits
= xfer
->tx_nbits
;
615 else if (xfer
->rx_buf
)
616 nbits
= xfer
->rx_nbits
;
618 a3700_spi_pin_mode_set(a3700_spi
, nbits
, xfer
->rx_buf
? true : false);
620 /* Flush the FIFOs */
621 a3700_spi_fifo_flush(a3700_spi
);
623 /* Transfer first bytes of data when buffer is not 4-byte aligned */
624 a3700_spi_header_set(a3700_spi
);
627 /* Clear WFIFO, since it's last 2 bytes are shifted out during
630 spireg_write(a3700_spi
, A3700_SPI_DATA_OUT_REG
, 0);
632 /* Set read data length */
633 spireg_write(a3700_spi
, A3700_SPI_IF_DIN_CNT_REG
,
635 /* Start READ transfer */
636 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
637 val
&= ~A3700_SPI_RW_EN
;
638 val
|= A3700_SPI_XFER_START
;
639 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
640 } else if (xfer
->tx_buf
) {
641 /* Start Write transfer */
642 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
643 val
|= (A3700_SPI_XFER_START
| A3700_SPI_RW_EN
);
644 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
647 * If there are data to be written to the SPI device, xmit_data
648 * flag is set true; otherwise the instruction in SPI_INSTR does
649 * not require data to be written to the SPI device, then
650 * xmit_data flag is set false.
652 a3700_spi
->xmit_data
= (a3700_spi
->buf_len
!= 0);
655 while (a3700_spi
->buf_len
) {
656 if (a3700_spi
->tx_buf
) {
657 /* Wait wfifo ready */
658 if (!a3700_spi_transfer_wait(spi
,
659 A3700_SPI_WFIFO_RDY
)) {
661 "wait wfifo ready timed out\n");
665 /* Fill up the wfifo */
666 ret
= a3700_spi_fifo_write(a3700_spi
);
669 } else if (a3700_spi
->rx_buf
) {
670 /* Wait rfifo ready */
671 if (!a3700_spi_transfer_wait(spi
,
672 A3700_SPI_RFIFO_RDY
)) {
674 "wait rfifo ready timed out\n");
678 /* Drain out the rfifo */
679 ret
= a3700_spi_fifo_read(a3700_spi
);
686 * Stop a write transfer in fifo mode:
687 * - wait all the bytes in wfifo to be shifted out
688 * - set XFER_STOP bit
689 * - wait XFER_START bit clear
690 * - clear XFER_STOP bit
691 * Stop a read transfer in fifo mode:
692 * - the hardware is to reset the XFER_START bit
693 * after the number of bytes indicated in DIN_CNT
695 * - just wait XFER_START bit clear
697 if (a3700_spi
->tx_buf
) {
698 if (a3700_spi
->xmit_data
) {
700 * If there are data written to the SPI device, wait
701 * until SPI_WFIFO_EMPTY is 1 to wait for all data to
702 * transfer out of write FIFO.
704 if (!a3700_spi_transfer_wait(spi
,
705 A3700_SPI_WFIFO_EMPTY
)) {
706 dev_err(&spi
->dev
, "wait wfifo empty timed out\n");
711 if (!a3700_spi_transfer_wait(spi
, A3700_SPI_XFER_RDY
)) {
712 dev_err(&spi
->dev
, "wait xfer ready timed out\n");
716 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
717 val
|= A3700_SPI_XFER_STOP
;
718 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
722 val
= spireg_read(a3700_spi
, A3700_SPI_IF_CFG_REG
);
723 if (!(val
& A3700_SPI_XFER_START
))
729 dev_err(&spi
->dev
, "wait transfer start clear timed out\n");
734 val
&= ~A3700_SPI_XFER_STOP
;
735 spireg_write(a3700_spi
, A3700_SPI_IF_CFG_REG
, val
);
739 a3700_spi_transfer_abort_fifo(a3700_spi
);
741 spi_finalize_current_transfer(master
);
746 static int a3700_spi_unprepare_message(struct spi_master
*master
,
747 struct spi_message
*message
)
749 struct a3700_spi
*a3700_spi
= spi_master_get_devdata(master
);
751 clk_disable(a3700_spi
->clk
);
756 static const struct of_device_id a3700_spi_dt_ids
[] = {
757 { .compatible
= "marvell,armada-3700-spi", .data
= NULL
},
761 MODULE_DEVICE_TABLE(of
, a3700_spi_dt_ids
);
763 static int a3700_spi_probe(struct platform_device
*pdev
)
765 struct device
*dev
= &pdev
->dev
;
766 struct device_node
*of_node
= dev
->of_node
;
767 struct resource
*res
;
768 struct spi_master
*master
;
769 struct a3700_spi
*spi
;
773 master
= spi_alloc_master(dev
, sizeof(*spi
));
775 dev_err(dev
, "master allocation failed\n");
780 if (of_property_read_u32(of_node
, "num-cs", &num_cs
)) {
781 dev_err(dev
, "could not find num-cs\n");
786 master
->bus_num
= pdev
->id
;
787 master
->dev
.of_node
= of_node
;
788 master
->mode_bits
= SPI_MODE_3
;
789 master
->num_chipselect
= num_cs
;
790 master
->bits_per_word_mask
= SPI_BPW_MASK(8) | SPI_BPW_MASK(32);
791 master
->prepare_message
= a3700_spi_prepare_message
;
792 master
->transfer_one
= a3700_spi_transfer_one
;
793 master
->unprepare_message
= a3700_spi_unprepare_message
;
794 master
->set_cs
= a3700_spi_set_cs
;
795 master
->flags
= SPI_MASTER_HALF_DUPLEX
;
796 master
->mode_bits
|= (SPI_RX_DUAL
| SPI_TX_DUAL
|
797 SPI_RX_QUAD
| SPI_TX_QUAD
);
799 platform_set_drvdata(pdev
, master
);
801 spi
= spi_master_get_devdata(master
);
802 memset(spi
, 0, sizeof(struct a3700_spi
));
804 spi
->master
= master
;
806 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
807 spi
->base
= devm_ioremap_resource(dev
, res
);
808 if (IS_ERR(spi
->base
)) {
809 ret
= PTR_ERR(spi
->base
);
813 irq
= platform_get_irq(pdev
, 0);
815 dev_err(dev
, "could not get irq: %d\n", irq
);
821 init_completion(&spi
->done
);
823 spi
->clk
= devm_clk_get(dev
, NULL
);
824 if (IS_ERR(spi
->clk
)) {
825 dev_err(dev
, "could not find clk: %ld\n", PTR_ERR(spi
->clk
));
829 ret
= clk_prepare(spi
->clk
);
831 dev_err(dev
, "could not prepare clk: %d\n", ret
);
835 ret
= a3700_spi_init(spi
);
839 ret
= devm_request_irq(dev
, spi
->irq
, a3700_spi_interrupt
, 0,
840 dev_name(dev
), master
);
842 dev_err(dev
, "could not request IRQ: %d\n", ret
);
846 ret
= devm_spi_register_master(dev
, master
);
848 dev_err(dev
, "Failed to register master\n");
855 clk_disable_unprepare(spi
->clk
);
857 spi_master_put(master
);
862 static int a3700_spi_remove(struct platform_device
*pdev
)
864 struct spi_master
*master
= platform_get_drvdata(pdev
);
865 struct a3700_spi
*spi
= spi_master_get_devdata(master
);
867 clk_unprepare(spi
->clk
);
872 static struct platform_driver a3700_spi_driver
= {
875 .of_match_table
= of_match_ptr(a3700_spi_dt_ids
),
877 .probe
= a3700_spi_probe
,
878 .remove
= a3700_spi_remove
,
881 module_platform_driver(a3700_spi_driver
);
883 MODULE_DESCRIPTION("Armada-3700 SPI driver");
884 MODULE_AUTHOR("Wilson Ding <dingwei@marvell.com>");
885 MODULE_LICENSE("GPL");
886 MODULE_ALIAS("platform:" DRIVER_NAME
);