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.
17 #include <linux/errno.h>
19 #include <asm/arch/clock.h>
20 #include <asm/arch/imx-regs.h>
21 #include <asm/arch/sys_proto.h>
22 #include <asm/mach-imx/dma.h>
24 #define MXS_SPI_MAX_TIMEOUT 1000000
25 #define MXS_SPI_PORT_OFFSET 0x2000
26 #define MXS_SSP_CHIPSELECT_MASK 0x00300000
27 #define MXS_SSP_CHIPSELECT_SHIFT 20
29 #define MXSSSP_SMALL_TRANSFER 512
31 struct mxs_spi_slave
{
32 struct spi_slave slave
;
35 struct mxs_ssp_regs
*regs
;
38 static inline struct mxs_spi_slave
*to_mxs_slave(struct spi_slave
*slave
)
40 return container_of(slave
, struct mxs_spi_slave
, slave
);
47 int spi_cs_is_valid(unsigned int bus
, unsigned int cs
)
49 /* MXS SPI: 4 ports and 3 chip selects maximum */
50 if (!mxs_ssp_bus_id_valid(bus
) || cs
> 2)
56 struct spi_slave
*spi_setup_slave(unsigned int bus
, unsigned int cs
,
57 unsigned int max_hz
, unsigned int mode
)
59 struct mxs_spi_slave
*mxs_slave
;
61 if (!spi_cs_is_valid(bus
, cs
)) {
62 printf("mxs_spi: invalid bus %d / chip select %d\n", bus
, cs
);
66 mxs_slave
= spi_alloc_slave(struct mxs_spi_slave
, bus
, cs
);
70 if (mxs_dma_init_channel(MXS_DMA_CHANNEL_AHB_APBH_SSP0
+ bus
))
73 mxs_slave
->max_khz
= max_hz
/ 1000;
74 mxs_slave
->mode
= mode
;
75 mxs_slave
->regs
= mxs_ssp_regs_by_bus(bus
);
77 return &mxs_slave
->slave
;
84 void spi_free_slave(struct spi_slave
*slave
)
86 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
90 int spi_claim_bus(struct spi_slave
*slave
)
92 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
93 struct mxs_ssp_regs
*ssp_regs
= mxs_slave
->regs
;
96 mxs_reset_block(&ssp_regs
->hw_ssp_ctrl0_reg
);
98 writel((slave
->cs
<< MXS_SSP_CHIPSELECT_SHIFT
) |
99 SSP_CTRL0_BUS_WIDTH_ONE_BIT
,
100 &ssp_regs
->hw_ssp_ctrl0
);
102 reg
= SSP_CTRL1_SSP_MODE_SPI
| SSP_CTRL1_WORD_LENGTH_EIGHT_BITS
;
103 reg
|= (mxs_slave
->mode
& SPI_CPOL
) ? SSP_CTRL1_POLARITY
: 0;
104 reg
|= (mxs_slave
->mode
& SPI_CPHA
) ? SSP_CTRL1_PHASE
: 0;
105 writel(reg
, &ssp_regs
->hw_ssp_ctrl1
);
107 writel(0, &ssp_regs
->hw_ssp_cmd0
);
109 mxs_set_ssp_busclock(slave
->bus
, mxs_slave
->max_khz
);
114 void spi_release_bus(struct spi_slave
*slave
)
118 static void mxs_spi_start_xfer(struct mxs_ssp_regs
*ssp_regs
)
120 writel(SSP_CTRL0_LOCK_CS
, &ssp_regs
->hw_ssp_ctrl0_set
);
121 writel(SSP_CTRL0_IGNORE_CRC
, &ssp_regs
->hw_ssp_ctrl0_clr
);
124 static void mxs_spi_end_xfer(struct mxs_ssp_regs
*ssp_regs
)
126 writel(SSP_CTRL0_LOCK_CS
, &ssp_regs
->hw_ssp_ctrl0_clr
);
127 writel(SSP_CTRL0_IGNORE_CRC
, &ssp_regs
->hw_ssp_ctrl0_set
);
130 static int mxs_spi_xfer_pio(struct mxs_spi_slave
*slave
,
131 char *data
, int length
, int write
, unsigned long flags
)
133 struct mxs_ssp_regs
*ssp_regs
= slave
->regs
;
135 if (flags
& SPI_XFER_BEGIN
)
136 mxs_spi_start_xfer(ssp_regs
);
139 /* We transfer 1 byte */
140 #if defined(CONFIG_MX23)
141 writel(SSP_CTRL0_XFER_COUNT_MASK
, &ssp_regs
->hw_ssp_ctrl0_clr
);
142 writel(1, &ssp_regs
->hw_ssp_ctrl0_set
);
143 #elif defined(CONFIG_MX28)
144 writel(1, &ssp_regs
->hw_ssp_xfer_size
);
147 if ((flags
& SPI_XFER_END
) && !length
)
148 mxs_spi_end_xfer(ssp_regs
);
151 writel(SSP_CTRL0_READ
, &ssp_regs
->hw_ssp_ctrl0_clr
);
153 writel(SSP_CTRL0_READ
, &ssp_regs
->hw_ssp_ctrl0_set
);
155 writel(SSP_CTRL0_RUN
, &ssp_regs
->hw_ssp_ctrl0_set
);
157 if (mxs_wait_mask_set(&ssp_regs
->hw_ssp_ctrl0_reg
,
158 SSP_CTRL0_RUN
, MXS_SPI_MAX_TIMEOUT
)) {
159 printf("MXS SPI: Timeout waiting for start\n");
164 writel(*data
++, &ssp_regs
->hw_ssp_data
);
166 writel(SSP_CTRL0_DATA_XFER
, &ssp_regs
->hw_ssp_ctrl0_set
);
169 if (mxs_wait_mask_clr(&ssp_regs
->hw_ssp_status_reg
,
170 SSP_STATUS_FIFO_EMPTY
, MXS_SPI_MAX_TIMEOUT
)) {
171 printf("MXS SPI: Timeout waiting for data\n");
175 *data
= readl(&ssp_regs
->hw_ssp_data
);
179 if (mxs_wait_mask_clr(&ssp_regs
->hw_ssp_ctrl0_reg
,
180 SSP_CTRL0_RUN
, MXS_SPI_MAX_TIMEOUT
)) {
181 printf("MXS SPI: Timeout waiting for finish\n");
189 static int mxs_spi_xfer_dma(struct mxs_spi_slave
*slave
,
190 char *data
, int length
, int write
, unsigned long flags
)
192 const int xfer_max_sz
= 0xff00;
193 const int desc_count
= DIV_ROUND_UP(length
, xfer_max_sz
) + 1;
194 struct mxs_ssp_regs
*ssp_regs
= slave
->regs
;
195 struct mxs_dma_desc
*dp
;
197 uint32_t cache_data_count
;
198 const uint32_t dstart
= (uint32_t)data
;
203 #if defined(CONFIG_MX23)
204 const int mxs_spi_pio_words
= 1;
205 #elif defined(CONFIG_MX28)
206 const int mxs_spi_pio_words
= 4;
209 ALLOC_CACHE_ALIGN_BUFFER(struct mxs_dma_desc
, desc
, desc_count
);
211 memset(desc
, 0, sizeof(struct mxs_dma_desc
) * desc_count
);
213 ctrl0
= readl(&ssp_regs
->hw_ssp_ctrl0
);
214 ctrl0
|= SSP_CTRL0_DATA_XFER
;
216 if (flags
& SPI_XFER_BEGIN
)
217 ctrl0
|= SSP_CTRL0_LOCK_CS
;
219 ctrl0
|= SSP_CTRL0_READ
;
221 if (length
% ARCH_DMA_MINALIGN
)
222 cache_data_count
= roundup(length
, ARCH_DMA_MINALIGN
);
224 cache_data_count
= length
;
226 /* Flush data to DRAM so DMA can pick them up */
228 flush_dcache_range(dstart
, dstart
+ cache_data_count
);
230 /* Invalidate the area, so no writeback into the RAM races with DMA */
231 invalidate_dcache_range(dstart
, dstart
+ cache_data_count
);
233 dmach
= MXS_DMA_CHANNEL_AHB_APBH_SSP0
+ slave
->slave
.bus
;
237 dp
->address
= (dma_addr_t
)dp
;
238 dp
->cmd
.address
= (dma_addr_t
)data
;
241 * This is correct, even though it does indeed look insane.
242 * I hereby have to, wholeheartedly, thank Freescale Inc.,
243 * for always inventing insane hardware and keeping me busy
247 dp
->cmd
.data
= MXS_DMA_DESC_COMMAND_DMA_READ
;
249 dp
->cmd
.data
= MXS_DMA_DESC_COMMAND_DMA_WRITE
;
252 * The DMA controller can transfer large chunks (64kB) at
253 * time by setting the transfer length to 0. Setting tl to
254 * 0x10000 will overflow below and make .data contain 0.
255 * Otherwise, 0xff00 is the transfer maximum.
257 if (length
>= 0x10000)
260 tl
= min(length
, xfer_max_sz
);
263 ((tl
& 0xffff) << MXS_DMA_DESC_BYTES_OFFSET
) |
264 (mxs_spi_pio_words
<< MXS_DMA_DESC_PIO_WORDS_OFFSET
) |
265 MXS_DMA_DESC_HALT_ON_TERMINATE
|
266 MXS_DMA_DESC_TERMINATE_FLUSH
;
272 dp
->cmd
.data
|= MXS_DMA_DESC_IRQ
| MXS_DMA_DESC_DEC_SEM
;
274 if (flags
& SPI_XFER_END
) {
275 ctrl0
&= ~SSP_CTRL0_LOCK_CS
;
276 ctrl0
|= SSP_CTRL0_IGNORE_CRC
;
281 * Write CTRL0, CMD0, CMD1 and XFER_SIZE registers in
282 * case of MX28, write only CTRL0 in case of MX23 due
283 * to the difference in register layout. It is utterly
284 * essential that the XFER_SIZE register is written on
285 * a per-descriptor basis with the same size as is the
288 dp
->cmd
.pio_words
[0] = ctrl0
;
290 dp
->cmd
.pio_words
[1] = 0;
291 dp
->cmd
.pio_words
[2] = 0;
292 dp
->cmd
.pio_words
[3] = tl
;
295 mxs_dma_desc_append(dmach
, dp
);
300 if (mxs_dma_go(dmach
))
303 /* The data arrived into DRAM, invalidate cache over them */
305 invalidate_dcache_range(dstart
, dstart
+ cache_data_count
);
310 int spi_xfer(struct spi_slave
*slave
, unsigned int bitlen
,
311 const void *dout
, void *din
, unsigned long flags
)
313 struct mxs_spi_slave
*mxs_slave
= to_mxs_slave(slave
);
314 struct mxs_ssp_regs
*ssp_regs
= mxs_slave
->regs
;
315 int len
= bitlen
/ 8;
322 if (flags
& SPI_XFER_END
) {
323 din
= (void *)&dummy
;
329 /* Half-duplex only */
345 * Check for alignment, if the buffer is aligned, do DMA transfer,
346 * PIO otherwise. This is a temporary workaround until proper bounce
347 * buffer is in place.
350 if (((uint32_t)data
) & (ARCH_DMA_MINALIGN
- 1))
352 if (((uint32_t)len
) & (ARCH_DMA_MINALIGN
- 1))
356 if (!dma
|| (len
< MXSSSP_SMALL_TRANSFER
)) {
357 writel(SSP_CTRL1_DMA_ENABLE
, &ssp_regs
->hw_ssp_ctrl1_clr
);
358 return mxs_spi_xfer_pio(mxs_slave
, data
, len
, write
, flags
);
360 writel(SSP_CTRL1_DMA_ENABLE
, &ssp_regs
->hw_ssp_ctrl1_set
);
361 return mxs_spi_xfer_dma(mxs_slave
, data
, len
, write
, flags
);