xref: /linux/drivers/base/power/qos.c (revision 4413e16d9d21673bb5048a2e542f1aaa00015c2e)
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 */
514