1 // SPDX-License-Identifier: GPL-2.0+
4 * (C) Copyright 2000-2003
5 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
7 * Copyright (C) 2004-2009 Freescale Semiconductor, Inc.
8 * TsiChung Liew (Tsi-Chung.Liew@freescale.com)
10 * Support for DM and DT, non-DM code removed.
11 * Copyright (C) 2018 Angelo Dureghello <angelo@sysam.it>
13 * TODO: fsl_dspi.c should work as a driver for the DSPI module.
19 #include <asm/global_data.h>
20 #include <dm/platform_data/spi_coldfire.h>
23 #include <asm/coldfire/dspi.h>
26 struct coldfire_spi_priv
{
33 DECLARE_GLOBAL_DATA_PTR
;
35 #ifndef CONFIG_SPI_IDLE_VAL
36 #if defined(CONFIG_SPI_MMC)
37 #define CONFIG_SPI_IDLE_VAL 0xFFFF
39 #define CONFIG_SPI_IDLE_VAL 0x0
46 * bit 31 - 28: Transfer size 3 to 16 bits
47 * 27 - 26: PCS to SCK delay prescaler
48 * 25 - 24: After SCK delay prescaler
49 * 23 - 22: Delay after transfer prescaler
50 * 21 : Allow overwrite for bit 31-22 and bit 20-8
51 * 20 : Double baud rate
52 * 19 - 16: PCS to SCK delay scaler
53 * 15 - 12: After SCK delay scaler
54 * 11 - 8: Delay after transfer scaler
55 * 7 - 0: SPI_CPHA, SPI_CPOL, SPI_LSB_FIRST
57 #define SPI_MODE_MOD 0x00200000
58 #define SPI_MODE_DBLRATE 0x00100000
60 #define SPI_MODE_XFER_SZ_MASK 0xf0000000
61 #define SPI_MODE_DLY_PRE_MASK 0x0fc00000
62 #define SPI_MODE_DLY_SCA_MASK 0x000fff00
64 #define MCF_FRM_SZ_16BIT DSPI_CTAR_TRSZ(0xf)
65 #define MCF_DSPI_SPEED_BESTMATCH 0x7FFFFFFF
66 #define MCF_DSPI_MAX_CTAR_REGS 8
69 #define MCF_DSPI_DEFAULT_SCK_FREQ 10000000
70 #define MCF_DSPI_DEFAULT_MAX_CS 4
71 #define MCF_DSPI_DEFAULT_MODE 0
73 #define MCF_DSPI_DEFAULT_CTAR (DSPI_CTAR_TRSZ(7) | \
74 DSPI_CTAR_PCSSCK_1CLK | \
77 DSPI_CTAR_CSSCK(0) | \
82 #define MCF_CTAR_MODE_MASK (MCF_FRM_SZ_16BIT | \
83 DSPI_CTAR_PCSSCK(3) | \
84 DSPI_CTAR_PASC_7CLK | \
86 DSPI_CTAR_CSSCK(0x0f) | \
87 DSPI_CTAR_ASC(0x0f) | \
90 #define setup_ctrl(ctrl, cs) ((ctrl & 0xFF000000) | ((1 << cs) << 16))
92 static inline void cfspi_tx(struct coldfire_spi_priv
*cfspi
,
96 * Need to check fifo level here
98 while ((readl(&cfspi
->regs
->sr
) & 0x0000F000) >= 0x4000)
101 writel(ctrl
| data
, &cfspi
->regs
->tfr
);
104 static inline u16
cfspi_rx(struct coldfire_spi_priv
*cfspi
)
107 while ((readl(&cfspi
->regs
->sr
) & 0x000000F0) == 0)
110 return readw(&cfspi
->regs
->rfr
);
113 static int coldfire_spi_claim_bus(struct udevice
*dev
)
115 struct udevice
*bus
= dev
->parent
;
116 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
117 struct dspi
*dspi
= cfspi
->regs
;
118 struct dm_spi_slave_plat
*slave_plat
=
119 dev_get_parent_plat(dev
);
121 if ((in_be32(&dspi
->sr
) & DSPI_SR_TXRXS
) != DSPI_SR_TXRXS
)
124 /* Clear FIFO and resume transfer */
125 clrbits_be32(&dspi
->mcr
, DSPI_MCR_CTXF
| DSPI_MCR_CRXF
);
127 dspi_chip_select(slave_plat
->cs
);
132 static int coldfire_spi_release_bus(struct udevice
*dev
)
134 struct udevice
*bus
= dev
->parent
;
135 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
136 struct dspi
*dspi
= cfspi
->regs
;
137 struct dm_spi_slave_plat
*slave_plat
=
138 dev_get_parent_plat(dev
);
141 clrbits_be32(&dspi
->mcr
, DSPI_MCR_CTXF
| DSPI_MCR_CRXF
);
143 dspi_chip_unselect(slave_plat
->cs
);
148 static int coldfire_spi_xfer(struct udevice
*dev
, unsigned int bitlen
,
149 const void *dout
, void *din
,
152 struct udevice
*bus
= dev_get_parent(dev
);
153 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
154 struct dm_spi_slave_plat
*slave_plat
= dev_get_parent_plat(dev
);
155 u16
*spi_rd16
= NULL
, *spi_wr16
= NULL
;
156 u8
*spi_rd
= NULL
, *spi_wr
= NULL
;
158 uint len
= bitlen
>> 3;
160 if (cfspi
->charbit
== 16) {
162 spi_wr16
= (u16
*)dout
;
163 spi_rd16
= (u16
*)din
;
169 if ((flags
& SPI_XFER_BEGIN
) == SPI_XFER_BEGIN
)
170 ctrl
|= DSPI_TFR_CONT
;
172 ctrl
= setup_ctrl(ctrl
, slave_plat
->cs
);
175 int tmp_len
= len
- 1;
179 if (cfspi
->charbit
== 16)
180 cfspi_tx(cfspi
, ctrl
, *spi_wr16
++);
182 cfspi_tx(cfspi
, ctrl
, *spi_wr
++);
187 cfspi_tx(cfspi
, ctrl
, CONFIG_SPI_IDLE_VAL
);
188 if (cfspi
->charbit
== 16)
189 *spi_rd16
++ = cfspi_rx(cfspi
);
191 *spi_rd
++ = cfspi_rx(cfspi
);
195 len
= 1; /* remaining byte */
198 if (flags
& SPI_XFER_END
)
199 ctrl
&= ~DSPI_TFR_CONT
;
203 if (cfspi
->charbit
== 16)
204 cfspi_tx(cfspi
, ctrl
, *spi_wr16
);
206 cfspi_tx(cfspi
, ctrl
, *spi_wr
);
211 cfspi_tx(cfspi
, ctrl
, CONFIG_SPI_IDLE_VAL
);
212 if (cfspi
->charbit
== 16)
213 *spi_rd16
= cfspi_rx(cfspi
);
215 *spi_rd
= cfspi_rx(cfspi
);
219 cfspi_tx(cfspi
, ctrl
, CONFIG_SPI_IDLE_VAL
);
226 static int coldfire_spi_set_speed(struct udevice
*bus
, uint max_hz
)
228 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
229 struct dspi
*dspi
= cfspi
->regs
;
230 int prescaler
[] = { 2, 3, 5, 7 };
234 256, 512, 1024, 2048,
235 4096, 8192, 16384, 32768
237 int i
, j
, pbrcnt
, brcnt
, diff
, tmp
, dbr
= 0;
238 int best_i
, best_j
, bestmatch
= MCF_DSPI_SPEED_BESTMATCH
, baud_speed
;
241 cfspi
->baudrate
= max_hz
;
243 /* Read current setup */
244 bus_setup
= readl(&dspi
->ctar
[dev_seq(bus
)]);
246 tmp
= (prescaler
[3] * scaler
[15]);
247 /* Maximum and minimum baudrate it can handle */
248 if ((cfspi
->baudrate
> (gd
->bus_clk
>> 1)) ||
249 (cfspi
->baudrate
< (gd
->bus_clk
/ tmp
))) {
250 printf("Exceed baudrate limitation: Max %d - Min %d\n",
251 (int)(gd
->bus_clk
>> 1), (int)(gd
->bus_clk
/ tmp
));
255 /* Activate Double Baud when it exceed 1/4 the bus clk */
256 if ((bus_setup
& DSPI_CTAR_DBR
) ||
257 (cfspi
->baudrate
> (gd
->bus_clk
/ (prescaler
[0] * scaler
[0])))) {
258 bus_setup
|= DSPI_CTAR_DBR
;
262 /* Overwrite default value set in platform configuration file */
263 if (cfspi
->mode
& SPI_MODE_MOD
) {
265 * Check to see if it is enabled by default in platform
266 * config, or manual setting passed by mode parameter
268 if (cfspi
->mode
& SPI_MODE_DBLRATE
) {
269 bus_setup
|= DSPI_CTAR_DBR
;
274 pbrcnt
= sizeof(prescaler
) / sizeof(int);
275 brcnt
= sizeof(scaler
) / sizeof(int);
277 /* baudrate calculation - to closer value, may not be exact match */
278 for (best_i
= 0, best_j
= 0, i
= 0; i
< pbrcnt
; i
++) {
279 baud_speed
= gd
->bus_clk
/ prescaler
[i
];
280 for (j
= 0; j
< brcnt
; j
++) {
281 tmp
= (baud_speed
/ scaler
[j
]) * (1 + dbr
);
283 if (tmp
> cfspi
->baudrate
)
284 diff
= tmp
- cfspi
->baudrate
;
286 diff
= cfspi
->baudrate
- tmp
;
288 if (diff
< bestmatch
) {
296 bus_setup
&= ~(DSPI_CTAR_PBR(0x03) | DSPI_CTAR_BR(0x0f));
297 bus_setup
|= (DSPI_CTAR_PBR(best_i
) | DSPI_CTAR_BR(best_j
));
298 writel(bus_setup
, &dspi
->ctar
[dev_seq(bus
)]);
303 static int coldfire_spi_set_mode(struct udevice
*bus
, uint mode
)
305 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
306 struct dspi
*dspi
= cfspi
->regs
;
311 if (cfspi
->mode
& SPI_CPOL
)
312 bus_setup
|= DSPI_CTAR_CPOL
;
313 if (cfspi
->mode
& SPI_CPHA
)
314 bus_setup
|= DSPI_CTAR_CPHA
;
315 if (cfspi
->mode
& SPI_LSB_FIRST
)
316 bus_setup
|= DSPI_CTAR_LSBFE
;
318 /* Overwrite default value set in platform configuration file */
319 if (cfspi
->mode
& SPI_MODE_MOD
) {
320 if ((cfspi
->mode
& SPI_MODE_XFER_SZ_MASK
) == 0)
322 readl(&dspi
->ctar
[dev_seq(bus
)]) & MCF_FRM_SZ_16BIT
;
325 ((cfspi
->mode
& SPI_MODE_XFER_SZ_MASK
) >> 1);
327 /* PSCSCK, PASC, PDT */
328 bus_setup
|= (cfspi
->mode
& SPI_MODE_DLY_PRE_MASK
) >> 4;
330 bus_setup
|= (cfspi
->mode
& SPI_MODE_DLY_SCA_MASK
) >> 4;
333 (readl(&dspi
->ctar
[dev_seq(bus
)]) & MCF_CTAR_MODE_MASK
);
337 ((readl(&dspi
->ctar
[dev_seq(bus
)]) & MCF_FRM_SZ_16BIT
) ==
338 MCF_FRM_SZ_16BIT
) ? 16 : 8;
340 setbits_be32(&dspi
->ctar
[dev_seq(bus
)], bus_setup
);
345 static int coldfire_spi_probe(struct udevice
*bus
)
347 struct coldfire_spi_plat
*plat
= dev_get_plat(bus
);
348 struct coldfire_spi_priv
*cfspi
= dev_get_priv(bus
);
349 struct dspi
*dspi
= cfspi
->regs
;
352 cfspi
->regs
= (struct dspi
*)plat
->regs_addr
;
354 cfspi
->baudrate
= plat
->speed_hz
;
355 cfspi
->mode
= plat
->mode
;
357 for (i
= 0; i
< MCF_DSPI_MAX_CTAR_REGS
; i
++) {
358 unsigned int ctar
= 0;
360 if (plat
->ctar
[i
][0] == 0)
363 ctar
= DSPI_CTAR_TRSZ(plat
->ctar
[i
][0]) |
364 DSPI_CTAR_PCSSCK(plat
->ctar
[i
][1]) |
365 DSPI_CTAR_PASC(plat
->ctar
[i
][2]) |
366 DSPI_CTAR_PDT(plat
->ctar
[i
][3]) |
367 DSPI_CTAR_CSSCK(plat
->ctar
[i
][4]) |
368 DSPI_CTAR_ASC(plat
->ctar
[i
][5]) |
369 DSPI_CTAR_DT(plat
->ctar
[i
][6]) |
370 DSPI_CTAR_BR(plat
->ctar
[i
][7]);
372 writel(ctar
, &cfspi
->regs
->ctar
[i
]);
376 for (i
= 0; i
< MCF_DSPI_MAX_CTAR_REGS
; i
++)
377 writel(MCF_DSPI_DEFAULT_CTAR
, &dspi
->ctar
[i
]);
379 dspi
->mcr
= DSPI_MCR_MSTR
| DSPI_MCR_CSIS7
| DSPI_MCR_CSIS6
|
380 DSPI_MCR_CSIS5
| DSPI_MCR_CSIS4
| DSPI_MCR_CSIS3
|
381 DSPI_MCR_CSIS2
| DSPI_MCR_CSIS1
| DSPI_MCR_CSIS0
|
382 DSPI_MCR_CRXF
| DSPI_MCR_CTXF
;
387 #if CONFIG_IS_ENABLED(OF_REAL)
388 static int coldfire_dspi_of_to_plat(struct udevice
*bus
)
391 struct coldfire_spi_plat
*plat
= dev_get_plat(bus
);
392 const void *blob
= gd
->fdt_blob
;
393 int node
= dev_of_offset(bus
);
396 addr
= dev_read_addr(bus
);
397 if (addr
== FDT_ADDR_T_NONE
)
400 plat
->regs_addr
= addr
;
402 plat
->num_cs
= fdtdec_get_int(blob
, node
, "num-cs",
403 MCF_DSPI_DEFAULT_MAX_CS
);
405 plat
->speed_hz
= fdtdec_get_int(blob
, node
, "spi-max-frequency",
406 MCF_DSPI_DEFAULT_SCK_FREQ
);
408 plat
->mode
= fdtdec_get_int(blob
, node
, "spi-mode",
409 MCF_DSPI_DEFAULT_MODE
);
411 memset(plat
->ctar
, 0, sizeof(plat
->ctar
));
413 ctar
= (int *)fdt_getprop(blob
, node
, "ctar-params", &len
);
418 ctar_regs
= len
/ sizeof(unsigned int) / MAX_CTAR_FIELDS
;
420 if (ctar_regs
> MAX_CTAR_REGS
)
421 ctar_regs
= MAX_CTAR_REGS
;
423 for (i
= 0; i
< ctar_regs
; i
++) {
424 for (q
= 0; q
< MAX_CTAR_FIELDS
; q
++)
425 plat
->ctar
[i
][q
] = *ctar
++;
429 debug("DSPI: regs=%pa, max-frequency=%d, num-cs=%d, mode=%d\n",
430 (void *)plat
->regs_addr
,
431 plat
->speed_hz
, plat
->num_cs
, plat
->mode
);
436 static const struct udevice_id coldfire_spi_ids
[] = {
437 { .compatible
= "fsl,mcf-dspi" },
442 static const struct dm_spi_ops coldfire_spi_ops
= {
443 .claim_bus
= coldfire_spi_claim_bus
,
444 .release_bus
= coldfire_spi_release_bus
,
445 .xfer
= coldfire_spi_xfer
,
446 .set_speed
= coldfire_spi_set_speed
,
447 .set_mode
= coldfire_spi_set_mode
,
450 U_BOOT_DRIVER(coldfire_spi
) = {
451 .name
= "spi_coldfire",
453 #if CONFIG_IS_ENABLED(OF_REAL)
454 .of_match
= coldfire_spi_ids
,
455 .of_to_plat
= coldfire_dspi_of_to_plat
,
456 .plat_auto
= sizeof(struct coldfire_spi_plat
),
458 .probe
= coldfire_spi_probe
,
459 .ops
= &coldfire_spi_ops
,
460 .priv_auto
= sizeof(struct coldfire_spi_priv
),