1
2
3
4
5
6#define LOG_CATEGORY UCLASS_SPI
7
8#include <common.h>
9#include <dm.h>
10#include <errno.h>
11#include <log.h>
12#include <malloc.h>
13#include <spi.h>
14#include <spi-mem.h>
15#include <dm/device_compat.h>
16#include <asm/global_data.h>
17#include <dm/device-internal.h>
18#include <dm/uclass-internal.h>
19#include <dm/lists.h>
20#include <dm/util.h>
21
22DECLARE_GLOBAL_DATA_PTR;
23
24#define SPI_DEFAULT_SPEED_HZ 100000
25
26static int spi_set_speed_mode(struct udevice *bus, int speed, int mode)
27{
28 struct dm_spi_ops *ops;
29 int ret;
30
31 ops = spi_get_ops(bus);
32 if (ops->set_speed)
33 ret = ops->set_speed(bus, speed);
34 else
35 ret = -EINVAL;
36 if (ret) {
37 dev_err(bus, "Cannot set speed (err=%d)\n", ret);
38 return ret;
39 }
40
41 if (ops->set_mode)
42 ret = ops->set_mode(bus, mode);
43 else
44 ret = -EINVAL;
45 if (ret) {
46 dev_err(bus, "Cannot set mode (err=%d)\n", ret);
47 return ret;
48 }
49
50 return 0;
51}
52
53int dm_spi_claim_bus(struct udevice *dev)
54{
55 struct udevice *bus = dev->parent;
56 struct dm_spi_ops *ops = spi_get_ops(bus);
57 struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
58 struct spi_slave *slave = dev_get_parent_priv(dev);
59 uint speed, mode;
60
61 speed = slave->max_hz;
62 mode = slave->mode;
63
64 if (spi->max_hz) {
65 if (speed)
66 speed = min(speed, spi->max_hz);
67 else
68 speed = spi->max_hz;
69 }
70 if (!speed)
71 speed = SPI_DEFAULT_SPEED_HZ;
72
73 if (speed != spi->speed || mode != spi->mode) {
74 int ret = spi_set_speed_mode(bus, speed, slave->mode);
75
76 if (ret)
77 return log_ret(ret);
78
79 spi->speed = speed;
80 spi->mode = mode;
81 }
82
83 return log_ret(ops->claim_bus ? ops->claim_bus(dev) : 0);
84}
85
86void dm_spi_release_bus(struct udevice *dev)
87{
88 struct udevice *bus = dev->parent;
89 struct dm_spi_ops *ops = spi_get_ops(bus);
90
91 if (ops->release_bus)
92 ops->release_bus(dev);
93}
94
95int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
96 const void *dout, void *din, unsigned long flags)
97{
98 struct udevice *bus = dev->parent;
99 struct dm_spi_ops *ops = spi_get_ops(bus);
100
101 if (bus->uclass->uc_drv->id != UCLASS_SPI)
102 return -EOPNOTSUPP;
103 if (!ops->xfer)
104 return -ENOSYS;
105
106 return ops->xfer(dev, bitlen, dout, din, flags);
107}
108
109int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep,
110 uint *offsetp)
111{
112 struct udevice *bus = dev->parent;
113 struct dm_spi_ops *ops = spi_get_ops(bus);
114
115 if (bus->uclass->uc_drv->id != UCLASS_SPI)
116 return -EOPNOTSUPP;
117 if (!ops->get_mmap)
118 return -ENOSYS;
119
120 return ops->get_mmap(dev, map_basep, map_sizep, offsetp);
121}
122
123int spi_claim_bus(struct spi_slave *slave)
124{
125 return log_ret(dm_spi_claim_bus(slave->dev));
126}
127
128void spi_release_bus(struct spi_slave *slave)
129{
130 dm_spi_release_bus(slave->dev);
131}
132
133int spi_set_speed(struct spi_slave *slave, uint hz)
134{
135 struct dm_spi_ops *ops;
136 int ret;
137
138 ops = spi_get_ops(slave->dev->parent);
139 if (ops->set_speed)
140 ret = ops->set_speed(slave->dev->parent, hz);
141 else
142 ret = -EINVAL;
143 if (ret)
144 dev_err(slave->dev, "Cannot set speed (err=%d)\n", ret);
145 return ret;
146}
147
148int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
149 const void *dout, void *din, unsigned long flags)
150{
151 return dm_spi_xfer(slave->dev, bitlen, dout, din, flags);
152}
153
154int spi_write_then_read(struct spi_slave *slave, const u8 *opcode,
155 size_t n_opcode, const u8 *txbuf, u8 *rxbuf,
156 size_t n_buf)
157{
158 unsigned long flags = SPI_XFER_BEGIN;
159 int ret;
160
161 if (n_buf == 0)
162 flags |= SPI_XFER_END;
163
164 ret = spi_xfer(slave, n_opcode * 8, opcode, NULL, flags);
165 if (ret) {
166 dev_dbg(slave->dev,
167 "spi: failed to send command (%zu bytes): %d\n",
168 n_opcode, ret);
169 } else if (n_buf != 0) {
170 ret = spi_xfer(slave, n_buf * 8, txbuf, rxbuf, SPI_XFER_END);
171 if (ret)
172 dev_dbg(slave->dev,
173 "spi: failed to transfer %zu bytes of data: %d\n",
174 n_buf, ret);
175 }
176
177 return ret;
178}
179
180#if CONFIG_IS_ENABLED(OF_REAL)
181static int spi_child_post_bind(struct udevice *dev)
182{
183 struct dm_spi_slave_plat *plat = dev_get_parent_plat(dev);
184
185 if (!dev_has_ofnode(dev))
186 return 0;
187
188 return spi_slave_of_to_plat(dev, plat);
189}
190#endif
191
192static int spi_post_probe(struct udevice *bus)
193{
194 if (CONFIG_IS_ENABLED(OF_REAL)) {
195 struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
196
197 spi->max_hz = dev_read_u32_default(bus, "spi-max-frequency", 0);
198 }
199#if defined(CONFIG_NEEDS_MANUAL_RELOC)
200 struct dm_spi_ops *ops = spi_get_ops(bus);
201 static int reloc_done;
202
203 if (!reloc_done) {
204 if (ops->claim_bus)
205 ops->claim_bus += gd->reloc_off;
206 if (ops->release_bus)
207 ops->release_bus += gd->reloc_off;
208 if (ops->set_wordlen)
209 ops->set_wordlen += gd->reloc_off;
210 if (ops->xfer)
211 ops->xfer += gd->reloc_off;
212 if (ops->set_speed)
213 ops->set_speed += gd->reloc_off;
214 if (ops->set_mode)
215 ops->set_mode += gd->reloc_off;
216 if (ops->cs_info)
217 ops->cs_info += gd->reloc_off;
218 if (ops->mem_ops) {
219 struct spi_controller_mem_ops *mem_ops =
220 (struct spi_controller_mem_ops *)ops->mem_ops;
221 if (mem_ops->adjust_op_size)
222 mem_ops->adjust_op_size += gd->reloc_off;
223 if (mem_ops->supports_op)
224 mem_ops->supports_op += gd->reloc_off;
225 if (mem_ops->exec_op)
226 mem_ops->exec_op += gd->reloc_off;
227 }
228 reloc_done++;
229 }
230#endif
231
232 return 0;
233}
234
235static int spi_child_pre_probe(struct udevice *dev)
236{
237 struct dm_spi_slave_plat *plat = dev_get_parent_plat(dev);
238 struct spi_slave *slave = dev_get_parent_priv(dev);
239
240
241
242
243
244
245
246
247 slave->dev = dev;
248
249 slave->max_hz = plat->max_hz;
250 slave->mode = plat->mode;
251 slave->wordlen = SPI_DEFAULT_WORDLEN;
252
253 return 0;
254}
255
256int spi_chip_select(struct udevice *dev)
257{
258 struct dm_spi_slave_plat *plat = dev_get_parent_plat(dev);
259
260 return plat ? plat->cs : -ENOENT;
261}
262
263int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp)
264{
265 struct dm_spi_ops *ops;
266 struct spi_cs_info info;
267 struct udevice *dev;
268 int ret;
269
270
271
272
273
274
275
276 ops = spi_get_ops(bus);
277 if (ops->cs_info) {
278 ret = ops->cs_info(bus, cs, &info);
279 } else {
280
281
282
283
284 ret = 0;
285 }
286
287 if (ret) {
288 dev_err(bus, "Invalid cs %d (err=%d)\n", cs, ret);
289 return ret;
290 }
291
292 for (device_find_first_child(bus, &dev); dev;
293 device_find_next_child(&dev)) {
294 struct dm_spi_slave_plat *plat;
295
296 plat = dev_get_parent_plat(dev);
297 dev_dbg(bus, "%s: plat=%p, cs=%d\n", __func__, plat, plat->cs);
298 if (plat->cs == cs) {
299 *devp = dev;
300 return 0;
301 }
302 }
303
304 return -ENODEV;
305}
306
307int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
308{
309 struct spi_cs_info info;
310 struct udevice *bus;
311 int ret;
312
313 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, &bus);
314 if (ret) {
315 log_debug("%s: No bus %d\n", __func__, busnum);
316 return ret;
317 }
318
319 return spi_cs_info(bus, cs, &info);
320}
321
322int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info)
323{
324 struct spi_cs_info local_info;
325 int ret;
326
327 if (!info)
328 info = &local_info;
329
330
331 info->dev = NULL;
332 ret = spi_find_chip_select(bus, cs, &info->dev);
333 return ret == -ENODEV ? 0 : ret;
334}
335
336int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
337 struct udevice **devp)
338{
339 struct udevice *bus, *dev;
340 int ret;
341
342 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, &bus);
343 if (ret) {
344 log_debug("%s: No bus %d\n", __func__, busnum);
345 return ret;
346 }
347 ret = spi_find_chip_select(bus, cs, &dev);
348 if (ret) {
349 dev_dbg(bus, "%s: No cs %d\n", __func__, cs);
350 return ret;
351 }
352 *busp = bus;
353 *devp = dev;
354
355 return ret;
356}
357
358int spi_get_bus_and_cs(int busnum, int cs, struct udevice **busp,
359 struct spi_slave **devp)
360{
361 struct udevice *bus, *dev;
362 struct dm_spi_bus *bus_data;
363 struct spi_slave *slave;
364 int ret;
365
366#if CONFIG_IS_ENABLED(OF_PLATDATA)
367 ret = uclass_first_device_err(UCLASS_SPI, &bus);
368#else
369 ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
370#endif
371 if (ret) {
372 log_err("Invalid bus %d (err=%d)\n", busnum, ret);
373 return ret;
374 }
375 ret = spi_find_chip_select(bus, cs, &dev);
376 if (ret) {
377 dev_err(bus, "Invalid chip select %d:%d (err=%d)\n", busnum, cs, ret);
378 return ret;
379 }
380
381 if (!device_active(dev)) {
382 struct spi_slave *slave;
383
384 ret = device_probe(dev);
385 if (ret)
386 goto err;
387 slave = dev_get_parent_priv(dev);
388 slave->dev = dev;
389 }
390
391 slave = dev_get_parent_priv(dev);
392 bus_data = dev_get_uclass_priv(bus);
393
394
395
396
397
398 if (!bus_data->speed) {
399 ret = spi_claim_bus(slave);
400 if (ret)
401 goto err;
402 }
403 *busp = bus;
404 *devp = slave;
405
406 return 0;
407
408err:
409 log_debug("%s: Error path, device '%s'\n", __func__, dev->name);
410
411 return ret;
412}
413
414int _spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
415 const char *drv_name, const char *dev_name,
416 struct udevice **busp, struct spi_slave **devp)
417{
418 struct udevice *bus, *dev;
419 struct dm_spi_slave_plat *plat;
420 struct dm_spi_bus *bus_data;
421 struct spi_slave *slave;
422 bool created = false;
423 int ret;
424
425#if CONFIG_IS_ENABLED(OF_PLATDATA)
426 ret = uclass_first_device_err(UCLASS_SPI, &bus);
427#else
428 ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
429#endif
430 if (ret) {
431 log_err("Invalid bus %d (err=%d)\n", busnum, ret);
432 return ret;
433 }
434 ret = spi_find_chip_select(bus, cs, &dev);
435
436
437
438
439
440
441 if (ret == -ENODEV && drv_name) {
442 dev_dbg(bus, "%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
443 __func__, dev_name, busnum, cs, drv_name);
444 ret = device_bind_driver(bus, drv_name, dev_name, &dev);
445 if (ret) {
446 dev_dbg(bus, "%s: Unable to bind driver (ret=%d)\n",
447 __func__, ret);
448 return ret;
449 }
450 plat = dev_get_parent_plat(dev);
451 plat->cs = cs;
452 if (speed) {
453 plat->max_hz = speed;
454 } else {
455 dev_warn(bus,
456 "Warning: SPI speed fallback to %u kHz\n",
457 SPI_DEFAULT_SPEED_HZ / 1000);
458 plat->max_hz = SPI_DEFAULT_SPEED_HZ;
459 }
460 plat->mode = mode;
461 created = true;
462 } else if (ret) {
463 dev_err(bus, "Invalid chip select %d:%d (err=%d)\n", busnum, cs, ret);
464 return ret;
465 } else if (dev) {
466 plat = dev_get_parent_plat(dev);
467 }
468
469 if (!device_active(dev)) {
470 struct spi_slave *slave;
471
472 ret = device_probe(dev);
473 if (ret)
474 goto err;
475 slave = dev_get_parent_priv(dev);
476 slave->dev = dev;
477 }
478
479 slave = dev_get_parent_priv(dev);
480 bus_data = dev_get_uclass_priv(bus);
481
482
483
484
485
486 if (!bus_data->speed) {
487 ret = spi_claim_bus(slave);
488 if (ret)
489 goto err;
490 }
491
492
493 if ((speed && bus_data->speed && bus_data->speed != speed) ||
494 (plat && plat->mode != mode)) {
495 ret = spi_set_speed_mode(bus, speed, mode);
496 if (ret)
497 goto err_speed_mode;
498 }
499
500 *busp = bus;
501 *devp = slave;
502 log_debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);
503
504 return 0;
505
506err_speed_mode:
507 spi_release_bus(slave);
508err:
509 log_debug("%s: Error path, created=%d, device '%s'\n", __func__,
510 created, dev->name);
511 if (created) {
512 device_remove(dev, DM_REMOVE_NORMAL);
513 device_unbind(dev);
514 }
515
516 return ret;
517}
518
519
520struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
521 unsigned int speed, unsigned int mode)
522{
523 struct spi_slave *slave;
524 struct udevice *dev;
525 int ret;
526
527 ret = _spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
528 &slave);
529 if (ret)
530 return NULL;
531
532 return slave;
533}
534
535void spi_free_slave(struct spi_slave *slave)
536{
537 device_remove(slave->dev, DM_REMOVE_NORMAL);
538}
539
540int spi_slave_of_to_plat(struct udevice *dev, struct dm_spi_slave_plat *plat)
541{
542 int mode = 0;
543 int value;
544
545 plat->cs = dev_read_u32_default(dev, "reg", -1);
546 plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency",
547 SPI_DEFAULT_SPEED_HZ);
548 if (dev_read_bool(dev, "spi-cpol"))
549 mode |= SPI_CPOL;
550 if (dev_read_bool(dev, "spi-cpha"))
551 mode |= SPI_CPHA;
552 if (dev_read_bool(dev, "spi-cs-high"))
553 mode |= SPI_CS_HIGH;
554 if (dev_read_bool(dev, "spi-3wire"))
555 mode |= SPI_3WIRE;
556 if (dev_read_bool(dev, "spi-half-duplex"))
557 mode |= SPI_PREAMBLE;
558
559
560 value = dev_read_u32_default(dev, "spi-tx-bus-width", 1);
561 switch (value) {
562 case 1:
563 break;
564 case 2:
565 mode |= SPI_TX_DUAL;
566 break;
567 case 4:
568 mode |= SPI_TX_QUAD;
569 break;
570 case 8:
571 mode |= SPI_TX_OCTAL;
572 break;
573 default:
574 warn_non_spl("spi-tx-bus-width %d not supported\n", value);
575 break;
576 }
577
578 value = dev_read_u32_default(dev, "spi-rx-bus-width", 1);
579 switch (value) {
580 case 1:
581 break;
582 case 2:
583 mode |= SPI_RX_DUAL;
584 break;
585 case 4:
586 mode |= SPI_RX_QUAD;
587 break;
588 case 8:
589 mode |= SPI_RX_OCTAL;
590 break;
591 default:
592 warn_non_spl("spi-rx-bus-width %d not supported\n", value);
593 break;
594 }
595
596 plat->mode = mode;
597
598 return 0;
599}
600
601UCLASS_DRIVER(spi) = {
602 .id = UCLASS_SPI,
603 .name = "spi",
604 .flags = DM_UC_FLAG_SEQ_ALIAS,
605#if CONFIG_IS_ENABLED(OF_REAL)
606 .post_bind = dm_scan_fdt_dev,
607#endif
608 .post_probe = spi_post_probe,
609 .child_pre_probe = spi_child_pre_probe,
610 .per_device_auto = sizeof(struct dm_spi_bus),
611 .per_child_auto = sizeof(struct spi_slave),
612 .per_child_plat_auto = sizeof(struct dm_spi_slave_plat),
613#if CONFIG_IS_ENABLED(OF_REAL)
614 .child_post_bind = spi_child_post_bind,
615#endif
616};
617
618UCLASS_DRIVER(spi_generic) = {
619 .id = UCLASS_SPI_GENERIC,
620 .name = "spi_generic",
621};
622
623U_BOOT_DRIVER(spi_generic_drv) = {
624 .name = "spi_generic_drv",
625 .id = UCLASS_SPI_GENERIC,
626};
627
