Merge branch 'spi-4.18' into spi-4.19 for DSPI dep
[muen/linux.git] / drivers / spi / spi-fsl-dspi.c
1 /*
2  * drivers/spi/spi-fsl-dspi.c
3  *
4  * Copyright 2013 Freescale Semiconductor, Inc.
5  *
6  * Freescale DSPI driver
7  * This file contains a driver for the Freescale DSPI
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 as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  */
15
16 #include <linux/clk.h>
17 #include <linux/delay.h>
18 #include <linux/dmaengine.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/err.h>
21 #include <linux/errno.h>
22 #include <linux/interrupt.h>
23 #include <linux/io.h>
24 #include <linux/kernel.h>
25 #include <linux/math64.h>
26 #include <linux/module.h>
27 #include <linux/of.h>
28 #include <linux/of_device.h>
29 #include <linux/pinctrl/consumer.h>
30 #include <linux/platform_device.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/regmap.h>
33 #include <linux/sched.h>
34 #include <linux/spi/spi.h>
35 #include <linux/spi/spi-fsl-dspi.h>
36 #include <linux/spi/spi_bitbang.h>
37 #include <linux/time.h>
38
39 #define DRIVER_NAME "fsl-dspi"
40
41 #define DSPI_FIFO_SIZE                  4
42 #define DSPI_DMA_BUFSIZE                (DSPI_FIFO_SIZE * 1024)
43
44 #define SPI_MCR         0x00
45 #define SPI_MCR_MASTER          (1 << 31)
46 #define SPI_MCR_PCSIS           (0x3F << 16)
47 #define SPI_MCR_CLR_TXF (1 << 11)
48 #define SPI_MCR_CLR_RXF (1 << 10)
49
50 #define SPI_TCR                 0x08
51 #define SPI_TCR_GET_TCNT(x)     (((x) & 0xffff0000) >> 16)
52
53 #define SPI_CTAR(x)             (0x0c + (((x) & 0x3) * 4))
54 #define SPI_CTAR_FMSZ(x)        (((x) & 0x0000000f) << 27)
55 #define SPI_CTAR_CPOL(x)        ((x) << 26)
56 #define SPI_CTAR_CPHA(x)        ((x) << 25)
57 #define SPI_CTAR_LSBFE(x)       ((x) << 24)
58 #define SPI_CTAR_PCSSCK(x)      (((x) & 0x00000003) << 22)
59 #define SPI_CTAR_PASC(x)        (((x) & 0x00000003) << 20)
60 #define SPI_CTAR_PDT(x) (((x) & 0x00000003) << 18)
61 #define SPI_CTAR_PBR(x) (((x) & 0x00000003) << 16)
62 #define SPI_CTAR_CSSCK(x)       (((x) & 0x0000000f) << 12)
63 #define SPI_CTAR_ASC(x) (((x) & 0x0000000f) << 8)
64 #define SPI_CTAR_DT(x)          (((x) & 0x0000000f) << 4)
65 #define SPI_CTAR_BR(x)          ((x) & 0x0000000f)
66 #define SPI_CTAR_SCALE_BITS     0xf
67
68 #define SPI_CTAR0_SLAVE 0x0c
69
70 #define SPI_SR                  0x2c
71 #define SPI_SR_EOQF             0x10000000
72 #define SPI_SR_TCFQF            0x80000000
73 #define SPI_SR_CLEAR            0xdaad0000
74
75 #define SPI_RSER_TFFFE          BIT(25)
76 #define SPI_RSER_TFFFD          BIT(24)
77 #define SPI_RSER_RFDFE          BIT(17)
78 #define SPI_RSER_RFDFD          BIT(16)
79
80 #define SPI_RSER                0x30
81 #define SPI_RSER_EOQFE          0x10000000
82 #define SPI_RSER_TCFQE          0x80000000
83
84 #define SPI_PUSHR               0x34
85 #define SPI_PUSHR_CMD_CONT      (1 << 15)
86 #define SPI_PUSHR_CONT          (SPI_PUSHR_CMD_CONT << 16)
87 #define SPI_PUSHR_CMD_CTAS(x)   (((x) & 0x0003) << 12)
88 #define SPI_PUSHR_CTAS(x)       (SPI_PUSHR_CMD_CTAS(x) << 16)
89 #define SPI_PUSHR_CMD_EOQ       (1 << 11)
90 #define SPI_PUSHR_EOQ           (SPI_PUSHR_CMD_EOQ << 16)
91 #define SPI_PUSHR_CMD_CTCNT     (1 << 10)
92 #define SPI_PUSHR_CTCNT         (SPI_PUSHR_CMD_CTCNT << 16)
93 #define SPI_PUSHR_CMD_PCS(x)    ((1 << x) & 0x003f)
94 #define SPI_PUSHR_PCS(x)        (SPI_PUSHR_CMD_PCS(x) << 16)
95 #define SPI_PUSHR_TXDATA(x)     ((x) & 0x0000ffff)
96
97 #define SPI_PUSHR_SLAVE 0x34
98
99 #define SPI_POPR                0x38
100 #define SPI_POPR_RXDATA(x)      ((x) & 0x0000ffff)
101
102 #define SPI_TXFR0               0x3c
103 #define SPI_TXFR1               0x40
104 #define SPI_TXFR2               0x44
105 #define SPI_TXFR3               0x48
106 #define SPI_RXFR0               0x7c
107 #define SPI_RXFR1               0x80
108 #define SPI_RXFR2               0x84
109 #define SPI_RXFR3               0x88
110
111 #define SPI_FRAME_BITS(bits)    SPI_CTAR_FMSZ((bits) - 1)
112 #define SPI_FRAME_BITS_MASK     SPI_CTAR_FMSZ(0xf)
113 #define SPI_FRAME_BITS_16       SPI_CTAR_FMSZ(0xf)
114 #define SPI_FRAME_BITS_8        SPI_CTAR_FMSZ(0x7)
115
116 #define SPI_CS_INIT             0x01
117 #define SPI_CS_ASSERT           0x02
118 #define SPI_CS_DROP             0x04
119
120 #define DMA_COMPLETION_TIMEOUT  msecs_to_jiffies(3000)
121
122 struct chip_data {
123         u32 ctar_val;
124         u16 void_write_data;
125 };
126
127 enum dspi_trans_mode {
128         DSPI_EOQ_MODE = 0,
129         DSPI_TCFQ_MODE,
130         DSPI_DMA_MODE,
131 };
132
133 struct fsl_dspi_devtype_data {
134         enum dspi_trans_mode trans_mode;
135         u8 max_clock_factor;
136 };
137
138 static const struct fsl_dspi_devtype_data vf610_data = {
139         .trans_mode = DSPI_DMA_MODE,
140         .max_clock_factor = 2,
141 };
142
143 static const struct fsl_dspi_devtype_data ls1021a_v1_data = {
144         .trans_mode = DSPI_TCFQ_MODE,
145         .max_clock_factor = 8,
146 };
147
148 static const struct fsl_dspi_devtype_data ls2085a_data = {
149         .trans_mode = DSPI_TCFQ_MODE,
150         .max_clock_factor = 8,
151 };
152
153 static const struct fsl_dspi_devtype_data coldfire_data = {
154         .trans_mode = DSPI_EOQ_MODE,
155         .max_clock_factor = 8,
156 };
157
158 struct fsl_dspi_dma {
159         /* Length of transfer in words of DSPI_FIFO_SIZE */
160         u32 curr_xfer_len;
161
162         u32 *tx_dma_buf;
163         struct dma_chan *chan_tx;
164         dma_addr_t tx_dma_phys;
165         struct completion cmd_tx_complete;
166         struct dma_async_tx_descriptor *tx_desc;
167
168         u32 *rx_dma_buf;
169         struct dma_chan *chan_rx;
170         dma_addr_t rx_dma_phys;
171         struct completion cmd_rx_complete;
172         struct dma_async_tx_descriptor *rx_desc;
173 };
174
175 struct fsl_dspi {
176         struct spi_master       *master;
177         struct platform_device  *pdev;
178
179         struct regmap           *regmap;
180         int                     irq;
181         struct clk              *clk;
182
183         struct spi_transfer     *cur_transfer;
184         struct spi_message      *cur_msg;
185         struct chip_data        *cur_chip;
186         size_t                  len;
187         const void              *tx;
188         void                    *rx;
189         void                    *rx_end;
190         u16                     void_write_data;
191         u16                     tx_cmd;
192         u8                      bits_per_word;
193         u8                      bytes_per_word;
194         const struct fsl_dspi_devtype_data *devtype_data;
195
196         wait_queue_head_t       waitq;
197         u32                     waitflags;
198
199         struct fsl_dspi_dma     *dma;
200 };
201
202 static u16 dspi_pop_tx(struct fsl_dspi *dspi)
203 {
204         u16 txdata = 0;
205
206         if (dspi->tx) {
207                 if (dspi->bytes_per_word == 1)
208                         txdata = *(u8 *)dspi->tx;
209                 else /* dspi->bytes_per_word == 2 */
210                         txdata = *(u16 *)dspi->tx;
211                 dspi->tx += dspi->bytes_per_word;
212         }
213         dspi->len -= dspi->bytes_per_word;
214         return txdata;
215 }
216
217 static u32 dspi_pop_tx_pushr(struct fsl_dspi *dspi)
218 {
219         u16 cmd = dspi->tx_cmd, data = dspi_pop_tx(dspi);
220
221         if (dspi->len > 0)
222                 cmd |= SPI_PUSHR_CMD_CONT;
223         return cmd << 16 | data;
224 }
225
226 static void dspi_push_rx(struct fsl_dspi *dspi, u32 rxdata)
227 {
228         if (!dspi->rx)
229                 return;
230
231         /* Mask of undefined bits */
232         rxdata &= (1 << dspi->bits_per_word) - 1;
233
234         if (dspi->bytes_per_word == 1)
235                 *(u8 *)dspi->rx = rxdata;
236         else /* dspi->bytes_per_word == 2 */
237                 *(u16 *)dspi->rx = rxdata;
238         dspi->rx += dspi->bytes_per_word;
239 }
240
241 static void dspi_tx_dma_callback(void *arg)
242 {
243         struct fsl_dspi *dspi = arg;
244         struct fsl_dspi_dma *dma = dspi->dma;
245
246         complete(&dma->cmd_tx_complete);
247 }
248
249 static void dspi_rx_dma_callback(void *arg)
250 {
251         struct fsl_dspi *dspi = arg;
252         struct fsl_dspi_dma *dma = dspi->dma;
253         int i;
254
255         if (dspi->rx) {
256                 for (i = 0; i < dma->curr_xfer_len; i++)
257                         dspi_push_rx(dspi, dspi->dma->rx_dma_buf[i]);
258         }
259
260         complete(&dma->cmd_rx_complete);
261 }
262
263 static int dspi_next_xfer_dma_submit(struct fsl_dspi *dspi)
264 {
265         struct fsl_dspi_dma *dma = dspi->dma;
266         struct device *dev = &dspi->pdev->dev;
267         int time_left;
268         int i;
269
270         for (i = 0; i < dma->curr_xfer_len; i++)
271                 dspi->dma->tx_dma_buf[i] = dspi_pop_tx_pushr(dspi);
272
273         dma->tx_desc = dmaengine_prep_slave_single(dma->chan_tx,
274                                         dma->tx_dma_phys,
275                                         dma->curr_xfer_len *
276                                         DMA_SLAVE_BUSWIDTH_4_BYTES,
277                                         DMA_MEM_TO_DEV,
278                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
279         if (!dma->tx_desc) {
280                 dev_err(dev, "Not able to get desc for DMA xfer\n");
281                 return -EIO;
282         }
283
284         dma->tx_desc->callback = dspi_tx_dma_callback;
285         dma->tx_desc->callback_param = dspi;
286         if (dma_submit_error(dmaengine_submit(dma->tx_desc))) {
287                 dev_err(dev, "DMA submit failed\n");
288                 return -EINVAL;
289         }
290
291         dma->rx_desc = dmaengine_prep_slave_single(dma->chan_rx,
292                                         dma->rx_dma_phys,
293                                         dma->curr_xfer_len *
294                                         DMA_SLAVE_BUSWIDTH_4_BYTES,
295                                         DMA_DEV_TO_MEM,
296                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
297         if (!dma->rx_desc) {
298                 dev_err(dev, "Not able to get desc for DMA xfer\n");
299                 return -EIO;
300         }
301
302         dma->rx_desc->callback = dspi_rx_dma_callback;
303         dma->rx_desc->callback_param = dspi;
304         if (dma_submit_error(dmaengine_submit(dma->rx_desc))) {
305                 dev_err(dev, "DMA submit failed\n");
306                 return -EINVAL;
307         }
308
309         reinit_completion(&dspi->dma->cmd_rx_complete);
310         reinit_completion(&dspi->dma->cmd_tx_complete);
311
312         dma_async_issue_pending(dma->chan_rx);
313         dma_async_issue_pending(dma->chan_tx);
314
315         time_left = wait_for_completion_timeout(&dspi->dma->cmd_tx_complete,
316                                         DMA_COMPLETION_TIMEOUT);
317         if (time_left == 0) {
318                 dev_err(dev, "DMA tx timeout\n");
319                 dmaengine_terminate_all(dma->chan_tx);
320                 dmaengine_terminate_all(dma->chan_rx);
321                 return -ETIMEDOUT;
322         }
323
324         time_left = wait_for_completion_timeout(&dspi->dma->cmd_rx_complete,
325                                         DMA_COMPLETION_TIMEOUT);
326         if (time_left == 0) {
327                 dev_err(dev, "DMA rx timeout\n");
328                 dmaengine_terminate_all(dma->chan_tx);
329                 dmaengine_terminate_all(dma->chan_rx);
330                 return -ETIMEDOUT;
331         }
332
333         return 0;
334 }
335
336 static int dspi_dma_xfer(struct fsl_dspi *dspi)
337 {
338         struct fsl_dspi_dma *dma = dspi->dma;
339         struct device *dev = &dspi->pdev->dev;
340         int curr_remaining_bytes;
341         int bytes_per_buffer;
342         int ret = 0;
343
344         curr_remaining_bytes = dspi->len;
345         bytes_per_buffer = DSPI_DMA_BUFSIZE / DSPI_FIFO_SIZE;
346         while (curr_remaining_bytes) {
347                 /* Check if current transfer fits the DMA buffer */
348                 dma->curr_xfer_len = curr_remaining_bytes
349                         / dspi->bytes_per_word;
350                 if (dma->curr_xfer_len > bytes_per_buffer)
351                         dma->curr_xfer_len = bytes_per_buffer;
352
353                 ret = dspi_next_xfer_dma_submit(dspi);
354                 if (ret) {
355                         dev_err(dev, "DMA transfer failed\n");
356                         goto exit;
357
358                 } else {
359                         curr_remaining_bytes -= dma->curr_xfer_len
360                                 * dspi->bytes_per_word;
361                         if (curr_remaining_bytes < 0)
362                                 curr_remaining_bytes = 0;
363                 }
364         }
365
366 exit:
367         return ret;
368 }
369
370 static int dspi_request_dma(struct fsl_dspi *dspi, phys_addr_t phy_addr)
371 {
372         struct fsl_dspi_dma *dma;
373         struct dma_slave_config cfg;
374         struct device *dev = &dspi->pdev->dev;
375         int ret;
376
377         dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
378         if (!dma)
379                 return -ENOMEM;
380
381         dma->chan_rx = dma_request_slave_channel(dev, "rx");
382         if (!dma->chan_rx) {
383                 dev_err(dev, "rx dma channel not available\n");
384                 ret = -ENODEV;
385                 return ret;
386         }
387
388         dma->chan_tx = dma_request_slave_channel(dev, "tx");
389         if (!dma->chan_tx) {
390                 dev_err(dev, "tx dma channel not available\n");
391                 ret = -ENODEV;
392                 goto err_tx_channel;
393         }
394
395         dma->tx_dma_buf = dma_alloc_coherent(dev, DSPI_DMA_BUFSIZE,
396                                         &dma->tx_dma_phys, GFP_KERNEL);
397         if (!dma->tx_dma_buf) {
398                 ret = -ENOMEM;
399                 goto err_tx_dma_buf;
400         }
401
402         dma->rx_dma_buf = dma_alloc_coherent(dev, DSPI_DMA_BUFSIZE,
403                                         &dma->rx_dma_phys, GFP_KERNEL);
404         if (!dma->rx_dma_buf) {
405                 ret = -ENOMEM;
406                 goto err_rx_dma_buf;
407         }
408
409         cfg.src_addr = phy_addr + SPI_POPR;
410         cfg.dst_addr = phy_addr + SPI_PUSHR;
411         cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
412         cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
413         cfg.src_maxburst = 1;
414         cfg.dst_maxburst = 1;
415
416         cfg.direction = DMA_DEV_TO_MEM;
417         ret = dmaengine_slave_config(dma->chan_rx, &cfg);
418         if (ret) {
419                 dev_err(dev, "can't configure rx dma channel\n");
420                 ret = -EINVAL;
421                 goto err_slave_config;
422         }
423
424         cfg.direction = DMA_MEM_TO_DEV;
425         ret = dmaengine_slave_config(dma->chan_tx, &cfg);
426         if (ret) {
427                 dev_err(dev, "can't configure tx dma channel\n");
428                 ret = -EINVAL;
429                 goto err_slave_config;
430         }
431
432         dspi->dma = dma;
433         init_completion(&dma->cmd_tx_complete);
434         init_completion(&dma->cmd_rx_complete);
435
436         return 0;
437
438 err_slave_config:
439         dma_free_coherent(dev, DSPI_DMA_BUFSIZE,
440                         dma->rx_dma_buf, dma->rx_dma_phys);
441 err_rx_dma_buf:
442         dma_free_coherent(dev, DSPI_DMA_BUFSIZE,
443                         dma->tx_dma_buf, dma->tx_dma_phys);
444 err_tx_dma_buf:
445         dma_release_channel(dma->chan_tx);
446 err_tx_channel:
447         dma_release_channel(dma->chan_rx);
448
449         devm_kfree(dev, dma);
450         dspi->dma = NULL;
451
452         return ret;
453 }
454
455 static void dspi_release_dma(struct fsl_dspi *dspi)
456 {
457         struct fsl_dspi_dma *dma = dspi->dma;
458         struct device *dev = &dspi->pdev->dev;
459
460         if (dma) {
461                 if (dma->chan_tx) {
462                         dma_unmap_single(dev, dma->tx_dma_phys,
463                                         DSPI_DMA_BUFSIZE, DMA_TO_DEVICE);
464                         dma_release_channel(dma->chan_tx);
465                 }
466
467                 if (dma->chan_rx) {
468                         dma_unmap_single(dev, dma->rx_dma_phys,
469                                         DSPI_DMA_BUFSIZE, DMA_FROM_DEVICE);
470                         dma_release_channel(dma->chan_rx);
471                 }
472         }
473 }
474
475 static void hz_to_spi_baud(char *pbr, char *br, int speed_hz,
476                 unsigned long clkrate)
477 {
478         /* Valid baud rate pre-scaler values */
479         int pbr_tbl[4] = {2, 3, 5, 7};
480         int brs[16] = { 2,      4,      6,      8,
481                 16,     32,     64,     128,
482                 256,    512,    1024,   2048,
483                 4096,   8192,   16384,  32768 };
484         int scale_needed, scale, minscale = INT_MAX;
485         int i, j;
486
487         scale_needed = clkrate / speed_hz;
488         if (clkrate % speed_hz)
489                 scale_needed++;
490
491         for (i = 0; i < ARRAY_SIZE(brs); i++)
492                 for (j = 0; j < ARRAY_SIZE(pbr_tbl); j++) {
493                         scale = brs[i] * pbr_tbl[j];
494                         if (scale >= scale_needed) {
495                                 if (scale < minscale) {
496                                         minscale = scale;
497                                         *br = i;
498                                         *pbr = j;
499                                 }
500                                 break;
501                         }
502                 }
503
504         if (minscale == INT_MAX) {
505                 pr_warn("Can not find valid baud rate,speed_hz is %d,clkrate is %ld, we use the max prescaler value.\n",
506                         speed_hz, clkrate);
507                 *pbr = ARRAY_SIZE(pbr_tbl) - 1;
508                 *br =  ARRAY_SIZE(brs) - 1;
509         }
510 }
511
512 static void ns_delay_scale(char *psc, char *sc, int delay_ns,
513                 unsigned long clkrate)
514 {
515         int pscale_tbl[4] = {1, 3, 5, 7};
516         int scale_needed, scale, minscale = INT_MAX;
517         int i, j;
518         u32 remainder;
519
520         scale_needed = div_u64_rem((u64)delay_ns * clkrate, NSEC_PER_SEC,
521                         &remainder);
522         if (remainder)
523                 scale_needed++;
524
525         for (i = 0; i < ARRAY_SIZE(pscale_tbl); i++)
526                 for (j = 0; j <= SPI_CTAR_SCALE_BITS; j++) {
527                         scale = pscale_tbl[i] * (2 << j);
528                         if (scale >= scale_needed) {
529                                 if (scale < minscale) {
530                                         minscale = scale;
531                                         *psc = i;
532                                         *sc = j;
533                                 }
534                                 break;
535                         }
536                 }
537
538         if (minscale == INT_MAX) {
539                 pr_warn("Cannot find correct scale values for %dns delay at clkrate %ld, using max prescaler value",
540                         delay_ns, clkrate);
541                 *psc = ARRAY_SIZE(pscale_tbl) - 1;
542                 *sc = SPI_CTAR_SCALE_BITS;
543         }
544 }
545
546 static void fifo_write(struct fsl_dspi *dspi)
547 {
548         regmap_write(dspi->regmap, SPI_PUSHR, dspi_pop_tx_pushr(dspi));
549 }
550
551 static void dspi_tcfq_write(struct fsl_dspi *dspi)
552 {
553         /* Clear transfer count */
554         dspi->tx_cmd |= SPI_PUSHR_CMD_CTCNT;
555         /* Write one entry to both TX FIFO and CMD FIFO simultaneously */
556         fifo_write(dspi);
557 }
558
559 static u32 fifo_read(struct fsl_dspi *dspi)
560 {
561         u32 rxdata = 0;
562
563         regmap_read(dspi->regmap, SPI_POPR, &rxdata);
564         return rxdata;
565 }
566
567 static void dspi_tcfq_read(struct fsl_dspi *dspi)
568 {
569         dspi_push_rx(dspi, fifo_read(dspi));
570 }
571
572 static void dspi_eoq_write(struct fsl_dspi *dspi)
573 {
574         int fifo_size = DSPI_FIFO_SIZE;
575
576         /* Fill TX FIFO with as many transfers as possible */
577         while (dspi->len && fifo_size--) {
578                 /* Request EOQF for last transfer in FIFO */
579                 if (dspi->len == dspi->bytes_per_word || fifo_size == 0)
580                         dspi->tx_cmd |= SPI_PUSHR_CMD_EOQ;
581                 /* Clear transfer count for first transfer in FIFO */
582                 if (fifo_size == (DSPI_FIFO_SIZE - 1))
583                         dspi->tx_cmd |= SPI_PUSHR_CMD_CTCNT;
584                 /* Write combined TX FIFO and CMD FIFO entry */
585                 fifo_write(dspi);
586         }
587 }
588
589 static void dspi_eoq_read(struct fsl_dspi *dspi)
590 {
591         int fifo_size = DSPI_FIFO_SIZE;
592
593         /* Read one FIFO entry at and push to rx buffer */
594         while ((dspi->rx < dspi->rx_end) && fifo_size--)
595                 dspi_push_rx(dspi, fifo_read(dspi));
596 }
597
598 static int dspi_transfer_one_message(struct spi_master *master,
599                 struct spi_message *message)
600 {
601         struct fsl_dspi *dspi = spi_master_get_devdata(master);
602         struct spi_device *spi = message->spi;
603         struct spi_transfer *transfer;
604         int status = 0;
605         enum dspi_trans_mode trans_mode;
606
607         message->actual_length = 0;
608
609         list_for_each_entry(transfer, &message->transfers, transfer_list) {
610                 dspi->cur_transfer = transfer;
611                 dspi->cur_msg = message;
612                 dspi->cur_chip = spi_get_ctldata(spi);
613                 /* Prepare command word for CMD FIFO */
614                 dspi->tx_cmd = SPI_PUSHR_CMD_CTAS(0) |
615                         SPI_PUSHR_CMD_PCS(spi->chip_select);
616                 if (list_is_last(&dspi->cur_transfer->transfer_list,
617                                  &dspi->cur_msg->transfers)) {
618                         /* Leave PCS activated after last transfer when
619                          * cs_change is set.
620                          */
621                         if (transfer->cs_change)
622                                 dspi->tx_cmd |= SPI_PUSHR_CMD_CONT;
623                 } else {
624                         /* Keep PCS active between transfers in same message
625                          * when cs_change is not set, and de-activate PCS
626                          * between transfers in the same message when
627                          * cs_change is set.
628                          */
629                         if (!transfer->cs_change)
630                                 dspi->tx_cmd |= SPI_PUSHR_CMD_CONT;
631                 }
632
633                 dspi->void_write_data = dspi->cur_chip->void_write_data;
634
635                 dspi->tx = transfer->tx_buf;
636                 dspi->rx = transfer->rx_buf;
637                 dspi->rx_end = dspi->rx + transfer->len;
638                 dspi->len = transfer->len;
639                 /* Validated transfer specific frame size (defaults applied) */
640                 dspi->bits_per_word = transfer->bits_per_word;
641                 if (transfer->bits_per_word <= 8)
642                         dspi->bytes_per_word = 1;
643                 else
644                         dspi->bytes_per_word = 2;
645
646                 regmap_update_bits(dspi->regmap, SPI_MCR,
647                                    SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF,
648                                    SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF);
649                 regmap_write(dspi->regmap, SPI_CTAR(0),
650                              dspi->cur_chip->ctar_val |
651                              SPI_FRAME_BITS(transfer->bits_per_word));
652
653                 trans_mode = dspi->devtype_data->trans_mode;
654                 switch (trans_mode) {
655                 case DSPI_EOQ_MODE:
656                         regmap_write(dspi->regmap, SPI_RSER, SPI_RSER_EOQFE);
657                         dspi_eoq_write(dspi);
658                         break;
659                 case DSPI_TCFQ_MODE:
660                         regmap_write(dspi->regmap, SPI_RSER, SPI_RSER_TCFQE);
661                         dspi_tcfq_write(dspi);
662                         break;
663                 case DSPI_DMA_MODE:
664                         regmap_write(dspi->regmap, SPI_RSER,
665                                 SPI_RSER_TFFFE | SPI_RSER_TFFFD |
666                                 SPI_RSER_RFDFE | SPI_RSER_RFDFD);
667                         status = dspi_dma_xfer(dspi);
668                         break;
669                 default:
670                         dev_err(&dspi->pdev->dev, "unsupported trans_mode %u\n",
671                                 trans_mode);
672                         status = -EINVAL;
673                         goto out;
674                 }
675
676                 if (trans_mode != DSPI_DMA_MODE) {
677                         if (wait_event_interruptible(dspi->waitq,
678                                                 dspi->waitflags))
679                                 dev_err(&dspi->pdev->dev,
680                                         "wait transfer complete fail!\n");
681                         dspi->waitflags = 0;
682                 }
683
684                 if (transfer->delay_usecs)
685                         udelay(transfer->delay_usecs);
686         }
687
688 out:
689         message->status = status;
690         spi_finalize_current_message(master);
691
692         return status;
693 }
694
695 static int dspi_setup(struct spi_device *spi)
696 {
697         struct chip_data *chip;
698         struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
699         struct fsl_dspi_platform_data *pdata;
700         u32 cs_sck_delay = 0, sck_cs_delay = 0;
701         unsigned char br = 0, pbr = 0, pcssck = 0, cssck = 0;
702         unsigned char pasc = 0, asc = 0;
703         unsigned long clkrate;
704
705         /* Only alloc on first setup */
706         chip = spi_get_ctldata(spi);
707         if (chip == NULL) {
708                 chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
709                 if (!chip)
710                         return -ENOMEM;
711         }
712
713         pdata = dev_get_platdata(&dspi->pdev->dev);
714
715         if (!pdata) {
716                 of_property_read_u32(spi->dev.of_node, "fsl,spi-cs-sck-delay",
717                                 &cs_sck_delay);
718
719                 of_property_read_u32(spi->dev.of_node, "fsl,spi-sck-cs-delay",
720                                 &sck_cs_delay);
721         } else {
722                 cs_sck_delay = pdata->cs_sck_delay;
723                 sck_cs_delay = pdata->sck_cs_delay;
724         }
725
726         chip->void_write_data = 0;
727
728         clkrate = clk_get_rate(dspi->clk);
729         hz_to_spi_baud(&pbr, &br, spi->max_speed_hz, clkrate);
730
731         /* Set PCS to SCK delay scale values */
732         ns_delay_scale(&pcssck, &cssck, cs_sck_delay, clkrate);
733
734         /* Set After SCK delay scale values */
735         ns_delay_scale(&pasc, &asc, sck_cs_delay, clkrate);
736
737         chip->ctar_val = SPI_CTAR_CPOL(spi->mode & SPI_CPOL ? 1 : 0)
738                 | SPI_CTAR_CPHA(spi->mode & SPI_CPHA ? 1 : 0)
739                 | SPI_CTAR_LSBFE(spi->mode & SPI_LSB_FIRST ? 1 : 0)
740                 | SPI_CTAR_PCSSCK(pcssck)
741                 | SPI_CTAR_CSSCK(cssck)
742                 | SPI_CTAR_PASC(pasc)
743                 | SPI_CTAR_ASC(asc)
744                 | SPI_CTAR_PBR(pbr)
745                 | SPI_CTAR_BR(br);
746
747         spi_set_ctldata(spi, chip);
748
749         return 0;
750 }
751
752 static void dspi_cleanup(struct spi_device *spi)
753 {
754         struct chip_data *chip = spi_get_ctldata((struct spi_device *)spi);
755
756         dev_dbg(&spi->dev, "spi_device %u.%u cleanup\n",
757                         spi->master->bus_num, spi->chip_select);
758
759         kfree(chip);
760 }
761
762 static irqreturn_t dspi_interrupt(int irq, void *dev_id)
763 {
764         struct fsl_dspi *dspi = (struct fsl_dspi *)dev_id;
765         struct spi_message *msg = dspi->cur_msg;
766         enum dspi_trans_mode trans_mode;
767         u32 spi_sr, spi_tcr;
768         u16 spi_tcnt;
769
770         regmap_read(dspi->regmap, SPI_SR, &spi_sr);
771         regmap_write(dspi->regmap, SPI_SR, spi_sr);
772
773
774         if (spi_sr & (SPI_SR_EOQF | SPI_SR_TCFQF)) {
775                 /* Get transfer counter (in number of SPI transfers). It was
776                  * reset to 0 when transfer(s) were started.
777                  */
778                 regmap_read(dspi->regmap, SPI_TCR, &spi_tcr);
779                 spi_tcnt = SPI_TCR_GET_TCNT(spi_tcr);
780                 /* Update total number of bytes that were transferred */
781                 msg->actual_length += spi_tcnt * dspi->bytes_per_word;
782
783                 trans_mode = dspi->devtype_data->trans_mode;
784                 switch (trans_mode) {
785                 case DSPI_EOQ_MODE:
786                         dspi_eoq_read(dspi);
787                         break;
788                 case DSPI_TCFQ_MODE:
789                         dspi_tcfq_read(dspi);
790                         break;
791                 default:
792                         dev_err(&dspi->pdev->dev, "unsupported trans_mode %u\n",
793                                 trans_mode);
794                                 return IRQ_HANDLED;
795                 }
796
797                 if (!dspi->len) {
798                         dspi->waitflags = 1;
799                         wake_up_interruptible(&dspi->waitq);
800                 } else {
801                         switch (trans_mode) {
802                         case DSPI_EOQ_MODE:
803                                 dspi_eoq_write(dspi);
804                                 break;
805                         case DSPI_TCFQ_MODE:
806                                 dspi_tcfq_write(dspi);
807                                 break;
808                         default:
809                                 dev_err(&dspi->pdev->dev,
810                                         "unsupported trans_mode %u\n",
811                                         trans_mode);
812                         }
813                 }
814         }
815
816         return IRQ_HANDLED;
817 }
818
819 static const struct of_device_id fsl_dspi_dt_ids[] = {
820         { .compatible = "fsl,vf610-dspi", .data = &vf610_data, },
821         { .compatible = "fsl,ls1021a-v1.0-dspi", .data = &ls1021a_v1_data, },
822         { .compatible = "fsl,ls2085a-dspi", .data = &ls2085a_data, },
823         { /* sentinel */ }
824 };
825 MODULE_DEVICE_TABLE(of, fsl_dspi_dt_ids);
826
827 #ifdef CONFIG_PM_SLEEP
828 static int dspi_suspend(struct device *dev)
829 {
830         struct spi_master *master = dev_get_drvdata(dev);
831         struct fsl_dspi *dspi = spi_master_get_devdata(master);
832
833         spi_master_suspend(master);
834         clk_disable_unprepare(dspi->clk);
835
836         pinctrl_pm_select_sleep_state(dev);
837
838         return 0;
839 }
840
841 static int dspi_resume(struct device *dev)
842 {
843         struct spi_master *master = dev_get_drvdata(dev);
844         struct fsl_dspi *dspi = spi_master_get_devdata(master);
845         int ret;
846
847         pinctrl_pm_select_default_state(dev);
848
849         ret = clk_prepare_enable(dspi->clk);
850         if (ret)
851                 return ret;
852         spi_master_resume(master);
853
854         return 0;
855 }
856 #endif /* CONFIG_PM_SLEEP */
857
858 static SIMPLE_DEV_PM_OPS(dspi_pm, dspi_suspend, dspi_resume);
859
860 static const struct regmap_range dspi_volatile_ranges[] = {
861         regmap_reg_range(SPI_MCR, SPI_TCR),
862         regmap_reg_range(SPI_SR, SPI_SR),
863         regmap_reg_range(SPI_PUSHR, SPI_RXFR3),
864 };
865
866 static const struct regmap_access_table dspi_volatile_table = {
867         .yes_ranges     = dspi_volatile_ranges,
868         .n_yes_ranges   = ARRAY_SIZE(dspi_volatile_ranges),
869 };
870
871 static const struct regmap_config dspi_regmap_config = {
872         .reg_bits = 32,
873         .val_bits = 32,
874         .reg_stride = 4,
875         .max_register = 0x88,
876         .volatile_table = &dspi_volatile_table,
877 };
878
879 static void dspi_init(struct fsl_dspi *dspi)
880 {
881         regmap_write(dspi->regmap, SPI_MCR, SPI_MCR_MASTER | SPI_MCR_PCSIS);
882         regmap_write(dspi->regmap, SPI_SR, SPI_SR_CLEAR);
883 }
884
885 static int dspi_probe(struct platform_device *pdev)
886 {
887         struct device_node *np = pdev->dev.of_node;
888         struct spi_master *master;
889         struct fsl_dspi *dspi;
890         struct resource *res;
891         void __iomem *base;
892         struct fsl_dspi_platform_data *pdata;
893         int ret = 0, cs_num, bus_num;
894
895         master = spi_alloc_master(&pdev->dev, sizeof(struct fsl_dspi));
896         if (!master)
897                 return -ENOMEM;
898
899         dspi = spi_master_get_devdata(master);
900         dspi->pdev = pdev;
901         dspi->master = master;
902
903         master->transfer = NULL;
904         master->setup = dspi_setup;
905         master->transfer_one_message = dspi_transfer_one_message;
906         master->dev.of_node = pdev->dev.of_node;
907
908         master->cleanup = dspi_cleanup;
909         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
910         master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16);
911
912         pdata = dev_get_platdata(&pdev->dev);
913         if (pdata) {
914                 master->num_chipselect = pdata->cs_num;
915                 master->bus_num = pdata->bus_num;
916
917                 dspi->devtype_data = &coldfire_data;
918         } else {
919
920                 ret = of_property_read_u32(np, "spi-num-chipselects", &cs_num);
921                 if (ret < 0) {
922                         dev_err(&pdev->dev, "can't get spi-num-chipselects\n");
923                         goto out_master_put;
924                 }
925                 master->num_chipselect = cs_num;
926
927                 ret = of_property_read_u32(np, "bus-num", &bus_num);
928                 if (ret < 0) {
929                         dev_err(&pdev->dev, "can't get bus-num\n");
930                         goto out_master_put;
931                 }
932                 master->bus_num = bus_num;
933
934                 dspi->devtype_data = of_device_get_match_data(&pdev->dev);
935                 if (!dspi->devtype_data) {
936                         dev_err(&pdev->dev, "can't get devtype_data\n");
937                         ret = -EFAULT;
938                         goto out_master_put;
939                 }
940         }
941
942         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
943         base = devm_ioremap_resource(&pdev->dev, res);
944         if (IS_ERR(base)) {
945                 ret = PTR_ERR(base);
946                 goto out_master_put;
947         }
948
949         dspi->regmap = devm_regmap_init_mmio_clk(&pdev->dev, NULL, base,
950                                                 &dspi_regmap_config);
951         if (IS_ERR(dspi->regmap)) {
952                 dev_err(&pdev->dev, "failed to init regmap: %ld\n",
953                                 PTR_ERR(dspi->regmap));
954                 ret = PTR_ERR(dspi->regmap);
955                 goto out_master_put;
956         }
957
958         dspi_init(dspi);
959         dspi->irq = platform_get_irq(pdev, 0);
960         if (dspi->irq < 0) {
961                 dev_err(&pdev->dev, "can't get platform irq\n");
962                 ret = dspi->irq;
963                 goto out_master_put;
964         }
965
966         ret = devm_request_irq(&pdev->dev, dspi->irq, dspi_interrupt, 0,
967                         pdev->name, dspi);
968         if (ret < 0) {
969                 dev_err(&pdev->dev, "Unable to attach DSPI interrupt\n");
970                 goto out_master_put;
971         }
972
973         dspi->clk = devm_clk_get(&pdev->dev, "dspi");
974         if (IS_ERR(dspi->clk)) {
975                 ret = PTR_ERR(dspi->clk);
976                 dev_err(&pdev->dev, "unable to get clock\n");
977                 goto out_master_put;
978         }
979         ret = clk_prepare_enable(dspi->clk);
980         if (ret)
981                 goto out_master_put;
982
983         if (dspi->devtype_data->trans_mode == DSPI_DMA_MODE) {
984                 ret = dspi_request_dma(dspi, res->start);
985                 if (ret < 0) {
986                         dev_err(&pdev->dev, "can't get dma channels\n");
987                         goto out_clk_put;
988                 }
989         }
990
991         master->max_speed_hz =
992                 clk_get_rate(dspi->clk) / dspi->devtype_data->max_clock_factor;
993
994         init_waitqueue_head(&dspi->waitq);
995         platform_set_drvdata(pdev, master);
996
997         ret = spi_register_master(master);
998         if (ret != 0) {
999                 dev_err(&pdev->dev, "Problem registering DSPI master\n");
1000                 goto out_clk_put;
1001         }
1002
1003         return ret;
1004
1005 out_clk_put:
1006         clk_disable_unprepare(dspi->clk);
1007 out_master_put:
1008         spi_master_put(master);
1009
1010         return ret;
1011 }
1012
1013 static int dspi_remove(struct platform_device *pdev)
1014 {
1015         struct spi_master *master = platform_get_drvdata(pdev);
1016         struct fsl_dspi *dspi = spi_master_get_devdata(master);
1017
1018         /* Disconnect from the SPI framework */
1019         dspi_release_dma(dspi);
1020         clk_disable_unprepare(dspi->clk);
1021         spi_unregister_master(dspi->master);
1022
1023         return 0;
1024 }
1025
1026 static struct platform_driver fsl_dspi_driver = {
1027         .driver.name    = DRIVER_NAME,
1028         .driver.of_match_table = fsl_dspi_dt_ids,
1029         .driver.owner   = THIS_MODULE,
1030         .driver.pm = &dspi_pm,
1031         .probe          = dspi_probe,
1032         .remove         = dspi_remove,
1033 };
1034 module_platform_driver(fsl_dspi_driver);
1035
1036 MODULE_DESCRIPTION("Freescale DSPI Controller Driver");
1037 MODULE_LICENSE("GPL");
1038 MODULE_ALIAS("platform:" DRIVER_NAME);