device.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392
  1. /*
  2. * Device manager
  3. *
  4. * Copyright (c) 2013 Google, Inc
  5. *
  6. * (C) Copyright 2012
  7. * Pavel Herrmann <morpheus.ibis@gmail.com>
  8. *
  9. * SPDX-License-Identifier: GPL-2.0+
  10. */
  11. #include <common.h>
  12. #include <fdtdec.h>
  13. #include <malloc.h>
  14. #include <dm/device.h>
  15. #include <dm/device-internal.h>
  16. #include <dm/lists.h>
  17. #include <dm/platdata.h>
  18. #include <dm/uclass.h>
  19. #include <dm/uclass-internal.h>
  20. #include <dm/util.h>
  21. #include <linux/err.h>
  22. #include <linux/list.h>
  23. DECLARE_GLOBAL_DATA_PTR;
  24. int device_bind(struct udevice *parent, struct driver *drv, const char *name,
  25. void *platdata, int of_offset, struct udevice **devp)
  26. {
  27. struct udevice *dev;
  28. struct uclass *uc;
  29. int ret = 0;
  30. *devp = NULL;
  31. if (!name)
  32. return -EINVAL;
  33. ret = uclass_get(drv->id, &uc);
  34. if (ret)
  35. return ret;
  36. dev = calloc(1, sizeof(struct udevice));
  37. if (!dev)
  38. return -ENOMEM;
  39. INIT_LIST_HEAD(&dev->sibling_node);
  40. INIT_LIST_HEAD(&dev->child_head);
  41. INIT_LIST_HEAD(&dev->uclass_node);
  42. dev->platdata = platdata;
  43. dev->name = name;
  44. dev->of_offset = of_offset;
  45. dev->parent = parent;
  46. dev->driver = drv;
  47. dev->uclass = uc;
  48. /*
  49. * For some devices, such as a SPI or I2C bus, the 'reg' property
  50. * is a reasonable indicator of the sequence number. But if there is
  51. * an alias, we use that in preference. In any case, this is just
  52. * a 'requested' sequence, and will be resolved (and ->seq updated)
  53. * when the device is probed.
  54. */
  55. dev->seq = -1;
  56. #ifdef CONFIG_OF_CONTROL
  57. dev->req_seq = fdtdec_get_int(gd->fdt_blob, of_offset, "reg", -1);
  58. if (!IS_ERR_VALUE(dev->req_seq))
  59. dev->req_seq &= INT_MAX;
  60. if (uc->uc_drv->name && of_offset != -1) {
  61. fdtdec_get_alias_seq(gd->fdt_blob, uc->uc_drv->name, of_offset,
  62. &dev->req_seq);
  63. }
  64. #else
  65. dev->req_seq = -1;
  66. #endif
  67. if (!dev->platdata && drv->platdata_auto_alloc_size)
  68. dev->flags |= DM_FLAG_ALLOC_PDATA;
  69. /* put dev into parent's successor list */
  70. if (parent)
  71. list_add_tail(&dev->sibling_node, &parent->child_head);
  72. ret = uclass_bind_device(dev);
  73. if (ret)
  74. goto fail_bind;
  75. /* if we fail to bind we remove device from successors and free it */
  76. if (drv->bind) {
  77. ret = drv->bind(dev);
  78. if (ret) {
  79. if (uclass_unbind_device(dev)) {
  80. dm_warn("Failed to unbind dev '%s' on error path\n",
  81. dev->name);
  82. }
  83. goto fail_bind;
  84. }
  85. }
  86. if (parent)
  87. dm_dbg("Bound device %s to %s\n", dev->name, parent->name);
  88. *devp = dev;
  89. return 0;
  90. fail_bind:
  91. list_del(&dev->sibling_node);
  92. free(dev);
  93. return ret;
  94. }
  95. int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
  96. const struct driver_info *info, struct udevice **devp)
  97. {
  98. struct driver *drv;
  99. drv = lists_driver_lookup_name(info->name);
  100. if (!drv)
  101. return -ENOENT;
  102. if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
  103. return -EPERM;
  104. return device_bind(parent, drv, info->name, (void *)info->platdata,
  105. -1, devp);
  106. }
  107. int device_probe_child(struct udevice *dev, void *parent_priv)
  108. {
  109. struct driver *drv;
  110. int size = 0;
  111. int ret;
  112. int seq;
  113. if (!dev)
  114. return -EINVAL;
  115. if (dev->flags & DM_FLAG_ACTIVATED)
  116. return 0;
  117. drv = dev->driver;
  118. assert(drv);
  119. /* Allocate private data and platdata if requested */
  120. if (drv->priv_auto_alloc_size) {
  121. dev->priv = calloc(1, drv->priv_auto_alloc_size);
  122. if (!dev->priv) {
  123. ret = -ENOMEM;
  124. goto fail;
  125. }
  126. }
  127. /* Allocate private data if requested */
  128. if (dev->flags & DM_FLAG_ALLOC_PDATA) {
  129. dev->platdata = calloc(1, drv->platdata_auto_alloc_size);
  130. if (!dev->platdata) {
  131. ret = -ENOMEM;
  132. goto fail;
  133. }
  134. }
  135. size = dev->uclass->uc_drv->per_device_auto_alloc_size;
  136. if (size) {
  137. dev->uclass_priv = calloc(1, size);
  138. if (!dev->uclass_priv) {
  139. ret = -ENOMEM;
  140. goto fail;
  141. }
  142. }
  143. /* Ensure all parents are probed */
  144. if (dev->parent) {
  145. size = dev->parent->driver->per_child_auto_alloc_size;
  146. if (size) {
  147. dev->parent_priv = calloc(1, size);
  148. if (!dev->parent_priv) {
  149. ret = -ENOMEM;
  150. goto fail;
  151. }
  152. if (parent_priv)
  153. memcpy(dev->parent_priv, parent_priv, size);
  154. }
  155. ret = device_probe(dev->parent);
  156. if (ret)
  157. goto fail;
  158. }
  159. seq = uclass_resolve_seq(dev);
  160. if (seq < 0) {
  161. ret = seq;
  162. goto fail;
  163. }
  164. dev->seq = seq;
  165. if (dev->parent && dev->parent->driver->child_pre_probe) {
  166. ret = dev->parent->driver->child_pre_probe(dev);
  167. if (ret)
  168. goto fail;
  169. }
  170. if (drv->ofdata_to_platdata && dev->of_offset >= 0) {
  171. ret = drv->ofdata_to_platdata(dev);
  172. if (ret)
  173. goto fail;
  174. }
  175. if (drv->probe) {
  176. ret = drv->probe(dev);
  177. if (ret)
  178. goto fail;
  179. }
  180. dev->flags |= DM_FLAG_ACTIVATED;
  181. ret = uclass_post_probe_device(dev);
  182. if (ret) {
  183. dev->flags &= ~DM_FLAG_ACTIVATED;
  184. goto fail_uclass;
  185. }
  186. return 0;
  187. fail_uclass:
  188. if (device_remove(dev)) {
  189. dm_warn("%s: Device '%s' failed to remove on error path\n",
  190. __func__, dev->name);
  191. }
  192. fail:
  193. dev->seq = -1;
  194. device_free(dev);
  195. return ret;
  196. }
  197. int device_probe(struct udevice *dev)
  198. {
  199. return device_probe_child(dev, NULL);
  200. }
  201. void *dev_get_platdata(struct udevice *dev)
  202. {
  203. if (!dev) {
  204. dm_warn("%s: null device\n", __func__);
  205. return NULL;
  206. }
  207. return dev->platdata;
  208. }
  209. void *dev_get_priv(struct udevice *dev)
  210. {
  211. if (!dev) {
  212. dm_warn("%s: null device\n", __func__);
  213. return NULL;
  214. }
  215. return dev->priv;
  216. }
  217. void *dev_get_parentdata(struct udevice *dev)
  218. {
  219. if (!dev) {
  220. dm_warn("%s: null device\n", __func__);
  221. return NULL;
  222. }
  223. return dev->parent_priv;
  224. }
  225. static int device_get_device_tail(struct udevice *dev, int ret,
  226. struct udevice **devp)
  227. {
  228. if (ret)
  229. return ret;
  230. ret = device_probe(dev);
  231. if (ret)
  232. return ret;
  233. *devp = dev;
  234. return 0;
  235. }
  236. int device_get_child(struct udevice *parent, int index, struct udevice **devp)
  237. {
  238. struct udevice *dev;
  239. list_for_each_entry(dev, &parent->child_head, sibling_node) {
  240. if (!index--)
  241. return device_get_device_tail(dev, 0, devp);
  242. }
  243. return -ENODEV;
  244. }
  245. int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
  246. bool find_req_seq, struct udevice **devp)
  247. {
  248. struct udevice *dev;
  249. *devp = NULL;
  250. if (seq_or_req_seq == -1)
  251. return -ENODEV;
  252. list_for_each_entry(dev, &parent->child_head, sibling_node) {
  253. if ((find_req_seq ? dev->req_seq : dev->seq) ==
  254. seq_or_req_seq) {
  255. *devp = dev;
  256. return 0;
  257. }
  258. }
  259. return -ENODEV;
  260. }
  261. int device_get_child_by_seq(struct udevice *parent, int seq,
  262. struct udevice **devp)
  263. {
  264. struct udevice *dev;
  265. int ret;
  266. *devp = NULL;
  267. ret = device_find_child_by_seq(parent, seq, false, &dev);
  268. if (ret == -ENODEV) {
  269. /*
  270. * We didn't find it in probed devices. See if there is one
  271. * that will request this seq if probed.
  272. */
  273. ret = device_find_child_by_seq(parent, seq, true, &dev);
  274. }
  275. return device_get_device_tail(dev, ret, devp);
  276. }
  277. int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
  278. struct udevice **devp)
  279. {
  280. struct udevice *dev;
  281. *devp = NULL;
  282. list_for_each_entry(dev, &parent->child_head, sibling_node) {
  283. if (dev->of_offset == of_offset) {
  284. *devp = dev;
  285. return 0;
  286. }
  287. }
  288. return -ENODEV;
  289. }
  290. int device_get_child_by_of_offset(struct udevice *parent, int seq,
  291. struct udevice **devp)
  292. {
  293. struct udevice *dev;
  294. int ret;
  295. *devp = NULL;
  296. ret = device_find_child_by_of_offset(parent, seq, &dev);
  297. return device_get_device_tail(dev, ret, devp);
  298. }
  299. int device_find_first_child(struct udevice *parent, struct udevice **devp)
  300. {
  301. if (list_empty(&parent->child_head)) {
  302. *devp = NULL;
  303. } else {
  304. *devp = list_first_entry(&parent->child_head, struct udevice,
  305. sibling_node);
  306. }
  307. return 0;
  308. }
  309. int device_find_next_child(struct udevice **devp)
  310. {
  311. struct udevice *dev = *devp;
  312. struct udevice *parent = dev->parent;
  313. if (list_is_last(&dev->sibling_node, &parent->child_head)) {
  314. *devp = NULL;
  315. } else {
  316. *devp = list_entry(dev->sibling_node.next, struct udevice,
  317. sibling_node);
  318. }
  319. return 0;
  320. }
  321. struct udevice *dev_get_parent(struct udevice *child)
  322. {
  323. return child->parent;
  324. }
  325. ulong dev_get_of_data(struct udevice *dev)
  326. {
  327. return dev->of_id->data;
  328. }