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