2 * Freescale i.MX28 SPI driver
4 * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
5 * on behalf of DENX Software Engineering GmbH
7 * SPDX-License-Identifier: GPL-2.0+
9 * NOTE: This driver only supports the SPI-controller chipselects,
10 * GPIO driven chipselects are not supported.
16 #include <asm/errno.h>
18 #include <asm/arch/clock.h>
19 #include <asm/arch/imx-regs.h>
20 #include <asm/arch/sys_proto.h>
21 #include <asm/imx-common/dma.h>
23 #define MXS_SPI_MAX_TIMEOUT 1000000
24 #define MXS_SPI_PORT_OFFSET 0x2000
25 #define MXS_SSP_CHIPSELECT_MASK 0x00300000
26 #define MXS_SSP_CHIPSELECT_SHIFT 20
28 #define MXSSSP_SMALL_TRANSFER 512
30 struct mxs_spi_slave
{
31 struct spi_slave slave
;
34 struct mxs_ssp_regs
*regs
;
37 static inline struct mxs_spi_slave
*to_mxs_slave(struct spi_slave
*slave
)
39 return container_of(slave
, struct mxs_spi_slave
, slave
);
46 int spi_cs_is_valid(unsigned int bus
, unsigned int cs
)
48 /* MXS SPI: 4 ports and 3 chip selects maximum */
49 if (!mxs_ssp_bus_id_valid(bus
) || cs
> 2)
55 struct spi_slave
*spi_setup_slave(unsigned int bus
, unsigned int cs
,
56 unsigned int max_hz
, unsigned int mode
)
58 struct mxs_spi_slave
*mxs_slave
;
59 struct mxs_ssp_regs
*ssp_regs
;
62 if (!spi_cs_is_valid(bus
, cs
)) {
63 printf("mxs_spi: invalid bus %d / chip select %d\n", bus
, cs
);
67 mxs_slave
= spi_alloc_slave(struct mxs_spi_slave
, bus
, cs
);
71 if (mxs_dma_init_channel(MXS_DMA_CHANNEL_AHB_APBH_SSP0
+ bus
))
74 mxs_slave
->max_khz
= max_hz
/ 1000;
75 mxs_slave
->mode
= mode
;
76 mxs_slave
->regs
= mxs_ssp_regs_by_bus(bus
);
77 ssp_regs
= mxs_slave
->regs
;
79 reg
= readl(&ssp_regs
->hw_ssp_ctrl0
);
80 reg
&= ~(MXS_SSP_CHIPSELECT_MASK
);
81 reg
|= cs
<< MXS_SSP_CHIPSELECT_SHIFT
;
83 writel(reg
, &ssp_regs
->hw_ssp_ctrl0
);
84 return &mxs_slave
->slave
;
91 void spi_free_slave(struct spi_slave
*slave
)
93 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
97 int spi_claim_bus(struct spi_slave
*slave
)
99 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
100 struct mxs_ssp_regs
*ssp_regs
= mxs_slave
->regs
;
103 mxs_reset_block(&ssp_regs
->hw_ssp_ctrl0_reg
);
105 writel(SSP_CTRL0_BUS_WIDTH_ONE_BIT
, &ssp_regs
->hw_ssp_ctrl0
);
107 reg
= SSP_CTRL1_SSP_MODE_SPI
| SSP_CTRL1_WORD_LENGTH_EIGHT_BITS
;
108 reg
|= (mxs_slave
->mode
& SPI_CPOL
) ? SSP_CTRL1_POLARITY
: 0;
109 reg
|= (mxs_slave
->mode
& SPI_CPHA
) ? SSP_CTRL1_PHASE
: 0;
110 writel(reg
, &ssp_regs
->hw_ssp_ctrl1
);
112 writel(0, &ssp_regs
->hw_ssp_cmd0
);
114 mxs_set_ssp_busclock(slave
->bus
, mxs_slave
->max_khz
);
119 void spi_release_bus(struct spi_slave
*slave
)
123 static void mxs_spi_start_xfer(struct mxs_ssp_regs
*ssp_regs
)
125 writel(SSP_CTRL0_LOCK_CS
, &ssp_regs
->hw_ssp_ctrl0_set
);
126 writel(SSP_CTRL0_IGNORE_CRC
, &ssp_regs
->hw_ssp_ctrl0_clr
);
129 static void mxs_spi_end_xfer(struct mxs_ssp_regs
*ssp_regs
)
131 writel(SSP_CTRL0_LOCK_CS
, &ssp_regs
->hw_ssp_ctrl0_clr
);
132 writel(SSP_CTRL0_IGNORE_CRC
, &ssp_regs
->hw_ssp_ctrl0_set
);
135 static int mxs_spi_xfer_pio(struct mxs_spi_slave
*slave
,
136 char *data
, int length
, int write
, unsigned long flags
)
138 struct mxs_ssp_regs
*ssp_regs
= slave
->regs
;
140 if (flags
& SPI_XFER_BEGIN
)
141 mxs_spi_start_xfer(ssp_regs
);
144 /* We transfer 1 byte */
145 #if defined(CONFIG_MX23)
146 writel(SSP_CTRL0_XFER_COUNT_MASK
, &ssp_regs
->hw_ssp_ctrl0_clr
);
147 writel(1, &ssp_regs
->hw_ssp_ctrl0_set
);
148 #elif defined(CONFIG_MX28)
149 writel(1, &ssp_regs
->hw_ssp_xfer_size
);
152 if ((flags
& SPI_XFER_END
) && !length
)
153 mxs_spi_end_xfer(ssp_regs
);
156 writel(SSP_CTRL0_READ
, &ssp_regs
->hw_ssp_ctrl0_clr
);
158 writel(SSP_CTRL0_READ
, &ssp_regs
->hw_ssp_ctrl0_set
);
160 writel(SSP_CTRL0_RUN
, &ssp_regs
->hw_ssp_ctrl0_set
);
162 if (mxs_wait_mask_set(&ssp_regs
->hw_ssp_ctrl0_reg
,
163 SSP_CTRL0_RUN
, MXS_SPI_MAX_TIMEOUT
)) {
164 printf("MXS SPI: Timeout waiting for start\n");
169 writel(*data
++, &ssp_regs
->hw_ssp_data
);
171 writel(SSP_CTRL0_DATA_XFER
, &ssp_regs
->hw_ssp_ctrl0_set
);
174 if (mxs_wait_mask_clr(&ssp_regs
->hw_ssp_status_reg
,
175 SSP_STATUS_FIFO_EMPTY
, MXS_SPI_MAX_TIMEOUT
)) {
176 printf("MXS SPI: Timeout waiting for data\n");
180 *data
= readl(&ssp_regs
->hw_ssp_data
);
184 if (mxs_wait_mask_clr(&ssp_regs
->hw_ssp_ctrl0_reg
,
185 SSP_CTRL0_RUN
, MXS_SPI_MAX_TIMEOUT
)) {
186 printf("MXS SPI: Timeout waiting for finish\n");
194 static int mxs_spi_xfer_dma(struct mxs_spi_slave
*slave
,
195 char *data
, int length
, int write
, unsigned long flags
)
197 const int xfer_max_sz
= 0xff00;
198 const int desc_count
= DIV_ROUND_UP(length
, xfer_max_sz
) + 1;
199 struct mxs_ssp_regs
*ssp_regs
= slave
->regs
;
200 struct mxs_dma_desc
*dp
;
202 uint32_t cache_data_count
;
203 const uint32_t dstart
= (uint32_t)data
;
208 #if defined(CONFIG_MX23)
209 const int mxs_spi_pio_words
= 1;
210 #elif defined(CONFIG_MX28)
211 const int mxs_spi_pio_words
= 4;
214 ALLOC_CACHE_ALIGN_BUFFER(struct mxs_dma_desc
, desc
, desc_count
);
216 memset(desc
, 0, sizeof(struct mxs_dma_desc
) * desc_count
);
218 ctrl0
= readl(&ssp_regs
->hw_ssp_ctrl0
);
219 ctrl0
|= SSP_CTRL0_DATA_XFER
;
221 if (flags
& SPI_XFER_BEGIN
)
222 ctrl0
|= SSP_CTRL0_LOCK_CS
;
224 ctrl0
|= SSP_CTRL0_READ
;
226 if (length
% ARCH_DMA_MINALIGN
)
227 cache_data_count
= roundup(length
, ARCH_DMA_MINALIGN
);
229 cache_data_count
= length
;
231 /* Flush data to DRAM so DMA can pick them up */
233 flush_dcache_range(dstart
, dstart
+ cache_data_count
);
235 /* Invalidate the area, so no writeback into the RAM races with DMA */
236 invalidate_dcache_range(dstart
, dstart
+ cache_data_count
);
238 dmach
= MXS_DMA_CHANNEL_AHB_APBH_SSP0
+ slave
->slave
.bus
;
242 dp
->address
= (dma_addr_t
)dp
;
243 dp
->cmd
.address
= (dma_addr_t
)data
;
246 * This is correct, even though it does indeed look insane.
247 * I hereby have to, wholeheartedly, thank Freescale Inc.,
248 * for always inventing insane hardware and keeping me busy
252 dp
->cmd
.data
= MXS_DMA_DESC_COMMAND_DMA_READ
;
254 dp
->cmd
.data
= MXS_DMA_DESC_COMMAND_DMA_WRITE
;
257 * The DMA controller can transfer large chunks (64kB) at
258 * time by setting the transfer length to 0. Setting tl to
259 * 0x10000 will overflow below and make .data contain 0.
260 * Otherwise, 0xff00 is the transfer maximum.
262 if (length
>= 0x10000)
265 tl
= min(length
, xfer_max_sz
);
268 ((tl
& 0xffff) << MXS_DMA_DESC_BYTES_OFFSET
) |
269 (mxs_spi_pio_words
<< MXS_DMA_DESC_PIO_WORDS_OFFSET
) |
270 MXS_DMA_DESC_HALT_ON_TERMINATE
|
271 MXS_DMA_DESC_TERMINATE_FLUSH
;
277 dp
->cmd
.data
|= MXS_DMA_DESC_IRQ
| MXS_DMA_DESC_DEC_SEM
;
279 if (flags
& SPI_XFER_END
) {
280 ctrl0
&= ~SSP_CTRL0_LOCK_CS
;
281 ctrl0
|= SSP_CTRL0_IGNORE_CRC
;
286 * Write CTRL0, CMD0, CMD1 and XFER_SIZE registers in
287 * case of MX28, write only CTRL0 in case of MX23 due
288 * to the difference in register layout. It is utterly
289 * essential that the XFER_SIZE register is written on
290 * a per-descriptor basis with the same size as is the
293 dp
->cmd
.pio_words
[0] = ctrl0
;
295 dp
->cmd
.pio_words
[1] = 0;
296 dp
->cmd
.pio_words
[2] = 0;
297 dp
->cmd
.pio_words
[3] = tl
;
300 mxs_dma_desc_append(dmach
, dp
);
305 if (mxs_dma_go(dmach
))
308 /* The data arrived into DRAM, invalidate cache over them */
310 invalidate_dcache_range(dstart
, dstart
+ cache_data_count
);
315 int spi_xfer(struct spi_slave
*slave
, unsigned int bitlen
,
316 const void *dout
, void *din
, unsigned long flags
)
318 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
319 struct mxs_ssp_regs
*ssp_regs
= mxs_slave
->regs
;
320 int len
= bitlen
/ 8;
327 if (flags
& SPI_XFER_END
) {
328 din
= (void *)&dummy
;
334 /* Half-duplex only */
350 * Check for alignment, if the buffer is aligned, do DMA transfer,
351 * PIO otherwise. This is a temporary workaround until proper bounce
352 * buffer is in place.
355 if (((uint32_t)data
) & (ARCH_DMA_MINALIGN
- 1))
357 if (((uint32_t)len
) & (ARCH_DMA_MINALIGN
- 1))
361 if (!dma
|| (len
< MXSSSP_SMALL_TRANSFER
)) {
362 writel(SSP_CTRL1_DMA_ENABLE
, &ssp_regs
->hw_ssp_ctrl1_clr
);
363 return mxs_spi_xfer_pio(mxs_slave
, data
, len
, write
, flags
);
365 writel(SSP_CTRL1_DMA_ENABLE
, &ssp_regs
->hw_ssp_ctrl1_set
);
366 return mxs_spi_xfer_dma(mxs_slave
, data
, len
, write
, flags
);