uclass.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013 Google, Inc
  4. *
  5. * (C) Copyright 2012
  6. * Pavel Herrmann <morpheus.ibis@gmail.com>
  7. */
  8. #define LOG_CATEGORY LOGC_DM
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <errno.h>
  12. #include <log.h>
  13. #include <malloc.h>
  14. #include <asm/global_data.h>
  15. #include <dm/device.h>
  16. #include <dm/device-internal.h>
  17. #include <dm/lists.h>
  18. #include <dm/uclass.h>
  19. #include <dm/uclass-internal.h>
  20. #include <dm/util.h>
  21. DECLARE_GLOBAL_DATA_PTR;
  22. struct uclass *uclass_find(enum uclass_id key)
  23. {
  24. struct uclass *uc;
  25. if (!gd->dm_root)
  26. return NULL;
  27. /*
  28. * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
  29. * node to the start of the list, or creating a linear array mapping
  30. * id to node.
  31. */
  32. list_for_each_entry(uc, gd->uclass_root, sibling_node) {
  33. if (uc->uc_drv->id == key)
  34. return uc;
  35. }
  36. return NULL;
  37. }
  38. /**
  39. * uclass_add() - Create new uclass in list
  40. * @id: Id number to create
  41. * @ucp: Returns pointer to uclass, or NULL on error
  42. * @return 0 on success, -ve on error
  43. *
  44. * The new uclass is added to the list. There must be only one uclass for
  45. * each id.
  46. */
  47. static int uclass_add(enum uclass_id id, struct uclass **ucp)
  48. {
  49. struct uclass_driver *uc_drv;
  50. struct uclass *uc;
  51. int ret;
  52. *ucp = NULL;
  53. uc_drv = lists_uclass_lookup(id);
  54. if (!uc_drv) {
  55. debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
  56. id);
  57. /*
  58. * Use a strange error to make this case easier to find. When
  59. * a uclass is not available it can prevent driver model from
  60. * starting up and this failure is otherwise hard to debug.
  61. */
  62. return -EPFNOSUPPORT;
  63. }
  64. uc = calloc(1, sizeof(*uc));
  65. if (!uc)
  66. return -ENOMEM;
  67. if (uc_drv->priv_auto) {
  68. void *ptr;
  69. ptr = calloc(1, uc_drv->priv_auto);
  70. if (!ptr) {
  71. ret = -ENOMEM;
  72. goto fail_mem;
  73. }
  74. uclass_set_priv(uc, ptr);
  75. }
  76. uc->uc_drv = uc_drv;
  77. INIT_LIST_HEAD(&uc->sibling_node);
  78. INIT_LIST_HEAD(&uc->dev_head);
  79. list_add(&uc->sibling_node, DM_UCLASS_ROOT_NON_CONST);
  80. if (uc_drv->init) {
  81. ret = uc_drv->init(uc);
  82. if (ret)
  83. goto fail;
  84. }
  85. *ucp = uc;
  86. return 0;
  87. fail:
  88. if (uc_drv->priv_auto) {
  89. free(uclass_get_priv(uc));
  90. uclass_set_priv(uc, NULL);
  91. }
  92. list_del(&uc->sibling_node);
  93. fail_mem:
  94. free(uc);
  95. return ret;
  96. }
  97. int uclass_destroy(struct uclass *uc)
  98. {
  99. struct uclass_driver *uc_drv;
  100. struct udevice *dev;
  101. int ret;
  102. /*
  103. * We cannot use list_for_each_entry_safe() here. If a device in this
  104. * uclass has a child device also in this uclass, it will be also be
  105. * unbound (by the recursion in the call to device_unbind() below).
  106. * We can loop until the list is empty.
  107. */
  108. while (!list_empty(&uc->dev_head)) {
  109. dev = list_first_entry(&uc->dev_head, struct udevice,
  110. uclass_node);
  111. ret = device_remove(dev, DM_REMOVE_NORMAL | DM_REMOVE_NO_PD);
  112. if (ret)
  113. return log_msg_ret("remove", ret);
  114. ret = device_unbind(dev);
  115. if (ret)
  116. return log_msg_ret("unbind", ret);
  117. }
  118. uc_drv = uc->uc_drv;
  119. if (uc_drv->destroy)
  120. uc_drv->destroy(uc);
  121. list_del(&uc->sibling_node);
  122. if (uc_drv->priv_auto)
  123. free(uclass_get_priv(uc));
  124. free(uc);
  125. return 0;
  126. }
  127. int uclass_get(enum uclass_id id, struct uclass **ucp)
  128. {
  129. struct uclass *uc;
  130. /* Immediately fail if driver model is not set up */
  131. if (!gd->uclass_root)
  132. return -EDEADLK;
  133. *ucp = NULL;
  134. uc = uclass_find(id);
  135. if (!uc) {
  136. if (CONFIG_IS_ENABLED(OF_PLATDATA_INST))
  137. return -ENOENT;
  138. return uclass_add(id, ucp);
  139. }
  140. *ucp = uc;
  141. return 0;
  142. }
  143. const char *uclass_get_name(enum uclass_id id)
  144. {
  145. struct uclass *uc;
  146. if (uclass_get(id, &uc))
  147. return NULL;
  148. return uc->uc_drv->name;
  149. }
  150. void *uclass_get_priv(const struct uclass *uc)
  151. {
  152. return uc->priv_;
  153. }
  154. void uclass_set_priv(struct uclass *uc, void *priv)
  155. {
  156. uc->priv_ = priv;
  157. }
  158. enum uclass_id uclass_get_by_name(const char *name)
  159. {
  160. int i;
  161. for (i = 0; i < UCLASS_COUNT; i++) {
  162. struct uclass_driver *uc_drv = lists_uclass_lookup(i);
  163. if (uc_drv && !strcmp(uc_drv->name, name))
  164. return i;
  165. }
  166. return UCLASS_INVALID;
  167. }
  168. int dev_get_uclass_index(struct udevice *dev, struct uclass **ucp)
  169. {
  170. struct udevice *iter;
  171. struct uclass *uc = dev->uclass;
  172. int i = 0;
  173. if (list_empty(&uc->dev_head))
  174. return -ENODEV;
  175. uclass_foreach_dev(iter, uc) {
  176. if (iter == dev) {
  177. if (ucp)
  178. *ucp = uc;
  179. return i;
  180. }
  181. i++;
  182. }
  183. return -ENODEV;
  184. }
  185. int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
  186. {
  187. struct uclass *uc;
  188. struct udevice *dev;
  189. int ret;
  190. *devp = NULL;
  191. ret = uclass_get(id, &uc);
  192. if (ret)
  193. return ret;
  194. if (list_empty(&uc->dev_head))
  195. return -ENODEV;
  196. uclass_foreach_dev(dev, uc) {
  197. if (!index--) {
  198. *devp = dev;
  199. return 0;
  200. }
  201. }
  202. return -ENODEV;
  203. }
  204. int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
  205. {
  206. struct uclass *uc;
  207. int ret;
  208. *devp = NULL;
  209. ret = uclass_get(id, &uc);
  210. if (ret)
  211. return ret;
  212. if (list_empty(&uc->dev_head))
  213. return 0;
  214. *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
  215. return 0;
  216. }
  217. int uclass_find_next_device(struct udevice **devp)
  218. {
  219. struct udevice *dev = *devp;
  220. *devp = NULL;
  221. if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
  222. return 0;
  223. *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
  224. return 0;
  225. }
  226. int uclass_find_device_by_name(enum uclass_id id, const char *name,
  227. struct udevice **devp)
  228. {
  229. struct uclass *uc;
  230. struct udevice *dev;
  231. int ret;
  232. *devp = NULL;
  233. if (!name)
  234. return -EINVAL;
  235. ret = uclass_get(id, &uc);
  236. if (ret)
  237. return ret;
  238. uclass_foreach_dev(dev, uc) {
  239. if (!strcmp(dev->name, name)) {
  240. *devp = dev;
  241. return 0;
  242. }
  243. }
  244. return -ENODEV;
  245. }
  246. int uclass_find_next_free_seq(struct uclass *uc)
  247. {
  248. struct udevice *dev;
  249. int max = -1;
  250. /* If using aliases, start with the highest alias value */
  251. if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
  252. (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS))
  253. max = dev_read_alias_highest_id(uc->uc_drv->name);
  254. /* Avoid conflict with existing devices */
  255. list_for_each_entry(dev, &uc->dev_head, uclass_node) {
  256. if (dev->seq_ > max)
  257. max = dev->seq_;
  258. }
  259. /*
  260. * At this point, max will be -1 if there are no existing aliases or
  261. * devices
  262. */
  263. return max + 1;
  264. }
  265. int uclass_find_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
  266. {
  267. struct uclass *uc;
  268. struct udevice *dev;
  269. int ret;
  270. *devp = NULL;
  271. log_debug("%d\n", seq);
  272. if (seq == -1)
  273. return -ENODEV;
  274. ret = uclass_get(id, &uc);
  275. if (ret)
  276. return ret;
  277. uclass_foreach_dev(dev, uc) {
  278. log_debug(" - %d '%s'\n", dev->seq_, dev->name);
  279. if (dev->seq_ == seq) {
  280. *devp = dev;
  281. log_debug(" - found\n");
  282. return 0;
  283. }
  284. }
  285. log_debug(" - not found\n");
  286. return -ENODEV;
  287. }
  288. int uclass_find_device_by_of_offset(enum uclass_id id, int node,
  289. struct udevice **devp)
  290. {
  291. struct uclass *uc;
  292. struct udevice *dev;
  293. int ret;
  294. *devp = NULL;
  295. if (node < 0)
  296. return -ENODEV;
  297. ret = uclass_get(id, &uc);
  298. if (ret)
  299. return ret;
  300. uclass_foreach_dev(dev, uc) {
  301. if (dev_of_offset(dev) == node) {
  302. *devp = dev;
  303. return 0;
  304. }
  305. }
  306. return -ENODEV;
  307. }
  308. int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
  309. struct udevice **devp)
  310. {
  311. struct uclass *uc;
  312. struct udevice *dev;
  313. int ret;
  314. log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
  315. *devp = NULL;
  316. if (!ofnode_valid(node))
  317. return -ENODEV;
  318. ret = uclass_get(id, &uc);
  319. if (ret)
  320. return ret;
  321. uclass_foreach_dev(dev, uc) {
  322. log(LOGC_DM, LOGL_DEBUG_CONTENT, " - checking %s\n",
  323. dev->name);
  324. if (ofnode_equal(dev_ofnode(dev), node)) {
  325. *devp = dev;
  326. goto done;
  327. }
  328. }
  329. ret = -ENODEV;
  330. done:
  331. log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
  332. ofnode_get_name(node), *devp ? (*devp)->name : "(none)", ret);
  333. return ret;
  334. }
  335. #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
  336. int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent,
  337. const char *name, struct udevice **devp)
  338. {
  339. struct udevice *dev;
  340. struct uclass *uc;
  341. int find_phandle;
  342. int ret;
  343. *devp = NULL;
  344. find_phandle = dev_read_u32_default(parent, name, -1);
  345. if (find_phandle <= 0)
  346. return -ENOENT;
  347. ret = uclass_get(id, &uc);
  348. if (ret)
  349. return ret;
  350. uclass_foreach_dev(dev, uc) {
  351. uint phandle;
  352. phandle = dev_read_phandle(dev);
  353. if (phandle == find_phandle) {
  354. *devp = dev;
  355. return 0;
  356. }
  357. }
  358. return -ENODEV;
  359. }
  360. #endif
  361. int uclass_get_device_by_driver(enum uclass_id id,
  362. const struct driver *find_drv,
  363. struct udevice **devp)
  364. {
  365. struct udevice *dev;
  366. struct uclass *uc;
  367. int ret;
  368. ret = uclass_get(id, &uc);
  369. if (ret)
  370. return ret;
  371. uclass_foreach_dev(dev, uc) {
  372. if (dev->driver == find_drv)
  373. return uclass_get_device_tail(dev, 0, devp);
  374. }
  375. return -ENODEV;
  376. }
  377. int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
  378. {
  379. if (ret)
  380. return ret;
  381. assert(dev);
  382. ret = device_probe(dev);
  383. if (ret)
  384. return ret;
  385. *devp = dev;
  386. return 0;
  387. }
  388. int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
  389. {
  390. struct udevice *dev;
  391. int ret;
  392. *devp = NULL;
  393. ret = uclass_find_device(id, index, &dev);
  394. return uclass_get_device_tail(dev, ret, devp);
  395. }
  396. int uclass_get_device_by_name(enum uclass_id id, const char *name,
  397. struct udevice **devp)
  398. {
  399. struct udevice *dev;
  400. int ret;
  401. *devp = NULL;
  402. ret = uclass_find_device_by_name(id, name, &dev);
  403. return uclass_get_device_tail(dev, ret, devp);
  404. }
  405. int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
  406. {
  407. struct udevice *dev;
  408. int ret;
  409. *devp = NULL;
  410. ret = uclass_find_device_by_seq(id, seq, &dev);
  411. return uclass_get_device_tail(dev, ret, devp);
  412. }
  413. int uclass_get_device_by_of_offset(enum uclass_id id, int node,
  414. struct udevice **devp)
  415. {
  416. struct udevice *dev;
  417. int ret;
  418. *devp = NULL;
  419. ret = uclass_find_device_by_of_offset(id, node, &dev);
  420. return uclass_get_device_tail(dev, ret, devp);
  421. }
  422. int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
  423. struct udevice **devp)
  424. {
  425. struct udevice *dev;
  426. int ret;
  427. log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
  428. *devp = NULL;
  429. ret = uclass_find_device_by_ofnode(id, node, &dev);
  430. log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
  431. ofnode_get_name(node), dev ? dev->name : "(none)", ret);
  432. return uclass_get_device_tail(dev, ret, devp);
  433. }
  434. #if CONFIG_IS_ENABLED(OF_CONTROL)
  435. int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
  436. struct udevice **devp)
  437. {
  438. struct udevice *dev;
  439. struct uclass *uc;
  440. int ret;
  441. *devp = NULL;
  442. ret = uclass_get(id, &uc);
  443. if (ret)
  444. return ret;
  445. uclass_foreach_dev(dev, uc) {
  446. uint phandle;
  447. phandle = dev_read_phandle(dev);
  448. if (phandle == phandle_id) {
  449. *devp = dev;
  450. return uclass_get_device_tail(dev, ret, devp);
  451. }
  452. }
  453. return -ENODEV;
  454. }
  455. int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
  456. const char *name, struct udevice **devp)
  457. {
  458. struct udevice *dev;
  459. int ret;
  460. *devp = NULL;
  461. ret = uclass_find_device_by_phandle(id, parent, name, &dev);
  462. return uclass_get_device_tail(dev, ret, devp);
  463. }
  464. #endif
  465. int uclass_first_device(enum uclass_id id, struct udevice **devp)
  466. {
  467. struct udevice *dev;
  468. int ret;
  469. *devp = NULL;
  470. ret = uclass_find_first_device(id, &dev);
  471. if (!dev)
  472. return 0;
  473. return uclass_get_device_tail(dev, ret, devp);
  474. }
  475. int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
  476. {
  477. int ret;
  478. ret = uclass_first_device(id, devp);
  479. if (ret)
  480. return ret;
  481. else if (!*devp)
  482. return -ENODEV;
  483. return 0;
  484. }
  485. int uclass_next_device(struct udevice **devp)
  486. {
  487. struct udevice *dev = *devp;
  488. int ret;
  489. *devp = NULL;
  490. ret = uclass_find_next_device(&dev);
  491. if (!dev)
  492. return 0;
  493. return uclass_get_device_tail(dev, ret, devp);
  494. }
  495. int uclass_next_device_err(struct udevice **devp)
  496. {
  497. int ret;
  498. ret = uclass_next_device(devp);
  499. if (ret)
  500. return ret;
  501. else if (!*devp)
  502. return -ENODEV;
  503. return 0;
  504. }
  505. int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
  506. {
  507. int ret;
  508. *devp = NULL;
  509. ret = uclass_find_first_device(id, devp);
  510. if (ret)
  511. return ret;
  512. if (!*devp)
  513. return 0;
  514. return device_probe(*devp);
  515. }
  516. int uclass_next_device_check(struct udevice **devp)
  517. {
  518. int ret;
  519. ret = uclass_find_next_device(devp);
  520. if (ret)
  521. return ret;
  522. if (!*devp)
  523. return 0;
  524. return device_probe(*devp);
  525. }
  526. int uclass_first_device_drvdata(enum uclass_id id, ulong driver_data,
  527. struct udevice **devp)
  528. {
  529. struct udevice *dev;
  530. struct uclass *uc;
  531. uclass_id_foreach_dev(id, dev, uc) {
  532. if (dev_get_driver_data(dev) == driver_data) {
  533. *devp = dev;
  534. return device_probe(dev);
  535. }
  536. }
  537. return -ENODEV;
  538. }
  539. int uclass_bind_device(struct udevice *dev)
  540. {
  541. struct uclass *uc;
  542. int ret;
  543. uc = dev->uclass;
  544. list_add_tail(&dev->uclass_node, &uc->dev_head);
  545. if (dev->parent) {
  546. struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
  547. if (uc_drv->child_post_bind) {
  548. ret = uc_drv->child_post_bind(dev);
  549. if (ret)
  550. goto err;
  551. }
  552. }
  553. return 0;
  554. err:
  555. /* There is no need to undo the parent's post_bind call */
  556. list_del(&dev->uclass_node);
  557. return ret;
  558. }
  559. #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
  560. int uclass_unbind_device(struct udevice *dev)
  561. {
  562. struct uclass *uc;
  563. int ret;
  564. uc = dev->uclass;
  565. if (uc->uc_drv->pre_unbind) {
  566. ret = uc->uc_drv->pre_unbind(dev);
  567. if (ret)
  568. return ret;
  569. }
  570. list_del(&dev->uclass_node);
  571. return 0;
  572. }
  573. #endif
  574. int uclass_pre_probe_device(struct udevice *dev)
  575. {
  576. struct uclass_driver *uc_drv;
  577. int ret;
  578. uc_drv = dev->uclass->uc_drv;
  579. if (uc_drv->pre_probe) {
  580. ret = uc_drv->pre_probe(dev);
  581. if (ret)
  582. return ret;
  583. }
  584. if (!dev->parent)
  585. return 0;
  586. uc_drv = dev->parent->uclass->uc_drv;
  587. if (uc_drv->child_pre_probe) {
  588. ret = uc_drv->child_pre_probe(dev);
  589. if (ret)
  590. return ret;
  591. }
  592. return 0;
  593. }
  594. int uclass_post_probe_device(struct udevice *dev)
  595. {
  596. struct uclass_driver *uc_drv;
  597. int ret;
  598. if (dev->parent) {
  599. uc_drv = dev->parent->uclass->uc_drv;
  600. if (uc_drv->child_post_probe) {
  601. ret = uc_drv->child_post_probe(dev);
  602. if (ret)
  603. return ret;
  604. }
  605. }
  606. uc_drv = dev->uclass->uc_drv;
  607. if (uc_drv->post_probe) {
  608. ret = uc_drv->post_probe(dev);
  609. if (ret)
  610. return ret;
  611. }
  612. return 0;
  613. }
  614. #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
  615. int uclass_pre_remove_device(struct udevice *dev)
  616. {
  617. struct uclass *uc;
  618. int ret;
  619. uc = dev->uclass;
  620. if (uc->uc_drv->pre_remove) {
  621. ret = uc->uc_drv->pre_remove(dev);
  622. if (ret)
  623. return ret;
  624. }
  625. return 0;
  626. }
  627. #endif
  628. int uclass_probe_all(enum uclass_id id)
  629. {
  630. struct udevice *dev;
  631. int ret;
  632. ret = uclass_first_device(id, &dev);
  633. if (ret || !dev)
  634. return ret;
  635. /* Scanning uclass to probe all devices */
  636. while (dev) {
  637. ret = uclass_next_device(&dev);
  638. if (ret)
  639. return ret;
  640. }
  641. return 0;
  642. }
  643. UCLASS_DRIVER(nop) = {
  644. .id = UCLASS_NOP,
  645. .name = "nop",
  646. };