1
2
3
4
5
6
7
8
9
10
11#include <common.h>
12#include <malloc.h>
13#include <spi.h>
14
15#include <asm/blackfin.h>
16#include <asm/dma.h>
17#include <asm/gpio.h>
18#include <asm/portmux.h>
19#include <asm/mach-common/bits/spi.h>
20
21struct bfin_spi_slave {
22 struct spi_slave slave;
23 void *mmr_base;
24 u16 ctl, baud, flg;
25};
26
27#define MAKE_SPI_FUNC(mmr, off) \
28static inline void write_##mmr(struct bfin_spi_slave *bss, u16 val) { bfin_write16(bss->mmr_base + off, val); } \
29static inline u16 read_##mmr(struct bfin_spi_slave *bss) { return bfin_read16(bss->mmr_base + off); }
30MAKE_SPI_FUNC(SPI_CTL, 0x00)
31MAKE_SPI_FUNC(SPI_FLG, 0x04)
32MAKE_SPI_FUNC(SPI_STAT, 0x08)
33MAKE_SPI_FUNC(SPI_TDBR, 0x0c)
34MAKE_SPI_FUNC(SPI_RDBR, 0x10)
35MAKE_SPI_FUNC(SPI_BAUD, 0x14)
36
37#define to_bfin_spi_slave(s) container_of(s, struct bfin_spi_slave, slave)
38
39#define gpio_cs(cs) ((cs) - MAX_CTRL_CS)
40#ifdef CONFIG_BFIN_SPI_GPIO_CS
41# define is_gpio_cs(cs) ((cs) > MAX_CTRL_CS)
42#else
43# define is_gpio_cs(cs) 0
44#endif
45
46int spi_cs_is_valid(unsigned int bus, unsigned int cs)
47{
48 if (is_gpio_cs(cs))
49 return gpio_is_valid(gpio_cs(cs));
50 else
51 return (cs >= 1 && cs <= MAX_CTRL_CS);
52}
53
54void spi_cs_activate(struct spi_slave *slave)
55{
56 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
57
58 if (is_gpio_cs(slave->cs)) {
59 unsigned int cs = gpio_cs(slave->cs);
60 gpio_set_value(cs, bss->flg);
61 debug("%s: SPI_CS_GPIO:%x\n", __func__, gpio_get_value(cs));
62 } else {
63 write_SPI_FLG(bss,
64 (read_SPI_FLG(bss) &
65 ~((!bss->flg << 8) << slave->cs)) |
66 (1 << slave->cs));
67 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
68 }
69
70 SSYNC();
71}
72
73void spi_cs_deactivate(struct spi_slave *slave)
74{
75 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
76
77 if (is_gpio_cs(slave->cs)) {
78 unsigned int cs = gpio_cs(slave->cs);
79 gpio_set_value(cs, !bss->flg);
80 debug("%s: SPI_CS_GPIO:%x\n", __func__, gpio_get_value(cs));
81 } else {
82 u16 flg;
83
84
85
86
87
88 flg = read_SPI_FLG(bss) | ((!bss->flg << 8) << slave->cs);
89 write_SPI_FLG(bss, flg);
90 SSYNC();
91 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
92
93 flg &= ~(1 << slave->cs);
94 write_SPI_FLG(bss, flg);
95 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
96 }
97
98 SSYNC();
99}
100
101void spi_init()
102{
103}
104
105#ifdef SPI_CTL
106# define SPI0_CTL SPI_CTL
107#endif
108
109#define SPI_PINS(n) \
110 [n] = { 0, P_SPI##n##_SCK, P_SPI##n##_MISO, P_SPI##n##_MOSI, 0 }
111static unsigned short pins[][5] = {
112#ifdef SPI0_CTL
113 SPI_PINS(0),
114#endif
115#ifdef SPI1_CTL
116 SPI_PINS(1),
117#endif
118#ifdef SPI2_CTL
119 SPI_PINS(2),
120#endif
121};
122
123#define SPI_CS_PINS(n) \
124 [n] = { \
125 P_SPI##n##_SSEL1, P_SPI##n##_SSEL2, P_SPI##n##_SSEL3, \
126 P_SPI##n##_SSEL4, P_SPI##n##_SSEL5, P_SPI##n##_SSEL6, \
127 P_SPI##n##_SSEL7, \
128 }
129static const unsigned short cs_pins[][7] = {
130#ifdef SPI0_CTL
131 SPI_CS_PINS(0),
132#endif
133#ifdef SPI1_CTL
134 SPI_CS_PINS(1),
135#endif
136#ifdef SPI2_CTL
137 SPI_CS_PINS(2),
138#endif
139};
140
141void spi_set_speed(struct spi_slave *slave, uint hz)
142{
143 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
144 ulong sclk;
145 u32 baud;
146
147 sclk = get_sclk();
148 baud = sclk / (2 * hz);
149
150 if (sclk % (2 * hz))
151 baud += 1;
152 if (baud < 2)
153 baud = 2;
154 else if (baud > (u16)-1)
155 baud = -1;
156 bss->baud = baud;
157}
158
159struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
160 unsigned int max_hz, unsigned int mode)
161{
162 struct bfin_spi_slave *bss;
163 u32 mmr_base;
164
165 if (!spi_cs_is_valid(bus, cs))
166 return NULL;
167
168 if (bus >= ARRAY_SIZE(pins) || pins[bus] == NULL) {
169 debug("%s: invalid bus %u\n", __func__, bus);
170 return NULL;
171 }
172 switch (bus) {
173#ifdef SPI0_CTL
174 case 0: mmr_base = SPI0_CTL; break;
175#endif
176#ifdef SPI1_CTL
177 case 1: mmr_base = SPI1_CTL; break;
178#endif
179#ifdef SPI2_CTL
180 case 2: mmr_base = SPI2_CTL; break;
181#endif
182 default: return NULL;
183 }
184
185 bss = spi_alloc_slave(struct bfin_spi_slave, bus, cs);
186 if (!bss)
187 return NULL;
188
189 bss->mmr_base = (void *)mmr_base;
190 bss->ctl = SPE | MSTR | TDBR_CORE;
191 if (mode & SPI_CPHA) bss->ctl |= CPHA;
192 if (mode & SPI_CPOL) bss->ctl |= CPOL;
193 if (mode & SPI_LSB_FIRST) bss->ctl |= LSBF;
194 bss->flg = mode & SPI_CS_HIGH ? 1 : 0;
195 spi_set_speed(&bss->slave, max_hz);
196
197 debug("%s: bus:%i cs:%i mmr:%x ctl:%x baud:%i flg:%i\n", __func__,
198 bus, cs, mmr_base, bss->ctl, bss->baud, bss->flg);
199
200 return &bss->slave;
201}
202
203void spi_free_slave(struct spi_slave *slave)
204{
205 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
206 free(bss);
207}
208
209int spi_claim_bus(struct spi_slave *slave)
210{
211 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
212
213 debug("%s: bus:%i cs:%i\n", __func__, slave->bus, slave->cs);
214
215 if (is_gpio_cs(slave->cs)) {
216 unsigned int cs = gpio_cs(slave->cs);
217 gpio_request(cs, "bfin-spi");
218 gpio_direction_output(cs, !bss->flg);
219 pins[slave->bus][0] = P_DONTCARE;
220 } else
221 pins[slave->bus][0] = cs_pins[slave->bus][slave->cs - 1];
222 peripheral_request_list(pins[slave->bus], "bfin-spi");
223
224 write_SPI_CTL(bss, bss->ctl);
225 write_SPI_BAUD(bss, bss->baud);
226 SSYNC();
227
228 return 0;
229}
230
231void spi_release_bus(struct spi_slave *slave)
232{
233 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
234
235 debug("%s: bus:%i cs:%i\n", __func__, slave->bus, slave->cs);
236
237 peripheral_free_list(pins[slave->bus]);
238 if (is_gpio_cs(slave->cs))
239 gpio_free(gpio_cs(slave->cs));
240
241 write_SPI_CTL(bss, 0);
242 SSYNC();
243}
244
245#ifdef __ADSPBF54x__
246# define SPI_DMA_BASE DMA4_NEXT_DESC_PTR
247#elif defined(__ADSPBF533__) || defined(__ADSPBF532__) || defined(__ADSPBF531__) || \
248 defined(__ADSPBF538__) || defined(__ADSPBF539__)
249# define SPI_DMA_BASE DMA5_NEXT_DESC_PTR
250#elif defined(__ADSPBF561__)
251# define SPI_DMA_BASE DMA2_4_NEXT_DESC_PTR
252#elif defined(__ADSPBF537__) || defined(__ADSPBF536__) || defined(__ADSPBF534__) || \
253 defined(__ADSPBF52x__) || defined(__ADSPBF51x__)
254# define SPI_DMA_BASE DMA7_NEXT_DESC_PTR
255# elif defined(__ADSPBF50x__)
256# define SPI_DMA_BASE DMA6_NEXT_DESC_PTR
257#else
258# error "Please provide SPI DMA channel defines"
259#endif
260static volatile struct dma_register *dma = (void *)SPI_DMA_BASE;
261
262#ifndef CONFIG_BFIN_SPI_IDLE_VAL
263# define CONFIG_BFIN_SPI_IDLE_VAL 0xff
264#endif
265
266#ifdef CONFIG_BFIN_SPI_NO_DMA
267# define SPI_DMA 0
268#else
269# define SPI_DMA 1
270#endif
271
272static int spi_dma_xfer(struct bfin_spi_slave *bss, const u8 *tx, u8 *rx,
273 uint bytes)
274{
275 int ret = -1;
276 u16 ndsize, spi_config, dma_config;
277 struct dmasg dmasg[2];
278 const u8 *buf;
279
280 if (tx) {
281 debug("%s: doing half duplex TX\n", __func__);
282 buf = tx;
283 spi_config = TDBR_DMA;
284 dma_config = 0;
285 } else {
286 debug("%s: doing half duplex RX\n", __func__);
287 buf = rx;
288 spi_config = RDBR_DMA;
289 dma_config = WNR;
290 }
291
292 dmasg[0].start_addr = (unsigned long)buf;
293 dmasg[0].x_modify = 1;
294 dma_config |= WDSIZE_8 | DMAEN;
295 if (bytes <= 65536) {
296 blackfin_dcache_flush_invalidate_range(buf, buf + bytes);
297 ndsize = NDSIZE_5;
298 dmasg[0].cfg = NDSIZE_0 | dma_config | FLOW_STOP | DI_EN;
299 dmasg[0].x_count = bytes;
300 } else {
301 blackfin_dcache_flush_invalidate_range(buf, buf + 65536 - 1);
302 ndsize = NDSIZE_7;
303 dmasg[0].cfg = NDSIZE_5 | dma_config | FLOW_ARRAY | DMA2D;
304 dmasg[0].x_count = 0;
305 dmasg[0].y_count = bytes >> 16;
306 dmasg[0].y_modify = 1;
307 dmasg[1].start_addr = (unsigned long)(buf + (bytes & ~0xFFFF));
308 dmasg[1].cfg = NDSIZE_0 | dma_config | FLOW_STOP | DI_EN;
309 dmasg[1].x_count = bytes & 0xFFFF;
310 dmasg[1].x_modify = 1;
311 }
312
313 dma->cfg = 0;
314 dma->irq_status = DMA_DONE | DMA_ERR;
315 dma->curr_desc_ptr = dmasg;
316 write_SPI_CTL(bss, (bss->ctl & ~TDBR_CORE));
317 write_SPI_STAT(bss, -1);
318 SSYNC();
319
320 write_SPI_TDBR(bss, CONFIG_BFIN_SPI_IDLE_VAL);
321 dma->cfg = ndsize | FLOW_ARRAY | DMAEN;
322 write_SPI_CTL(bss, (bss->ctl & ~TDBR_CORE) | spi_config);
323 SSYNC();
324
325
326
327
328
329
330 if (bytes > 65536)
331 blackfin_dcache_flush_invalidate_range(buf + 65536, buf + bytes);
332
333 while (!(dma->irq_status & DMA_DONE))
334 if (ctrlc())
335 goto done;
336
337 dma->cfg = 0;
338
339 ret = 0;
340 done:
341 write_SPI_CTL(bss, bss->ctl);
342 return ret;
343}
344
345static int spi_pio_xfer(struct bfin_spi_slave *bss, const u8 *tx, u8 *rx,
346 uint bytes)
347{
348
349 while (bytes--) {
350 u8 value = (tx ? *tx++ : CONFIG_BFIN_SPI_IDLE_VAL);
351 debug("%s: tx:%x ", __func__, value);
352 write_SPI_TDBR(bss, value);
353 SSYNC();
354 while ((read_SPI_STAT(bss) & TXS))
355 if (ctrlc())
356 return -1;
357 while (!(read_SPI_STAT(bss) & SPIF))
358 if (ctrlc())
359 return -1;
360 while (!(read_SPI_STAT(bss) & RXS))
361 if (ctrlc())
362 return -1;
363 value = read_SPI_RDBR(bss);
364 if (rx)
365 *rx++ = value;
366 debug("rx:%x\n", value);
367 }
368
369 return 0;
370}
371
372int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
373 void *din, unsigned long flags)
374{
375 struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
376 const u8 *tx = dout;
377 u8 *rx = din;
378 uint bytes = bitlen / 8;
379 int ret = 0;
380
381 debug("%s: bus:%i cs:%i bitlen:%i bytes:%i flags:%lx\n", __func__,
382 slave->bus, slave->cs, bitlen, bytes, flags);
383
384 if (bitlen == 0)
385 goto done;
386
387
388 if (bitlen % 8) {
389 flags |= SPI_XFER_END;
390 goto done;
391 }
392
393 if (flags & SPI_XFER_BEGIN)
394 spi_cs_activate(slave);
395
396
397 if (SPI_DMA && bytes > 6 && (!tx ))
398 ret = spi_dma_xfer(bss, tx, rx, bytes);
399 else
400 ret = spi_pio_xfer(bss, tx, rx, bytes);
401
402 done:
403 if (flags & SPI_XFER_END)
404 spi_cs_deactivate(slave);
405
406 return ret;
407}
408
