dm: exynos: Convert SPI to driver model
[karo-tx-uboot.git] / drivers / spi / exynos_spi.c
1 /*
2  * (C) Copyright 2012 SAMSUNG Electronics
3  * Padmavathi Venna <padma.v@samsung.com>
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <dm.h>
10 #include <errno.h>
11 #include <malloc.h>
12 #include <spi.h>
13 #include <fdtdec.h>
14 #include <asm/arch/clk.h>
15 #include <asm/arch/clock.h>
16 #include <asm/arch/cpu.h>
17 #include <asm/arch/gpio.h>
18 #include <asm/arch/pinmux.h>
19 #include <asm/arch-exynos/spi.h>
20 #include <asm/io.h>
21
22 DECLARE_GLOBAL_DATA_PTR;
23
24 struct exynos_spi_platdata {
25         enum periph_id periph_id;
26         s32 frequency;          /* Default clock frequency, -1 for none */
27         struct exynos_spi *regs;
28         uint deactivate_delay_us;       /* Delay to wait after deactivate */
29 };
30
31 struct exynos_spi_priv {
32         struct exynos_spi *regs;
33         unsigned int freq;              /* Default frequency */
34         unsigned int mode;
35         enum periph_id periph_id;       /* Peripheral ID for this device */
36         unsigned int fifo_size;
37         int skip_preamble;
38         ulong last_transaction_us;      /* Time of last transaction end */
39 };
40
41 /**
42  * Flush spi tx, rx fifos and reset the SPI controller
43  *
44  * @param regs  Pointer to SPI registers
45  */
46 static void spi_flush_fifo(struct exynos_spi *regs)
47 {
48         clrsetbits_le32(&regs->ch_cfg, SPI_CH_HS_EN, SPI_CH_RST);
49         clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
50         setbits_le32(&regs->ch_cfg, SPI_TX_CH_ON | SPI_RX_CH_ON);
51 }
52
53 static void spi_get_fifo_levels(struct exynos_spi *regs,
54         int *rx_lvl, int *tx_lvl)
55 {
56         uint32_t spi_sts = readl(&regs->spi_sts);
57
58         *rx_lvl = (spi_sts >> SPI_RX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
59         *tx_lvl = (spi_sts >> SPI_TX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
60 }
61
62 /**
63  * If there's something to transfer, do a software reset and set a
64  * transaction size.
65  *
66  * @param regs  SPI peripheral registers
67  * @param count Number of bytes to transfer
68  * @param step  Number of bytes to transfer in each packet (1 or 4)
69  */
70 static void spi_request_bytes(struct exynos_spi *regs, int count, int step)
71 {
72         debug("%s: regs=%p, count=%d, step=%d\n", __func__, regs, count, step);
73
74         /* For word address we need to swap bytes */
75         if (step == 4) {
76                 setbits_le32(&regs->mode_cfg,
77                              SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
78                 count /= 4;
79                 setbits_le32(&regs->swap_cfg, SPI_TX_SWAP_EN | SPI_RX_SWAP_EN |
80                         SPI_TX_BYTE_SWAP | SPI_RX_BYTE_SWAP |
81                         SPI_TX_HWORD_SWAP | SPI_RX_HWORD_SWAP);
82         } else {
83                 /* Select byte access and clear the swap configuration */
84                 clrbits_le32(&regs->mode_cfg,
85                              SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
86                 writel(0, &regs->swap_cfg);
87         }
88
89         assert(count && count < (1 << 16));
90         setbits_le32(&regs->ch_cfg, SPI_CH_RST);
91         clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
92
93         writel(count | SPI_PACKET_CNT_EN, &regs->pkt_cnt);
94 }
95
96 static int spi_rx_tx(struct exynos_spi_priv *priv, int todo,
97                         void **dinp, void const **doutp, unsigned long flags)
98 {
99         struct exynos_spi *regs = priv->regs;
100         uchar *rxp = *dinp;
101         const uchar *txp = *doutp;
102         int rx_lvl, tx_lvl;
103         uint out_bytes, in_bytes;
104         int toread;
105         unsigned start = get_timer(0);
106         int stopping;
107         int step;
108
109         out_bytes = in_bytes = todo;
110
111         stopping = priv->skip_preamble && (flags & SPI_XFER_END) &&
112                                         !(priv->mode & SPI_SLAVE);
113
114         /*
115          * Try to transfer words if we can. This helps read performance at
116          * SPI clock speeds above about 20MHz.
117          */
118         step = 1;
119         if (!((todo | (uintptr_t)rxp | (uintptr_t)txp) & 3) &&
120             !priv->skip_preamble)
121                 step = 4;
122
123         /*
124          * If there's something to send, do a software reset and set a
125          * transaction size.
126          */
127         spi_request_bytes(regs, todo, step);
128
129         /*
130          * Bytes are transmitted/received in pairs. Wait to receive all the
131          * data because then transmission will be done as well.
132          */
133         toread = in_bytes;
134
135         while (in_bytes) {
136                 int temp;
137
138                 /* Keep the fifos full/empty. */
139                 spi_get_fifo_levels(regs, &rx_lvl, &tx_lvl);
140
141                 /*
142                  * Don't completely fill the txfifo, since we don't want our
143                  * rxfifo to overflow, and it may already contain data.
144                  */
145                 while (tx_lvl < priv->fifo_size/2 && out_bytes) {
146                         if (!txp)
147                                 temp = -1;
148                         else if (step == 4)
149                                 temp = *(uint32_t *)txp;
150                         else
151                                 temp = *txp;
152                         writel(temp, &regs->tx_data);
153                         out_bytes -= step;
154                         if (txp)
155                                 txp += step;
156                         tx_lvl += step;
157                 }
158                 if (rx_lvl >= step) {
159                         while (rx_lvl >= step) {
160                                 temp = readl(&regs->rx_data);
161                                 if (priv->skip_preamble) {
162                                         if (temp == SPI_PREAMBLE_END_BYTE) {
163                                                 priv->skip_preamble = 0;
164                                                 stopping = 0;
165                                         }
166                                 } else {
167                                         if (rxp || stopping) {
168                                                 if (step == 4)
169                                                         *(uint32_t *)rxp = temp;
170                                                 else
171                                                         *rxp = temp;
172                                                 rxp += step;
173                                         }
174                                         in_bytes -= step;
175                                 }
176                                 toread -= step;
177                                 rx_lvl -= step;
178                         }
179                 } else if (!toread) {
180                         /*
181                          * We have run out of input data, but haven't read
182                          * enough bytes after the preamble yet. Read some more,
183                          * and make sure that we transmit dummy bytes too, to
184                          * keep things going.
185                          */
186                         assert(!out_bytes);
187                         out_bytes = in_bytes;
188                         toread = in_bytes;
189                         txp = NULL;
190                         spi_request_bytes(regs, toread, step);
191                 }
192                 if (priv->skip_preamble && get_timer(start) > 100) {
193                         printf("SPI timeout: in_bytes=%d, out_bytes=%d, ",
194                                in_bytes, out_bytes);
195                         return -1;
196                 }
197         }
198
199         *dinp = rxp;
200         *doutp = txp;
201
202         return 0;
203 }
204
205 /**
206  * Activate the CS by driving it LOW
207  *
208  * @param slave Pointer to spi_slave to which controller has to
209  *              communicate with
210  */
211 static void spi_cs_activate(struct udevice *dev)
212 {
213         struct udevice *bus = dev->parent;
214         struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
215         struct exynos_spi_priv *priv = dev_get_priv(bus);
216
217         /* If it's too soon to do another transaction, wait */
218         if (pdata->deactivate_delay_us &&
219             priv->last_transaction_us) {
220                 ulong delay_us;         /* The delay completed so far */
221                 delay_us = timer_get_us() - priv->last_transaction_us;
222                 if (delay_us < pdata->deactivate_delay_us)
223                         udelay(pdata->deactivate_delay_us - delay_us);
224         }
225
226         clrbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
227         debug("Activate CS, bus '%s'\n", bus->name);
228         priv->skip_preamble = priv->mode & SPI_PREAMBLE;
229 }
230
231 /**
232  * Deactivate the CS by driving it HIGH
233  *
234  * @param slave Pointer to spi_slave to which controller has to
235  *              communicate with
236  */
237 static void spi_cs_deactivate(struct udevice *dev)
238 {
239         struct udevice *bus = dev->parent;
240         struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
241         struct exynos_spi_priv *priv = dev_get_priv(bus);
242
243         setbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
244
245         /* Remember time of this transaction so we can honour the bus delay */
246         if (pdata->deactivate_delay_us)
247                 priv->last_transaction_us = timer_get_us();
248
249         debug("Deactivate CS, bus '%s'\n", bus->name);
250 }
251
252 static int exynos_spi_ofdata_to_platdata(struct udevice *bus)
253 {
254         struct exynos_spi_platdata *plat = bus->platdata;
255         const void *blob = gd->fdt_blob;
256         int node = bus->of_offset;
257
258         plat->regs = (struct exynos_spi *)fdtdec_get_addr(blob, node, "reg");
259         plat->periph_id = pinmux_decode_periph_id(blob, node);
260
261         if (plat->periph_id == PERIPH_ID_NONE) {
262                 debug("%s: Invalid peripheral ID %d\n", __func__,
263                         plat->periph_id);
264                 return -FDT_ERR_NOTFOUND;
265         }
266
267         /* Use 500KHz as a suitable default */
268         plat->frequency = fdtdec_get_int(blob, node, "spi-max-frequency",
269                                         500000);
270         plat->deactivate_delay_us = fdtdec_get_int(blob, node,
271                                         "spi-deactivate-delay", 0);
272         debug("%s: regs=%p, periph_id=%d, max-frequency=%d, deactivate_delay=%d\n",
273               __func__, plat->regs, plat->periph_id, plat->frequency,
274               plat->deactivate_delay_us);
275
276         return 0;
277 }
278
279 static int exynos_spi_probe(struct udevice *bus)
280 {
281         struct exynos_spi_platdata *plat = dev_get_platdata(bus);
282         struct exynos_spi_priv *priv = dev_get_priv(bus);
283
284         priv->regs = plat->regs;
285         if (plat->periph_id == PERIPH_ID_SPI1 ||
286             plat->periph_id == PERIPH_ID_SPI2)
287                 priv->fifo_size = 64;
288         else
289                 priv->fifo_size = 256;
290
291         priv->skip_preamble = 0;
292         priv->last_transaction_us = timer_get_us();
293         priv->freq = plat->frequency;
294         priv->periph_id = plat->periph_id;
295
296         return 0;
297 }
298
299 static int exynos_spi_claim_bus(struct udevice *bus)
300 {
301         struct exynos_spi_priv *priv = dev_get_priv(bus);
302
303         exynos_pinmux_config(priv->periph_id, PINMUX_FLAG_NONE);
304         spi_flush_fifo(priv->regs);
305
306         writel(SPI_FB_DELAY_180, &priv->regs->fb_clk);
307
308         return 0;
309 }
310
311 static int exynos_spi_release_bus(struct udevice *bus)
312 {
313         struct exynos_spi_priv *priv = dev_get_priv(bus);
314
315         spi_flush_fifo(priv->regs);
316
317         return 0;
318 }
319
320 static int exynos_spi_xfer(struct udevice *dev, unsigned int bitlen,
321                            const void *dout, void *din, unsigned long flags)
322 {
323         struct udevice *bus = dev->parent;
324         struct exynos_spi_priv *priv = dev_get_priv(bus);
325         int upto, todo;
326         int bytelen;
327         int ret = 0;
328
329         /* spi core configured to do 8 bit transfers */
330         if (bitlen % 8) {
331                 debug("Non byte aligned SPI transfer.\n");
332                 return -1;
333         }
334
335         /* Start the transaction, if necessary. */
336         if ((flags & SPI_XFER_BEGIN))
337                 spi_cs_activate(dev);
338
339         /*
340          * Exynos SPI limits each transfer to 65535 transfers. To keep
341          * things simple, allow a maximum of 65532 bytes. We could allow
342          * more in word mode, but the performance difference is small.
343          */
344         bytelen = bitlen / 8;
345         for (upto = 0; !ret && upto < bytelen; upto += todo) {
346                 todo = min(bytelen - upto, (1 << 16) - 4);
347                 ret = spi_rx_tx(priv, todo, &din, &dout, flags);
348                 if (ret)
349                         break;
350         }
351
352         /* Stop the transaction, if necessary. */
353         if ((flags & SPI_XFER_END) && !(priv->mode & SPI_SLAVE)) {
354                 spi_cs_deactivate(dev);
355                 if (priv->skip_preamble) {
356                         assert(!priv->skip_preamble);
357                         debug("Failed to complete premable transaction\n");
358                         ret = -1;
359                 }
360         }
361
362         return ret;
363 }
364
365 static int exynos_spi_set_speed(struct udevice *bus, uint speed)
366 {
367         struct exynos_spi_platdata *plat = bus->platdata;
368         struct exynos_spi_priv *priv = dev_get_priv(bus);
369         int ret;
370
371         if (speed > plat->frequency)
372                 speed = plat->frequency;
373         ret = set_spi_clk(priv->periph_id, speed);
374         if (ret)
375                 return ret;
376         priv->freq = speed;
377         debug("%s: regs=%p, speed=%d\n", __func__, priv->regs, priv->freq);
378
379         return 0;
380 }
381
382 static int exynos_spi_set_mode(struct udevice *bus, uint mode)
383 {
384         struct exynos_spi_priv *priv = dev_get_priv(bus);
385         uint32_t reg;
386
387         reg = readl(&priv->regs->ch_cfg);
388         reg &= ~(SPI_CH_CPHA_B | SPI_CH_CPOL_L);
389
390         if (mode & SPI_CPHA)
391                 reg |= SPI_CH_CPHA_B;
392
393         if (mode & SPI_CPOL)
394                 reg |= SPI_CH_CPOL_L;
395
396         writel(reg, &priv->regs->ch_cfg);
397         priv->mode = mode;
398         debug("%s: regs=%p, mode=%d\n", __func__, priv->regs, priv->mode);
399
400         return 0;
401 }
402
403 static const struct dm_spi_ops exynos_spi_ops = {
404         .claim_bus      = exynos_spi_claim_bus,
405         .release_bus    = exynos_spi_release_bus,
406         .xfer           = exynos_spi_xfer,
407         .set_speed      = exynos_spi_set_speed,
408         .set_mode       = exynos_spi_set_mode,
409         /*
410          * cs_info is not needed, since we require all chip selects to be
411          * in the device tree explicitly
412          */
413 };
414
415 static const struct udevice_id exynos_spi_ids[] = {
416         { .compatible = "samsung,exynos-spi" },
417         { }
418 };
419
420 U_BOOT_DRIVER(exynos_spi) = {
421         .name   = "exynos_spi",
422         .id     = UCLASS_SPI,
423         .of_match = exynos_spi_ids,
424         .ops    = &exynos_spi_ops,
425         .ofdata_to_platdata = exynos_spi_ofdata_to_platdata,
426         .platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
427         .priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
428         .per_child_auto_alloc_size      = sizeof(struct spi_slave),
429         .probe  = exynos_spi_probe,
430 };