domain_governor.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. /*
  2. * drivers/base/power/domain_governor.c - Governors for device PM domains.
  3. *
  4. * Copyright (C) 2011 Rafael J. Wysocki <[email protected]>, Renesas Electronics Corp.
  5. *
  6. * This file is released under the GPLv2.
  7. */
  8. #include <linux/kernel.h>
  9. #include <linux/pm_domain.h>
  10. #include <linux/pm_qos.h>
  11. #include <linux/hrtimer.h>
  12. static int dev_update_qos_constraint(struct device *dev, void *data)
  13. {
  14. s64 *constraint_ns_p = data;
  15. s32 constraint_ns = -1;
  16. if (dev->power.subsys_data && dev->power.subsys_data->domain_data)
  17. constraint_ns = dev_gpd_data(dev)->td.effective_constraint_ns;
  18. if (constraint_ns < 0) {
  19. constraint_ns = dev_pm_qos_read_value(dev);
  20. constraint_ns *= NSEC_PER_USEC;
  21. }
  22. if (constraint_ns == 0)
  23. return 0;
  24. /*
  25. * constraint_ns cannot be negative here, because the device has been
  26. * suspended.
  27. */
  28. if (constraint_ns < *constraint_ns_p || *constraint_ns_p == 0)
  29. *constraint_ns_p = constraint_ns;
  30. return 0;
  31. }
  32. /**
  33. * default_suspend_ok - Default PM domain governor routine to suspend devices.
  34. * @dev: Device to check.
  35. */
  36. static bool default_suspend_ok(struct device *dev)
  37. {
  38. struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
  39. unsigned long flags;
  40. s64 constraint_ns;
  41. dev_dbg(dev, "%s()\n", __func__);
  42. spin_lock_irqsave(&dev->power.lock, flags);
  43. if (!td->constraint_changed) {
  44. bool ret = td->cached_suspend_ok;
  45. spin_unlock_irqrestore(&dev->power.lock, flags);
  46. return ret;
  47. }
  48. td->constraint_changed = false;
  49. td->cached_suspend_ok = false;
  50. td->effective_constraint_ns = -1;
  51. constraint_ns = __dev_pm_qos_read_value(dev);
  52. spin_unlock_irqrestore(&dev->power.lock, flags);
  53. if (constraint_ns < 0)
  54. return false;
  55. constraint_ns *= NSEC_PER_USEC;
  56. /*
  57. * We can walk the children without any additional locking, because
  58. * they all have been suspended at this point and their
  59. * effective_constraint_ns fields won't be modified in parallel with us.
  60. */
  61. if (!dev->power.ignore_children)
  62. device_for_each_child(dev, &constraint_ns,
  63. dev_update_qos_constraint);
  64. if (constraint_ns > 0) {
  65. constraint_ns -= td->suspend_latency_ns +
  66. td->resume_latency_ns;
  67. if (constraint_ns == 0)
  68. return false;
  69. }
  70. td->effective_constraint_ns = constraint_ns;
  71. td->cached_suspend_ok = constraint_ns >= 0;
  72. /*
  73. * The children have been suspended already, so we don't need to take
  74. * their suspend latencies into account here.
  75. */
  76. return td->cached_suspend_ok;
  77. }
  78. /**
  79. * default_power_down_ok - Default generic PM domain power off governor routine.
  80. * @pd: PM domain to check.
  81. *
  82. * This routine must be executed under the PM domain's lock.
  83. */
  84. static bool __default_power_down_ok(struct dev_pm_domain *pd,
  85. unsigned int state)
  86. {
  87. struct generic_pm_domain *genpd = pd_to_genpd(pd);
  88. struct gpd_link *link;
  89. struct pm_domain_data *pdd;
  90. s64 min_off_time_ns;
  91. s64 off_on_time_ns;
  92. off_on_time_ns = genpd->states[state].power_off_latency_ns +
  93. genpd->states[state].power_on_latency_ns;
  94. min_off_time_ns = -1;
  95. /*
  96. * Check if subdomains can be off for enough time.
  97. *
  98. * All subdomains have been powered off already at this point.
  99. */
  100. list_for_each_entry(link, &genpd->master_links, master_node) {
  101. struct generic_pm_domain *sd = link->slave;
  102. s64 sd_max_off_ns = sd->max_off_time_ns;
  103. if (sd_max_off_ns < 0)
  104. continue;
  105. /*
  106. * Check if the subdomain is allowed to be off long enough for
  107. * the current domain to turn off and on (that's how much time
  108. * it will have to wait worst case).
  109. */
  110. if (sd_max_off_ns <= off_on_time_ns)
  111. return false;
  112. if (min_off_time_ns > sd_max_off_ns || min_off_time_ns < 0)
  113. min_off_time_ns = sd_max_off_ns;
  114. }
  115. /*
  116. * Check if the devices in the domain can be off enough time.
  117. */
  118. list_for_each_entry(pdd, &genpd->dev_list, list_node) {
  119. struct gpd_timing_data *td;
  120. s64 constraint_ns;
  121. /*
  122. * Check if the device is allowed to be off long enough for the
  123. * domain to turn off and on (that's how much time it will
  124. * have to wait worst case).
  125. */
  126. td = &to_gpd_data(pdd)->td;
  127. constraint_ns = td->effective_constraint_ns;
  128. /* default_suspend_ok() need not be called before us. */
  129. if (constraint_ns < 0) {
  130. constraint_ns = dev_pm_qos_read_value(pdd->dev);
  131. constraint_ns *= NSEC_PER_USEC;
  132. }
  133. if (constraint_ns == 0)
  134. continue;
  135. /*
  136. * constraint_ns cannot be negative here, because the device has
  137. * been suspended.
  138. */
  139. if (constraint_ns <= off_on_time_ns)
  140. return false;
  141. if (min_off_time_ns > constraint_ns || min_off_time_ns < 0)
  142. min_off_time_ns = constraint_ns;
  143. }
  144. /*
  145. * If the computed minimum device off time is negative, there are no
  146. * latency constraints, so the domain can spend arbitrary time in the
  147. * "off" state.
  148. */
  149. if (min_off_time_ns < 0)
  150. return true;
  151. /*
  152. * The difference between the computed minimum subdomain or device off
  153. * time and the time needed to turn the domain on is the maximum
  154. * theoretical time this domain can spend in the "off" state.
  155. */
  156. genpd->max_off_time_ns = min_off_time_ns -
  157. genpd->states[state].power_on_latency_ns;
  158. return true;
  159. }
  160. static bool default_power_down_ok(struct dev_pm_domain *pd)
  161. {
  162. struct generic_pm_domain *genpd = pd_to_genpd(pd);
  163. struct gpd_link *link;
  164. if (!genpd->max_off_time_changed)
  165. return genpd->cached_power_down_ok;
  166. /*
  167. * We have to invalidate the cached results for the masters, so
  168. * use the observation that default_power_down_ok() is not
  169. * going to be called for any master until this instance
  170. * returns.
  171. */
  172. list_for_each_entry(link, &genpd->slave_links, slave_node)
  173. link->master->max_off_time_changed = true;
  174. genpd->max_off_time_ns = -1;
  175. genpd->max_off_time_changed = false;
  176. genpd->cached_power_down_ok = true;
  177. genpd->state_idx = genpd->state_count - 1;
  178. /* Find a state to power down to, starting from the deepest. */
  179. while (!__default_power_down_ok(pd, genpd->state_idx)) {
  180. if (genpd->state_idx == 0) {
  181. genpd->cached_power_down_ok = false;
  182. break;
  183. }
  184. genpd->state_idx--;
  185. }
  186. return genpd->cached_power_down_ok;
  187. }
  188. static bool always_on_power_down_ok(struct dev_pm_domain *domain)
  189. {
  190. return false;
  191. }
  192. struct dev_power_governor simple_qos_governor = {
  193. .suspend_ok = default_suspend_ok,
  194. .power_down_ok = default_power_down_ok,
  195. };
  196. /**
  197. * pm_genpd_gov_always_on - A governor implementing an always-on policy
  198. */
  199. struct dev_power_governor pm_domain_always_on_gov = {
  200. .power_down_ok = always_on_power_down_ok,
  201. .suspend_ok = default_suspend_ok,
  202. };