]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/base/power/qos.c
74a67e0019a2d246820ccb2858399bca193ff789
[~shefty/rdma-dev.git] / drivers / base / power / qos.c
1 /*
2  * Devices PM QoS constraints management
3  *
4  * Copyright (C) 2011 Texas Instruments, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  *
11  * This module exposes the interface to kernel space for specifying
12  * per-device PM QoS dependencies. It provides infrastructure for registration
13  * of:
14  *
15  * Dependents on a QoS value : register requests
16  * Watchers of QoS value : get notified when target QoS value changes
17  *
18  * This QoS design is best effort based. Dependents register their QoS needs.
19  * Watchers register to keep track of the current QoS needs of the system.
20  * Watchers can register different types of notification callbacks:
21  *  . a per-device notification callback using the dev_pm_qos_*_notifier API.
22  *    The notification chain data is stored in the per-device constraint
23  *    data struct.
24  *  . a system-wide notification callback using the dev_pm_qos_*_global_notifier
25  *    API. The notification chain data is stored in a static variable.
26  *
27  * Note about the per-device constraint data struct allocation:
28  * . The per-device constraints data struct ptr is tored into the device
29  *    dev_pm_info.
30  * . To minimize the data usage by the per-device constraints, the data struct
31  *   is only allocated at the first call to dev_pm_qos_add_request.
32  * . The data is later free'd when the device is removed from the system.
33  *  . A global mutex protects the constraints users from the data being
34  *     allocated and free'd.
35  */
36
37 #include <linux/pm_qos.h>
38 #include <linux/spinlock.h>
39 #include <linux/slab.h>
40 #include <linux/device.h>
41 #include <linux/mutex.h>
42 #include <linux/export.h>
43
44 #include "power.h"
45
46 static DEFINE_MUTEX(dev_pm_qos_mtx);
47
48 static BLOCKING_NOTIFIER_HEAD(dev_pm_notifiers);
49
50 /**
51  * __dev_pm_qos_read_value - Get PM QoS constraint for a given device.
52  * @dev: Device to get the PM QoS constraint value for.
53  *
54  * This routine must be called with dev->power.lock held.
55  */
56 s32 __dev_pm_qos_read_value(struct device *dev)
57 {
58         struct pm_qos_constraints *c = dev->power.constraints;
59
60         return c ? pm_qos_read_value(c) : 0;
61 }
62
63 /**
64  * dev_pm_qos_read_value - Get PM QoS constraint for a given device (locked).
65  * @dev: Device to get the PM QoS constraint value for.
66  */
67 s32 dev_pm_qos_read_value(struct device *dev)
68 {
69         unsigned long flags;
70         s32 ret;
71
72         spin_lock_irqsave(&dev->power.lock, flags);
73         ret = __dev_pm_qos_read_value(dev);
74         spin_unlock_irqrestore(&dev->power.lock, flags);
75
76         return ret;
77 }
78
79 /*
80  * apply_constraint
81  * @req: constraint request to apply
82  * @action: action to perform add/update/remove, of type enum pm_qos_req_action
83  * @value: defines the qos request
84  *
85  * Internal function to update the constraints list using the PM QoS core
86  * code and if needed call the per-device and the global notification
87  * callbacks
88  */
89 static int apply_constraint(struct dev_pm_qos_request *req,
90                             enum pm_qos_req_action action, int value)
91 {
92         int ret, curr_value;
93
94         ret = pm_qos_update_target(req->dev->power.constraints,
95                                    &req->node, action, value);
96
97         if (ret) {
98                 /* Call the global callbacks if needed */
99                 curr_value = pm_qos_read_value(req->dev->power.constraints);
100                 blocking_notifier_call_chain(&dev_pm_notifiers,
101                                              (unsigned long)curr_value,
102                                              req);
103         }
104
105         return ret;
106 }
107
108 /*
109  * dev_pm_qos_constraints_allocate
110  * @dev: device to allocate data for
111  *
112  * Called at the first call to add_request, for constraint data allocation
113  * Must be called with the dev_pm_qos_mtx mutex held
114  */
115 static int dev_pm_qos_constraints_allocate(struct device *dev)
116 {
117         struct pm_qos_constraints *c;
118         struct blocking_notifier_head *n;
119
120         c = kzalloc(sizeof(*c), GFP_KERNEL);
121         if (!c)
122                 return -ENOMEM;
123
124         n = kzalloc(sizeof(*n), GFP_KERNEL);
125         if (!n) {
126                 kfree(c);
127                 return -ENOMEM;
128         }
129         BLOCKING_INIT_NOTIFIER_HEAD(n);
130
131         plist_head_init(&c->list);
132         c->target_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
133         c->default_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
134         c->type = PM_QOS_MIN;
135         c->notifiers = n;
136
137         spin_lock_irq(&dev->power.lock);
138         dev->power.constraints = c;
139         spin_unlock_irq(&dev->power.lock);
140
141         return 0;
142 }
143
144 /**
145  * dev_pm_qos_constraints_init - Initalize device's PM QoS constraints pointer.
146  * @dev: target device
147  *
148  * Called from the device PM subsystem during device insertion under
149  * device_pm_lock().
150  */
151 void dev_pm_qos_constraints_init(struct device *dev)
152 {
153         mutex_lock(&dev_pm_qos_mtx);
154         dev->power.constraints = NULL;
155         dev->power.power_state = PMSG_ON;
156         mutex_unlock(&dev_pm_qos_mtx);
157 }
158
159 /**
160  * dev_pm_qos_constraints_destroy
161  * @dev: target device
162  *
163  * Called from the device PM subsystem on device removal under device_pm_lock().
164  */
165 void dev_pm_qos_constraints_destroy(struct device *dev)
166 {
167         struct dev_pm_qos_request *req, *tmp;
168         struct pm_qos_constraints *c;
169
170         /*
171          * If the device's PM QoS resume latency limit has been exposed to user
172          * space, it has to be hidden at this point.
173          */
174         dev_pm_qos_hide_latency_limit(dev);
175
176         mutex_lock(&dev_pm_qos_mtx);
177
178         dev->power.power_state = PMSG_INVALID;
179         c = dev->power.constraints;
180         if (!c)
181                 goto out;
182
183         /* Flush the constraints list for the device */
184         plist_for_each_entry_safe(req, tmp, &c->list, node) {
185                 /*
186                  * Update constraints list and call the notification
187                  * callbacks if needed
188                  */
189                 apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
190                 memset(req, 0, sizeof(*req));
191         }
192
193         spin_lock_irq(&dev->power.lock);
194         dev->power.constraints = NULL;
195         spin_unlock_irq(&dev->power.lock);
196
197         kfree(c->notifiers);
198         kfree(c);
199
200  out:
201         mutex_unlock(&dev_pm_qos_mtx);
202 }
203
204 /**
205  * dev_pm_qos_add_request - inserts new qos request into the list
206  * @dev: target device for the constraint
207  * @req: pointer to a preallocated handle
208  * @value: defines the qos request
209  *
210  * This function inserts a new entry in the device constraints list of
211  * requested qos performance characteristics. It recomputes the aggregate
212  * QoS expectations of parameters and initializes the dev_pm_qos_request
213  * handle.  Caller needs to save this handle for later use in updates and
214  * removal.
215  *
216  * Returns 1 if the aggregated constraint value has changed,
217  * 0 if the aggregated constraint value has not changed,
218  * -EINVAL in case of wrong parameters, -ENOMEM if there's not enough memory
219  * to allocate for data structures, -ENODEV if the device has just been removed
220  * from the system.
221  */
222 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
223                            s32 value)
224 {
225         int ret = 0;
226
227         if (!dev || !req) /*guard against callers passing in null */
228                 return -EINVAL;
229
230         if (WARN(dev_pm_qos_request_active(req),
231                  "%s() called for already added request\n", __func__))
232                 return -EINVAL;
233
234         req->dev = dev;
235
236         mutex_lock(&dev_pm_qos_mtx);
237
238         if (!dev->power.constraints) {
239                 if (dev->power.power_state.event == PM_EVENT_INVALID) {
240                         /* The device has been removed from the system. */
241                         req->dev = NULL;
242                         ret = -ENODEV;
243                         goto out;
244                 } else {
245                         /*
246                          * Allocate the constraints data on the first call to
247                          * add_request, i.e. only if the data is not already
248                          * allocated and if the device has not been removed.
249                          */
250                         ret = dev_pm_qos_constraints_allocate(dev);
251                 }
252         }
253
254         if (!ret)
255                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
256
257  out:
258         mutex_unlock(&dev_pm_qos_mtx);
259
260         return ret;
261 }
262 EXPORT_SYMBOL_GPL(dev_pm_qos_add_request);
263
264 /**
265  * dev_pm_qos_update_request - modifies an existing qos request
266  * @req : handle to list element holding a dev_pm_qos request to use
267  * @new_value: defines the qos request
268  *
269  * Updates an existing dev PM qos request along with updating the
270  * target value.
271  *
272  * Attempts are made to make this code callable on hot code paths.
273  *
274  * Returns 1 if the aggregated constraint value has changed,
275  * 0 if the aggregated constraint value has not changed,
276  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
277  * removed from the system
278  */
279 int dev_pm_qos_update_request(struct dev_pm_qos_request *req,
280                               s32 new_value)
281 {
282         int ret = 0;
283
284         if (!req) /*guard against callers passing in null */
285                 return -EINVAL;
286
287         if (WARN(!dev_pm_qos_request_active(req),
288                  "%s() called for unknown object\n", __func__))
289                 return -EINVAL;
290
291         mutex_lock(&dev_pm_qos_mtx);
292
293         if (req->dev->power.constraints) {
294                 if (new_value != req->node.prio)
295                         ret = apply_constraint(req, PM_QOS_UPDATE_REQ,
296                                                new_value);
297         } else {
298                 /* Return if the device has been removed */
299                 ret = -ENODEV;
300         }
301
302         mutex_unlock(&dev_pm_qos_mtx);
303         return ret;
304 }
305 EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
306
307 /**
308  * dev_pm_qos_remove_request - modifies an existing qos request
309  * @req: handle to request list element
310  *
311  * Will remove pm qos request from the list of constraints and
312  * recompute the current target value. Call this on slow code paths.
313  *
314  * Returns 1 if the aggregated constraint value has changed,
315  * 0 if the aggregated constraint value has not changed,
316  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
317  * removed from the system
318  */
319 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
320 {
321         int ret = 0;
322
323         if (!req) /*guard against callers passing in null */
324                 return -EINVAL;
325
326         if (WARN(!dev_pm_qos_request_active(req),
327                  "%s() called for unknown object\n", __func__))
328                 return -EINVAL;
329
330         mutex_lock(&dev_pm_qos_mtx);
331
332         if (req->dev->power.constraints) {
333                 ret = apply_constraint(req, PM_QOS_REMOVE_REQ,
334                                        PM_QOS_DEFAULT_VALUE);
335                 memset(req, 0, sizeof(*req));
336         } else {
337                 /* Return if the device has been removed */
338                 ret = -ENODEV;
339         }
340
341         mutex_unlock(&dev_pm_qos_mtx);
342         return ret;
343 }
344 EXPORT_SYMBOL_GPL(dev_pm_qos_remove_request);
345
346 /**
347  * dev_pm_qos_add_notifier - sets notification entry for changes to target value
348  * of per-device PM QoS constraints
349  *
350  * @dev: target device for the constraint
351  * @notifier: notifier block managed by caller.
352  *
353  * Will register the notifier into a notification chain that gets called
354  * upon changes to the target value for the device.
355  *
356  * If the device's constraints object doesn't exist when this routine is called,
357  * it will be created (or error code will be returned if that fails).
358  */
359 int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)
360 {
361         int ret = 0;
362
363         mutex_lock(&dev_pm_qos_mtx);
364
365         if (!dev->power.constraints)
366                 ret = dev->power.power_state.event != PM_EVENT_INVALID ?
367                         dev_pm_qos_constraints_allocate(dev) : -ENODEV;
368
369         if (!ret)
370                 ret = blocking_notifier_chain_register(
371                                 dev->power.constraints->notifiers, notifier);
372
373         mutex_unlock(&dev_pm_qos_mtx);
374         return ret;
375 }
376 EXPORT_SYMBOL_GPL(dev_pm_qos_add_notifier);
377
378 /**
379  * dev_pm_qos_remove_notifier - deletes notification for changes to target value
380  * of per-device PM QoS constraints
381  *
382  * @dev: target device for the constraint
383  * @notifier: notifier block to be removed.
384  *
385  * Will remove the notifier from the notification chain that gets called
386  * upon changes to the target value.
387  */
388 int dev_pm_qos_remove_notifier(struct device *dev,
389                                struct notifier_block *notifier)
390 {
391         int retval = 0;
392
393         mutex_lock(&dev_pm_qos_mtx);
394
395         /* Silently return if the constraints object is not present. */
396         if (dev->power.constraints)
397                 retval = blocking_notifier_chain_unregister(
398                                 dev->power.constraints->notifiers,
399                                 notifier);
400
401         mutex_unlock(&dev_pm_qos_mtx);
402         return retval;
403 }
404 EXPORT_SYMBOL_GPL(dev_pm_qos_remove_notifier);
405
406 /**
407  * dev_pm_qos_add_global_notifier - sets notification entry for changes to
408  * target value of the PM QoS constraints for any device
409  *
410  * @notifier: notifier block managed by caller.
411  *
412  * Will register the notifier into a notification chain that gets called
413  * upon changes to the target value for any device.
414  */
415 int dev_pm_qos_add_global_notifier(struct notifier_block *notifier)
416 {
417         return blocking_notifier_chain_register(&dev_pm_notifiers, notifier);
418 }
419 EXPORT_SYMBOL_GPL(dev_pm_qos_add_global_notifier);
420
421 /**
422  * dev_pm_qos_remove_global_notifier - deletes notification for changes to
423  * target value of PM QoS constraints for any device
424  *
425  * @notifier: notifier block to be removed.
426  *
427  * Will remove the notifier from the notification chain that gets called
428  * upon changes to the target value for any device.
429  */
430 int dev_pm_qos_remove_global_notifier(struct notifier_block *notifier)
431 {
432         return blocking_notifier_chain_unregister(&dev_pm_notifiers, notifier);
433 }
434 EXPORT_SYMBOL_GPL(dev_pm_qos_remove_global_notifier);
435
436 /**
437  * dev_pm_qos_add_ancestor_request - Add PM QoS request for device's ancestor.
438  * @dev: Device whose ancestor to add the request for.
439  * @req: Pointer to the preallocated handle.
440  * @value: Constraint latency value.
441  */
442 int dev_pm_qos_add_ancestor_request(struct device *dev,
443                                     struct dev_pm_qos_request *req, s32 value)
444 {
445         struct device *ancestor = dev->parent;
446         int error = -ENODEV;
447
448         while (ancestor && !ancestor->power.ignore_children)
449                 ancestor = ancestor->parent;
450
451         if (ancestor)
452                 error = dev_pm_qos_add_request(ancestor, req, value);
453
454         if (error)
455                 req->dev = NULL;
456
457         return error;
458 }
459 EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
460
461 #ifdef CONFIG_PM_RUNTIME
462 static void __dev_pm_qos_drop_user_request(struct device *dev)
463 {
464         dev_pm_qos_remove_request(dev->power.pq_req);
465         dev->power.pq_req = NULL;
466 }
467
468 /**
469  * dev_pm_qos_expose_latency_limit - Expose PM QoS latency limit to user space.
470  * @dev: Device whose PM QoS latency limit is to be exposed to user space.
471  * @value: Initial value of the latency limit.
472  */
473 int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
474 {
475         struct dev_pm_qos_request *req;
476         int ret;
477
478         if (!device_is_registered(dev) || value < 0)
479                 return -EINVAL;
480
481         if (dev->power.pq_req)
482                 return -EEXIST;
483
484         req = kzalloc(sizeof(*req), GFP_KERNEL);
485         if (!req)
486                 return -ENOMEM;
487
488         ret = dev_pm_qos_add_request(dev, req, value);
489         if (ret < 0)
490                 return ret;
491
492         dev->power.pq_req = req;
493         ret = pm_qos_sysfs_add(dev);
494         if (ret)
495                 __dev_pm_qos_drop_user_request(dev);
496
497         return ret;
498 }
499 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_limit);
500
501 /**
502  * dev_pm_qos_hide_latency_limit - Hide PM QoS latency limit from user space.
503  * @dev: Device whose PM QoS latency limit is to be hidden from user space.
504  */
505 void dev_pm_qos_hide_latency_limit(struct device *dev)
506 {
507         if (dev->power.pq_req) {
508                 pm_qos_sysfs_remove(dev);
509                 __dev_pm_qos_drop_user_request(dev);
510         }
511 }
512 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_limit);
513 #endif /* CONFIG_PM_RUNTIME */