2 * drivers/spi/spi-fsl-dspi.c
4 * Copyright 2013 Freescale Semiconductor, Inc.
6 * Freescale DSPI driver
7 * This file contains a driver for the Freescale DSPI
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.
16 #include <linux/clk.h>
17 #include <linux/delay.h>
18 #include <linux/err.h>
19 #include <linux/errno.h>
20 #include <linux/interrupt.h>
22 #include <linux/kernel.h>
23 #include <linux/math64.h>
24 #include <linux/module.h>
26 #include <linux/of_device.h>
27 #include <linux/platform_device.h>
28 #include <linux/pm_runtime.h>
29 #include <linux/regmap.h>
30 #include <linux/sched.h>
31 #include <linux/spi/spi.h>
32 #include <linux/spi/spi_bitbang.h>
33 #include <linux/time.h>
35 #define DRIVER_NAME "fsl-dspi"
37 #define TRAN_STATE_RX_VOID 0x01
38 #define TRAN_STATE_TX_VOID 0x02
39 #define TRAN_STATE_WORD_ODD_NUM 0x04
41 #define DSPI_FIFO_SIZE 4
44 #define SPI_MCR_MASTER (1 << 31)
45 #define SPI_MCR_PCSIS (0x3F << 16)
46 #define SPI_MCR_CLR_TXF (1 << 11)
47 #define SPI_MCR_CLR_RXF (1 << 10)
51 #define SPI_CTAR(x) (0x0c + (((x) & 0x3) * 4))
52 #define SPI_CTAR_FMSZ(x) (((x) & 0x0000000f) << 27)
53 #define SPI_CTAR_CPOL(x) ((x) << 26)
54 #define SPI_CTAR_CPHA(x) ((x) << 25)
55 #define SPI_CTAR_LSBFE(x) ((x) << 24)
56 #define SPI_CTAR_PCSSCK(x) (((x) & 0x00000003) << 22)
57 #define SPI_CTAR_PASC(x) (((x) & 0x00000003) << 20)
58 #define SPI_CTAR_PDT(x) (((x) & 0x00000003) << 18)
59 #define SPI_CTAR_PBR(x) (((x) & 0x00000003) << 16)
60 #define SPI_CTAR_CSSCK(x) (((x) & 0x0000000f) << 12)
61 #define SPI_CTAR_ASC(x) (((x) & 0x0000000f) << 8)
62 #define SPI_CTAR_DT(x) (((x) & 0x0000000f) << 4)
63 #define SPI_CTAR_BR(x) ((x) & 0x0000000f)
64 #define SPI_CTAR_SCALE_BITS 0xf
66 #define SPI_CTAR0_SLAVE 0x0c
69 #define SPI_SR_EOQF 0x10000000
70 #define SPI_SR_TCFQF 0x80000000
73 #define SPI_RSER_EOQFE 0x10000000
74 #define SPI_RSER_TCFQE 0x80000000
76 #define SPI_PUSHR 0x34
77 #define SPI_PUSHR_CONT (1 << 31)
78 #define SPI_PUSHR_CTAS(x) (((x) & 0x00000003) << 28)
79 #define SPI_PUSHR_EOQ (1 << 27)
80 #define SPI_PUSHR_CTCNT (1 << 26)
81 #define SPI_PUSHR_PCS(x) (((1 << x) & 0x0000003f) << 16)
82 #define SPI_PUSHR_TXDATA(x) ((x) & 0x0000ffff)
84 #define SPI_PUSHR_SLAVE 0x34
87 #define SPI_POPR_RXDATA(x) ((x) & 0x0000ffff)
89 #define SPI_TXFR0 0x3c
90 #define SPI_TXFR1 0x40
91 #define SPI_TXFR2 0x44
92 #define SPI_TXFR3 0x48
93 #define SPI_RXFR0 0x7c
94 #define SPI_RXFR1 0x80
95 #define SPI_RXFR2 0x84
96 #define SPI_RXFR3 0x88
98 #define SPI_FRAME_BITS(bits) SPI_CTAR_FMSZ((bits) - 1)
99 #define SPI_FRAME_BITS_MASK SPI_CTAR_FMSZ(0xf)
100 #define SPI_FRAME_BITS_16 SPI_CTAR_FMSZ(0xf)
101 #define SPI_FRAME_BITS_8 SPI_CTAR_FMSZ(0x7)
103 #define SPI_CS_INIT 0x01
104 #define SPI_CS_ASSERT 0x02
105 #define SPI_CS_DROP 0x04
113 enum dspi_trans_mode
{
118 struct fsl_dspi_devtype_data
{
119 enum dspi_trans_mode trans_mode
;
122 static const struct fsl_dspi_devtype_data vf610_data
= {
123 .trans_mode
= DSPI_EOQ_MODE
,
126 static const struct fsl_dspi_devtype_data ls1021a_v1_data
= {
127 .trans_mode
= DSPI_TCFQ_MODE
,
130 static const struct fsl_dspi_devtype_data ls2085a_data
= {
131 .trans_mode
= DSPI_TCFQ_MODE
,
135 struct spi_master
*master
;
136 struct platform_device
*pdev
;
138 struct regmap
*regmap
;
142 struct spi_transfer
*cur_transfer
;
143 struct spi_message
*cur_msg
;
144 struct chip_data
*cur_chip
;
154 struct fsl_dspi_devtype_data
*devtype_data
;
156 wait_queue_head_t waitq
;
160 static inline int is_double_byte_mode(struct fsl_dspi
*dspi
)
164 regmap_read(dspi
->regmap
, SPI_CTAR(dspi
->cs
), &val
);
166 return ((val
& SPI_FRAME_BITS_MASK
) == SPI_FRAME_BITS(8)) ? 0 : 1;
169 static void hz_to_spi_baud(char *pbr
, char *br
, int speed_hz
,
170 unsigned long clkrate
)
172 /* Valid baud rate pre-scaler values */
173 int pbr_tbl
[4] = {2, 3, 5, 7};
174 int brs
[16] = { 2, 4, 6, 8,
176 256, 512, 1024, 2048,
177 4096, 8192, 16384, 32768 };
178 int scale_needed
, scale
, minscale
= INT_MAX
;
181 scale_needed
= clkrate
/ speed_hz
;
182 if (clkrate
% speed_hz
)
185 for (i
= 0; i
< ARRAY_SIZE(brs
); i
++)
186 for (j
= 0; j
< ARRAY_SIZE(pbr_tbl
); j
++) {
187 scale
= brs
[i
] * pbr_tbl
[j
];
188 if (scale
>= scale_needed
) {
189 if (scale
< minscale
) {
198 if (minscale
== INT_MAX
) {
199 pr_warn("Can not find valid baud rate,speed_hz is %d,clkrate is %ld, we use the max prescaler value.\n",
201 *pbr
= ARRAY_SIZE(pbr_tbl
) - 1;
202 *br
= ARRAY_SIZE(brs
) - 1;
206 static void ns_delay_scale(char *psc
, char *sc
, int delay_ns
,
207 unsigned long clkrate
)
209 int pscale_tbl
[4] = {1, 3, 5, 7};
210 int scale_needed
, scale
, minscale
= INT_MAX
;
214 scale_needed
= div_u64_rem((u64
)delay_ns
* clkrate
, NSEC_PER_SEC
,
219 for (i
= 0; i
< ARRAY_SIZE(pscale_tbl
); i
++)
220 for (j
= 0; j
<= SPI_CTAR_SCALE_BITS
; j
++) {
221 scale
= pscale_tbl
[i
] * (2 << j
);
222 if (scale
>= scale_needed
) {
223 if (scale
< minscale
) {
232 if (minscale
== INT_MAX
) {
233 pr_warn("Cannot find correct scale values for %dns delay at clkrate %ld, using max prescaler value",
235 *psc
= ARRAY_SIZE(pscale_tbl
) - 1;
236 *sc
= SPI_CTAR_SCALE_BITS
;
240 static u32
dspi_data_to_pushr(struct fsl_dspi
*dspi
, int tx_word
)
244 if (!(dspi
->dataflags
& TRAN_STATE_TX_VOID
))
245 d16
= tx_word
? *(u16
*)dspi
->tx
: *(u8
*)dspi
->tx
;
247 d16
= dspi
->void_write_data
;
249 dspi
->tx
+= tx_word
+ 1;
250 dspi
->len
-= tx_word
+ 1;
252 return SPI_PUSHR_TXDATA(d16
) |
253 SPI_PUSHR_PCS(dspi
->cs
) |
254 SPI_PUSHR_CTAS(dspi
->cs
) |
258 static void dspi_data_from_popr(struct fsl_dspi
*dspi
, int rx_word
)
263 regmap_read(dspi
->regmap
, SPI_POPR
, &val
);
264 d
= SPI_POPR_RXDATA(val
);
266 if (!(dspi
->dataflags
& TRAN_STATE_RX_VOID
))
267 rx_word
? (*(u16
*)dspi
->rx
= d
) : (*(u8
*)dspi
->rx
= d
);
269 dspi
->rx
+= rx_word
+ 1;
272 static int dspi_eoq_write(struct fsl_dspi
*dspi
)
279 tx_word
= is_double_byte_mode(dspi
);
281 while (dspi
->len
&& (tx_count
< DSPI_FIFO_SIZE
)) {
282 /* If we are in word mode, only have a single byte to transfer
283 * switch to byte mode temporarily. Will switch back at the
284 * end of the transfer.
286 if (tx_word
&& (dspi
->len
== 1)) {
287 dspi
->dataflags
|= TRAN_STATE_WORD_ODD_NUM
;
288 regmap_update_bits(dspi
->regmap
, SPI_CTAR(dspi
->cs
),
289 SPI_FRAME_BITS_MASK
, SPI_FRAME_BITS(8));
293 dspi_pushr
= dspi_data_to_pushr(dspi
, tx_word
);
295 if (dspi
->len
== 0 || tx_count
== DSPI_FIFO_SIZE
- 1) {
296 /* last transfer in the transfer */
297 dspi_pushr
|= SPI_PUSHR_EOQ
;
298 if ((dspi
->cs_change
) && (!dspi
->len
))
299 dspi_pushr
&= ~SPI_PUSHR_CONT
;
300 } else if (tx_word
&& (dspi
->len
== 1))
301 dspi_pushr
|= SPI_PUSHR_EOQ
;
305 dspi_pushr
|= SPI_PUSHR_CTCNT
; /* clear counter */
308 regmap_write(dspi
->regmap
, SPI_PUSHR
, dspi_pushr
);
313 return tx_count
* (tx_word
+ 1);
316 static int dspi_eoq_read(struct fsl_dspi
*dspi
)
319 int rx_word
= is_double_byte_mode(dspi
);
321 while ((dspi
->rx
< dspi
->rx_end
)
322 && (rx_count
< DSPI_FIFO_SIZE
)) {
323 if (rx_word
&& (dspi
->rx_end
- dspi
->rx
) == 1)
326 dspi_data_from_popr(dspi
, rx_word
);
333 static int dspi_tcfq_write(struct fsl_dspi
*dspi
)
338 tx_word
= is_double_byte_mode(dspi
);
340 if (tx_word
&& (dspi
->len
== 1)) {
341 dspi
->dataflags
|= TRAN_STATE_WORD_ODD_NUM
;
342 regmap_update_bits(dspi
->regmap
, SPI_CTAR(dspi
->cs
),
343 SPI_FRAME_BITS_MASK
, SPI_FRAME_BITS(8));
347 dspi_pushr
= dspi_data_to_pushr(dspi
, tx_word
);
349 if ((dspi
->cs_change
) && (!dspi
->len
))
350 dspi_pushr
&= ~SPI_PUSHR_CONT
;
352 regmap_write(dspi
->regmap
, SPI_PUSHR
, dspi_pushr
);
357 static void dspi_tcfq_read(struct fsl_dspi
*dspi
)
359 int rx_word
= is_double_byte_mode(dspi
);
361 if (rx_word
&& (dspi
->rx_end
- dspi
->rx
) == 1)
364 dspi_data_from_popr(dspi
, rx_word
);
367 static int dspi_transfer_one_message(struct spi_master
*master
,
368 struct spi_message
*message
)
370 struct fsl_dspi
*dspi
= spi_master_get_devdata(master
);
371 struct spi_device
*spi
= message
->spi
;
372 struct spi_transfer
*transfer
;
374 enum dspi_trans_mode trans_mode
;
376 message
->actual_length
= 0;
378 list_for_each_entry(transfer
, &message
->transfers
, transfer_list
) {
379 dspi
->cur_transfer
= transfer
;
380 dspi
->cur_msg
= message
;
381 dspi
->cur_chip
= spi_get_ctldata(spi
);
382 dspi
->cs
= spi
->chip_select
;
384 if (dspi
->cur_transfer
->transfer_list
.next
385 == &dspi
->cur_msg
->transfers
)
387 dspi
->void_write_data
= dspi
->cur_chip
->void_write_data
;
390 dspi
->tx
= (void *)transfer
->tx_buf
;
391 dspi
->tx_end
= dspi
->tx
+ transfer
->len
;
392 dspi
->rx
= transfer
->rx_buf
;
393 dspi
->rx_end
= dspi
->rx
+ transfer
->len
;
394 dspi
->len
= transfer
->len
;
397 dspi
->dataflags
|= TRAN_STATE_RX_VOID
;
400 dspi
->dataflags
|= TRAN_STATE_TX_VOID
;
402 regmap_write(dspi
->regmap
, SPI_MCR
, dspi
->cur_chip
->mcr_val
);
403 regmap_update_bits(dspi
->regmap
, SPI_MCR
,
404 SPI_MCR_CLR_TXF
| SPI_MCR_CLR_RXF
,
405 SPI_MCR_CLR_TXF
| SPI_MCR_CLR_RXF
);
406 regmap_write(dspi
->regmap
, SPI_CTAR(dspi
->cs
),
407 dspi
->cur_chip
->ctar_val
);
408 if (transfer
->speed_hz
)
409 regmap_write(dspi
->regmap
, SPI_CTAR(dspi
->cs
),
410 dspi
->cur_chip
->ctar_val
);
412 trans_mode
= dspi
->devtype_data
->trans_mode
;
413 switch (trans_mode
) {
415 regmap_write(dspi
->regmap
, SPI_RSER
, SPI_RSER_EOQFE
);
416 message
->actual_length
+= dspi_eoq_write(dspi
);
419 regmap_write(dspi
->regmap
, SPI_RSER
, SPI_RSER_TCFQE
);
420 message
->actual_length
+= dspi_tcfq_write(dspi
);
423 dev_err(&dspi
->pdev
->dev
, "unsupported trans_mode %u\n",
429 if (wait_event_interruptible(dspi
->waitq
, dspi
->waitflags
))
430 dev_err(&dspi
->pdev
->dev
, "wait transfer complete fail!\n");
433 if (transfer
->delay_usecs
)
434 udelay(transfer
->delay_usecs
);
438 message
->status
= status
;
439 spi_finalize_current_message(master
);
444 static int dspi_setup(struct spi_device
*spi
)
446 struct chip_data
*chip
;
447 struct fsl_dspi
*dspi
= spi_master_get_devdata(spi
->master
);
448 u32 cs_sck_delay
= 0, sck_cs_delay
= 0;
449 unsigned char br
= 0, pbr
= 0, pcssck
= 0, cssck
= 0;
450 unsigned char pasc
= 0, asc
= 0, fmsz
= 0;
451 unsigned long clkrate
;
453 if ((spi
->bits_per_word
>= 4) && (spi
->bits_per_word
<= 16)) {
454 fmsz
= spi
->bits_per_word
- 1;
456 pr_err("Invalid wordsize\n");
460 /* Only alloc on first setup */
461 chip
= spi_get_ctldata(spi
);
463 chip
= kzalloc(sizeof(struct chip_data
), GFP_KERNEL
);
468 of_property_read_u32(spi
->dev
.of_node
, "fsl,spi-cs-sck-delay",
471 of_property_read_u32(spi
->dev
.of_node
, "fsl,spi-sck-cs-delay",
474 chip
->mcr_val
= SPI_MCR_MASTER
| SPI_MCR_PCSIS
|
475 SPI_MCR_CLR_TXF
| SPI_MCR_CLR_RXF
;
477 chip
->void_write_data
= 0;
479 clkrate
= clk_get_rate(dspi
->clk
);
480 hz_to_spi_baud(&pbr
, &br
, spi
->max_speed_hz
, clkrate
);
482 /* Set PCS to SCK delay scale values */
483 ns_delay_scale(&pcssck
, &cssck
, cs_sck_delay
, clkrate
);
485 /* Set After SCK delay scale values */
486 ns_delay_scale(&pasc
, &asc
, sck_cs_delay
, clkrate
);
488 chip
->ctar_val
= SPI_CTAR_FMSZ(fmsz
)
489 | SPI_CTAR_CPOL(spi
->mode
& SPI_CPOL
? 1 : 0)
490 | SPI_CTAR_CPHA(spi
->mode
& SPI_CPHA
? 1 : 0)
491 | SPI_CTAR_LSBFE(spi
->mode
& SPI_LSB_FIRST
? 1 : 0)
492 | SPI_CTAR_PCSSCK(pcssck
)
493 | SPI_CTAR_CSSCK(cssck
)
494 | SPI_CTAR_PASC(pasc
)
499 spi_set_ctldata(spi
, chip
);
504 static void dspi_cleanup(struct spi_device
*spi
)
506 struct chip_data
*chip
= spi_get_ctldata((struct spi_device
*)spi
);
508 dev_dbg(&spi
->dev
, "spi_device %u.%u cleanup\n",
509 spi
->master
->bus_num
, spi
->chip_select
);
514 static irqreturn_t
dspi_interrupt(int irq
, void *dev_id
)
516 struct fsl_dspi
*dspi
= (struct fsl_dspi
*)dev_id
;
517 struct spi_message
*msg
= dspi
->cur_msg
;
518 enum dspi_trans_mode trans_mode
;
521 regmap_read(dspi
->regmap
, SPI_SR
, &spi_sr
);
522 regmap_write(dspi
->regmap
, SPI_SR
, spi_sr
);
524 trans_mode
= dspi
->devtype_data
->trans_mode
;
525 switch (trans_mode
) {
530 dspi_tcfq_read(dspi
);
533 dev_err(&dspi
->pdev
->dev
, "unsupported trans_mode %u\n",
539 if (dspi
->dataflags
& TRAN_STATE_WORD_ODD_NUM
) {
540 regmap_update_bits(dspi
->regmap
, SPI_CTAR(dspi
->cs
),
541 SPI_FRAME_BITS_MASK
, SPI_FRAME_BITS(16));
542 dspi
->dataflags
&= ~TRAN_STATE_WORD_ODD_NUM
;
546 wake_up_interruptible(&dspi
->waitq
);
548 switch (trans_mode
) {
550 msg
->actual_length
+= dspi_eoq_write(dspi
);
553 msg
->actual_length
+= dspi_tcfq_write(dspi
);
556 dev_err(&dspi
->pdev
->dev
, "unsupported trans_mode %u\n",
563 static const struct of_device_id fsl_dspi_dt_ids
[] = {
564 { .compatible
= "fsl,vf610-dspi", .data
= (void *)&vf610_data
, },
565 { .compatible
= "fsl,ls1021a-v1.0-dspi",
566 .data
= (void *)&ls1021a_v1_data
, },
567 { .compatible
= "fsl,ls2085a-dspi", .data
= (void *)&ls2085a_data
, },
570 MODULE_DEVICE_TABLE(of
, fsl_dspi_dt_ids
);
572 #ifdef CONFIG_PM_SLEEP
573 static int dspi_suspend(struct device
*dev
)
575 struct spi_master
*master
= dev_get_drvdata(dev
);
576 struct fsl_dspi
*dspi
= spi_master_get_devdata(master
);
578 spi_master_suspend(master
);
579 clk_disable_unprepare(dspi
->clk
);
584 static int dspi_resume(struct device
*dev
)
586 struct spi_master
*master
= dev_get_drvdata(dev
);
587 struct fsl_dspi
*dspi
= spi_master_get_devdata(master
);
589 clk_prepare_enable(dspi
->clk
);
590 spi_master_resume(master
);
594 #endif /* CONFIG_PM_SLEEP */
596 static SIMPLE_DEV_PM_OPS(dspi_pm
, dspi_suspend
, dspi_resume
);
598 static const struct regmap_config dspi_regmap_config
= {
602 .max_register
= 0x88,
605 static int dspi_probe(struct platform_device
*pdev
)
607 struct device_node
*np
= pdev
->dev
.of_node
;
608 struct spi_master
*master
;
609 struct fsl_dspi
*dspi
;
610 struct resource
*res
;
612 int ret
= 0, cs_num
, bus_num
;
613 const struct of_device_id
*of_id
=
614 of_match_device(fsl_dspi_dt_ids
, &pdev
->dev
);
616 master
= spi_alloc_master(&pdev
->dev
, sizeof(struct fsl_dspi
));
620 dspi
= spi_master_get_devdata(master
);
622 dspi
->master
= master
;
624 master
->transfer
= NULL
;
625 master
->setup
= dspi_setup
;
626 master
->transfer_one_message
= dspi_transfer_one_message
;
627 master
->dev
.of_node
= pdev
->dev
.of_node
;
629 master
->cleanup
= dspi_cleanup
;
630 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
;
631 master
->bits_per_word_mask
= SPI_BPW_MASK(4) | SPI_BPW_MASK(8) |
634 ret
= of_property_read_u32(np
, "spi-num-chipselects", &cs_num
);
636 dev_err(&pdev
->dev
, "can't get spi-num-chipselects\n");
639 master
->num_chipselect
= cs_num
;
641 ret
= of_property_read_u32(np
, "bus-num", &bus_num
);
643 dev_err(&pdev
->dev
, "can't get bus-num\n");
646 master
->bus_num
= bus_num
;
648 dspi
->devtype_data
= (struct fsl_dspi_devtype_data
*)of_id
->data
;
649 if (!dspi
->devtype_data
) {
650 dev_err(&pdev
->dev
, "can't get devtype_data\n");
655 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
656 base
= devm_ioremap_resource(&pdev
->dev
, res
);
662 dspi
->regmap
= devm_regmap_init_mmio_clk(&pdev
->dev
, NULL
, base
,
663 &dspi_regmap_config
);
664 if (IS_ERR(dspi
->regmap
)) {
665 dev_err(&pdev
->dev
, "failed to init regmap: %ld\n",
666 PTR_ERR(dspi
->regmap
));
667 return PTR_ERR(dspi
->regmap
);
670 dspi
->irq
= platform_get_irq(pdev
, 0);
672 dev_err(&pdev
->dev
, "can't get platform irq\n");
677 ret
= devm_request_irq(&pdev
->dev
, dspi
->irq
, dspi_interrupt
, 0,
680 dev_err(&pdev
->dev
, "Unable to attach DSPI interrupt\n");
684 dspi
->clk
= devm_clk_get(&pdev
->dev
, "dspi");
685 if (IS_ERR(dspi
->clk
)) {
686 ret
= PTR_ERR(dspi
->clk
);
687 dev_err(&pdev
->dev
, "unable to get clock\n");
690 clk_prepare_enable(dspi
->clk
);
692 init_waitqueue_head(&dspi
->waitq
);
693 platform_set_drvdata(pdev
, master
);
695 ret
= spi_register_master(master
);
697 dev_err(&pdev
->dev
, "Problem registering DSPI master\n");
704 clk_disable_unprepare(dspi
->clk
);
706 spi_master_put(master
);
711 static int dspi_remove(struct platform_device
*pdev
)
713 struct spi_master
*master
= platform_get_drvdata(pdev
);
714 struct fsl_dspi
*dspi
= spi_master_get_devdata(master
);
716 /* Disconnect from the SPI framework */
717 clk_disable_unprepare(dspi
->clk
);
718 spi_unregister_master(dspi
->master
);
719 spi_master_put(dspi
->master
);
724 static struct platform_driver fsl_dspi_driver
= {
725 .driver
.name
= DRIVER_NAME
,
726 .driver
.of_match_table
= fsl_dspi_dt_ids
,
727 .driver
.owner
= THIS_MODULE
,
728 .driver
.pm
= &dspi_pm
,
730 .remove
= dspi_remove
,
732 module_platform_driver(fsl_dspi_driver
);
734 MODULE_DESCRIPTION("Freescale DSPI Controller Driver");
735 MODULE_LICENSE("GPL");
736 MODULE_ALIAS("platform:" DRIVER_NAME
);