power-domain-uclass.c 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2016, NVIDIA CORPORATION.
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <log.h>
  8. #include <malloc.h>
  9. #include <power-domain.h>
  10. #include <power-domain-uclass.h>
  11. #include <dm/device-internal.h>
  12. static inline struct power_domain_ops *power_domain_dev_ops(struct udevice *dev)
  13. {
  14. return (struct power_domain_ops *)dev->driver->ops;
  15. }
  16. static int power_domain_of_xlate_default(struct power_domain *power_domain,
  17. struct ofnode_phandle_args *args)
  18. {
  19. debug("%s(power_domain=%p)\n", __func__, power_domain);
  20. if (args->args_count != 1) {
  21. debug("Invalid args_count: %d\n", args->args_count);
  22. return -EINVAL;
  23. }
  24. power_domain->id = args->args[0];
  25. return 0;
  26. }
  27. int power_domain_get_by_index(struct udevice *dev,
  28. struct power_domain *power_domain, int index)
  29. {
  30. struct ofnode_phandle_args args;
  31. int ret;
  32. struct udevice *dev_power_domain;
  33. struct power_domain_ops *ops;
  34. debug("%s(dev=%p, power_domain=%p)\n", __func__, dev, power_domain);
  35. ret = dev_read_phandle_with_args(dev, "power-domains",
  36. "#power-domain-cells", 0, index,
  37. &args);
  38. if (ret) {
  39. debug("%s: dev_read_phandle_with_args failed: %d\n",
  40. __func__, ret);
  41. return ret;
  42. }
  43. ret = uclass_get_device_by_ofnode(UCLASS_POWER_DOMAIN, args.node,
  44. &dev_power_domain);
  45. if (ret) {
  46. debug("%s: uclass_get_device_by_ofnode failed: %d\n",
  47. __func__, ret);
  48. return ret;
  49. }
  50. ops = power_domain_dev_ops(dev_power_domain);
  51. power_domain->dev = dev_power_domain;
  52. if (ops->of_xlate)
  53. ret = ops->of_xlate(power_domain, &args);
  54. else
  55. ret = power_domain_of_xlate_default(power_domain, &args);
  56. if (ret) {
  57. debug("of_xlate() failed: %d\n", ret);
  58. return ret;
  59. }
  60. ret = ops->request(power_domain);
  61. if (ret) {
  62. debug("ops->request() failed: %d\n", ret);
  63. return ret;
  64. }
  65. return 0;
  66. }
  67. int power_domain_get(struct udevice *dev, struct power_domain *power_domain)
  68. {
  69. return power_domain_get_by_index(dev, power_domain, 0);
  70. }
  71. int power_domain_free(struct power_domain *power_domain)
  72. {
  73. struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
  74. debug("%s(power_domain=%p)\n", __func__, power_domain);
  75. return ops->rfree(power_domain);
  76. }
  77. int power_domain_on(struct power_domain *power_domain)
  78. {
  79. struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
  80. debug("%s(power_domain=%p)\n", __func__, power_domain);
  81. return ops->on(power_domain);
  82. }
  83. int power_domain_off(struct power_domain *power_domain)
  84. {
  85. struct power_domain_ops *ops = power_domain_dev_ops(power_domain->dev);
  86. debug("%s(power_domain=%p)\n", __func__, power_domain);
  87. return ops->off(power_domain);
  88. }
  89. #if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA))
  90. static int dev_power_domain_ctrl(struct udevice *dev, bool on)
  91. {
  92. struct power_domain pd;
  93. int i, count, ret = 0;
  94. count = dev_count_phandle_with_args(dev, "power-domains",
  95. "#power-domain-cells");
  96. for (i = 0; i < count; i++) {
  97. ret = power_domain_get_by_index(dev, &pd, i);
  98. if (ret)
  99. return ret;
  100. if (on)
  101. ret = power_domain_on(&pd);
  102. else
  103. ret = power_domain_off(&pd);
  104. }
  105. /*
  106. * For platforms with parent and child power-domain devices
  107. * we may not run device_remove() on the power-domain parent
  108. * because it will result in removing its children and switching
  109. * off their power-domain parent. So we will get here again and
  110. * again and will be stuck in an endless loop.
  111. */
  112. if (!on && dev_get_parent(dev) == pd.dev &&
  113. device_get_uclass_id(dev) == UCLASS_POWER_DOMAIN)
  114. return ret;
  115. /*
  116. * power_domain_get() bound the device, thus
  117. * we must remove it again to prevent unbinding
  118. * active devices (which would result in unbind
  119. * error).
  120. */
  121. if (count > 0 && !on)
  122. device_remove(pd.dev, DM_REMOVE_NORMAL);
  123. return ret;
  124. }
  125. int dev_power_domain_on(struct udevice *dev)
  126. {
  127. return dev_power_domain_ctrl(dev, true);
  128. }
  129. int dev_power_domain_off(struct udevice *dev)
  130. {
  131. return dev_power_domain_ctrl(dev, false);
  132. }
  133. #endif
  134. UCLASS_DRIVER(power_domain) = {
  135. .id = UCLASS_POWER_DOMAIN,
  136. .name = "power_domain",
  137. };