]> git.sur5r.net Git - u-boot/blob - drivers/spi/altera_spi.c
pci: correct a function description
[u-boot] / drivers / spi / altera_spi.c
1 /*
2  * Altera SPI driver
3  *
4  * based on bfin_spi.c
5  * Copyright (c) 2005-2008 Analog Devices Inc.
6  * Copyright (C) 2010 Thomas Chou <thomas@wytron.com.tw>
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10 #include <common.h>
11 #include <dm.h>
12 #include <errno.h>
13 #include <malloc.h>
14 #include <fdtdec.h>
15 #include <spi.h>
16 #include <asm/io.h>
17
18 DECLARE_GLOBAL_DATA_PTR;
19
20 #define ALTERA_SPI_STATUS_RRDY_MSK      BIT(7)
21 #define ALTERA_SPI_CONTROL_SSO_MSK      BIT(10)
22
23 #ifndef CONFIG_ALTERA_SPI_IDLE_VAL
24 #define CONFIG_ALTERA_SPI_IDLE_VAL      0xff
25 #endif
26
27 struct altera_spi_regs {
28         u32     rxdata;
29         u32     txdata;
30         u32     status;
31         u32     control;
32         u32     _reserved;
33         u32     slave_sel;
34 };
35
36 struct altera_spi_platdata {
37         struct altera_spi_regs *regs;
38 };
39
40 struct altera_spi_priv {
41         struct altera_spi_regs *regs;
42 };
43
44 static void spi_cs_activate(struct udevice *dev, uint cs)
45 {
46         struct udevice *bus = dev->parent;
47         struct altera_spi_priv *priv = dev_get_priv(bus);
48         struct altera_spi_regs *const regs = priv->regs;
49
50         writel(1 << cs, &regs->slave_sel);
51         writel(ALTERA_SPI_CONTROL_SSO_MSK, &regs->control);
52 }
53
54 static void spi_cs_deactivate(struct udevice *dev)
55 {
56         struct udevice *bus = dev->parent;
57         struct altera_spi_priv *priv = dev_get_priv(bus);
58         struct altera_spi_regs *const regs = priv->regs;
59
60         writel(0, &regs->control);
61         writel(0, &regs->slave_sel);
62 }
63
64 static int altera_spi_claim_bus(struct udevice *dev)
65 {
66         struct udevice *bus = dev->parent;
67         struct altera_spi_priv *priv = dev_get_priv(bus);
68         struct altera_spi_regs *const regs = priv->regs;
69
70         writel(0, &regs->control);
71         writel(0, &regs->slave_sel);
72
73         return 0;
74 }
75
76 static int altera_spi_release_bus(struct udevice *dev)
77 {
78         struct udevice *bus = dev->parent;
79         struct altera_spi_priv *priv = dev_get_priv(bus);
80         struct altera_spi_regs *const regs = priv->regs;
81
82         writel(0, &regs->slave_sel);
83
84         return 0;
85 }
86
87 static int altera_spi_xfer(struct udevice *dev, unsigned int bitlen,
88                             const void *dout, void *din, unsigned long flags)
89 {
90         struct udevice *bus = dev->parent;
91         struct altera_spi_priv *priv = dev_get_priv(bus);
92         struct altera_spi_regs *const regs = priv->regs;
93         struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev);
94
95         /* assume spi core configured to do 8 bit transfers */
96         unsigned int bytes = bitlen / 8;
97         const unsigned char *txp = dout;
98         unsigned char *rxp = din;
99         uint32_t reg, data, start;
100
101         debug("%s: bus:%i cs:%i bitlen:%i bytes:%i flags:%lx\n", __func__,
102               bus->seq, slave_plat->cs, bitlen, bytes, flags);
103
104         if (bitlen == 0)
105                 goto done;
106
107         if (bitlen % 8) {
108                 flags |= SPI_XFER_END;
109                 goto done;
110         }
111
112         /* empty read buffer */
113         if (readl(&regs->status) & ALTERA_SPI_STATUS_RRDY_MSK)
114                 readl(&regs->rxdata);
115
116         if (flags & SPI_XFER_BEGIN)
117                 spi_cs_activate(dev, slave_plat->cs);
118
119         while (bytes--) {
120                 if (txp)
121                         data = *txp++;
122                 else
123                         data = CONFIG_ALTERA_SPI_IDLE_VAL;
124
125                 debug("%s: tx:%x ", __func__, data);
126                 writel(data, &regs->txdata);
127
128                 start = get_timer(0);
129                 while (1) {
130                         reg = readl(&regs->status);
131                         if (reg & ALTERA_SPI_STATUS_RRDY_MSK)
132                                 break;
133                         if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
134                                 debug("%s: Transmission timed out!\n", __func__);
135                                 return -1;
136                         }
137                 }
138
139                 data = readl(&regs->rxdata);
140                 if (rxp)
141                         *rxp++ = data & 0xff;
142
143                 debug("rx:%x\n", data);
144         }
145
146 done:
147         if (flags & SPI_XFER_END)
148                 spi_cs_deactivate(dev);
149
150         return 0;
151 }
152
153 static int altera_spi_set_speed(struct udevice *bus, uint speed)
154 {
155         return 0;
156 }
157
158 static int altera_spi_set_mode(struct udevice *bus, uint mode)
159 {
160         return 0;
161 }
162
163 static int altera_spi_probe(struct udevice *bus)
164 {
165         struct altera_spi_platdata *plat = dev_get_platdata(bus);
166         struct altera_spi_priv *priv = dev_get_priv(bus);
167
168         priv->regs = plat->regs;
169
170         return 0;
171 }
172
173 static int altera_spi_ofdata_to_platdata(struct udevice *bus)
174 {
175         struct altera_spi_platdata *plat = dev_get_platdata(bus);
176
177         plat->regs = map_physmem(dev_get_addr(bus),
178                                  sizeof(struct altera_spi_regs),
179                                  MAP_NOCACHE);
180
181         return 0;
182 }
183
184 static const struct dm_spi_ops altera_spi_ops = {
185         .claim_bus      = altera_spi_claim_bus,
186         .release_bus    = altera_spi_release_bus,
187         .xfer           = altera_spi_xfer,
188         .set_speed      = altera_spi_set_speed,
189         .set_mode       = altera_spi_set_mode,
190         /*
191          * cs_info is not needed, since we require all chip selects to be
192          * in the device tree explicitly
193          */
194 };
195
196 static const struct udevice_id altera_spi_ids[] = {
197         { .compatible = "altr,spi-1.0" },
198         {}
199 };
200
201 U_BOOT_DRIVER(altera_spi) = {
202         .name   = "altera_spi",
203         .id     = UCLASS_SPI,
204         .of_match = altera_spi_ids,
205         .ops    = &altera_spi_ops,
206         .ofdata_to_platdata = altera_spi_ofdata_to_platdata,
207         .platdata_auto_alloc_size = sizeof(struct altera_spi_platdata),
208         .priv_auto_alloc_size = sizeof(struct altera_spi_priv),
209         .probe  = altera_spi_probe,
210 };