device-remove.c 3.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207
  1. /*
  2. * Device manager
  3. *
  4. * Copyright (c) 2014 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 <errno.h>
  13. #include <malloc.h>
  14. #include <dm/device.h>
  15. #include <dm/device-internal.h>
  16. #include <dm/uclass.h>
  17. #include <dm/uclass-internal.h>
  18. #include <dm/util.h>
  19. /**
  20. * device_chld_unbind() - Unbind all device's children from the device
  21. *
  22. * On error, the function continues to unbind all children, and reports the
  23. * first error.
  24. *
  25. * @dev: The device that is to be stripped of its children
  26. * @return 0 on success, -ve on error
  27. */
  28. static int device_chld_unbind(struct udevice *dev)
  29. {
  30. struct udevice *pos, *n;
  31. int ret, saved_ret = 0;
  32. assert(dev);
  33. list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
  34. ret = device_unbind(pos);
  35. if (ret && !saved_ret)
  36. saved_ret = ret;
  37. }
  38. return saved_ret;
  39. }
  40. /**
  41. * device_chld_remove() - Stop all device's children
  42. * @dev: The device whose children are to be removed
  43. * @return 0 on success, -ve on error
  44. */
  45. static int device_chld_remove(struct udevice *dev)
  46. {
  47. struct udevice *pos, *n;
  48. int ret;
  49. assert(dev);
  50. list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
  51. ret = device_remove(pos);
  52. if (ret)
  53. return ret;
  54. }
  55. return 0;
  56. }
  57. int device_unbind(struct udevice *dev)
  58. {
  59. const struct driver *drv;
  60. int ret;
  61. if (!dev)
  62. return -EINVAL;
  63. if (dev->flags & DM_FLAG_ACTIVATED)
  64. return -EINVAL;
  65. if (!(dev->flags & DM_FLAG_BOUND))
  66. return -EINVAL;
  67. drv = dev->driver;
  68. assert(drv);
  69. if (drv->unbind) {
  70. ret = drv->unbind(dev);
  71. if (ret)
  72. return ret;
  73. }
  74. ret = device_chld_unbind(dev);
  75. if (ret)
  76. return ret;
  77. if (dev->flags & DM_FLAG_ALLOC_PDATA) {
  78. free(dev->platdata);
  79. dev->platdata = NULL;
  80. }
  81. if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
  82. free(dev->uclass_platdata);
  83. dev->uclass_platdata = NULL;
  84. }
  85. if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
  86. free(dev->parent_platdata);
  87. dev->parent_platdata = NULL;
  88. }
  89. ret = uclass_unbind_device(dev);
  90. if (ret)
  91. return ret;
  92. if (dev->parent)
  93. list_del(&dev->sibling_node);
  94. devres_release_all(dev);
  95. free(dev);
  96. return 0;
  97. }
  98. /**
  99. * device_free() - Free memory buffers allocated by a device
  100. * @dev: Device that is to be started
  101. */
  102. void device_free(struct udevice *dev)
  103. {
  104. int size;
  105. if (dev->driver->priv_auto_alloc_size) {
  106. free(dev->priv);
  107. dev->priv = NULL;
  108. }
  109. size = dev->uclass->uc_drv->per_device_auto_alloc_size;
  110. if (size) {
  111. free(dev->uclass_priv);
  112. dev->uclass_priv = NULL;
  113. }
  114. if (dev->parent) {
  115. size = dev->parent->driver->per_child_auto_alloc_size;
  116. if (!size) {
  117. size = dev->parent->uclass->uc_drv->
  118. per_child_auto_alloc_size;
  119. }
  120. if (size) {
  121. free(dev->parent_priv);
  122. dev->parent_priv = NULL;
  123. }
  124. }
  125. devres_release_probe(dev);
  126. }
  127. int device_remove(struct udevice *dev)
  128. {
  129. const struct driver *drv;
  130. int ret;
  131. if (!dev)
  132. return -EINVAL;
  133. if (!(dev->flags & DM_FLAG_ACTIVATED))
  134. return 0;
  135. drv = dev->driver;
  136. assert(drv);
  137. ret = uclass_pre_remove_device(dev);
  138. if (ret)
  139. return ret;
  140. ret = device_chld_remove(dev);
  141. if (ret)
  142. goto err;
  143. if (drv->remove) {
  144. ret = drv->remove(dev);
  145. if (ret)
  146. goto err_remove;
  147. }
  148. if (dev->parent && dev->parent->driver->child_post_remove) {
  149. ret = dev->parent->driver->child_post_remove(dev);
  150. if (ret) {
  151. dm_warn("%s: Device '%s' failed child_post_remove()",
  152. __func__, dev->name);
  153. }
  154. }
  155. device_free(dev);
  156. dev->seq = -1;
  157. dev->flags &= ~DM_FLAG_ACTIVATED;
  158. return ret;
  159. err_remove:
  160. /* We can't put the children back */
  161. dm_warn("%s: Device '%s' failed to remove, but children are gone\n",
  162. __func__, dev->name);
  163. err:
  164. ret = uclass_post_probe_device(dev);
  165. if (ret) {
  166. dm_warn("%s: Device '%s' failed to post_probe on error path\n",
  167. __func__, dev->name);
  168. }
  169. return ret;
  170. }