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