?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / spi / spi-sprd.c
blob6678f1cbc566078a7681a4aa047bc01a80cc4456
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 Spreadtrum Communications Inc.
3
4 #include <linux/clk.h>
5 #include <linux/dmaengine.h>
6 #include <linux/dma-mapping.h>
7 #include <linux/dma/sprd-dma.h>
8 #include <linux/interrupt.h>
9 #include <linux/io.h>
10 #include <linux/iopoll.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/of_device.h>
15 #include <linux/of_dma.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/spi/spi.h>
19
20 #define SPRD_SPI_TXD 0x0
21 #define SPRD_SPI_CLKD 0x4
22 #define SPRD_SPI_CTL0 0x8
23 #define SPRD_SPI_CTL1 0xc
24 #define SPRD_SPI_CTL2 0x10
25 #define SPRD_SPI_CTL3 0x14
26 #define SPRD_SPI_CTL4 0x18
27 #define SPRD_SPI_CTL5 0x1c
28 #define SPRD_SPI_INT_EN 0x20
29 #define SPRD_SPI_INT_CLR 0x24
30 #define SPRD_SPI_INT_RAW_STS 0x28
31 #define SPRD_SPI_INT_MASK_STS 0x2c
32 #define SPRD_SPI_STS1 0x30
33 #define SPRD_SPI_STS2 0x34
34 #define SPRD_SPI_DSP_WAIT 0x38
35 #define SPRD_SPI_STS3 0x3c
36 #define SPRD_SPI_CTL6 0x40
37 #define SPRD_SPI_STS4 0x44
38 #define SPRD_SPI_FIFO_RST 0x48
39 #define SPRD_SPI_CTL7 0x4c
40 #define SPRD_SPI_STS5 0x50
41 #define SPRD_SPI_CTL8 0x54
42 #define SPRD_SPI_CTL9 0x58
43 #define SPRD_SPI_CTL10 0x5c
44 #define SPRD_SPI_CTL11 0x60
45 #define SPRD_SPI_CTL12 0x64
46 #define SPRD_SPI_STS6 0x68
47 #define SPRD_SPI_STS7 0x6c
48 #define SPRD_SPI_STS8 0x70
49 #define SPRD_SPI_STS9 0x74
50
51 /* Bits & mask definition for register CTL0 */
52 #define SPRD_SPI_SCK_REV BIT(13)
53 #define SPRD_SPI_NG_TX BIT(1)
54 #define SPRD_SPI_NG_RX BIT(0)
55 #define SPRD_SPI_CHNL_LEN_MASK GENMASK(4, 0)
56 #define SPRD_SPI_CSN_MASK GENMASK(11, 8)
57 #define SPRD_SPI_CS0_VALID BIT(8)
58
59 /* Bits & mask definition for register SPI_INT_EN */
60 #define SPRD_SPI_TX_END_INT_EN BIT(8)
61 #define SPRD_SPI_RX_END_INT_EN BIT(9)
62
63 /* Bits & mask definition for register SPI_INT_RAW_STS */
64 #define SPRD_SPI_TX_END_RAW BIT(8)
65 #define SPRD_SPI_RX_END_RAW BIT(9)
66
67 /* Bits & mask definition for register SPI_INT_CLR */
68 #define SPRD_SPI_TX_END_CLR BIT(8)
69 #define SPRD_SPI_RX_END_CLR BIT(9)
70
71 /* Bits & mask definition for register INT_MASK_STS */
72 #define SPRD_SPI_MASK_RX_END BIT(9)
73 #define SPRD_SPI_MASK_TX_END BIT(8)
74
75 /* Bits & mask definition for register STS2 */
76 #define SPRD_SPI_TX_BUSY BIT(8)
77
78 /* Bits & mask definition for register CTL1 */
79 #define SPRD_SPI_RX_MODE BIT(12)
80 #define SPRD_SPI_TX_MODE BIT(13)
81 #define SPRD_SPI_RTX_MD_MASK GENMASK(13, 12)
82
83 /* Bits & mask definition for register CTL2 */
84 #define SPRD_SPI_DMA_EN BIT(6)
85
86 /* Bits & mask definition for register CTL4 */
87 #define SPRD_SPI_START_RX BIT(9)
88 #define SPRD_SPI_ONLY_RECV_MASK GENMASK(8, 0)
89
90 /* Bits & mask definition for register SPI_INT_CLR */
91 #define SPRD_SPI_RX_END_INT_CLR BIT(9)
92 #define SPRD_SPI_TX_END_INT_CLR BIT(8)
93
94 /* Bits & mask definition for register SPI_INT_RAW */
95 #define SPRD_SPI_RX_END_IRQ BIT(9)
96 #define SPRD_SPI_TX_END_IRQ BIT(8)
97
98 /* Bits & mask definition for register CTL12 */
99 #define SPRD_SPI_SW_RX_REQ BIT(0)
100 #define SPRD_SPI_SW_TX_REQ BIT(1)
101
102 /* Bits & mask definition for register CTL7 */
103 #define SPRD_SPI_DATA_LINE2_EN BIT(15)
104 #define SPRD_SPI_MODE_MASK GENMASK(5, 3)
105 #define SPRD_SPI_MODE_OFFSET 3
106 #define SPRD_SPI_3WIRE_MODE 4
107 #define SPRD_SPI_4WIRE_MODE 0
108
109 /* Bits & mask definition for register CTL8 */
110 #define SPRD_SPI_TX_MAX_LEN_MASK GENMASK(19, 0)
111 #define SPRD_SPI_TX_LEN_H_MASK GENMASK(3, 0)
112 #define SPRD_SPI_TX_LEN_H_OFFSET 16
113
114 /* Bits & mask definition for register CTL9 */
115 #define SPRD_SPI_TX_LEN_L_MASK GENMASK(15, 0)
116
117 /* Bits & mask definition for register CTL10 */
118 #define SPRD_SPI_RX_MAX_LEN_MASK GENMASK(19, 0)
119 #define SPRD_SPI_RX_LEN_H_MASK GENMASK(3, 0)
120 #define SPRD_SPI_RX_LEN_H_OFFSET 16
121
122 /* Bits & mask definition for register CTL11 */
123 #define SPRD_SPI_RX_LEN_L_MASK GENMASK(15, 0)
124
125 /* Default & maximum word delay cycles */
126 #define SPRD_SPI_MIN_DELAY_CYCLE 14
127 #define SPRD_SPI_MAX_DELAY_CYCLE 130
128
129 #define SPRD_SPI_FIFO_SIZE 32
130 #define SPRD_SPI_CHIP_CS_NUM 0x4
131 #define SPRD_SPI_CHNL_LEN 2
132 #define SPRD_SPI_DEFAULT_SOURCE 26000000
133 #define SPRD_SPI_MAX_SPEED_HZ 48000000
134 #define SPRD_SPI_AUTOSUSPEND_DELAY 100
135 #define SPRD_SPI_DMA_STEP 8
136
137 enum sprd_spi_dma_channel {
138 SPRD_SPI_RX,
139 SPRD_SPI_TX,
140 SPRD_SPI_MAX,
141 };
142
143 struct sprd_spi_dma {
144 bool enable;
145 struct dma_chan *dma_chan[SPRD_SPI_MAX];
146 enum dma_slave_buswidth width;
147 u32 fragmens_len;
148 u32 rx_len;
149 };
150
151 struct sprd_spi {
152 void __iomem *base;
153 phys_addr_t phy_base;
154 struct device *dev;
155 struct clk *clk;
156 int irq;
157 u32 src_clk;
158 u32 hw_mode;
159 u32 trans_len;
160 u32 trans_mode;
161 u32 word_delay;
162 u32 hw_speed_hz;
163 u32 len;
164 int status;
165 struct sprd_spi_dma dma;
166 struct completion xfer_completion;
167 const void *tx_buf;
168 void *rx_buf;
169 int (*read_bufs)(struct sprd_spi *ss, u32 len);
170 int (*write_bufs)(struct sprd_spi *ss, u32 len);
171 };
172
173 static u32 sprd_spi_transfer_max_timeout(struct sprd_spi *ss,
174 struct spi_transfer *t)
175 {
176 /*
177 * The time spent on transmission of the full FIFO data is the maximum
178 * SPI transmission time.
179 */
180 u32 size = t->bits_per_word * SPRD_SPI_FIFO_SIZE;
181 u32 bit_time_us = DIV_ROUND_UP(USEC_PER_SEC, ss->hw_speed_hz);
182 u32 total_time_us = size * bit_time_us;
183 /*
184 * There is an interval between data and the data in our SPI hardware,
185 * so the total transmission time need add the interval time.
186 */
187 u32 interval_cycle = SPRD_SPI_FIFO_SIZE * ss->word_delay;
188 u32 interval_time_us = DIV_ROUND_UP(interval_cycle * USEC_PER_SEC,
189 ss->src_clk);
190
191 return total_time_us + interval_time_us;
192 }
193
194 static int sprd_spi_wait_for_tx_end(struct sprd_spi *ss, struct spi_transfer *t)
195 {
196 u32 val, us;
197 int ret;
198
199 us = sprd_spi_transfer_max_timeout(ss, t);
200 ret = readl_relaxed_poll_timeout(ss->base + SPRD_SPI_INT_RAW_STS, val,
201 val & SPRD_SPI_TX_END_IRQ, 0, us);
202 if (ret) {
203 dev_err(ss->dev, "SPI error, spi send timeout!\n");
204 return ret;
205 }
206
207 ret = readl_relaxed_poll_timeout(ss->base + SPRD_SPI_STS2, val,
208 !(val & SPRD_SPI_TX_BUSY), 0, us);
209 if (ret) {
210 dev_err(ss->dev, "SPI error, spi busy timeout!\n");
211 return ret;
212 }
213
214 writel_relaxed(SPRD_SPI_TX_END_INT_CLR, ss->base + SPRD_SPI_INT_CLR);
215
216 return 0;
217 }
218
219 static int sprd_spi_wait_for_rx_end(struct sprd_spi *ss, struct spi_transfer *t)
220 {
221 u32 val, us;
222 int ret;
223
224 us = sprd_spi_transfer_max_timeout(ss, t);
225 ret = readl_relaxed_poll_timeout(ss->base + SPRD_SPI_INT_RAW_STS, val,
226 val & SPRD_SPI_RX_END_IRQ, 0, us);
227 if (ret) {
228 dev_err(ss->dev, "SPI error, spi rx timeout!\n");
229 return ret;
230 }
231
232 writel_relaxed(SPRD_SPI_RX_END_INT_CLR, ss->base + SPRD_SPI_INT_CLR);
233
234 return 0;
235 }
236
237 static void sprd_spi_tx_req(struct sprd_spi *ss)
238 {
239 writel_relaxed(SPRD_SPI_SW_TX_REQ, ss->base + SPRD_SPI_CTL12);
240 }
241
242 static void sprd_spi_rx_req(struct sprd_spi *ss)
243 {
244 writel_relaxed(SPRD_SPI_SW_RX_REQ, ss->base + SPRD_SPI_CTL12);
245 }
246
247 static void sprd_spi_enter_idle(struct sprd_spi *ss)
248 {
249 u32 val = readl_relaxed(ss->base + SPRD_SPI_CTL1);
250
251 val &= ~SPRD_SPI_RTX_MD_MASK;
252 writel_relaxed(val, ss->base + SPRD_SPI_CTL1);
253 }
254
255 static void sprd_spi_set_transfer_bits(struct sprd_spi *ss, u32 bits)
256 {
257 u32 val = readl_relaxed(ss->base + SPRD_SPI_CTL0);
258
259 /* Set the valid bits for every transaction */
260 val &= ~(SPRD_SPI_CHNL_LEN_MASK << SPRD_SPI_CHNL_LEN);
261 val |= bits << SPRD_SPI_CHNL_LEN;
262 writel_relaxed(val, ss->base + SPRD_SPI_CTL0);
263 }
264
265 static void sprd_spi_set_tx_length(struct sprd_spi *ss, u32 length)
266 {
267 u32 val = readl_relaxed(ss->base + SPRD_SPI_CTL8);
268
269 length &= SPRD_SPI_TX_MAX_LEN_MASK;
270 val &= ~SPRD_SPI_TX_LEN_H_MASK;
271 val |= length >> SPRD_SPI_TX_LEN_H_OFFSET;
272 writel_relaxed(val, ss->base + SPRD_SPI_CTL8);
273
274 val = length & SPRD_SPI_TX_LEN_L_MASK;
275 writel_relaxed(val, ss->base + SPRD_SPI_CTL9);
276 }
277
278 static void sprd_spi_set_rx_length(struct sprd_spi *ss, u32 length)
279 {
280 u32 val = readl_relaxed(ss->base + SPRD_SPI_CTL10);
281
282 length &= SPRD_SPI_RX_MAX_LEN_MASK;
283 val &= ~SPRD_SPI_RX_LEN_H_MASK;
284 val |= length >> SPRD_SPI_RX_LEN_H_OFFSET;
285 writel_relaxed(val, ss->base + SPRD_SPI_CTL10);
286
287 val = length & SPRD_SPI_RX_LEN_L_MASK;
288 writel_relaxed(val, ss->base + SPRD_SPI_CTL11);
289 }
290
291 static void sprd_spi_chipselect(struct spi_device *sdev, bool cs)
292 {
293 struct spi_controller *sctlr = sdev->controller;
294 struct sprd_spi *ss = spi_controller_get_devdata(sctlr);
295 u32 val;
296
297 val = readl_relaxed(ss->base + SPRD_SPI_CTL0);
298 /* The SPI controller will pull down CS pin if cs is 0 */
299 if (!cs) {
300 val &= ~SPRD_SPI_CS0_VALID;
301 writel_relaxed(val, ss->base + SPRD_SPI_CTL0);
302 } else {
303 val |= SPRD_SPI_CSN_MASK;
304 writel_relaxed(val, ss->base + SPRD_SPI_CTL0);
305 }
306 }
307
308 static int sprd_spi_write_only_receive(struct sprd_spi *ss, u32 len)
309 {
310 u32 val;
311
312 /* Clear the start receive bit and reset receive data number */
313 val = readl_relaxed(ss->base + SPRD_SPI_CTL4);
314 val &= ~(SPRD_SPI_START_RX | SPRD_SPI_ONLY_RECV_MASK);
315 writel_relaxed(val, ss->base + SPRD_SPI_CTL4);
316
317 /* Set the receive data length */
318 val = readl_relaxed(ss->base + SPRD_SPI_CTL4);
319 val |= len & SPRD_SPI_ONLY_RECV_MASK;
320 writel_relaxed(val, ss->base + SPRD_SPI_CTL4);
321
322 /* Trigger to receive data */
323 val = readl_relaxed(ss->base + SPRD_SPI_CTL4);
324 val |= SPRD_SPI_START_RX;
325 writel_relaxed(val, ss->base + SPRD_SPI_CTL4);
326
327 return len;
328 }
329
330 static int sprd_spi_write_bufs_u8(struct sprd_spi *ss, u32 len)
331 {
332 u8 *tx_p = (u8 *)ss->tx_buf;
333 int i;
334
335 for (i = 0; i < len; i++)
336 writeb_relaxed(tx_p[i], ss->base + SPRD_SPI_TXD);
337
338 ss->tx_buf += i;
339 return i;
340 }
341
342 static int sprd_spi_write_bufs_u16(struct sprd_spi *ss, u32 len)
343 {
344 u16 *tx_p = (u16 *)ss->tx_buf;
345 int i;
346
347 for (i = 0; i < len; i++)
348 writew_relaxed(tx_p[i], ss->base + SPRD_SPI_TXD);
349
350 ss->tx_buf += i << 1;
351 return i << 1;
352 }
353
354 static int sprd_spi_write_bufs_u32(struct sprd_spi *ss, u32 len)
355 {
356 u32 *tx_p = (u32 *)ss->tx_buf;
357 int i;
358
359 for (i = 0; i < len; i++)
360 writel_relaxed(tx_p[i], ss->base + SPRD_SPI_TXD);
361
362 ss->tx_buf += i << 2;
363 return i << 2;
364 }
365
366 static int sprd_spi_read_bufs_u8(struct sprd_spi *ss, u32 len)
367 {
368 u8 *rx_p = (u8 *)ss->rx_buf;
369 int i;
370
371 for (i = 0; i < len; i++)
372 rx_p[i] = readb_relaxed(ss->base + SPRD_SPI_TXD);
373
374 ss->rx_buf += i;
375 return i;
376 }
377
378 static int sprd_spi_read_bufs_u16(struct sprd_spi *ss, u32 len)
379 {
380 u16 *rx_p = (u16 *)ss->rx_buf;
381 int i;
382
383 for (i = 0; i < len; i++)
384 rx_p[i] = readw_relaxed(ss->base + SPRD_SPI_TXD);
385
386 ss->rx_buf += i << 1;
387 return i << 1;
388 }
389
390 static int sprd_spi_read_bufs_u32(struct sprd_spi *ss, u32 len)
391 {
392 u32 *rx_p = (u32 *)ss->rx_buf;
393 int i;
394
395 for (i = 0; i < len; i++)
396 rx_p[i] = readl_relaxed(ss->base + SPRD_SPI_TXD);
397
398 ss->rx_buf += i << 2;
399 return i << 2;
400 }
401
402 static int sprd_spi_txrx_bufs(struct spi_device *sdev, struct spi_transfer *t)
403 {
404 struct sprd_spi *ss = spi_controller_get_devdata(sdev->controller);
405 u32 trans_len = ss->trans_len, len;
406 int ret, write_size = 0, read_size = 0;
407
408 while (trans_len) {
409 len = trans_len > SPRD_SPI_FIFO_SIZE ? SPRD_SPI_FIFO_SIZE :
410 trans_len;
411 if (ss->trans_mode & SPRD_SPI_TX_MODE) {
412 sprd_spi_set_tx_length(ss, len);
413 write_size += ss->write_bufs(ss, len);
414
415 /*
416 * For our 3 wires mode or dual TX line mode, we need
417 * to request the controller to transfer.
418 */
419 if (ss->hw_mode & SPI_3WIRE || ss->hw_mode & SPI_TX_DUAL)
420 sprd_spi_tx_req(ss);
421
422 ret = sprd_spi_wait_for_tx_end(ss, t);
423 } else {
424 sprd_spi_set_rx_length(ss, len);
425
426 /*
427 * For our 3 wires mode or dual TX line mode, we need
428 * to request the controller to read.
429 */
430 if (ss->hw_mode & SPI_3WIRE || ss->hw_mode & SPI_TX_DUAL)
431 sprd_spi_rx_req(ss);
432 else
433 write_size += ss->write_bufs(ss, len);
434
435 ret = sprd_spi_wait_for_rx_end(ss, t);
436 }
437
438 if (ret)
439 goto complete;
440
441 if (ss->trans_mode & SPRD_SPI_RX_MODE)
442 read_size += ss->read_bufs(ss, len);
443
444 trans_len -= len;
445 }
446
447 if (ss->trans_mode & SPRD_SPI_TX_MODE)
448 ret = write_size;
449 else
450 ret = read_size;
451 complete:
452 sprd_spi_enter_idle(ss);
453
454 return ret;
455 }
456
457 static void sprd_spi_irq_enable(struct sprd_spi *ss)
458 {
459 u32 val;
460
461 /* Clear interrupt status before enabling interrupt. */
462 writel_relaxed(SPRD_SPI_TX_END_CLR | SPRD_SPI_RX_END_CLR,
463 ss->base + SPRD_SPI_INT_CLR);
464 /* Enable SPI interrupt only in DMA mode. */
465 val = readl_relaxed(ss->base + SPRD_SPI_INT_EN);
466 writel_relaxed(val | SPRD_SPI_TX_END_INT_EN |
467 SPRD_SPI_RX_END_INT_EN,
468 ss->base + SPRD_SPI_INT_EN);
469 }
470
471 static void sprd_spi_irq_disable(struct sprd_spi *ss)
472 {
473 writel_relaxed(0, ss->base + SPRD_SPI_INT_EN);
474 }
475
476 static void sprd_spi_dma_enable(struct sprd_spi *ss, bool enable)
477 {
478 u32 val = readl_relaxed(ss->base + SPRD_SPI_CTL2);
479
480 if (enable)
481 val |= SPRD_SPI_DMA_EN;
482 else
483 val &= ~SPRD_SPI_DMA_EN;
484
485 writel_relaxed(val, ss->base + SPRD_SPI_CTL2);
486 }
487
488 static int sprd_spi_dma_submit(struct dma_chan *dma_chan,
489 struct dma_slave_config *c,
490 struct sg_table *sg,
491 enum dma_transfer_direction dir)
492 {
493 struct dma_async_tx_descriptor *desc;
494 dma_cookie_t cookie;
495 unsigned long flags;
496 int ret;
497
498 ret = dmaengine_slave_config(dma_chan, c);
499 if (ret < 0)
500 return ret;
501
502 flags = SPRD_DMA_FLAGS(SPRD_DMA_CHN_MODE_NONE, SPRD_DMA_NO_TRG,
503 SPRD_DMA_FRAG_REQ, SPRD_DMA_TRANS_INT);
504 desc = dmaengine_prep_slave_sg(dma_chan, sg->sgl, sg->nents, dir, flags);
505 if (!desc)
506 return -ENODEV;
507
508 cookie = dmaengine_submit(desc);
509 if (dma_submit_error(cookie))
510 return dma_submit_error(cookie);
511
512 dma_async_issue_pending(dma_chan);
513
514 return 0;
515 }
516
517 static int sprd_spi_dma_rx_config(struct sprd_spi *ss, struct spi_transfer *t)
518 {
519 struct dma_chan *dma_chan = ss->dma.dma_chan[SPRD_SPI_RX];
520 struct dma_slave_config config = {
521 .src_addr = ss->phy_base,
522 .src_addr_width = ss->dma.width,
523 .dst_addr_width = ss->dma.width,
524 .dst_maxburst = ss->dma.fragmens_len,
525 };
526 int ret;
527
528 ret = sprd_spi_dma_submit(dma_chan, &config, &t->rx_sg, DMA_DEV_TO_MEM);
529 if (ret)
530 return ret;
531
532 return ss->dma.rx_len;
533 }
534
535 static int sprd_spi_dma_tx_config(struct sprd_spi *ss, struct spi_transfer *t)
536 {
537 struct dma_chan *dma_chan = ss->dma.dma_chan[SPRD_SPI_TX];
538 struct dma_slave_config config = {
539 .dst_addr = ss->phy_base,
540 .src_addr_width = ss->dma.width,
541 .dst_addr_width = ss->dma.width,
542 .src_maxburst = ss->dma.fragmens_len,
543 };
544 int ret;
545
546 ret = sprd_spi_dma_submit(dma_chan, &config, &t->tx_sg, DMA_MEM_TO_DEV);
547 if (ret)
548 return ret;
549
550 return t->len;
551 }
552
553 static int sprd_spi_dma_request(struct sprd_spi *ss)
554 {
555 ss->dma.dma_chan[SPRD_SPI_RX] = dma_request_chan(ss->dev, "rx_chn");
556 if (IS_ERR_OR_NULL(ss->dma.dma_chan[SPRD_SPI_RX])) {
557 if (PTR_ERR(ss->dma.dma_chan[SPRD_SPI_RX]) == -EPROBE_DEFER)
558 return PTR_ERR(ss->dma.dma_chan[SPRD_SPI_RX]);
559
560 dev_err(ss->dev, "request RX DMA channel failed!\n");
561 return PTR_ERR(ss->dma.dma_chan[SPRD_SPI_RX]);
562 }
563
564 ss->dma.dma_chan[SPRD_SPI_TX] = dma_request_chan(ss->dev, "tx_chn");
565 if (IS_ERR_OR_NULL(ss->dma.dma_chan[SPRD_SPI_TX])) {
566 if (PTR_ERR(ss->dma.dma_chan[SPRD_SPI_TX]) == -EPROBE_DEFER)
567 return PTR_ERR(ss->dma.dma_chan[SPRD_SPI_TX]);
568
569 dev_err(ss->dev, "request TX DMA channel failed!\n");
570 dma_release_channel(ss->dma.dma_chan[SPRD_SPI_RX]);
571 return PTR_ERR(ss->dma.dma_chan[SPRD_SPI_TX]);
572 }
573
574 return 0;
575 }
576
577 static void sprd_spi_dma_release(struct sprd_spi *ss)
578 {
579 if (ss->dma.dma_chan[SPRD_SPI_RX])
580 dma_release_channel(ss->dma.dma_chan[SPRD_SPI_RX]);
581
582 if (ss->dma.dma_chan[SPRD_SPI_TX])
583 dma_release_channel(ss->dma.dma_chan[SPRD_SPI_TX]);
584 }
585
586 static int sprd_spi_dma_txrx_bufs(struct spi_device *sdev,
587 struct spi_transfer *t)
588 {
589 struct sprd_spi *ss = spi_master_get_devdata(sdev->master);
590 u32 trans_len = ss->trans_len;
591 int ret, write_size = 0;
592
593 reinit_completion(&ss->xfer_completion);
594 sprd_spi_irq_enable(ss);
595 if (ss->trans_mode & SPRD_SPI_TX_MODE) {
596 write_size = sprd_spi_dma_tx_config(ss, t);
597 sprd_spi_set_tx_length(ss, trans_len);
598
599 /*
600 * For our 3 wires mode or dual TX line mode, we need
601 * to request the controller to transfer.
602 */
603 if (ss->hw_mode & SPI_3WIRE || ss->hw_mode & SPI_TX_DUAL)
604 sprd_spi_tx_req(ss);
605 } else {
606 sprd_spi_set_rx_length(ss, trans_len);
607
608 /*
609 * For our 3 wires mode or dual TX line mode, we need
610 * to request the controller to read.
611 */
612 if (ss->hw_mode & SPI_3WIRE || ss->hw_mode & SPI_TX_DUAL)
613 sprd_spi_rx_req(ss);
614 else
615 write_size = ss->write_bufs(ss, trans_len);
616 }
617
618 if (write_size < 0) {
619 ret = write_size;
620 dev_err(ss->dev, "failed to write, ret = %d\n", ret);
621 goto trans_complete;
622 }
623
624 if (ss->trans_mode & SPRD_SPI_RX_MODE) {
625 /*
626 * Set up the DMA receive data length, which must be an
627 * integral multiple of fragment length. But when the length
628 * of received data is less than fragment length, DMA can be
629 * configured to receive data according to the actual length
630 * of received data.
631 */
632 ss->dma.rx_len = t->len > ss->dma.fragmens_len ?
633 (t->len - t->len % ss->dma.fragmens_len) :
634 t->len;
635 ret = sprd_spi_dma_rx_config(ss, t);
636 if (ret < 0) {
637 dev_err(&sdev->dev,
638 "failed to configure rx DMA, ret = %d\n", ret);
639 goto trans_complete;
640 }
641 }
642
643 sprd_spi_dma_enable(ss, true);
644 wait_for_completion(&(ss->xfer_completion));
645
646 if (ss->trans_mode & SPRD_SPI_TX_MODE)
647 ret = write_size;
648 else
649 ret = ss->dma.rx_len;
650
651 trans_complete:
652 sprd_spi_dma_enable(ss, false);
653 sprd_spi_enter_idle(ss);
654 sprd_spi_irq_disable(ss);
655
656 return ret;
657 }
658
659 static void sprd_spi_set_speed(struct sprd_spi *ss, u32 speed_hz)
660 {
661 /*
662 * From SPI datasheet, the prescale calculation formula:
663 * prescale = SPI source clock / (2 * SPI_freq) - 1;
664 */
665 u32 clk_div = DIV_ROUND_UP(ss->src_clk, speed_hz << 1) - 1;
666
667 /* Save the real hardware speed */
668 ss->hw_speed_hz = (ss->src_clk >> 1) / (clk_div + 1);
669 writel_relaxed(clk_div, ss->base + SPRD_SPI_CLKD);
670 }
671
672 static int sprd_spi_init_hw(struct sprd_spi *ss, struct spi_transfer *t)
673 {
674 struct spi_delay *d = &t->word_delay;
675 u16 word_delay, interval;
676 u32 val;
677
678 if (d->unit != SPI_DELAY_UNIT_SCK)
679 return -EINVAL;
680
681 val = readl_relaxed(ss->base + SPRD_SPI_CTL0);
682 val &= ~(SPRD_SPI_SCK_REV | SPRD_SPI_NG_TX | SPRD_SPI_NG_RX);
683 /* Set default chip selection, clock phase and clock polarity */
684 val |= ss->hw_mode & SPI_CPHA ? SPRD_SPI_NG_RX : SPRD_SPI_NG_TX;
685 val |= ss->hw_mode & SPI_CPOL ? SPRD_SPI_SCK_REV : 0;
686 writel_relaxed(val, ss->base + SPRD_SPI_CTL0);
687
688 /*
689 * Set the intervals of two SPI frames, and the inteval calculation
690 * formula as below per datasheet:
691 * interval time (source clock cycles) = interval * 4 + 10.
692 */
693 word_delay = clamp_t(u16, d->value, SPRD_SPI_MIN_DELAY_CYCLE,
694 SPRD_SPI_MAX_DELAY_CYCLE);
695 interval = DIV_ROUND_UP(word_delay - 10, 4);
696 ss->word_delay = interval * 4 + 10;
697 writel_relaxed(interval, ss->base + SPRD_SPI_CTL5);
698
699 /* Reset SPI fifo */
700 writel_relaxed(1, ss->base + SPRD_SPI_FIFO_RST);
701 writel_relaxed(0, ss->base + SPRD_SPI_FIFO_RST);
702
703 /* Set SPI work mode */
704 val = readl_relaxed(ss->base + SPRD_SPI_CTL7);
705 val &= ~SPRD_SPI_MODE_MASK;
706
707 if (ss->hw_mode & SPI_3WIRE)
708 val |= SPRD_SPI_3WIRE_MODE << SPRD_SPI_MODE_OFFSET;
709 else
710 val |= SPRD_SPI_4WIRE_MODE << SPRD_SPI_MODE_OFFSET;
711
712 if (ss->hw_mode & SPI_TX_DUAL)
713 val |= SPRD_SPI_DATA_LINE2_EN;
714 else
715 val &= ~SPRD_SPI_DATA_LINE2_EN;
716
717 writel_relaxed(val, ss->base + SPRD_SPI_CTL7);
718
719 return 0;
720 }
721
722 static int sprd_spi_setup_transfer(struct spi_device *sdev,
723 struct spi_transfer *t)
724 {
725 struct sprd_spi *ss = spi_controller_get_devdata(sdev->controller);
726 u8 bits_per_word = t->bits_per_word;
727 u32 val, mode = 0;
728 int ret;
729
730 ss->len = t->len;
731 ss->tx_buf = t->tx_buf;
732 ss->rx_buf = t->rx_buf;
733
734 ss->hw_mode = sdev->mode;
735 ret = sprd_spi_init_hw(ss, t);
736 if (ret)
737 return ret;
738
739 /* Set tansfer speed and valid bits */
740 sprd_spi_set_speed(ss, t->speed_hz);
741 sprd_spi_set_transfer_bits(ss, bits_per_word);
742
743 if (bits_per_word > 16)
744 bits_per_word = round_up(bits_per_word, 16);
745 else
746 bits_per_word = round_up(bits_per_word, 8);
747
748 switch (bits_per_word) {
749 case 8:
750 ss->trans_len = t->len;
751 ss->read_bufs = sprd_spi_read_bufs_u8;
752 ss->write_bufs = sprd_spi_write_bufs_u8;
753 ss->dma.width = DMA_SLAVE_BUSWIDTH_1_BYTE;
754 ss->dma.fragmens_len = SPRD_SPI_DMA_STEP;
755 break;
756 case 16:
757 ss->trans_len = t->len >> 1;
758 ss->read_bufs = sprd_spi_read_bufs_u16;
759 ss->write_bufs = sprd_spi_write_bufs_u16;
760 ss->dma.width = DMA_SLAVE_BUSWIDTH_2_BYTES;
761 ss->dma.fragmens_len = SPRD_SPI_DMA_STEP << 1;
762 break;
763 case 32:
764 ss->trans_len = t->len >> 2;
765 ss->read_bufs = sprd_spi_read_bufs_u32;
766 ss->write_bufs = sprd_spi_write_bufs_u32;
767 ss->dma.width = DMA_SLAVE_BUSWIDTH_4_BYTES;
768 ss->dma.fragmens_len = SPRD_SPI_DMA_STEP << 2;
769 break;
770 default:
771 return -EINVAL;
772 }
773
774 /* Set transfer read or write mode */
775 val = readl_relaxed(ss->base + SPRD_SPI_CTL1);
776 val &= ~SPRD_SPI_RTX_MD_MASK;
777 if (t->tx_buf)
778 mode |= SPRD_SPI_TX_MODE;
779 if (t->rx_buf)
780 mode |= SPRD_SPI_RX_MODE;
781
782 writel_relaxed(val | mode, ss->base + SPRD_SPI_CTL1);
783
784 ss->trans_mode = mode;
785
786 /*
787 * If in only receive mode, we need to trigger the SPI controller to
788 * receive data automatically.
789 */
790 if (ss->trans_mode == SPRD_SPI_RX_MODE)
791 ss->write_bufs = sprd_spi_write_only_receive;
792
793 return 0;
794 }
795
796 static int sprd_spi_transfer_one(struct spi_controller *sctlr,
797 struct spi_device *sdev,
798 struct spi_transfer *t)
799 {
800 int ret;
801
802 ret = sprd_spi_setup_transfer(sdev, t);
803 if (ret)
804 goto setup_err;
805
806 if (sctlr->can_dma(sctlr, sdev, t))
807 ret = sprd_spi_dma_txrx_bufs(sdev, t);
808 else
809 ret = sprd_spi_txrx_bufs(sdev, t);
810
811 if (ret == t->len)
812 ret = 0;
813 else if (ret >= 0)
814 ret = -EREMOTEIO;
815
816 setup_err:
817 spi_finalize_current_transfer(sctlr);
818
819 return ret;
820 }
821
822 static irqreturn_t sprd_spi_handle_irq(int irq, void *data)
823 {
824 struct sprd_spi *ss = (struct sprd_spi *)data;
825 u32 val = readl_relaxed(ss->base + SPRD_SPI_INT_MASK_STS);
826
827 if (val & SPRD_SPI_MASK_TX_END) {
828 writel_relaxed(SPRD_SPI_TX_END_CLR, ss->base + SPRD_SPI_INT_CLR);
829 if (!(ss->trans_mode & SPRD_SPI_RX_MODE))
830 complete(&ss->xfer_completion);
831
832 return IRQ_HANDLED;
833 }
834
835 if (val & SPRD_SPI_MASK_RX_END) {
836 writel_relaxed(SPRD_SPI_RX_END_CLR, ss->base + SPRD_SPI_INT_CLR);
837 if (ss->dma.rx_len < ss->len) {
838 ss->rx_buf += ss->dma.rx_len;
839 ss->dma.rx_len +=
840 ss->read_bufs(ss, ss->len - ss->dma.rx_len);
841 }
842 complete(&ss->xfer_completion);
843
844 return IRQ_HANDLED;
845 }
846
847 return IRQ_NONE;
848 }
849
850 static int sprd_spi_irq_init(struct platform_device *pdev, struct sprd_spi *ss)
851 {
852 int ret;
853
854 ss->irq = platform_get_irq(pdev, 0);
855 if (ss->irq < 0)
856 return ss->irq;
857
858 ret = devm_request_irq(&pdev->dev, ss->irq, sprd_spi_handle_irq,
859 0, pdev->name, ss);
860 if (ret)
861 dev_err(&pdev->dev, "failed to request spi irq %d, ret = %d\n",
862 ss->irq, ret);
863
864 return ret;
865 }
866
867 static int sprd_spi_clk_init(struct platform_device *pdev, struct sprd_spi *ss)
868 {
869 struct clk *clk_spi, *clk_parent;
870
871 clk_spi = devm_clk_get(&pdev->dev, "spi");
872 if (IS_ERR(clk_spi)) {
873 dev_warn(&pdev->dev, "can't get the spi clock\n");
874 clk_spi = NULL;
875 }
876
877 clk_parent = devm_clk_get(&pdev->dev, "source");
878 if (IS_ERR(clk_parent)) {
879 dev_warn(&pdev->dev, "can't get the source clock\n");
880 clk_parent = NULL;
881 }
882
883 ss->clk = devm_clk_get(&pdev->dev, "enable");
884 if (IS_ERR(ss->clk)) {
885 dev_err(&pdev->dev, "can't get the enable clock\n");
886 return PTR_ERR(ss->clk);
887 }
888
889 if (!clk_set_parent(clk_spi, clk_parent))
890 ss->src_clk = clk_get_rate(clk_spi);
891 else
892 ss->src_clk = SPRD_SPI_DEFAULT_SOURCE;
893
894 return 0;
895 }
896
897 static bool sprd_spi_can_dma(struct spi_controller *sctlr,
898 struct spi_device *spi, struct spi_transfer *t)
899 {
900 struct sprd_spi *ss = spi_controller_get_devdata(sctlr);
901
902 return ss->dma.enable && (t->len > SPRD_SPI_FIFO_SIZE);
903 }
904
905 static int sprd_spi_dma_init(struct platform_device *pdev, struct sprd_spi *ss)
906 {
907 int ret;
908
909 ret = sprd_spi_dma_request(ss);
910 if (ret) {
911 if (ret == -EPROBE_DEFER)
912 return ret;
913
914 dev_warn(&pdev->dev,
915 "failed to request dma, enter no dma mode, ret = %d\n",
916 ret);
917
918 return 0;
919 }
920
921 ss->dma.enable = true;
922
923 return 0;
924 }
925
926 static int sprd_spi_probe(struct platform_device *pdev)
927 {
928 struct spi_controller *sctlr;
929 struct resource *res;
930 struct sprd_spi *ss;
931 int ret;
932
933 pdev->id = of_alias_get_id(pdev->dev.of_node, "spi");
934 sctlr = spi_alloc_master(&pdev->dev, sizeof(*ss));
935 if (!sctlr)
936 return -ENOMEM;
937
938 ss = spi_controller_get_devdata(sctlr);
939 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
940 ss->base = devm_ioremap_resource(&pdev->dev, res);
941 if (IS_ERR(ss->base)) {
942 ret = PTR_ERR(ss->base);
943 goto free_controller;
944 }
945
946 ss->phy_base = res->start;
947 ss->dev = &pdev->dev;
948 sctlr->dev.of_node = pdev->dev.of_node;
949 sctlr->mode_bits = SPI_CPOL | SPI_CPHA | SPI_3WIRE | SPI_TX_DUAL;
950 sctlr->bus_num = pdev->id;
951 sctlr->set_cs = sprd_spi_chipselect;
952 sctlr->transfer_one = sprd_spi_transfer_one;
953 sctlr->can_dma = sprd_spi_can_dma;
954 sctlr->auto_runtime_pm = true;
955 sctlr->max_speed_hz = min_t(u32, ss->src_clk >> 1,
956 SPRD_SPI_MAX_SPEED_HZ);
957
958 init_completion(&ss->xfer_completion);
959 platform_set_drvdata(pdev, sctlr);
960 ret = sprd_spi_clk_init(pdev, ss);
961 if (ret)
962 goto free_controller;
963
964 ret = sprd_spi_irq_init(pdev, ss);
965 if (ret)
966 goto free_controller;
967
968 ret = sprd_spi_dma_init(pdev, ss);
969 if (ret)
970 goto free_controller;
971
972 ret = clk_prepare_enable(ss->clk);
973 if (ret)
974 goto release_dma;
975
976 ret = pm_runtime_set_active(&pdev->dev);
977 if (ret < 0)
978 goto disable_clk;
979
980 pm_runtime_set_autosuspend_delay(&pdev->dev,
981 SPRD_SPI_AUTOSUSPEND_DELAY);
982 pm_runtime_use_autosuspend(&pdev->dev);
983 pm_runtime_enable(&pdev->dev);
984 ret = pm_runtime_get_sync(&pdev->dev);
985 if (ret < 0) {
986 dev_err(&pdev->dev, "failed to resume SPI controller\n");
987 goto err_rpm_put;
988 }
989
990 ret = devm_spi_register_controller(&pdev->dev, sctlr);
991 if (ret)
992 goto err_rpm_put;
993
994 pm_runtime_mark_last_busy(&pdev->dev);
995 pm_runtime_put_autosuspend(&pdev->dev);
996
997 return 0;
998
999 err_rpm_put:
1000 pm_runtime_put_noidle(&pdev->dev);
1001 pm_runtime_disable(&pdev->dev);
1002 disable_clk:
1003 clk_disable_unprepare(ss->clk);
1004 release_dma:
1005 sprd_spi_dma_release(ss);
1006 free_controller:
1007 spi_controller_put(sctlr);
1008
1009 return ret;
1010 }
1011
1012 static int sprd_spi_remove(struct platform_device *pdev)
1013 {
1014 struct spi_controller *sctlr = platform_get_drvdata(pdev);
1015 struct sprd_spi *ss = spi_controller_get_devdata(sctlr);
1016 int ret;
1017
1018 ret = pm_runtime_get_sync(ss->dev);
1019 if (ret < 0) {
1020 dev_err(ss->dev, "failed to resume SPI controller\n");
1021 return ret;
1022 }
1023
1024 spi_controller_suspend(sctlr);
1025
1026 if (ss->dma.enable)
1027 sprd_spi_dma_release(ss);
1028 clk_disable_unprepare(ss->clk);
1029 pm_runtime_put_noidle(&pdev->dev);
1030 pm_runtime_disable(&pdev->dev);
1031
1032 return 0;
1033 }
1034
1035 static int __maybe_unused sprd_spi_runtime_suspend(struct device *dev)
1036 {
1037 struct spi_controller *sctlr = dev_get_drvdata(dev);
1038 struct sprd_spi *ss = spi_controller_get_devdata(sctlr);
1039
1040 if (ss->dma.enable)
1041 sprd_spi_dma_release(ss);
1042
1043 clk_disable_unprepare(ss->clk);
1044
1045 return 0;
1046 }
1047
1048 static int __maybe_unused sprd_spi_runtime_resume(struct device *dev)
1049 {
1050 struct spi_controller *sctlr = dev_get_drvdata(dev);
1051 struct sprd_spi *ss = spi_controller_get_devdata(sctlr);
1052 int ret;
1053
1054 ret = clk_prepare_enable(ss->clk);
1055 if (ret)
1056 return ret;
1057
1058 if (!ss->dma.enable)
1059 return 0;
1060
1061 ret = sprd_spi_dma_request(ss);
1062 if (ret)
1063 clk_disable_unprepare(ss->clk);
1064
1065 return ret;
1066 }
1067
1068 static const struct dev_pm_ops sprd_spi_pm_ops = {
1069 SET_RUNTIME_PM_OPS(sprd_spi_runtime_suspend,
1070 sprd_spi_runtime_resume, NULL)
1071 };
1072
1073 static const struct of_device_id sprd_spi_of_match[] = {
1074 { .compatible = "sprd,sc9860-spi", },
1075 { /* sentinel */ }
1076 };
1077
1078 static struct platform_driver sprd_spi_driver = {
1079 .driver = {
1080 .name = "sprd-spi",
1081 .of_match_table = sprd_spi_of_match,
1082 .pm = &sprd_spi_pm_ops,
1083 },
1084 .probe = sprd_spi_probe,
1085 .remove = sprd_spi_remove,
1086 };
1087
1088 module_platform_driver(sprd_spi_driver);
1089
1090 MODULE_DESCRIPTION("Spreadtrum SPI Controller driver");
1091 MODULE_AUTHOR("Lanqing Liu <lanqing.liu@spreadtrum.com>");
1092 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support