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