diff options
Diffstat (limited to 'kernel/power/qos.c')
-rw-r--r-- | kernel/power/qos.c | 490 |
1 files changed, 490 insertions, 0 deletions
diff --git a/kernel/power/qos.c b/kernel/power/qos.c new file mode 100644 index 00000000000..1c1797dd1d1 --- /dev/null +++ b/kernel/power/qos.c | |||
@@ -0,0 +1,490 @@ | |||
1 | /* | ||
2 | * This module exposes the interface to kernel space for specifying | ||
3 | * QoS dependencies. It provides infrastructure for registration of: | ||
4 | * | ||
5 | * Dependents on a QoS value : register requests | ||
6 | * Watchers of QoS value : get notified when target QoS value changes | ||
7 | * | ||
8 | * This QoS design is best effort based. Dependents register their QoS needs. | ||
9 | * Watchers register to keep track of the current QoS needs of the system. | ||
10 | * | ||
11 | * There are 3 basic classes of QoS parameter: latency, timeout, throughput | ||
12 | * each have defined units: | ||
13 | * latency: usec | ||
14 | * timeout: usec <-- currently not used. | ||
15 | * throughput: kbs (kilo byte / sec) | ||
16 | * | ||
17 | * There are lists of pm_qos_objects each one wrapping requests, notifiers | ||
18 | * | ||
19 | * User mode requests on a QOS parameter register themselves to the | ||
20 | * subsystem by opening the device node /dev/... and writing there request to | ||
21 | * the node. As long as the process holds a file handle open to the node the | ||
22 | * client continues to be accounted for. Upon file release the usermode | ||
23 | * request is removed and a new qos target is computed. This way when the | ||
24 | * request that the application has is cleaned up when closes the file | ||
25 | * pointer or exits the pm_qos_object will get an opportunity to clean up. | ||
26 | * | ||
27 | * Mark Gross <mgross@linux.intel.com> | ||
28 | */ | ||
29 | |||
30 | /*#define DEBUG*/ | ||
31 | |||
32 | #include <linux/pm_qos.h> | ||
33 | #include <linux/sched.h> | ||
34 | #include <linux/spinlock.h> | ||
35 | #include <linux/slab.h> | ||
36 | #include <linux/time.h> | ||
37 | #include <linux/fs.h> | ||
38 | #include <linux/device.h> | ||
39 | #include <linux/miscdevice.h> | ||
40 | #include <linux/string.h> | ||
41 | #include <linux/platform_device.h> | ||
42 | #include <linux/init.h> | ||
43 | #include <linux/kernel.h> | ||
44 | |||
45 | #include <linux/uaccess.h> | ||
46 | |||
47 | /* | ||
48 | * locking rule: all changes to constraints or notifiers lists | ||
49 | * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock | ||
50 | * held, taken with _irqsave. One lock to rule them all | ||
51 | */ | ||
52 | struct pm_qos_object { | ||
53 | struct pm_qos_constraints *constraints; | ||
54 | struct miscdevice pm_qos_power_miscdev; | ||
55 | char *name; | ||
56 | }; | ||
57 | |||
58 | static DEFINE_SPINLOCK(pm_qos_lock); | ||
59 | |||
60 | static struct pm_qos_object null_pm_qos; | ||
61 | |||
62 | static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier); | ||
63 | static struct pm_qos_constraints cpu_dma_constraints = { | ||
64 | .list = PLIST_HEAD_INIT(cpu_dma_constraints.list), | ||
65 | .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE, | ||
66 | .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE, | ||
67 | .type = PM_QOS_MIN, | ||
68 | .notifiers = &cpu_dma_lat_notifier, | ||
69 | }; | ||
70 | static struct pm_qos_object cpu_dma_pm_qos = { | ||
71 | .constraints = &cpu_dma_constraints, | ||
72 | }; | ||
73 | |||
74 | static BLOCKING_NOTIFIER_HEAD(network_lat_notifier); | ||
75 | static struct pm_qos_constraints network_lat_constraints = { | ||
76 | .list = PLIST_HEAD_INIT(network_lat_constraints.list), | ||
77 | .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE, | ||
78 | .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE, | ||
79 | .type = PM_QOS_MIN, | ||
80 | .notifiers = &network_lat_notifier, | ||
81 | }; | ||
82 | static struct pm_qos_object network_lat_pm_qos = { | ||
83 | .constraints = &network_lat_constraints, | ||
84 | .name = "network_latency", | ||
85 | }; | ||
86 | |||
87 | |||
88 | static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier); | ||
89 | static struct pm_qos_constraints network_tput_constraints = { | ||
90 | .list = PLIST_HEAD_INIT(network_tput_constraints.list), | ||
91 | .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE, | ||
92 | .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE, | ||
93 | .type = PM_QOS_MAX, | ||
94 | .notifiers = &network_throughput_notifier, | ||
95 | }; | ||
96 | static struct pm_qos_object network_throughput_pm_qos = { | ||
97 | .constraints = &network_tput_constraints, | ||
98 | .name = "network_throughput", | ||
99 | }; | ||
100 | |||
101 | |||
102 | static struct pm_qos_object *pm_qos_array[] = { | ||
103 | &null_pm_qos, | ||
104 | &cpu_dma_pm_qos, | ||
105 | &network_lat_pm_qos, | ||
106 | &network_throughput_pm_qos | ||
107 | }; | ||
108 | |||
109 | static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf, | ||
110 | size_t count, loff_t *f_pos); | ||
111 | static ssize_t pm_qos_power_read(struct file *filp, char __user *buf, | ||
112 | size_t count, loff_t *f_pos); | ||
113 | static int pm_qos_power_open(struct inode *inode, struct file *filp); | ||
114 | static int pm_qos_power_release(struct inode *inode, struct file *filp); | ||
115 | |||
116 | static const struct file_operations pm_qos_power_fops = { | ||
117 | .write = pm_qos_power_write, | ||
118 | .read = pm_qos_power_read, | ||
119 | .open = pm_qos_power_open, | ||
120 | .release = pm_qos_power_release, | ||
121 | .llseek = noop_llseek, | ||
122 | }; | ||
123 | |||
124 | /* unlocked internal variant */ | ||
125 | static inline int pm_qos_get_value(struct pm_qos_constraints *c) | ||
126 | { | ||
127 | if (plist_head_empty(&c->list)) | ||
128 | return c->default_value; | ||
129 | |||
130 | switch (c->type) { | ||
131 | case PM_QOS_MIN: | ||
132 | return plist_first(&c->list)->prio; | ||
133 | |||
134 | case PM_QOS_MAX: | ||
135 | return plist_last(&c->list)->prio; | ||
136 | |||
137 | default: | ||
138 | /* runtime check for not using enum */ | ||
139 | BUG(); | ||
140 | } | ||
141 | } | ||
142 | |||
143 | s32 pm_qos_read_value(struct pm_qos_constraints *c) | ||
144 | { | ||
145 | return c->target_value; | ||
146 | } | ||
147 | |||
148 | static inline void pm_qos_set_value(struct pm_qos_constraints *c, s32 value) | ||
149 | { | ||
150 | c->target_value = value; | ||
151 | } | ||
152 | |||
153 | /** | ||
154 | * pm_qos_update_target - manages the constraints list and calls the notifiers | ||
155 | * if needed | ||
156 | * @c: constraints data struct | ||
157 | * @node: request to add to the list, to update or to remove | ||
158 | * @action: action to take on the constraints list | ||
159 | * @value: value of the request to add or update | ||
160 | * | ||
161 | * This function returns 1 if the aggregated constraint value has changed, 0 | ||
162 | * otherwise. | ||
163 | */ | ||
164 | int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node, | ||
165 | enum pm_qos_req_action action, int value) | ||
166 | { | ||
167 | unsigned long flags; | ||
168 | int prev_value, curr_value, new_value; | ||
169 | |||
170 | spin_lock_irqsave(&pm_qos_lock, flags); | ||
171 | prev_value = pm_qos_get_value(c); | ||
172 | if (value == PM_QOS_DEFAULT_VALUE) | ||
173 | new_value = c->default_value; | ||
174 | else | ||
175 | new_value = value; | ||
176 | |||
177 | switch (action) { | ||
178 | case PM_QOS_REMOVE_REQ: | ||
179 | plist_del(node, &c->list); | ||
180 | break; | ||
181 | case PM_QOS_UPDATE_REQ: | ||
182 | /* | ||
183 | * to change the list, we atomically remove, reinit | ||
184 | * with new value and add, then see if the extremal | ||
185 | * changed | ||
186 | */ | ||
187 | plist_del(node, &c->list); | ||
188 | case PM_QOS_ADD_REQ: | ||
189 | plist_node_init(node, new_value); | ||
190 | plist_add(node, &c->list); | ||
191 | break; | ||
192 | default: | ||
193 | /* no action */ | ||
194 | ; | ||
195 | } | ||
196 | |||
197 | curr_value = pm_qos_get_value(c); | ||
198 | pm_qos_set_value(c, curr_value); | ||
199 | |||
200 | spin_unlock_irqrestore(&pm_qos_lock, flags); | ||
201 | |||
202 | if (prev_value != curr_value) { | ||
203 | blocking_notifier_call_chain(c->notifiers, | ||
204 | (unsigned long)curr_value, | ||
205 | NULL); | ||
206 | return 1; | ||
207 | } else { | ||
208 | return 0; | ||
209 | } | ||
210 | } | ||
211 | |||
212 | /** | ||
213 | * pm_qos_request - returns current system wide qos expectation | ||
214 | * @pm_qos_class: identification of which qos value is requested | ||
215 | * | ||
216 | * This function returns the current target value. | ||
217 | */ | ||
218 | int pm_qos_request(int pm_qos_class) | ||
219 | { | ||
220 | return pm_qos_read_value(pm_qos_array[pm_qos_class]->constraints); | ||
221 | } | ||
222 | EXPORT_SYMBOL_GPL(pm_qos_request); | ||
223 | |||
224 | int pm_qos_request_active(struct pm_qos_request *req) | ||
225 | { | ||
226 | return req->pm_qos_class != 0; | ||
227 | } | ||
228 | EXPORT_SYMBOL_GPL(pm_qos_request_active); | ||
229 | |||
230 | /** | ||
231 | * pm_qos_add_request - inserts new qos request into the list | ||
232 | * @req: pointer to a preallocated handle | ||
233 | * @pm_qos_class: identifies which list of qos request to use | ||
234 | * @value: defines the qos request | ||
235 | * | ||
236 | * This function inserts a new entry in the pm_qos_class list of requested qos | ||
237 | * performance characteristics. It recomputes the aggregate QoS expectations | ||
238 | * for the pm_qos_class of parameters and initializes the pm_qos_request | ||
239 | * handle. Caller needs to save this handle for later use in updates and | ||
240 | * removal. | ||
241 | */ | ||
242 | |||
243 | void pm_qos_add_request(struct pm_qos_request *req, | ||
244 | int pm_qos_class, s32 value) | ||
245 | { | ||
246 | if (!req) /*guard against callers passing in null */ | ||
247 | return; | ||
248 | |||
249 | if (pm_qos_request_active(req)) { | ||
250 | WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n"); | ||
251 | return; | ||
252 | } | ||
253 | req->pm_qos_class = pm_qos_class; | ||
254 | pm_qos_update_target(pm_qos_array[pm_qos_class]->constraints, | ||
255 | &req->node, PM_QOS_ADD_REQ, value); | ||
256 | } | ||
257 | EXPORT_SYMBOL_GPL(pm_qos_add_request); | ||
258 | |||
259 | /** | ||
260 | * pm_qos_update_request - modifies an existing qos request | ||
261 | * @req : handle to list element holding a pm_qos request to use | ||
262 | * @value: defines the qos request | ||
263 | * | ||
264 | * Updates an existing qos request for the pm_qos_class of parameters along | ||
265 | * with updating the target pm_qos_class value. | ||
266 | * | ||
267 | * Attempts are made to make this code callable on hot code paths. | ||
268 | */ | ||
269 | void pm_qos_update_request(struct pm_qos_request *req, | ||
270 | s32 new_value) | ||
271 | { | ||
272 | if (!req) /*guard against callers passing in null */ | ||
273 | return; | ||
274 | |||
275 | if (!pm_qos_request_active(req)) { | ||
276 | WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n"); | ||
277 | return; | ||
278 | } | ||
279 | |||
280 | if (new_value != req->node.prio) | ||
281 | pm_qos_update_target( | ||
282 | pm_qos_array[req->pm_qos_class]->constraints, | ||
283 | &req->node, PM_QOS_UPDATE_REQ, new_value); | ||
284 | } | ||
285 | EXPORT_SYMBOL_GPL(pm_qos_update_request); | ||
286 | |||
287 | /** | ||
288 | * pm_qos_remove_request - modifies an existing qos request | ||
289 | * @req: handle to request list element | ||
290 | * | ||
291 | * Will remove pm qos request from the list of constraints and | ||
292 | * recompute the current target value for the pm_qos_class. Call this | ||
293 | * on slow code paths. | ||
294 | */ | ||
295 | void pm_qos_remove_request(struct pm_qos_request *req) | ||
296 | { | ||
297 | if (!req) /*guard against callers passing in null */ | ||
298 | return; | ||
299 | /* silent return to keep pcm code cleaner */ | ||
300 | |||
301 | if (!pm_qos_request_active(req)) { | ||
302 | WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n"); | ||
303 | return; | ||
304 | } | ||
305 | |||
306 | pm_qos_update_target(pm_qos_array[req->pm_qos_class]->constraints, | ||
307 | &req->node, PM_QOS_REMOVE_REQ, | ||
308 | PM_QOS_DEFAULT_VALUE); | ||
309 | memset(req, 0, sizeof(*req)); | ||
310 | } | ||
311 | EXPORT_SYMBOL_GPL(pm_qos_remove_request); | ||
312 | |||
313 | /** | ||
314 | * pm_qos_add_notifier - sets notification entry for changes to target value | ||
315 | * @pm_qos_class: identifies which qos target changes should be notified. | ||
316 | * @notifier: notifier block managed by caller. | ||
317 | * | ||
318 | * will register the notifier into a notification chain that gets called | ||
319 | * upon changes to the pm_qos_class target value. | ||
320 | */ | ||
321 | int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier) | ||
322 | { | ||
323 | int retval; | ||
324 | |||
325 | retval = blocking_notifier_chain_register( | ||
326 | pm_qos_array[pm_qos_class]->constraints->notifiers, | ||
327 | notifier); | ||
328 | |||
329 | return retval; | ||
330 | } | ||
331 | EXPORT_SYMBOL_GPL(pm_qos_add_notifier); | ||
332 | |||
333 | /** | ||
334 | * pm_qos_remove_notifier - deletes notification entry from chain. | ||
335 | * @pm_qos_class: identifies which qos target changes are notified. | ||
336 | * @notifier: notifier block to be removed. | ||
337 | * | ||
338 | * will remove the notifier from the notification chain that gets called | ||
339 | * upon changes to the pm_qos_class target value. | ||
340 | */ | ||
341 | int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier) | ||
342 | { | ||
343 | int retval; | ||
344 | |||
345 | retval = blocking_notifier_chain_unregister( | ||
346 | pm_qos_array[pm_qos_class]->constraints->notifiers, | ||
347 | notifier); | ||
348 | |||
349 | return retval; | ||
350 | } | ||
351 | EXPORT_SYMBOL_GPL(pm_qos_remove_notifier); | ||
352 | |||
353 | /* User space interface to PM QoS classes via misc devices */ | ||
354 | static int register_pm_qos_misc(struct pm_qos_object *qos) | ||
355 | { | ||
356 | qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR; | ||
357 | qos->pm_qos_power_miscdev.name = qos->name; | ||
358 | qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops; | ||
359 | |||
360 | return misc_register(&qos->pm_qos_power_miscdev); | ||
361 | } | ||
362 | |||
363 | static int find_pm_qos_object_by_minor(int minor) | ||
364 | { | ||
365 | int pm_qos_class; | ||
366 | |||
367 | for (pm_qos_class = 0; | ||
368 | pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) { | ||
369 | if (minor == | ||
370 | pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor) | ||
371 | return pm_qos_class; | ||
372 | } | ||
373 | return -1; | ||
374 | } | ||
375 | |||
376 | static int pm_qos_power_open(struct inode *inode, struct file *filp) | ||
377 | { | ||
378 | long pm_qos_class; | ||
379 | |||
380 | pm_qos_class = find_pm_qos_object_by_minor(iminor(inode)); | ||
381 | if (pm_qos_class >= 0) { | ||
382 | struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL); | ||
383 | if (!req) | ||
384 | return -ENOMEM; | ||
385 | |||
386 | pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE); | ||
387 | filp->private_data = req; | ||
388 | |||
389 | if (filp->private_data) | ||
390 | return 0; | ||
391 | } | ||
392 | return -EPERM; | ||
393 | } | ||
394 | |||
395 | static int pm_qos_power_release(struct inode *inode, struct file *filp) | ||
396 | { | ||
397 | struct pm_qos_request *req; | ||
398 | |||
399 | req = filp->private_data; | ||
400 | pm_qos_remove_request(req); | ||
401 | kfree(req); | ||
402 | |||
403 | return 0; | ||
404 | } | ||
405 | |||
406 | |||
407 | static ssize_t pm_qos_power_read(struct file *filp, char __user *buf, | ||
408 | size_t count, loff_t *f_pos) | ||
409 | { | ||
410 | s32 value; | ||
411 | unsigned long flags; | ||
412 | struct pm_qos_request *req = filp->private_data; | ||
413 | |||
414 | if (!req) | ||
415 | return -EINVAL; | ||
416 | if (!pm_qos_request_active(req)) | ||
417 | return -EINVAL; | ||
418 | |||
419 | spin_lock_irqsave(&pm_qos_lock, flags); | ||
420 | value = pm_qos_get_value(pm_qos_array[req->pm_qos_class]->constraints); | ||
421 | spin_unlock_irqrestore(&pm_qos_lock, flags); | ||
422 | |||
423 | return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32)); | ||
424 | } | ||
425 | |||
426 | static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf, | ||
427 | size_t count, loff_t *f_pos) | ||
428 | { | ||
429 | s32 value; | ||
430 | struct pm_qos_request *req; | ||
431 | |||
432 | if (count == sizeof(s32)) { | ||
433 | if (copy_from_user(&value, buf, sizeof(s32))) | ||
434 | return -EFAULT; | ||
435 | } else if (count <= 11) { /* ASCII perhaps? */ | ||
436 | char ascii_value[11]; | ||
437 | unsigned long int ulval; | ||
438 | int ret; | ||
439 | |||
440 | if (copy_from_user(ascii_value, buf, count)) | ||
441 | return -EFAULT; | ||
442 | |||
443 | if (count > 10) { | ||
444 | if (ascii_value[10] == '\n') | ||
445 | ascii_value[10] = '\0'; | ||
446 | else | ||
447 | return -EINVAL; | ||
448 | } else { | ||
449 | ascii_value[count] = '\0'; | ||
450 | } | ||
451 | ret = strict_strtoul(ascii_value, 16, &ulval); | ||
452 | if (ret) { | ||
453 | pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret); | ||
454 | return -EINVAL; | ||
455 | } | ||
456 | value = (s32)lower_32_bits(ulval); | ||
457 | } else { | ||
458 | return -EINVAL; | ||
459 | } | ||
460 | |||
461 | req = filp->private_data; | ||
462 | pm_qos_update_request(req, value); | ||
463 | |||
464 | return count; | ||
465 | } | ||
466 | |||
467 | |||
468 | static int __init pm_qos_power_init(void) | ||
469 | { | ||
470 | int ret = 0; | ||
471 | |||
472 | ret = register_pm_qos_misc(&cpu_dma_pm_qos); | ||
473 | if (ret < 0) { | ||
474 | printk(KERN_ERR "pm_qos_param: cpu_dma_latency setup failed\n"); | ||
475 | return ret; | ||
476 | } | ||
477 | ret = register_pm_qos_misc(&network_lat_pm_qos); | ||
478 | if (ret < 0) { | ||
479 | printk(KERN_ERR "pm_qos_param: network_latency setup failed\n"); | ||
480 | return ret; | ||
481 | } | ||
482 | ret = register_pm_qos_misc(&network_throughput_pm_qos); | ||
483 | if (ret < 0) | ||
484 | printk(KERN_ERR | ||
485 | "pm_qos_param: network_throughput setup failed\n"); | ||
486 | |||
487 | return ret; | ||
488 | } | ||
489 | |||
490 | late_initcall(pm_qos_power_init); | ||