blob: cffd9cf0b0e7d7c5ebd0d3d684ff88b0bb669595 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassd7af6a42014-10-13 23:41:52 -06002/*
3 * Copyright (c) 2014 Google, Inc
Simon Glassd7af6a42014-10-13 23:41:52 -06004 */
5
6#include <common.h>
7#include <dm.h>
8#include <errno.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -06009#include <log.h>
Simon Glassd7af6a42014-10-13 23:41:52 -060010#include <malloc.h>
11#include <spi.h>
12#include <dm/device-internal.h>
13#include <dm/uclass-internal.h>
Simon Glassd7af6a42014-10-13 23:41:52 -060014#include <dm/lists.h>
15#include <dm/util.h>
16
17DECLARE_GLOBAL_DATA_PTR;
18
Simon Goldschmidt12bfb2e2018-10-30 21:09:48 +010019#define SPI_DEFAULT_SPEED_HZ 100000
20
Simon Glassd7af6a42014-10-13 23:41:52 -060021static 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
Peng Fan7a3eff42016-05-03 10:02:22 +080048int dm_spi_claim_bus(struct udevice *dev)
Simon Glassd7af6a42014-10-13 23:41:52 -060049{
Simon Glassd7af6a42014-10-13 23:41:52 -060050 struct udevice *bus = dev->parent;
51 struct dm_spi_ops *ops = spi_get_ops(bus);
Simon Glasse564f052015-03-05 12:25:20 -070052 struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
Peng Fan7a3eff42016-05-03 10:02:22 +080053 struct spi_slave *slave = dev_get_parent_priv(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -060054 int speed;
Simon Glassd7af6a42014-10-13 23:41:52 -060055
56 speed = slave->max_hz;
57 if (spi->max_hz) {
58 if (speed)
Masahiro Yamadab4141192014-11-07 03:03:31 +090059 speed = min(speed, (int)spi->max_hz);
Simon Glassd7af6a42014-10-13 23:41:52 -060060 else
61 speed = spi->max_hz;
62 }
63 if (!speed)
Simon Goldschmidt12bfb2e2018-10-30 21:09:48 +010064 speed = SPI_DEFAULT_SPEED_HZ;
Simon Glass60e28092015-02-17 15:29:35 -070065 if (speed != slave->speed) {
Mario Six24fc1ec2018-01-15 11:08:41 +010066 int ret = spi_set_speed_mode(bus, speed, slave->mode);
67
Simon Glass60e28092015-02-17 15:29:35 -070068 if (ret)
Simon Glass5e24a2e2018-10-01 12:22:24 -060069 return log_ret(ret);
Simon Glass60e28092015-02-17 15:29:35 -070070 slave->speed = speed;
71 }
Simon Glassd7af6a42014-10-13 23:41:52 -060072
Simon Glass5e24a2e2018-10-01 12:22:24 -060073 return log_ret(ops->claim_bus ? ops->claim_bus(dev) : 0);
Simon Glassd7af6a42014-10-13 23:41:52 -060074}
75
Peng Fan7a3eff42016-05-03 10:02:22 +080076void dm_spi_release_bus(struct udevice *dev)
Simon Glassd7af6a42014-10-13 23:41:52 -060077{
Simon Glassd7af6a42014-10-13 23:41:52 -060078 struct udevice *bus = dev->parent;
79 struct dm_spi_ops *ops = spi_get_ops(bus);
80
81 if (ops->release_bus)
Simon Glass9694b722015-04-19 09:05:40 -060082 ops->release_bus(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -060083}
84
Peng Fan7a3eff42016-05-03 10:02:22 +080085int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
86 const void *dout, void *din, unsigned long flags)
Simon Glassd7af6a42014-10-13 23:41:52 -060087{
Simon Glassd7af6a42014-10-13 23:41:52 -060088 struct udevice *bus = dev->parent;
Simon Glassccdabd82019-12-06 21:42:35 -070089 struct dm_spi_ops *ops = spi_get_ops(bus);
Simon Glassd7af6a42014-10-13 23:41:52 -060090
91 if (bus->uclass->uc_drv->id != UCLASS_SPI)
92 return -EOPNOTSUPP;
Simon Glassccdabd82019-12-06 21:42:35 -070093 if (!ops->xfer)
94 return -ENOSYS;
Simon Glassd7af6a42014-10-13 23:41:52 -060095
Simon Glassccdabd82019-12-06 21:42:35 -070096 return ops->xfer(dev, bitlen, dout, din, flags);
Simon Glassd7af6a42014-10-13 23:41:52 -060097}
98
Simon Glassc53b3182019-10-20 21:31:47 -060099int dm_spi_get_mmap(struct udevice *dev, ulong *map_basep, uint *map_sizep,
100 uint *offsetp)
101{
102 struct udevice *bus = dev->parent;
103 struct dm_spi_ops *ops = spi_get_ops(bus);
104
105 if (bus->uclass->uc_drv->id != UCLASS_SPI)
106 return -EOPNOTSUPP;
107 if (!ops->get_mmap)
108 return -ENOSYS;
109
110 return ops->get_mmap(dev, map_basep, map_sizep, offsetp);
111}
112
Peng Fan7a3eff42016-05-03 10:02:22 +0800113int spi_claim_bus(struct spi_slave *slave)
114{
Simon Glass5e24a2e2018-10-01 12:22:24 -0600115 return log_ret(dm_spi_claim_bus(slave->dev));
Peng Fan7a3eff42016-05-03 10:02:22 +0800116}
117
118void spi_release_bus(struct spi_slave *slave)
119{
120 dm_spi_release_bus(slave->dev);
121}
122
123int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
124 const void *dout, void *din, unsigned long flags)
125{
126 return dm_spi_xfer(slave->dev, bitlen, dout, din, flags);
127}
128
Jagan Teki8473b322019-07-22 17:22:56 +0530129int spi_write_then_read(struct spi_slave *slave, const u8 *opcode,
130 size_t n_opcode, const u8 *txbuf, u8 *rxbuf,
131 size_t n_buf)
132{
133 unsigned long flags = SPI_XFER_BEGIN;
134 int ret;
135
136 if (n_buf == 0)
137 flags |= SPI_XFER_END;
138
139 ret = spi_xfer(slave, n_opcode * 8, opcode, NULL, flags);
140 if (ret) {
141 debug("spi: failed to send command (%zu bytes): %d\n",
142 n_opcode, ret);
143 } else if (n_buf != 0) {
144 ret = spi_xfer(slave, n_buf * 8, txbuf, rxbuf, SPI_XFER_END);
145 if (ret)
146 debug("spi: failed to transfer %zu bytes of data: %d\n",
147 n_buf, ret);
148 }
149
150 return ret;
151}
152
Simon Glass71634f22016-11-13 14:22:01 -0700153#if !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass6f849c32015-06-23 15:39:05 -0600154static int spi_child_post_bind(struct udevice *dev)
Simon Glassd7af6a42014-10-13 23:41:52 -0600155{
Simon Glassd0cff032015-01-25 08:27:12 -0700156 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600157
Simon Glass279e26f2017-05-18 20:09:54 -0600158 if (!dev_of_valid(dev))
Simon Glassd0cff032015-01-25 08:27:12 -0700159 return 0;
160
Simon Glass279e26f2017-05-18 20:09:54 -0600161 return spi_slave_ofdata_to_platdata(dev, plat);
Simon Glassd0cff032015-01-25 08:27:12 -0700162}
Simon Glass71634f22016-11-13 14:22:01 -0700163#endif
Simon Glassd0cff032015-01-25 08:27:12 -0700164
Simon Glass6f849c32015-06-23 15:39:05 -0600165static int spi_post_probe(struct udevice *bus)
Simon Glassd0cff032015-01-25 08:27:12 -0700166{
Simon Glass71634f22016-11-13 14:22:01 -0700167#if !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glasse564f052015-03-05 12:25:20 -0700168 struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
Simon Glassd0cff032015-01-25 08:27:12 -0700169
Simon Glass279e26f2017-05-18 20:09:54 -0600170 spi->max_hz = dev_read_u32_default(bus, "spi-max-frequency", 0);
Simon Glass71634f22016-11-13 14:22:01 -0700171#endif
Michal Simek281f1562015-10-27 13:36:42 +0100172#if defined(CONFIG_NEEDS_MANUAL_RELOC)
173 struct dm_spi_ops *ops = spi_get_ops(bus);
Ashok Reddy Soma4d9b1af2019-09-17 00:11:02 -0600174 static int reloc_done;
Michal Simek281f1562015-10-27 13:36:42 +0100175
Ashok Reddy Soma4d9b1af2019-09-17 00:11:02 -0600176 if (!reloc_done) {
177 if (ops->claim_bus)
178 ops->claim_bus += gd->reloc_off;
179 if (ops->release_bus)
180 ops->release_bus += gd->reloc_off;
181 if (ops->set_wordlen)
182 ops->set_wordlen += gd->reloc_off;
183 if (ops->xfer)
184 ops->xfer += gd->reloc_off;
185 if (ops->set_speed)
186 ops->set_speed += gd->reloc_off;
187 if (ops->set_mode)
188 ops->set_mode += gd->reloc_off;
189 if (ops->cs_info)
190 ops->cs_info += gd->reloc_off;
191 reloc_done++;
192 }
Michal Simek281f1562015-10-27 13:36:42 +0100193#endif
194
Simon Glassd7af6a42014-10-13 23:41:52 -0600195 return 0;
196}
197
Simon Glass6f849c32015-06-23 15:39:05 -0600198static int spi_child_pre_probe(struct udevice *dev)
Simon Glass440714e2015-01-25 08:27:11 -0700199{
Simon Glassd0cff032015-01-25 08:27:12 -0700200 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
Simon Glassbcbe3d12015-09-28 23:32:01 -0600201 struct spi_slave *slave = dev_get_parent_priv(dev);
Simon Glass440714e2015-01-25 08:27:11 -0700202
Simon Glassd0cff032015-01-25 08:27:12 -0700203 /*
204 * This is needed because we pass struct spi_slave around the place
205 * instead slave->dev (a struct udevice). So we have to have some
206 * way to access the slave udevice given struct spi_slave. Once we
207 * change the SPI API to use udevice instead of spi_slave, we can
208 * drop this.
209 */
Simon Glass440714e2015-01-25 08:27:11 -0700210 slave->dev = dev;
211
Simon Glassd0cff032015-01-25 08:27:12 -0700212 slave->max_hz = plat->max_hz;
213 slave->mode = plat->mode;
Christophe Ricard674f3602016-01-17 11:56:48 +0100214 slave->wordlen = SPI_DEFAULT_WORDLEN;
Simon Glassd0cff032015-01-25 08:27:12 -0700215
Simon Glass440714e2015-01-25 08:27:11 -0700216 return 0;
217}
218
Simon Glassd7af6a42014-10-13 23:41:52 -0600219int spi_chip_select(struct udevice *dev)
220{
Simon Glassd0cff032015-01-25 08:27:12 -0700221 struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600222
Simon Glassd0cff032015-01-25 08:27:12 -0700223 return plat ? plat->cs : -ENOENT;
Simon Glassd7af6a42014-10-13 23:41:52 -0600224}
225
Simon Glassff56bba2014-11-11 10:46:22 -0700226int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp)
Simon Glassd7af6a42014-10-13 23:41:52 -0600227{
Bin Meng7bacce52019-09-09 06:00:02 -0700228 struct dm_spi_ops *ops;
229 struct spi_cs_info info;
Simon Glassd7af6a42014-10-13 23:41:52 -0600230 struct udevice *dev;
Bin Meng7bacce52019-09-09 06:00:02 -0700231 int ret;
232
233 /*
234 * Ask the driver. For the moment we don't have CS info.
235 * When we do we could provide the driver with a helper function
236 * to figure out what chip selects are valid, or just handle the
237 * request.
238 */
239 ops = spi_get_ops(bus);
240 if (ops->cs_info) {
241 ret = ops->cs_info(bus, cs, &info);
242 } else {
243 /*
244 * We could assume there is at least one valid chip select.
245 * The driver didn't care enough to tell us.
246 */
247 ret = 0;
248 }
249
250 if (ret) {
251 printf("Invalid cs %d (err=%d)\n", cs, ret);
252 return ret;
253 }
Simon Glassd7af6a42014-10-13 23:41:52 -0600254
255 for (device_find_first_child(bus, &dev); dev;
256 device_find_next_child(&dev)) {
Simon Glassd0cff032015-01-25 08:27:12 -0700257 struct dm_spi_slave_platdata *plat;
Simon Glassd7af6a42014-10-13 23:41:52 -0600258
Simon Glassd0cff032015-01-25 08:27:12 -0700259 plat = dev_get_parent_platdata(dev);
260 debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs);
261 if (plat->cs == cs) {
Simon Glassd7af6a42014-10-13 23:41:52 -0600262 *devp = dev;
263 return 0;
264 }
265 }
266
267 return -ENODEV;
268}
269
270int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
271{
272 struct spi_cs_info info;
273 struct udevice *bus;
274 int ret;
275
276 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
277 if (ret) {
278 debug("%s: No bus %d\n", __func__, busnum);
279 return ret;
280 }
281
282 return spi_cs_info(bus, cs, &info);
283}
284
285int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info)
286{
287 struct spi_cs_info local_info;
Simon Glassd7af6a42014-10-13 23:41:52 -0600288 int ret;
289
290 if (!info)
291 info = &local_info;
292
293 /* If there is a device attached, return it */
294 info->dev = NULL;
295 ret = spi_find_chip_select(bus, cs, &info->dev);
Bin Meng7bacce52019-09-09 06:00:02 -0700296 return ret == -ENODEV ? 0 : ret;
Simon Glassd7af6a42014-10-13 23:41:52 -0600297}
298
Simon Glassd7af6a42014-10-13 23:41:52 -0600299int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
300 struct udevice **devp)
301{
302 struct udevice *bus, *dev;
303 int ret;
304
305 ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
306 if (ret) {
307 debug("%s: No bus %d\n", __func__, busnum);
308 return ret;
309 }
310 ret = spi_find_chip_select(bus, cs, &dev);
311 if (ret) {
312 debug("%s: No cs %d\n", __func__, cs);
313 return ret;
314 }
315 *busp = bus;
316 *devp = dev;
317
318 return ret;
319}
320
321int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
322 const char *drv_name, const char *dev_name,
323 struct udevice **busp, struct spi_slave **devp)
324{
325 struct udevice *bus, *dev;
Vignesh R96907c02016-07-06 10:04:28 +0530326 struct dm_spi_slave_platdata *plat;
Marcin Wojtasf7dd5372019-11-21 05:38:47 +0100327 struct spi_slave *slave;
Simon Glassd7af6a42014-10-13 23:41:52 -0600328 bool created = false;
329 int ret;
330
Thomas Fitzsimmons640abba2019-09-06 07:51:19 -0400331#if CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass71634f22016-11-13 14:22:01 -0700332 ret = uclass_first_device_err(UCLASS_SPI, &bus);
333#else
Simon Glassd7af6a42014-10-13 23:41:52 -0600334 ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
Simon Glass71634f22016-11-13 14:22:01 -0700335#endif
Simon Glassd7af6a42014-10-13 23:41:52 -0600336 if (ret) {
337 printf("Invalid bus %d (err=%d)\n", busnum, ret);
338 return ret;
339 }
340 ret = spi_find_chip_select(bus, cs, &dev);
341
342 /*
343 * If there is no such device, create one automatically. This means
344 * that we don't need a device tree node or platform data for the
345 * SPI flash chip - we will bind to the correct driver.
346 */
347 if (ret == -ENODEV && drv_name) {
348 debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
349 __func__, dev_name, busnum, cs, drv_name);
Simon Glass6b186562014-11-11 10:46:23 -0700350 ret = device_bind_driver(bus, drv_name, dev_name, &dev);
Simon Glass28f98852016-11-13 14:22:05 -0700351 if (ret) {
352 debug("%s: Unable to bind driver (ret=%d)\n", __func__,
353 ret);
Simon Glassd7af6a42014-10-13 23:41:52 -0600354 return ret;
Simon Glass28f98852016-11-13 14:22:05 -0700355 }
Simon Glassd0cff032015-01-25 08:27:12 -0700356 plat = dev_get_parent_platdata(dev);
357 plat->cs = cs;
Simon Goldschmidt12bfb2e2018-10-30 21:09:48 +0100358 if (speed) {
359 plat->max_hz = speed;
360 } else {
361 printf("Warning: SPI speed fallback to %u kHz\n",
362 SPI_DEFAULT_SPEED_HZ / 1000);
363 plat->max_hz = SPI_DEFAULT_SPEED_HZ;
364 }
Simon Glassd0cff032015-01-25 08:27:12 -0700365 plat->mode = mode;
Simon Glassd7af6a42014-10-13 23:41:52 -0600366 created = true;
367 } else if (ret) {
368 printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
369 ret);
370 return ret;
371 }
372
373 if (!device_active(dev)) {
Simon Glassd0cff032015-01-25 08:27:12 -0700374 struct spi_slave *slave;
Simon Glassd7af6a42014-10-13 23:41:52 -0600375
Simon Glassd0cff032015-01-25 08:27:12 -0700376 ret = device_probe(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600377 if (ret)
378 goto err;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600379 slave = dev_get_parent_priv(dev);
Simon Glassd7af6a42014-10-13 23:41:52 -0600380 slave->dev = dev;
Simon Glassd7af6a42014-10-13 23:41:52 -0600381 }
382
Marcin Wojtasf7dd5372019-11-21 05:38:47 +0100383 slave = dev_get_parent_priv(dev);
Patrick Delaunayb0cc1b82019-02-27 15:36:44 +0100384
Marcin Wojtasf7dd5372019-11-21 05:38:47 +0100385 /*
386 * In case the operation speed is not yet established by
387 * dm_spi_claim_bus() ensure the bus is configured properly.
388 */
389 if (!slave->speed) {
390 ret = spi_claim_bus(slave);
391 if (ret)
392 goto err;
Vignesh R96907c02016-07-06 10:04:28 +0530393 }
Simon Glassd7af6a42014-10-13 23:41:52 -0600394
395 *busp = bus;
Marcin Wojtasf7dd5372019-11-21 05:38:47 +0100396 *devp = slave;
Simon Glassd7af6a42014-10-13 23:41:52 -0600397 debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);
398
399 return 0;
400
401err:
Anatolij Gustschinc8864d72016-04-21 09:28:02 +0200402 debug("%s: Error path, created=%d, device '%s'\n", __func__,
Simon Glassd0cff032015-01-25 08:27:12 -0700403 created, dev->name);
Simon Glassd7af6a42014-10-13 23:41:52 -0600404 if (created) {
Stefan Roese706865a2017-03-20 12:51:48 +0100405 device_remove(dev, DM_REMOVE_NORMAL);
Simon Glassd7af6a42014-10-13 23:41:52 -0600406 device_unbind(dev);
407 }
408
409 return ret;
410}
411
412/* Compatibility function - to be removed */
Simon Glassd7af6a42014-10-13 23:41:52 -0600413struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
414 unsigned int speed, unsigned int mode)
415{
416 struct spi_slave *slave;
417 struct udevice *dev;
418 int ret;
419
420 ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
Simon Glass279e26f2017-05-18 20:09:54 -0600421 &slave);
Simon Glassd7af6a42014-10-13 23:41:52 -0600422 if (ret)
423 return NULL;
424
425 return slave;
426}
427
428void spi_free_slave(struct spi_slave *slave)
429{
Stefan Roese706865a2017-03-20 12:51:48 +0100430 device_remove(slave->dev, DM_REMOVE_NORMAL);
Simon Glassd7af6a42014-10-13 23:41:52 -0600431 slave->dev = NULL;
432}
433
Simon Glass279e26f2017-05-18 20:09:54 -0600434int spi_slave_ofdata_to_platdata(struct udevice *dev,
Simon Glassd0cff032015-01-25 08:27:12 -0700435 struct dm_spi_slave_platdata *plat)
Simon Glassd7af6a42014-10-13 23:41:52 -0600436{
Jagan Teki08fe9c22016-08-08 17:12:12 +0530437 int mode = 0;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530438 int value;
Simon Glassd7af6a42014-10-13 23:41:52 -0600439
Simon Glass279e26f2017-05-18 20:09:54 -0600440 plat->cs = dev_read_u32_default(dev, "reg", -1);
Simon Goldschmidt12bfb2e2018-10-30 21:09:48 +0100441 plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency",
442 SPI_DEFAULT_SPEED_HZ);
Simon Glass279e26f2017-05-18 20:09:54 -0600443 if (dev_read_bool(dev, "spi-cpol"))
Simon Glassd7af6a42014-10-13 23:41:52 -0600444 mode |= SPI_CPOL;
Simon Glass279e26f2017-05-18 20:09:54 -0600445 if (dev_read_bool(dev, "spi-cpha"))
Simon Glassd7af6a42014-10-13 23:41:52 -0600446 mode |= SPI_CPHA;
Simon Glass279e26f2017-05-18 20:09:54 -0600447 if (dev_read_bool(dev, "spi-cs-high"))
Simon Glassd7af6a42014-10-13 23:41:52 -0600448 mode |= SPI_CS_HIGH;
Simon Glass279e26f2017-05-18 20:09:54 -0600449 if (dev_read_bool(dev, "spi-3wire"))
Jagan Teki379b49d2015-12-03 22:19:05 +0530450 mode |= SPI_3WIRE;
Simon Glass279e26f2017-05-18 20:09:54 -0600451 if (dev_read_bool(dev, "spi-half-duplex"))
Simon Glassd7af6a42014-10-13 23:41:52 -0600452 mode |= SPI_PREAMBLE;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530453
454 /* Device DUAL/QUAD mode */
Simon Glass279e26f2017-05-18 20:09:54 -0600455 value = dev_read_u32_default(dev, "spi-tx-bus-width", 1);
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530456 switch (value) {
457 case 1:
458 break;
459 case 2:
460 mode |= SPI_TX_DUAL;
461 break;
462 case 4:
463 mode |= SPI_TX_QUAD;
464 break;
Vignesh Raghavendra658df8b2019-12-05 15:46:05 +0530465 case 8:
466 mode |= SPI_TX_OCTAL;
467 break;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530468 default:
Simon Glass1b7c28f2016-11-29 20:00:13 -0700469 warn_non_spl("spi-tx-bus-width %d not supported\n", value);
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530470 break;
471 }
472
Simon Glass279e26f2017-05-18 20:09:54 -0600473 value = dev_read_u32_default(dev, "spi-rx-bus-width", 1);
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530474 switch (value) {
475 case 1:
476 break;
477 case 2:
Jagan Teki08fe9c22016-08-08 17:12:12 +0530478 mode |= SPI_RX_DUAL;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530479 break;
480 case 4:
Jagan Teki08fe9c22016-08-08 17:12:12 +0530481 mode |= SPI_RX_QUAD;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530482 break;
Vignesh Raghavendra658df8b2019-12-05 15:46:05 +0530483 case 8:
484 mode |= SPI_RX_OCTAL;
485 break;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530486 default:
Simon Glass1b7c28f2016-11-29 20:00:13 -0700487 warn_non_spl("spi-rx-bus-width %d not supported\n", value);
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530488 break;
489 }
490
Jagan Teki08fe9c22016-08-08 17:12:12 +0530491 plat->mode = mode;
Mugunthan V Nf8e2f922015-12-23 20:39:37 +0530492
Simon Glassd7af6a42014-10-13 23:41:52 -0600493 return 0;
494}
495
496UCLASS_DRIVER(spi) = {
497 .id = UCLASS_SPI,
498 .name = "spi",
Simon Glass9cc36a22015-01-25 08:27:05 -0700499 .flags = DM_UC_FLAG_SEQ_ALIAS,
Simon Glass71634f22016-11-13 14:22:01 -0700500#if !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass91195482016-07-05 17:10:10 -0600501 .post_bind = dm_scan_fdt_dev,
Simon Glass71634f22016-11-13 14:22:01 -0700502#endif
Simon Glassd7af6a42014-10-13 23:41:52 -0600503 .post_probe = spi_post_probe,
Simon Glass440714e2015-01-25 08:27:11 -0700504 .child_pre_probe = spi_child_pre_probe,
Simon Glassd7af6a42014-10-13 23:41:52 -0600505 .per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
Simon Glass19a25f62015-01-25 08:27:07 -0700506 .per_child_auto_alloc_size = sizeof(struct spi_slave),
Simon Glassd0cff032015-01-25 08:27:12 -0700507 .per_child_platdata_auto_alloc_size =
508 sizeof(struct dm_spi_slave_platdata),
Simon Glass71634f22016-11-13 14:22:01 -0700509#if !CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glassd0cff032015-01-25 08:27:12 -0700510 .child_post_bind = spi_child_post_bind,
Simon Glass71634f22016-11-13 14:22:01 -0700511#endif
Simon Glassd7af6a42014-10-13 23:41:52 -0600512};
513
514UCLASS_DRIVER(spi_generic) = {
515 .id = UCLASS_SPI_GENERIC,
516 .name = "spi_generic",
517};
518
519U_BOOT_DRIVER(spi_generic_drv) = {
520 .name = "spi_generic_drv",
521 .id = UCLASS_SPI_GENERIC,
522};