]> git.sur5r.net Git - u-boot/blob - drivers/spi/bfin_spi.c
pci: correct a function description
[u-boot] / drivers / spi / bfin_spi.c
1 /*
2  * Driver for Blackfin On-Chip SPI device
3  *
4  * Copyright (c) 2005-2010 Analog Devices Inc.
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 /*#define DEBUG*/
10
11 #include <common.h>
12 #include <console.h>
13 #include <malloc.h>
14 #include <spi.h>
15
16 #include <asm/blackfin.h>
17 #include <asm/clock.h>
18 #include <asm/gpio.h>
19 #include <asm/portmux.h>
20 #include <asm/mach-common/bits/spi.h>
21
22 struct bfin_spi_slave {
23         struct spi_slave slave;
24         void *mmr_base;
25         u16 ctl, baud, flg;
26 };
27
28 #define MAKE_SPI_FUNC(mmr, off) \
29 static inline void write_##mmr(struct bfin_spi_slave *bss, u16 val) { bfin_write16(bss->mmr_base + off, val); } \
30 static inline u16 read_##mmr(struct bfin_spi_slave *bss) { return bfin_read16(bss->mmr_base + off); }
31 MAKE_SPI_FUNC(SPI_CTL,  0x00)
32 MAKE_SPI_FUNC(SPI_FLG,  0x04)
33 MAKE_SPI_FUNC(SPI_STAT, 0x08)
34 MAKE_SPI_FUNC(SPI_TDBR, 0x0c)
35 MAKE_SPI_FUNC(SPI_RDBR, 0x10)
36 MAKE_SPI_FUNC(SPI_BAUD, 0x14)
37
38 #define to_bfin_spi_slave(s) container_of(s, struct bfin_spi_slave, slave)
39
40 #define gpio_cs(cs) ((cs) - MAX_CTRL_CS)
41 #ifdef CONFIG_BFIN_SPI_GPIO_CS
42 # define is_gpio_cs(cs) ((cs) > MAX_CTRL_CS)
43 #else
44 # define is_gpio_cs(cs) 0
45 #endif
46
47 int spi_cs_is_valid(unsigned int bus, unsigned int cs)
48 {
49         if (is_gpio_cs(cs))
50                 return gpio_is_valid(gpio_cs(cs));
51         else
52                 return (cs >= 1 && cs <= MAX_CTRL_CS);
53 }
54
55 void spi_cs_activate(struct spi_slave *slave)
56 {
57         struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
58
59         if (is_gpio_cs(slave->cs)) {
60                 unsigned int cs = gpio_cs(slave->cs);
61                 gpio_set_value(cs, bss->flg);
62                 debug("%s: SPI_CS_GPIO:%x\n", __func__, gpio_get_value(cs));
63         } else {
64                 write_SPI_FLG(bss,
65                         (read_SPI_FLG(bss) &
66                         ~((!bss->flg << 8) << slave->cs)) |
67                         (1 << slave->cs));
68                 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
69         }
70
71         SSYNC();
72 }
73
74 void spi_cs_deactivate(struct spi_slave *slave)
75 {
76         struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
77
78         if (is_gpio_cs(slave->cs)) {
79                 unsigned int cs = gpio_cs(slave->cs);
80                 gpio_set_value(cs, !bss->flg);
81                 debug("%s: SPI_CS_GPIO:%x\n", __func__, gpio_get_value(cs));
82         } else {
83                 u16 flg;
84
85                 /* make sure we force the cs to deassert rather than let the
86                  * pin float back up.  otherwise, exact timings may not be
87                  * met some of the time leading to random behavior (ugh).
88                  */
89                 flg = read_SPI_FLG(bss) | ((!bss->flg << 8) << slave->cs);
90                 write_SPI_FLG(bss, flg);
91                 SSYNC();
92                 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
93
94                 flg &= ~(1 << slave->cs);
95                 write_SPI_FLG(bss, flg);
96                 debug("%s: SPI_FLG:%x\n", __func__, read_SPI_FLG(bss));
97         }
98
99         SSYNC();
100 }
101
102 void spi_init()
103 {
104 }
105
106 #ifdef SPI_CTL
107 # define SPI0_CTL SPI_CTL
108 #endif
109
110 #define SPI_PINS(n) \
111         [n] = { 0, P_SPI##n##_SCK, P_SPI##n##_MISO, P_SPI##n##_MOSI, 0 }
112 static unsigned short pins[][5] = {
113 #ifdef SPI0_CTL
114         SPI_PINS(0),
115 #endif
116 #ifdef SPI1_CTL
117         SPI_PINS(1),
118 #endif
119 #ifdef SPI2_CTL
120         SPI_PINS(2),
121 #endif
122 };
123
124 #define SPI_CS_PINS(n) \
125         [n] = { \
126                 P_SPI##n##_SSEL1, P_SPI##n##_SSEL2, P_SPI##n##_SSEL3, \
127                 P_SPI##n##_SSEL4, P_SPI##n##_SSEL5, P_SPI##n##_SSEL6, \
128                 P_SPI##n##_SSEL7, \
129         }
130 static const unsigned short cs_pins[][7] = {
131 #ifdef SPI0_CTL
132         SPI_CS_PINS(0),
133 #endif
134 #ifdef SPI1_CTL
135         SPI_CS_PINS(1),
136 #endif
137 #ifdef SPI2_CTL
138         SPI_CS_PINS(2),
139 #endif
140 };
141
142 void spi_set_speed(struct spi_slave *slave, uint hz)
143 {
144         struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
145         ulong clk;
146         u32 baud;
147
148         clk = get_spi_clk();
149         /* baud should be rounded up */
150         baud = DIV_ROUND_UP(clk, 2 * hz);
151         if (baud < 2)
152                 baud = 2;
153         else if (baud > (u16)-1)
154                 baud = -1;
155         bss->baud = baud;
156 }
157
158 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
159                 unsigned int max_hz, unsigned int mode)
160 {
161         struct bfin_spi_slave *bss;
162         u32 mmr_base;
163
164         if (!spi_cs_is_valid(bus, cs))
165                 return NULL;
166
167         switch (bus) {
168 #ifdef SPI0_CTL
169         case 0:
170                 mmr_base = SPI0_CTL; break;
171 #endif
172 #ifdef SPI1_CTL
173         case 1:
174                 mmr_base = SPI1_CTL; break;
175 #endif
176 #ifdef SPI2_CTL
177         case 2:
178                 mmr_base = SPI2_CTL; break;
179 #endif
180         default:
181                 debug("%s: invalid bus %u\n", __func__, bus);
182                 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
203 void spi_free_slave(struct spi_slave *slave)
204 {
205         struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
206         free(bss);
207 }
208
209 int 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
231 void 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 #ifndef CONFIG_BFIN_SPI_IDLE_VAL
246 # define CONFIG_BFIN_SPI_IDLE_VAL 0xff
247 #endif
248
249 static int spi_pio_xfer(struct bfin_spi_slave *bss, const u8 *tx, u8 *rx,
250                         uint bytes)
251 {
252         /* discard invalid data and clear RXS */
253         read_SPI_RDBR(bss);
254         /* todo: take advantage of hardware fifos  */
255         while (bytes--) {
256                 u8 value = (tx ? *tx++ : CONFIG_BFIN_SPI_IDLE_VAL);
257                 debug("%s: tx:%x ", __func__, value);
258                 write_SPI_TDBR(bss, value);
259                 SSYNC();
260                 while ((read_SPI_STAT(bss) & TXS))
261                         if (ctrlc())
262                                 return -1;
263                 while (!(read_SPI_STAT(bss) & SPIF))
264                         if (ctrlc())
265                                 return -1;
266                 while (!(read_SPI_STAT(bss) & RXS))
267                         if (ctrlc())
268                                 return -1;
269                 value = read_SPI_RDBR(bss);
270                 if (rx)
271                         *rx++ = value;
272                 debug("rx:%x\n", value);
273         }
274
275         return 0;
276 }
277
278 int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout,
279                 void *din, unsigned long flags)
280 {
281         struct bfin_spi_slave *bss = to_bfin_spi_slave(slave);
282         const u8 *tx = dout;
283         u8 *rx = din;
284         uint bytes = bitlen / 8;
285         int ret = 0;
286
287         debug("%s: bus:%i cs:%i bitlen:%i bytes:%i flags:%lx\n", __func__,
288                 slave->bus, slave->cs, bitlen, bytes, flags);
289
290         if (bitlen == 0)
291                 goto done;
292
293         /* we can only do 8 bit transfers */
294         if (bitlen % 8) {
295                 flags |= SPI_XFER_END;
296                 goto done;
297         }
298
299         if (flags & SPI_XFER_BEGIN)
300                 spi_cs_activate(slave);
301
302         ret = spi_pio_xfer(bss, tx, rx, bytes);
303
304  done:
305         if (flags & SPI_XFER_END)
306                 spi_cs_deactivate(slave);
307
308         return ret;
309 }