]>
Commit | Line | Data |
---|---|---|
d7af6a48 SG |
1 | /* |
2 | * Copyright (c) 2014 Google, Inc | |
3 | * | |
4 | * SPDX-License-Identifier: GPL-2.0+ | |
5 | */ | |
6 | ||
7 | #include <common.h> | |
8 | #include <dm.h> | |
9 | #include <errno.h> | |
d7af6a48 SG |
10 | #include <malloc.h> |
11 | #include <spi.h> | |
12 | #include <dm/device-internal.h> | |
13 | #include <dm/uclass-internal.h> | |
d7af6a48 SG |
14 | #include <dm/lists.h> |
15 | #include <dm/util.h> | |
16 | ||
17 | DECLARE_GLOBAL_DATA_PTR; | |
18 | ||
19 | static int spi_set_speed_mode(struct udevice *bus, int speed, int mode) | |
20 | { | |
21 | struct dm_spi_ops *ops; | |
22 | int ret; | |
23 | ||
24 | ops = spi_get_ops(bus); | |
25 | if (ops->set_speed) | |
26 | ret = ops->set_speed(bus, speed); | |
27 | else | |
28 | ret = -EINVAL; | |
29 | if (ret) { | |
30 | printf("Cannot set speed (err=%d)\n", ret); | |
31 | return ret; | |
32 | } | |
33 | ||
34 | if (ops->set_mode) | |
35 | ret = ops->set_mode(bus, mode); | |
36 | else | |
37 | ret = -EINVAL; | |
38 | if (ret) { | |
39 | printf("Cannot set mode (err=%d)\n", ret); | |
40 | return ret; | |
41 | } | |
42 | ||
43 | return 0; | |
44 | } | |
45 | ||
7a3eff4c | 46 | int dm_spi_claim_bus(struct udevice *dev) |
d7af6a48 | 47 | { |
d7af6a48 SG |
48 | struct udevice *bus = dev->parent; |
49 | struct dm_spi_ops *ops = spi_get_ops(bus); | |
e564f054 | 50 | struct dm_spi_bus *spi = dev_get_uclass_priv(bus); |
7a3eff4c | 51 | struct spi_slave *slave = dev_get_parent_priv(dev); |
d7af6a48 SG |
52 | int speed; |
53 | int ret; | |
54 | ||
55 | speed = slave->max_hz; | |
56 | if (spi->max_hz) { | |
57 | if (speed) | |
b4141195 | 58 | speed = min(speed, (int)spi->max_hz); |
d7af6a48 SG |
59 | else |
60 | speed = spi->max_hz; | |
61 | } | |
62 | if (!speed) | |
63 | speed = 100000; | |
60e2809a SG |
64 | if (speed != slave->speed) { |
65 | ret = spi_set_speed_mode(bus, speed, slave->mode); | |
66 | if (ret) | |
67 | return ret; | |
68 | slave->speed = speed; | |
69 | } | |
d7af6a48 | 70 | |
9694b724 | 71 | return ops->claim_bus ? ops->claim_bus(dev) : 0; |
d7af6a48 SG |
72 | } |
73 | ||
7a3eff4c | 74 | void dm_spi_release_bus(struct udevice *dev) |
d7af6a48 | 75 | { |
d7af6a48 SG |
76 | struct udevice *bus = dev->parent; |
77 | struct dm_spi_ops *ops = spi_get_ops(bus); | |
78 | ||
79 | if (ops->release_bus) | |
9694b724 | 80 | ops->release_bus(dev); |
d7af6a48 SG |
81 | } |
82 | ||
7a3eff4c PF |
83 | int dm_spi_xfer(struct udevice *dev, unsigned int bitlen, |
84 | const void *dout, void *din, unsigned long flags) | |
d7af6a48 | 85 | { |
d7af6a48 SG |
86 | struct udevice *bus = dev->parent; |
87 | ||
88 | if (bus->uclass->uc_drv->id != UCLASS_SPI) | |
89 | return -EOPNOTSUPP; | |
90 | ||
91 | return spi_get_ops(bus)->xfer(dev, bitlen, dout, din, flags); | |
7a3eff4c PF |
92 | } |
93 | ||
94 | int spi_claim_bus(struct spi_slave *slave) | |
95 | { | |
96 | return dm_spi_claim_bus(slave->dev); | |
97 | } | |
98 | ||
99 | void spi_release_bus(struct spi_slave *slave) | |
100 | { | |
101 | dm_spi_release_bus(slave->dev); | |
102 | } | |
103 | ||
104 | int spi_xfer(struct spi_slave *slave, unsigned int bitlen, | |
105 | const void *dout, void *din, unsigned long flags) | |
106 | { | |
107 | return dm_spi_xfer(slave->dev, bitlen, dout, din, flags); | |
d7af6a48 SG |
108 | } |
109 | ||
71634f28 | 110 | #if !CONFIG_IS_ENABLED(OF_PLATDATA) |
6f849c30 | 111 | static int spi_child_post_bind(struct udevice *dev) |
d7af6a48 | 112 | { |
d0cff03e | 113 | struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); |
d7af6a48 | 114 | |
279e26f5 | 115 | if (!dev_of_valid(dev)) |
d0cff03e SG |
116 | return 0; |
117 | ||
279e26f5 | 118 | return spi_slave_ofdata_to_platdata(dev, plat); |
d0cff03e | 119 | } |
71634f28 | 120 | #endif |
d0cff03e | 121 | |
6f849c30 | 122 | static int spi_post_probe(struct udevice *bus) |
d0cff03e | 123 | { |
71634f28 | 124 | #if !CONFIG_IS_ENABLED(OF_PLATDATA) |
e564f054 | 125 | struct dm_spi_bus *spi = dev_get_uclass_priv(bus); |
d0cff03e | 126 | |
279e26f5 | 127 | spi->max_hz = dev_read_u32_default(bus, "spi-max-frequency", 0); |
71634f28 | 128 | #endif |
281f1566 MS |
129 | #if defined(CONFIG_NEEDS_MANUAL_RELOC) |
130 | struct dm_spi_ops *ops = spi_get_ops(bus); | |
131 | ||
132 | ||
133 | if (ops->claim_bus) | |
134 | ops->claim_bus += gd->reloc_off; | |
135 | if (ops->release_bus) | |
136 | ops->release_bus += gd->reloc_off; | |
137 | if (ops->set_wordlen) | |
138 | ops->set_wordlen += gd->reloc_off; | |
139 | if (ops->xfer) | |
140 | ops->xfer += gd->reloc_off; | |
141 | if (ops->set_speed) | |
142 | ops->set_speed += gd->reloc_off; | |
143 | if (ops->set_mode) | |
144 | ops->set_mode += gd->reloc_off; | |
145 | if (ops->cs_info) | |
146 | ops->cs_info += gd->reloc_off; | |
147 | #endif | |
148 | ||
d7af6a48 SG |
149 | return 0; |
150 | } | |
151 | ||
6f849c30 | 152 | static int spi_child_pre_probe(struct udevice *dev) |
440714ee | 153 | { |
d0cff03e | 154 | struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); |
bcbe3d15 | 155 | struct spi_slave *slave = dev_get_parent_priv(dev); |
440714ee | 156 | |
d0cff03e SG |
157 | /* |
158 | * This is needed because we pass struct spi_slave around the place | |
159 | * instead slave->dev (a struct udevice). So we have to have some | |
160 | * way to access the slave udevice given struct spi_slave. Once we | |
161 | * change the SPI API to use udevice instead of spi_slave, we can | |
162 | * drop this. | |
163 | */ | |
440714ee SG |
164 | slave->dev = dev; |
165 | ||
d0cff03e SG |
166 | slave->max_hz = plat->max_hz; |
167 | slave->mode = plat->mode; | |
674f3609 | 168 | slave->wordlen = SPI_DEFAULT_WORDLEN; |
d0cff03e | 169 | |
440714ee SG |
170 | return 0; |
171 | } | |
172 | ||
d7af6a48 SG |
173 | int spi_chip_select(struct udevice *dev) |
174 | { | |
d0cff03e | 175 | struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); |
d7af6a48 | 176 | |
d0cff03e | 177 | return plat ? plat->cs : -ENOENT; |
d7af6a48 SG |
178 | } |
179 | ||
ff56bba2 | 180 | int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp) |
d7af6a48 SG |
181 | { |
182 | struct udevice *dev; | |
183 | ||
184 | for (device_find_first_child(bus, &dev); dev; | |
185 | device_find_next_child(&dev)) { | |
d0cff03e | 186 | struct dm_spi_slave_platdata *plat; |
d7af6a48 | 187 | |
d0cff03e SG |
188 | plat = dev_get_parent_platdata(dev); |
189 | debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs); | |
190 | if (plat->cs == cs) { | |
d7af6a48 SG |
191 | *devp = dev; |
192 | return 0; | |
193 | } | |
194 | } | |
195 | ||
196 | return -ENODEV; | |
197 | } | |
198 | ||
199 | int spi_cs_is_valid(unsigned int busnum, unsigned int cs) | |
200 | { | |
201 | struct spi_cs_info info; | |
202 | struct udevice *bus; | |
203 | int ret; | |
204 | ||
205 | ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); | |
206 | if (ret) { | |
207 | debug("%s: No bus %d\n", __func__, busnum); | |
208 | return ret; | |
209 | } | |
210 | ||
211 | return spi_cs_info(bus, cs, &info); | |
212 | } | |
213 | ||
214 | int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info) | |
215 | { | |
216 | struct spi_cs_info local_info; | |
217 | struct dm_spi_ops *ops; | |
218 | int ret; | |
219 | ||
220 | if (!info) | |
221 | info = &local_info; | |
222 | ||
223 | /* If there is a device attached, return it */ | |
224 | info->dev = NULL; | |
225 | ret = spi_find_chip_select(bus, cs, &info->dev); | |
226 | if (!ret) | |
227 | return 0; | |
228 | ||
229 | /* | |
230 | * Otherwise ask the driver. For the moment we don't have CS info. | |
231 | * When we do we could provide the driver with a helper function | |
232 | * to figure out what chip selects are valid, or just handle the | |
233 | * request. | |
234 | */ | |
235 | ops = spi_get_ops(bus); | |
236 | if (ops->cs_info) | |
237 | return ops->cs_info(bus, cs, info); | |
238 | ||
239 | /* | |
240 | * We could assume there is at least one valid chip select, but best | |
241 | * to be sure and return an error in this case. The driver didn't | |
242 | * care enough to tell us. | |
243 | */ | |
244 | return -ENODEV; | |
245 | } | |
246 | ||
d7af6a48 SG |
247 | int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp, |
248 | struct udevice **devp) | |
249 | { | |
250 | struct udevice *bus, *dev; | |
251 | int ret; | |
252 | ||
253 | ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus); | |
254 | if (ret) { | |
255 | debug("%s: No bus %d\n", __func__, busnum); | |
256 | return ret; | |
257 | } | |
258 | ret = spi_find_chip_select(bus, cs, &dev); | |
259 | if (ret) { | |
260 | debug("%s: No cs %d\n", __func__, cs); | |
261 | return ret; | |
262 | } | |
263 | *busp = bus; | |
264 | *devp = dev; | |
265 | ||
266 | return ret; | |
267 | } | |
268 | ||
269 | int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode, | |
270 | const char *drv_name, const char *dev_name, | |
271 | struct udevice **busp, struct spi_slave **devp) | |
272 | { | |
273 | struct udevice *bus, *dev; | |
96907c0f | 274 | struct dm_spi_slave_platdata *plat; |
d7af6a48 SG |
275 | bool created = false; |
276 | int ret; | |
277 | ||
71634f28 SG |
278 | #if CONFIG_IS_ENABLED(OF_PLATDATA) |
279 | ret = uclass_first_device_err(UCLASS_SPI, &bus); | |
280 | #else | |
d7af6a48 | 281 | ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus); |
71634f28 | 282 | #endif |
d7af6a48 SG |
283 | if (ret) { |
284 | printf("Invalid bus %d (err=%d)\n", busnum, ret); | |
285 | return ret; | |
286 | } | |
287 | ret = spi_find_chip_select(bus, cs, &dev); | |
288 | ||
289 | /* | |
290 | * If there is no such device, create one automatically. This means | |
291 | * that we don't need a device tree node or platform data for the | |
292 | * SPI flash chip - we will bind to the correct driver. | |
293 | */ | |
294 | if (ret == -ENODEV && drv_name) { | |
295 | debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n", | |
296 | __func__, dev_name, busnum, cs, drv_name); | |
6b18656a | 297 | ret = device_bind_driver(bus, drv_name, dev_name, &dev); |
28f98858 SG |
298 | if (ret) { |
299 | debug("%s: Unable to bind driver (ret=%d)\n", __func__, | |
300 | ret); | |
d7af6a48 | 301 | return ret; |
28f98858 | 302 | } |
d0cff03e SG |
303 | plat = dev_get_parent_platdata(dev); |
304 | plat->cs = cs; | |
305 | plat->max_hz = speed; | |
306 | plat->mode = mode; | |
d7af6a48 SG |
307 | created = true; |
308 | } else if (ret) { | |
309 | printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs, | |
310 | ret); | |
311 | return ret; | |
312 | } | |
313 | ||
314 | if (!device_active(dev)) { | |
d0cff03e | 315 | struct spi_slave *slave; |
d7af6a48 | 316 | |
d0cff03e | 317 | ret = device_probe(dev); |
d7af6a48 SG |
318 | if (ret) |
319 | goto err; | |
bcbe3d15 | 320 | slave = dev_get_parent_priv(dev); |
d7af6a48 | 321 | slave->dev = dev; |
d7af6a48 SG |
322 | } |
323 | ||
96907c0f V |
324 | plat = dev_get_parent_platdata(dev); |
325 | if (!speed) { | |
326 | speed = plat->max_hz; | |
327 | mode = plat->mode; | |
328 | } | |
d7af6a48 SG |
329 | ret = spi_set_speed_mode(bus, speed, mode); |
330 | if (ret) | |
331 | goto err; | |
332 | ||
333 | *busp = bus; | |
bcbe3d15 | 334 | *devp = dev_get_parent_priv(dev); |
d7af6a48 SG |
335 | debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp); |
336 | ||
337 | return 0; | |
338 | ||
339 | err: | |
c8864d72 | 340 | debug("%s: Error path, created=%d, device '%s'\n", __func__, |
d0cff03e | 341 | created, dev->name); |
d7af6a48 | 342 | if (created) { |
706865af | 343 | device_remove(dev, DM_REMOVE_NORMAL); |
d7af6a48 SG |
344 | device_unbind(dev); |
345 | } | |
346 | ||
347 | return ret; | |
348 | } | |
349 | ||
350 | /* Compatibility function - to be removed */ | |
351 | struct spi_slave *spi_setup_slave_fdt(const void *blob, int node, | |
352 | int bus_node) | |
353 | { | |
354 | struct udevice *bus, *dev; | |
355 | int ret; | |
356 | ||
357 | ret = uclass_get_device_by_of_offset(UCLASS_SPI, bus_node, &bus); | |
358 | if (ret) | |
359 | return NULL; | |
360 | ret = device_get_child_by_of_offset(bus, node, &dev); | |
361 | if (ret) | |
362 | return NULL; | |
bcbe3d15 | 363 | return dev_get_parent_priv(dev); |
d7af6a48 SG |
364 | } |
365 | ||
366 | /* Compatibility function - to be removed */ | |
367 | struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs, | |
368 | unsigned int speed, unsigned int mode) | |
369 | { | |
370 | struct spi_slave *slave; | |
371 | struct udevice *dev; | |
372 | int ret; | |
373 | ||
374 | ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev, | |
279e26f5 | 375 | &slave); |
d7af6a48 SG |
376 | if (ret) |
377 | return NULL; | |
378 | ||
379 | return slave; | |
380 | } | |
381 | ||
382 | void spi_free_slave(struct spi_slave *slave) | |
383 | { | |
706865af | 384 | device_remove(slave->dev, DM_REMOVE_NORMAL); |
d7af6a48 SG |
385 | slave->dev = NULL; |
386 | } | |
387 | ||
279e26f5 | 388 | int spi_slave_ofdata_to_platdata(struct udevice *dev, |
d0cff03e | 389 | struct dm_spi_slave_platdata *plat) |
d7af6a48 | 390 | { |
08fe9c29 | 391 | int mode = 0; |
f8e2f92d | 392 | int value; |
d7af6a48 | 393 | |
279e26f5 SG |
394 | plat->cs = dev_read_u32_default(dev, "reg", -1); |
395 | plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency", 0); | |
396 | if (dev_read_bool(dev, "spi-cpol")) | |
d7af6a48 | 397 | mode |= SPI_CPOL; |
279e26f5 | 398 | if (dev_read_bool(dev, "spi-cpha")) |
d7af6a48 | 399 | mode |= SPI_CPHA; |
279e26f5 | 400 | if (dev_read_bool(dev, "spi-cs-high")) |
d7af6a48 | 401 | mode |= SPI_CS_HIGH; |
279e26f5 | 402 | if (dev_read_bool(dev, "spi-3wire")) |
379b49d8 | 403 | mode |= SPI_3WIRE; |
279e26f5 | 404 | if (dev_read_bool(dev, "spi-half-duplex")) |
d7af6a48 | 405 | mode |= SPI_PREAMBLE; |
f8e2f92d M |
406 | |
407 | /* Device DUAL/QUAD mode */ | |
279e26f5 | 408 | value = dev_read_u32_default(dev, "spi-tx-bus-width", 1); |
f8e2f92d M |
409 | switch (value) { |
410 | case 1: | |
411 | break; | |
412 | case 2: | |
413 | mode |= SPI_TX_DUAL; | |
414 | break; | |
415 | case 4: | |
416 | mode |= SPI_TX_QUAD; | |
417 | break; | |
418 | default: | |
1b7c28f5 | 419 | warn_non_spl("spi-tx-bus-width %d not supported\n", value); |
f8e2f92d M |
420 | break; |
421 | } | |
422 | ||
279e26f5 | 423 | value = dev_read_u32_default(dev, "spi-rx-bus-width", 1); |
f8e2f92d M |
424 | switch (value) { |
425 | case 1: | |
426 | break; | |
427 | case 2: | |
08fe9c29 | 428 | mode |= SPI_RX_DUAL; |
f8e2f92d M |
429 | break; |
430 | case 4: | |
08fe9c29 | 431 | mode |= SPI_RX_QUAD; |
f8e2f92d M |
432 | break; |
433 | default: | |
1b7c28f5 | 434 | warn_non_spl("spi-rx-bus-width %d not supported\n", value); |
f8e2f92d M |
435 | break; |
436 | } | |
437 | ||
08fe9c29 | 438 | plat->mode = mode; |
f8e2f92d | 439 | |
d7af6a48 SG |
440 | return 0; |
441 | } | |
442 | ||
443 | UCLASS_DRIVER(spi) = { | |
444 | .id = UCLASS_SPI, | |
445 | .name = "spi", | |
9cc36a2b | 446 | .flags = DM_UC_FLAG_SEQ_ALIAS, |
71634f28 | 447 | #if !CONFIG_IS_ENABLED(OF_PLATDATA) |
91195485 | 448 | .post_bind = dm_scan_fdt_dev, |
71634f28 | 449 | #endif |
d7af6a48 | 450 | .post_probe = spi_post_probe, |
440714ee | 451 | .child_pre_probe = spi_child_pre_probe, |
d7af6a48 | 452 | .per_device_auto_alloc_size = sizeof(struct dm_spi_bus), |
19a25f67 | 453 | .per_child_auto_alloc_size = sizeof(struct spi_slave), |
d0cff03e SG |
454 | .per_child_platdata_auto_alloc_size = |
455 | sizeof(struct dm_spi_slave_platdata), | |
71634f28 | 456 | #if !CONFIG_IS_ENABLED(OF_PLATDATA) |
d0cff03e | 457 | .child_post_bind = spi_child_post_bind, |
71634f28 | 458 | #endif |
d7af6a48 SG |
459 | }; |
460 | ||
461 | UCLASS_DRIVER(spi_generic) = { | |
462 | .id = UCLASS_SPI_GENERIC, | |
463 | .name = "spi_generic", | |
464 | }; | |
465 | ||
466 | U_BOOT_DRIVER(spi_generic_drv) = { | |
467 | .name = "spi_generic_drv", | |
468 | .id = UCLASS_SPI_GENERIC, | |
469 | }; |