spi: a3700: Remove endianness swapping for full-duplex transfers
[muen/linux.git] / drivers / spi / spi-armada-3700.c
1 /*
2  * Marvell Armada-3700 SPI controller driver
3  *
4  * Copyright (C) 2016 Marvell Ltd.
5  *
6  * Author: Wilson Ding <dingwei@marvell.com>
7  * Author: Romain Perier <romain.perier@free-electrons.com>
8  *
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.
12  */
13
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>
19 #include <linux/io.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/of.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>
27
28 #define DRIVER_NAME                     "armada_3700_spi"
29
30 #define A3700_SPI_MAX_SPEED_HZ          100000000
31 #define A3700_SPI_MAX_PRESCALE          30
32 #define A3700_SPI_TIMEOUT               10
33
34 /* SPI Register Offest */
35 #define A3700_SPI_IF_CTRL_REG           0x00
36 #define A3700_SPI_IF_CFG_REG            0x04
37 #define A3700_SPI_DATA_OUT_REG          0x08
38 #define A3700_SPI_DATA_IN_REG           0x0C
39 #define A3700_SPI_IF_INST_REG           0x10
40 #define A3700_SPI_IF_ADDR_REG           0x14
41 #define A3700_SPI_IF_RMODE_REG          0x18
42 #define A3700_SPI_IF_HDR_CNT_REG        0x1C
43 #define A3700_SPI_IF_DIN_CNT_REG        0x20
44 #define A3700_SPI_IF_TIME_REG           0x24
45 #define A3700_SPI_INT_STAT_REG          0x28
46 #define A3700_SPI_INT_MASK_REG          0x2C
47
48 /* A3700_SPI_IF_CTRL_REG */
49 #define A3700_SPI_EN                    BIT(16)
50 #define A3700_SPI_ADDR_NOT_CONFIG       BIT(12)
51 #define A3700_SPI_WFIFO_OVERFLOW        BIT(11)
52 #define A3700_SPI_WFIFO_UNDERFLOW       BIT(10)
53 #define A3700_SPI_RFIFO_OVERFLOW        BIT(9)
54 #define A3700_SPI_RFIFO_UNDERFLOW       BIT(8)
55 #define A3700_SPI_WFIFO_FULL            BIT(7)
56 #define A3700_SPI_WFIFO_EMPTY           BIT(6)
57 #define A3700_SPI_RFIFO_FULL            BIT(5)
58 #define A3700_SPI_RFIFO_EMPTY           BIT(4)
59 #define A3700_SPI_WFIFO_RDY             BIT(3)
60 #define A3700_SPI_RFIFO_RDY             BIT(2)
61 #define A3700_SPI_XFER_RDY              BIT(1)
62 #define A3700_SPI_XFER_DONE             BIT(0)
63
64 /* A3700_SPI_IF_CFG_REG */
65 #define A3700_SPI_WFIFO_THRS            BIT(28)
66 #define A3700_SPI_RFIFO_THRS            BIT(24)
67 #define A3700_SPI_AUTO_CS               BIT(20)
68 #define A3700_SPI_DMA_RD_EN             BIT(18)
69 #define A3700_SPI_FIFO_MODE             BIT(17)
70 #define A3700_SPI_SRST                  BIT(16)
71 #define A3700_SPI_XFER_START            BIT(15)
72 #define A3700_SPI_XFER_STOP             BIT(14)
73 #define A3700_SPI_INST_PIN              BIT(13)
74 #define A3700_SPI_ADDR_PIN              BIT(12)
75 #define A3700_SPI_DATA_PIN1             BIT(11)
76 #define A3700_SPI_DATA_PIN0             BIT(10)
77 #define A3700_SPI_FIFO_FLUSH            BIT(9)
78 #define A3700_SPI_RW_EN                 BIT(8)
79 #define A3700_SPI_CLK_POL               BIT(7)
80 #define A3700_SPI_CLK_PHA               BIT(6)
81 #define A3700_SPI_BYTE_LEN              BIT(5)
82 #define A3700_SPI_CLK_PRESCALE          BIT(0)
83 #define A3700_SPI_CLK_PRESCALE_MASK     (0x1f)
84
85 #define A3700_SPI_WFIFO_THRS_BIT        28
86 #define A3700_SPI_RFIFO_THRS_BIT        24
87 #define A3700_SPI_FIFO_THRS_MASK        0x7
88
89 #define A3700_SPI_DATA_PIN_MASK         0x3
90
91 /* A3700_SPI_IF_HDR_CNT_REG */
92 #define A3700_SPI_DUMMY_CNT_BIT         12
93 #define A3700_SPI_DUMMY_CNT_MASK        0x7
94 #define A3700_SPI_RMODE_CNT_BIT         8
95 #define A3700_SPI_RMODE_CNT_MASK        0x3
96 #define A3700_SPI_ADDR_CNT_BIT          4
97 #define A3700_SPI_ADDR_CNT_MASK         0x7
98 #define A3700_SPI_INSTR_CNT_BIT         0
99 #define A3700_SPI_INSTR_CNT_MASK        0x3
100
101 /* A3700_SPI_IF_TIME_REG */
102 #define A3700_SPI_CLK_CAPT_EDGE         BIT(7)
103
104 struct a3700_spi {
105         struct spi_master *master;
106         void __iomem *base;
107         struct clk *clk;
108         unsigned int irq;
109         unsigned int flags;
110         bool xmit_data;
111         const u8 *tx_buf;
112         u8 *rx_buf;
113         size_t buf_len;
114         u8 byte_len;
115         u32 wait_mask;
116         struct completion done;
117 };
118
119 static u32 spireg_read(struct a3700_spi *a3700_spi, u32 offset)
120 {
121         return readl(a3700_spi->base + offset);
122 }
123
124 static void spireg_write(struct a3700_spi *a3700_spi, u32 offset, u32 data)
125 {
126         writel(data, a3700_spi->base + offset);
127 }
128
129 static void a3700_spi_auto_cs_unset(struct a3700_spi *a3700_spi)
130 {
131         u32 val;
132
133         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
134         val &= ~A3700_SPI_AUTO_CS;
135         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
136 }
137
138 static void a3700_spi_activate_cs(struct a3700_spi *a3700_spi, unsigned int cs)
139 {
140         u32 val;
141
142         val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
143         val |= (A3700_SPI_EN << cs);
144         spireg_write(a3700_spi, A3700_SPI_IF_CTRL_REG, val);
145 }
146
147 static void a3700_spi_deactivate_cs(struct a3700_spi *a3700_spi,
148                                     unsigned int cs)
149 {
150         u32 val;
151
152         val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
153         val &= ~(A3700_SPI_EN << cs);
154         spireg_write(a3700_spi, A3700_SPI_IF_CTRL_REG, val);
155 }
156
157 static int a3700_spi_pin_mode_set(struct a3700_spi *a3700_spi,
158                                   unsigned int pin_mode, bool receiving)
159 {
160         u32 val;
161
162         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
163         val &= ~(A3700_SPI_INST_PIN | A3700_SPI_ADDR_PIN);
164         val &= ~(A3700_SPI_DATA_PIN0 | A3700_SPI_DATA_PIN1);
165
166         switch (pin_mode) {
167         case SPI_NBITS_SINGLE:
168                 break;
169         case SPI_NBITS_DUAL:
170                 val |= A3700_SPI_DATA_PIN0;
171                 break;
172         case SPI_NBITS_QUAD:
173                 val |= A3700_SPI_DATA_PIN1;
174                 /* RX during address reception uses 4-pin */
175                 if (receiving)
176                         val |= A3700_SPI_ADDR_PIN;
177                 break;
178         default:
179                 dev_err(&a3700_spi->master->dev, "wrong pin mode %u", pin_mode);
180                 return -EINVAL;
181         }
182
183         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
184
185         return 0;
186 }
187
188 static void a3700_spi_fifo_mode_set(struct a3700_spi *a3700_spi, bool enable)
189 {
190         u32 val;
191
192         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
193         if (enable)
194                 val |= A3700_SPI_FIFO_MODE;
195         else
196                 val &= ~A3700_SPI_FIFO_MODE;
197         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
198 }
199
200 static void a3700_spi_mode_set(struct a3700_spi *a3700_spi,
201                                unsigned int mode_bits)
202 {
203         u32 val;
204
205         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
206
207         if (mode_bits & SPI_CPOL)
208                 val |= A3700_SPI_CLK_POL;
209         else
210                 val &= ~A3700_SPI_CLK_POL;
211
212         if (mode_bits & SPI_CPHA)
213                 val |= A3700_SPI_CLK_PHA;
214         else
215                 val &= ~A3700_SPI_CLK_PHA;
216
217         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
218 }
219
220 static void a3700_spi_clock_set(struct a3700_spi *a3700_spi,
221                                 unsigned int speed_hz)
222 {
223         u32 val;
224         u32 prescale;
225
226         prescale = DIV_ROUND_UP(clk_get_rate(a3700_spi->clk), speed_hz);
227
228         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
229         val = val & ~A3700_SPI_CLK_PRESCALE_MASK;
230
231         val = val | (prescale & A3700_SPI_CLK_PRESCALE_MASK);
232         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
233
234         if (prescale <= 2) {
235                 val = spireg_read(a3700_spi, A3700_SPI_IF_TIME_REG);
236                 val |= A3700_SPI_CLK_CAPT_EDGE;
237                 spireg_write(a3700_spi, A3700_SPI_IF_TIME_REG, val);
238         }
239 }
240
241 static void a3700_spi_bytelen_set(struct a3700_spi *a3700_spi, unsigned int len)
242 {
243         u32 val;
244
245         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
246         if (len == 4)
247                 val |= A3700_SPI_BYTE_LEN;
248         else
249                 val &= ~A3700_SPI_BYTE_LEN;
250         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
251
252         a3700_spi->byte_len = len;
253 }
254
255 static int a3700_spi_fifo_flush(struct a3700_spi *a3700_spi)
256 {
257         int timeout = A3700_SPI_TIMEOUT;
258         u32 val;
259
260         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
261         val |= A3700_SPI_FIFO_FLUSH;
262         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
263
264         while (--timeout) {
265                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
266                 if (!(val & A3700_SPI_FIFO_FLUSH))
267                         return 0;
268                 udelay(1);
269         }
270
271         return -ETIMEDOUT;
272 }
273
274 static int a3700_spi_init(struct a3700_spi *a3700_spi)
275 {
276         struct spi_master *master = a3700_spi->master;
277         u32 val;
278         int i, ret = 0;
279
280         /* Reset SPI unit */
281         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
282         val |= A3700_SPI_SRST;
283         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
284
285         udelay(A3700_SPI_TIMEOUT);
286
287         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
288         val &= ~A3700_SPI_SRST;
289         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
290
291         /* Disable AUTO_CS and deactivate all chip-selects */
292         a3700_spi_auto_cs_unset(a3700_spi);
293         for (i = 0; i < master->num_chipselect; i++)
294                 a3700_spi_deactivate_cs(a3700_spi, i);
295
296         /* Enable FIFO mode */
297         a3700_spi_fifo_mode_set(a3700_spi, true);
298
299         /* Set SPI mode */
300         a3700_spi_mode_set(a3700_spi, master->mode_bits);
301
302         /* Reset counters */
303         spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, 0);
304         spireg_write(a3700_spi, A3700_SPI_IF_DIN_CNT_REG, 0);
305
306         /* Mask the interrupts and clear cause bits */
307         spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0);
308         spireg_write(a3700_spi, A3700_SPI_INT_STAT_REG, ~0U);
309
310         return ret;
311 }
312
313 static irqreturn_t a3700_spi_interrupt(int irq, void *dev_id)
314 {
315         struct spi_master *master = dev_id;
316         struct a3700_spi *a3700_spi;
317         u32 cause;
318
319         a3700_spi = spi_master_get_devdata(master);
320
321         /* Get interrupt causes */
322         cause = spireg_read(a3700_spi, A3700_SPI_INT_STAT_REG);
323
324         if (!cause || !(a3700_spi->wait_mask & cause))
325                 return IRQ_NONE;
326
327         /* mask and acknowledge the SPI interrupts */
328         spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0);
329         spireg_write(a3700_spi, A3700_SPI_INT_STAT_REG, cause);
330
331         /* Wake up the transfer */
332         complete(&a3700_spi->done);
333
334         return IRQ_HANDLED;
335 }
336
337 static bool a3700_spi_wait_completion(struct spi_device *spi)
338 {
339         struct a3700_spi *a3700_spi;
340         unsigned int timeout;
341         unsigned int ctrl_reg;
342         unsigned long timeout_jiffies;
343
344         a3700_spi = spi_master_get_devdata(spi->master);
345
346         /* SPI interrupt is edge-triggered, which means an interrupt will
347          * be generated only when detecting a specific status bit changed
348          * from '0' to '1'. So when we start waiting for a interrupt, we
349          * need to check status bit in control reg first, if it is already 1,
350          * then we do not need to wait for interrupt
351          */
352         ctrl_reg = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
353         if (a3700_spi->wait_mask & ctrl_reg)
354                 return true;
355
356         reinit_completion(&a3700_spi->done);
357
358         spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG,
359                      a3700_spi->wait_mask);
360
361         timeout_jiffies = msecs_to_jiffies(A3700_SPI_TIMEOUT);
362         timeout = wait_for_completion_timeout(&a3700_spi->done,
363                                               timeout_jiffies);
364
365         a3700_spi->wait_mask = 0;
366
367         if (timeout)
368                 return true;
369
370         /* there might be the case that right after we checked the
371          * status bits in this routine and before start to wait for
372          * interrupt by wait_for_completion_timeout, the interrupt
373          * happens, to avoid missing it we need to double check
374          * status bits in control reg, if it is already 1, then
375          * consider that we have the interrupt successfully and
376          * return true.
377          */
378         ctrl_reg = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
379         if (a3700_spi->wait_mask & ctrl_reg)
380                 return true;
381
382         spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0);
383
384         /* Timeout was reached */
385         return false;
386 }
387
388 static bool a3700_spi_transfer_wait(struct spi_device *spi,
389                                     unsigned int bit_mask)
390 {
391         struct a3700_spi *a3700_spi;
392
393         a3700_spi = spi_master_get_devdata(spi->master);
394         a3700_spi->wait_mask = bit_mask;
395
396         return a3700_spi_wait_completion(spi);
397 }
398
399 static void a3700_spi_fifo_thres_set(struct a3700_spi *a3700_spi,
400                                      unsigned int bytes)
401 {
402         u32 val;
403
404         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
405         val &= ~(A3700_SPI_FIFO_THRS_MASK << A3700_SPI_RFIFO_THRS_BIT);
406         val |= (bytes - 1) << A3700_SPI_RFIFO_THRS_BIT;
407         val &= ~(A3700_SPI_FIFO_THRS_MASK << A3700_SPI_WFIFO_THRS_BIT);
408         val |= (7 - bytes) << A3700_SPI_WFIFO_THRS_BIT;
409         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
410 }
411
412 static void a3700_spi_transfer_setup(struct spi_device *spi,
413                                      struct spi_transfer *xfer)
414 {
415         struct a3700_spi *a3700_spi;
416
417         a3700_spi = spi_master_get_devdata(spi->master);
418
419         a3700_spi_clock_set(a3700_spi, xfer->speed_hz);
420
421         /* Use 4 bytes long transfers. Each transfer method has its way to deal
422          * with the remaining bytes for non 4-bytes aligned transfers.
423          */
424         a3700_spi_bytelen_set(a3700_spi, 4);
425
426         /* Initialize the working buffers */
427         a3700_spi->tx_buf  = xfer->tx_buf;
428         a3700_spi->rx_buf  = xfer->rx_buf;
429         a3700_spi->buf_len = xfer->len;
430 }
431
432 static void a3700_spi_set_cs(struct spi_device *spi, bool enable)
433 {
434         struct a3700_spi *a3700_spi = spi_master_get_devdata(spi->master);
435
436         if (!enable)
437                 a3700_spi_activate_cs(a3700_spi, spi->chip_select);
438         else
439                 a3700_spi_deactivate_cs(a3700_spi, spi->chip_select);
440 }
441
442 static void a3700_spi_header_set(struct a3700_spi *a3700_spi)
443 {
444         unsigned int addr_cnt;
445         u32 val = 0;
446
447         /* Clear the header registers */
448         spireg_write(a3700_spi, A3700_SPI_IF_INST_REG, 0);
449         spireg_write(a3700_spi, A3700_SPI_IF_ADDR_REG, 0);
450         spireg_write(a3700_spi, A3700_SPI_IF_RMODE_REG, 0);
451         spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, 0);
452
453         /* Set header counters */
454         if (a3700_spi->tx_buf) {
455                 /*
456                  * when tx data is not 4 bytes aligned, there will be unexpected
457                  * bytes out of SPI output register, since it always shifts out
458                  * as whole 4 bytes. This might cause incorrect transaction with
459                  * some devices. To avoid that, use SPI header count feature to
460                  * transfer up to 3 bytes of data first, and then make the rest
461                  * of data 4-byte aligned.
462                  */
463                 addr_cnt = a3700_spi->buf_len % 4;
464                 if (addr_cnt) {
465                         val = (addr_cnt & A3700_SPI_ADDR_CNT_MASK)
466                                 << A3700_SPI_ADDR_CNT_BIT;
467                         spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, val);
468
469                         /* Update the buffer length to be transferred */
470                         a3700_spi->buf_len -= addr_cnt;
471
472                         /* transfer 1~3 bytes through address count */
473                         val = 0;
474                         while (addr_cnt--) {
475                                 val = (val << 8) | a3700_spi->tx_buf[0];
476                                 a3700_spi->tx_buf++;
477                         }
478                         spireg_write(a3700_spi, A3700_SPI_IF_ADDR_REG, val);
479                 }
480         }
481 }
482
483 static int a3700_is_wfifo_full(struct a3700_spi *a3700_spi)
484 {
485         u32 val;
486
487         val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
488         return (val & A3700_SPI_WFIFO_FULL);
489 }
490
491 static int a3700_spi_fifo_write(struct a3700_spi *a3700_spi)
492 {
493         u32 val;
494
495         while (!a3700_is_wfifo_full(a3700_spi) && a3700_spi->buf_len) {
496                 val = *(u32 *)a3700_spi->tx_buf;
497                 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, val);
498                 a3700_spi->buf_len -= 4;
499                 a3700_spi->tx_buf += 4;
500         }
501
502         return 0;
503 }
504
505 static int a3700_is_rfifo_empty(struct a3700_spi *a3700_spi)
506 {
507         u32 val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG);
508
509         return (val & A3700_SPI_RFIFO_EMPTY);
510 }
511
512 static int a3700_spi_fifo_read(struct a3700_spi *a3700_spi)
513 {
514         u32 val;
515
516         while (!a3700_is_rfifo_empty(a3700_spi) && a3700_spi->buf_len) {
517                 val = spireg_read(a3700_spi, A3700_SPI_DATA_IN_REG);
518                 if (a3700_spi->buf_len >= 4) {
519
520                         memcpy(a3700_spi->rx_buf, &val, 4);
521
522                         a3700_spi->buf_len -= 4;
523                         a3700_spi->rx_buf += 4;
524                 } else {
525                         /*
526                          * When remain bytes is not larger than 4, we should
527                          * avoid memory overwriting and just write the left rx
528                          * buffer bytes.
529                          */
530                         while (a3700_spi->buf_len) {
531                                 *a3700_spi->rx_buf = val & 0xff;
532                                 val >>= 8;
533
534                                 a3700_spi->buf_len--;
535                                 a3700_spi->rx_buf++;
536                         }
537                 }
538         }
539
540         return 0;
541 }
542
543 static void a3700_spi_transfer_abort_fifo(struct a3700_spi *a3700_spi)
544 {
545         int timeout = A3700_SPI_TIMEOUT;
546         u32 val;
547
548         val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
549         val |= A3700_SPI_XFER_STOP;
550         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
551
552         while (--timeout) {
553                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
554                 if (!(val & A3700_SPI_XFER_START))
555                         break;
556                 udelay(1);
557         }
558
559         a3700_spi_fifo_flush(a3700_spi);
560
561         val &= ~A3700_SPI_XFER_STOP;
562         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
563 }
564
565 static int a3700_spi_prepare_message(struct spi_master *master,
566                                      struct spi_message *message)
567 {
568         struct a3700_spi *a3700_spi = spi_master_get_devdata(master);
569         struct spi_device *spi = message->spi;
570         int ret;
571
572         ret = clk_enable(a3700_spi->clk);
573         if (ret) {
574                 dev_err(&spi->dev, "failed to enable clk with error %d\n", ret);
575                 return ret;
576         }
577
578         /* Flush the FIFOs */
579         ret = a3700_spi_fifo_flush(a3700_spi);
580         if (ret)
581                 return ret;
582
583         a3700_spi_mode_set(a3700_spi, spi->mode);
584
585         return 0;
586 }
587
588 static int a3700_spi_transfer_one_fifo(struct spi_master *master,
589                                   struct spi_device *spi,
590                                   struct spi_transfer *xfer)
591 {
592         struct a3700_spi *a3700_spi = spi_master_get_devdata(master);
593         int ret = 0, timeout = A3700_SPI_TIMEOUT;
594         unsigned int nbits = 0, byte_len;
595         u32 val;
596
597         /* Make sure we use FIFO mode */
598         a3700_spi_fifo_mode_set(a3700_spi, true);
599
600         /* Configure FIFO thresholds */
601         byte_len = xfer->bits_per_word >> 3;
602         a3700_spi_fifo_thres_set(a3700_spi, byte_len);
603
604         if (xfer->tx_buf)
605                 nbits = xfer->tx_nbits;
606         else if (xfer->rx_buf)
607                 nbits = xfer->rx_nbits;
608
609         a3700_spi_pin_mode_set(a3700_spi, nbits, xfer->rx_buf ? true : false);
610
611         /* Flush the FIFOs */
612         a3700_spi_fifo_flush(a3700_spi);
613
614         /* Transfer first bytes of data when buffer is not 4-byte aligned */
615         a3700_spi_header_set(a3700_spi);
616
617         if (xfer->rx_buf) {
618                 /* Clear WFIFO, since it's last 2 bytes are shifted out during
619                  * a read operation
620                  */
621                 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, 0);
622
623                 /* Set read data length */
624                 spireg_write(a3700_spi, A3700_SPI_IF_DIN_CNT_REG,
625                              a3700_spi->buf_len);
626                 /* Start READ transfer */
627                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
628                 val &= ~A3700_SPI_RW_EN;
629                 val |= A3700_SPI_XFER_START;
630                 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
631         } else if (xfer->tx_buf) {
632                 /* Start Write transfer */
633                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
634                 val |= (A3700_SPI_XFER_START | A3700_SPI_RW_EN);
635                 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
636
637                 /*
638                  * If there are data to be written to the SPI device, xmit_data
639                  * flag is set true; otherwise the instruction in SPI_INSTR does
640                  * not require data to be written to the SPI device, then
641                  * xmit_data flag is set false.
642                  */
643                 a3700_spi->xmit_data = (a3700_spi->buf_len != 0);
644         }
645
646         while (a3700_spi->buf_len) {
647                 if (a3700_spi->tx_buf) {
648                         /* Wait wfifo ready */
649                         if (!a3700_spi_transfer_wait(spi,
650                                                      A3700_SPI_WFIFO_RDY)) {
651                                 dev_err(&spi->dev,
652                                         "wait wfifo ready timed out\n");
653                                 ret = -ETIMEDOUT;
654                                 goto error;
655                         }
656                         /* Fill up the wfifo */
657                         ret = a3700_spi_fifo_write(a3700_spi);
658                         if (ret)
659                                 goto error;
660                 } else if (a3700_spi->rx_buf) {
661                         /* Wait rfifo ready */
662                         if (!a3700_spi_transfer_wait(spi,
663                                                      A3700_SPI_RFIFO_RDY)) {
664                                 dev_err(&spi->dev,
665                                         "wait rfifo ready timed out\n");
666                                 ret = -ETIMEDOUT;
667                                 goto error;
668                         }
669                         /* Drain out the rfifo */
670                         ret = a3700_spi_fifo_read(a3700_spi);
671                         if (ret)
672                                 goto error;
673                 }
674         }
675
676         /*
677          * Stop a write transfer in fifo mode:
678          *      - wait all the bytes in wfifo to be shifted out
679          *       - set XFER_STOP bit
680          *      - wait XFER_START bit clear
681          *      - clear XFER_STOP bit
682          * Stop a read transfer in fifo mode:
683          *      - the hardware is to reset the XFER_START bit
684          *         after the number of bytes indicated in DIN_CNT
685          *         register
686          *      - just wait XFER_START bit clear
687          */
688         if (a3700_spi->tx_buf) {
689                 if (a3700_spi->xmit_data) {
690                         /*
691                          * If there are data written to the SPI device, wait
692                          * until SPI_WFIFO_EMPTY is 1 to wait for all data to
693                          * transfer out of write FIFO.
694                          */
695                         if (!a3700_spi_transfer_wait(spi,
696                                                      A3700_SPI_WFIFO_EMPTY)) {
697                                 dev_err(&spi->dev, "wait wfifo empty timed out\n");
698                                 return -ETIMEDOUT;
699                         }
700                 }
701
702                 if (!a3700_spi_transfer_wait(spi, A3700_SPI_XFER_RDY)) {
703                         dev_err(&spi->dev, "wait xfer ready timed out\n");
704                         return -ETIMEDOUT;
705                 }
706
707                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
708                 val |= A3700_SPI_XFER_STOP;
709                 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
710         }
711
712         while (--timeout) {
713                 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG);
714                 if (!(val & A3700_SPI_XFER_START))
715                         break;
716                 udelay(1);
717         }
718
719         if (timeout == 0) {
720                 dev_err(&spi->dev, "wait transfer start clear timed out\n");
721                 ret = -ETIMEDOUT;
722                 goto error;
723         }
724
725         val &= ~A3700_SPI_XFER_STOP;
726         spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val);
727         goto out;
728
729 error:
730         a3700_spi_transfer_abort_fifo(a3700_spi);
731 out:
732         spi_finalize_current_transfer(master);
733
734         return ret;
735 }
736
737 static int a3700_spi_transfer_one_full_duplex(struct spi_master *master,
738                                   struct spi_device *spi,
739                                   struct spi_transfer *xfer)
740 {
741         struct a3700_spi *a3700_spi = spi_master_get_devdata(master);
742         u32 val;
743
744         /* Disable FIFO mode */
745         a3700_spi_fifo_mode_set(a3700_spi, false);
746
747         while (a3700_spi->buf_len) {
748
749                 /* When we have less than 4 bytes to transfer, switch to 1 byte
750                  * mode. This is reset after each transfer
751                  */
752                 if (a3700_spi->buf_len < 4)
753                         a3700_spi_bytelen_set(a3700_spi, 1);
754
755                 if (a3700_spi->byte_len == 1)
756                         val = *a3700_spi->tx_buf;
757                 else
758                         val = *(u32 *)a3700_spi->tx_buf;
759
760                 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, val);
761
762                 /* Wait for all the data to be shifted in / out */
763                 while (!(spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG) &
764                                 A3700_SPI_XFER_DONE))
765                         cpu_relax();
766
767                 val = spireg_read(a3700_spi, A3700_SPI_DATA_IN_REG);
768
769                 memcpy(a3700_spi->rx_buf, &val, a3700_spi->byte_len);
770
771                 a3700_spi->buf_len -= a3700_spi->byte_len;
772                 a3700_spi->tx_buf += a3700_spi->byte_len;
773                 a3700_spi->rx_buf += a3700_spi->byte_len;
774
775         }
776
777         spi_finalize_current_transfer(master);
778
779         return 0;
780 }
781
782 static int a3700_spi_transfer_one(struct spi_master *master,
783                                   struct spi_device *spi,
784                                   struct spi_transfer *xfer)
785 {
786         a3700_spi_transfer_setup(spi, xfer);
787
788         if (xfer->tx_buf && xfer->rx_buf)
789                 return a3700_spi_transfer_one_full_duplex(master, spi, xfer);
790
791         return a3700_spi_transfer_one_fifo(master, spi, xfer);
792 }
793
794 static int a3700_spi_unprepare_message(struct spi_master *master,
795                                        struct spi_message *message)
796 {
797         struct a3700_spi *a3700_spi = spi_master_get_devdata(master);
798
799         clk_disable(a3700_spi->clk);
800
801         return 0;
802 }
803
804 static const struct of_device_id a3700_spi_dt_ids[] = {
805         { .compatible = "marvell,armada-3700-spi", .data = NULL },
806         {},
807 };
808
809 MODULE_DEVICE_TABLE(of, a3700_spi_dt_ids);
810
811 static int a3700_spi_probe(struct platform_device *pdev)
812 {
813         struct device *dev = &pdev->dev;
814         struct device_node *of_node = dev->of_node;
815         struct resource *res;
816         struct spi_master *master;
817         struct a3700_spi *spi;
818         u32 num_cs = 0;
819         int irq, ret = 0;
820
821         master = spi_alloc_master(dev, sizeof(*spi));
822         if (!master) {
823                 dev_err(dev, "master allocation failed\n");
824                 ret = -ENOMEM;
825                 goto out;
826         }
827
828         if (of_property_read_u32(of_node, "num-cs", &num_cs)) {
829                 dev_err(dev, "could not find num-cs\n");
830                 ret = -ENXIO;
831                 goto error;
832         }
833
834         master->bus_num = pdev->id;
835         master->dev.of_node = of_node;
836         master->mode_bits = SPI_MODE_3;
837         master->num_chipselect = num_cs;
838         master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(32);
839         master->prepare_message =  a3700_spi_prepare_message;
840         master->transfer_one = a3700_spi_transfer_one;
841         master->unprepare_message = a3700_spi_unprepare_message;
842         master->set_cs = a3700_spi_set_cs;
843         master->mode_bits |= (SPI_RX_DUAL | SPI_TX_DUAL |
844                               SPI_RX_QUAD | SPI_TX_QUAD);
845
846         platform_set_drvdata(pdev, master);
847
848         spi = spi_master_get_devdata(master);
849         memset(spi, 0, sizeof(struct a3700_spi));
850
851         spi->master = master;
852
853         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
854         spi->base = devm_ioremap_resource(dev, res);
855         if (IS_ERR(spi->base)) {
856                 ret = PTR_ERR(spi->base);
857                 goto error;
858         }
859
860         irq = platform_get_irq(pdev, 0);
861         if (irq < 0) {
862                 dev_err(dev, "could not get irq: %d\n", irq);
863                 ret = -ENXIO;
864                 goto error;
865         }
866         spi->irq = irq;
867
868         init_completion(&spi->done);
869
870         spi->clk = devm_clk_get(dev, NULL);
871         if (IS_ERR(spi->clk)) {
872                 dev_err(dev, "could not find clk: %ld\n", PTR_ERR(spi->clk));
873                 goto error;
874         }
875
876         ret = clk_prepare(spi->clk);
877         if (ret) {
878                 dev_err(dev, "could not prepare clk: %d\n", ret);
879                 goto error;
880         }
881
882         master->max_speed_hz = min_t(unsigned long, A3700_SPI_MAX_SPEED_HZ,
883                                         clk_get_rate(spi->clk));
884         master->min_speed_hz = DIV_ROUND_UP(clk_get_rate(spi->clk),
885                                                 A3700_SPI_MAX_PRESCALE);
886
887         ret = a3700_spi_init(spi);
888         if (ret)
889                 goto error_clk;
890
891         ret = devm_request_irq(dev, spi->irq, a3700_spi_interrupt, 0,
892                                dev_name(dev), master);
893         if (ret) {
894                 dev_err(dev, "could not request IRQ: %d\n", ret);
895                 goto error_clk;
896         }
897
898         ret = devm_spi_register_master(dev, master);
899         if (ret) {
900                 dev_err(dev, "Failed to register master\n");
901                 goto error_clk;
902         }
903
904         return 0;
905
906 error_clk:
907         clk_disable_unprepare(spi->clk);
908 error:
909         spi_master_put(master);
910 out:
911         return ret;
912 }
913
914 static int a3700_spi_remove(struct platform_device *pdev)
915 {
916         struct spi_master *master = platform_get_drvdata(pdev);
917         struct a3700_spi *spi = spi_master_get_devdata(master);
918
919         clk_unprepare(spi->clk);
920
921         return 0;
922 }
923
924 static struct platform_driver a3700_spi_driver = {
925         .driver = {
926                 .name   = DRIVER_NAME,
927                 .of_match_table = of_match_ptr(a3700_spi_dt_ids),
928         },
929         .probe          = a3700_spi_probe,
930         .remove         = a3700_spi_remove,
931 };
932
933 module_platform_driver(a3700_spi_driver);
934
935 MODULE_DESCRIPTION("Armada-3700 SPI driver");
936 MODULE_AUTHOR("Wilson Ding <dingwei@marvell.com>");
937 MODULE_LICENSE("GPL");
938 MODULE_ALIAS("platform:" DRIVER_NAME);