spi-uclass.c 11 KB

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