spi-uclass.c 12 KB

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