GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / base / power / qos.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Devices PM QoS constraints management
4  *
5  * Copyright (C) 2011 Texas Instruments, Inc.
6  *
7  * This module exposes the interface to kernel space for specifying
8  * per-device PM QoS dependencies. It provides infrastructure for registration
9  * of:
10  *
11  * Dependents on a QoS value : register requests
12  * Watchers of QoS value : get notified when target QoS value changes
13  *
14  * This QoS design is best effort based. Dependents register their QoS needs.
15  * Watchers register to keep track of the current QoS needs of the system.
16  * Watchers can register a per-device notification callback using the
17  * dev_pm_qos_*_notifier API. The notification chain data is stored in the
18  * per-device constraint data struct.
19  *
20  * Note about the per-device constraint data struct allocation:
21  * . The per-device constraints data struct ptr is stored into the device
22  *    dev_pm_info.
23  * . To minimize the data usage by the per-device constraints, the data struct
24  *   is only allocated at the first call to dev_pm_qos_add_request.
25  * . The data is later free'd when the device is removed from the system.
26  *  . A global mutex protects the constraints users from the data being
27  *     allocated and free'd.
28  */
29
30 #include <linux/pm_qos.h>
31 #include <linux/spinlock.h>
32 #include <linux/slab.h>
33 #include <linux/device.h>
34 #include <linux/mutex.h>
35 #include <linux/export.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/err.h>
38 #include <trace/events/power.h>
39
40 #include "power.h"
41
42 static DEFINE_MUTEX(dev_pm_qos_mtx);
43 static DEFINE_MUTEX(dev_pm_qos_sysfs_mtx);
44
45 /**
46  * __dev_pm_qos_flags - Check PM QoS flags for a given device.
47  * @dev: Device to check the PM QoS flags for.
48  * @mask: Flags to check against.
49  *
50  * This routine must be called with dev->power.lock held.
51  */
52 enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask)
53 {
54         struct dev_pm_qos *qos = dev->power.qos;
55         struct pm_qos_flags *pqf;
56         s32 val;
57
58         lockdep_assert_held(&dev->power.lock);
59
60         if (IS_ERR_OR_NULL(qos))
61                 return PM_QOS_FLAGS_UNDEFINED;
62
63         pqf = &qos->flags;
64         if (list_empty(&pqf->list))
65                 return PM_QOS_FLAGS_UNDEFINED;
66
67         val = pqf->effective_flags & mask;
68         if (val)
69                 return (val == mask) ? PM_QOS_FLAGS_ALL : PM_QOS_FLAGS_SOME;
70
71         return PM_QOS_FLAGS_NONE;
72 }
73
74 /**
75  * dev_pm_qos_flags - Check PM QoS flags for a given device (locked).
76  * @dev: Device to check the PM QoS flags for.
77  * @mask: Flags to check against.
78  */
79 enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask)
80 {
81         unsigned long irqflags;
82         enum pm_qos_flags_status ret;
83
84         spin_lock_irqsave(&dev->power.lock, irqflags);
85         ret = __dev_pm_qos_flags(dev, mask);
86         spin_unlock_irqrestore(&dev->power.lock, irqflags);
87
88         return ret;
89 }
90 EXPORT_SYMBOL_GPL(dev_pm_qos_flags);
91
92 /**
93  * __dev_pm_qos_resume_latency - Get resume latency constraint for a given device.
94  * @dev: Device to get the PM QoS constraint value for.
95  *
96  * This routine must be called with dev->power.lock held.
97  */
98 s32 __dev_pm_qos_resume_latency(struct device *dev)
99 {
100         lockdep_assert_held(&dev->power.lock);
101
102         return dev_pm_qos_raw_resume_latency(dev);
103 }
104
105 /**
106  * dev_pm_qos_read_value - Get PM QoS constraint for a given device (locked).
107  * @dev: Device to get the PM QoS constraint value for.
108  * @type: QoS request type.
109  */
110 s32 dev_pm_qos_read_value(struct device *dev, enum dev_pm_qos_req_type type)
111 {
112         struct dev_pm_qos *qos = dev->power.qos;
113         unsigned long flags;
114         s32 ret;
115
116         spin_lock_irqsave(&dev->power.lock, flags);
117
118         switch (type) {
119         case DEV_PM_QOS_RESUME_LATENCY:
120                 ret = IS_ERR_OR_NULL(qos) ? PM_QOS_RESUME_LATENCY_NO_CONSTRAINT
121                         : pm_qos_read_value(&qos->resume_latency);
122                 break;
123         case DEV_PM_QOS_MIN_FREQUENCY:
124                 ret = IS_ERR_OR_NULL(qos) ? PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE
125                         : freq_qos_read_value(&qos->freq, FREQ_QOS_MIN);
126                 break;
127         case DEV_PM_QOS_MAX_FREQUENCY:
128                 ret = IS_ERR_OR_NULL(qos) ? PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE
129                         : freq_qos_read_value(&qos->freq, FREQ_QOS_MAX);
130                 break;
131         default:
132                 WARN_ON(1);
133                 ret = 0;
134         }
135
136         spin_unlock_irqrestore(&dev->power.lock, flags);
137
138         return ret;
139 }
140
141 /**
142  * apply_constraint - Add/modify/remove device PM QoS request.
143  * @req: Constraint request to apply
144  * @action: Action to perform (add/update/remove).
145  * @value: Value to assign to the QoS request.
146  *
147  * Internal function to update the constraints list using the PM QoS core
148  * code and if needed call the per-device callbacks.
149  */
150 static int apply_constraint(struct dev_pm_qos_request *req,
151                             enum pm_qos_req_action action, s32 value)
152 {
153         struct dev_pm_qos *qos = req->dev->power.qos;
154         int ret;
155
156         switch(req->type) {
157         case DEV_PM_QOS_RESUME_LATENCY:
158                 if (WARN_ON(action != PM_QOS_REMOVE_REQ && value < 0))
159                         value = 0;
160
161                 ret = pm_qos_update_target(&qos->resume_latency,
162                                            &req->data.pnode, action, value);
163                 break;
164         case DEV_PM_QOS_LATENCY_TOLERANCE:
165                 ret = pm_qos_update_target(&qos->latency_tolerance,
166                                            &req->data.pnode, action, value);
167                 if (ret) {
168                         value = pm_qos_read_value(&qos->latency_tolerance);
169                         req->dev->power.set_latency_tolerance(req->dev, value);
170                 }
171                 break;
172         case DEV_PM_QOS_MIN_FREQUENCY:
173         case DEV_PM_QOS_MAX_FREQUENCY:
174                 ret = freq_qos_apply(&req->data.freq, action, value);
175                 break;
176         case DEV_PM_QOS_FLAGS:
177                 ret = pm_qos_update_flags(&qos->flags, &req->data.flr,
178                                           action, value);
179                 break;
180         default:
181                 ret = -EINVAL;
182         }
183
184         return ret;
185 }
186
187 /*
188  * dev_pm_qos_constraints_allocate
189  * @dev: device to allocate data for
190  *
191  * Called at the first call to add_request, for constraint data allocation
192  * Must be called with the dev_pm_qos_mtx mutex held
193  */
194 static int dev_pm_qos_constraints_allocate(struct device *dev)
195 {
196         struct dev_pm_qos *qos;
197         struct pm_qos_constraints *c;
198         struct blocking_notifier_head *n;
199
200         qos = kzalloc(sizeof(*qos), GFP_KERNEL);
201         if (!qos)
202                 return -ENOMEM;
203
204         n = kzalloc(3 * sizeof(*n), GFP_KERNEL);
205         if (!n) {
206                 kfree(qos);
207                 return -ENOMEM;
208         }
209
210         c = &qos->resume_latency;
211         plist_head_init(&c->list);
212         c->target_value = PM_QOS_RESUME_LATENCY_DEFAULT_VALUE;
213         c->default_value = PM_QOS_RESUME_LATENCY_DEFAULT_VALUE;
214         c->no_constraint_value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
215         c->type = PM_QOS_MIN;
216         c->notifiers = n;
217         BLOCKING_INIT_NOTIFIER_HEAD(n);
218
219         c = &qos->latency_tolerance;
220         plist_head_init(&c->list);
221         c->target_value = PM_QOS_LATENCY_TOLERANCE_DEFAULT_VALUE;
222         c->default_value = PM_QOS_LATENCY_TOLERANCE_DEFAULT_VALUE;
223         c->no_constraint_value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
224         c->type = PM_QOS_MIN;
225
226         freq_constraints_init(&qos->freq);
227
228         INIT_LIST_HEAD(&qos->flags.list);
229
230         spin_lock_irq(&dev->power.lock);
231         dev->power.qos = qos;
232         spin_unlock_irq(&dev->power.lock);
233
234         return 0;
235 }
236
237 static void __dev_pm_qos_hide_latency_limit(struct device *dev);
238 static void __dev_pm_qos_hide_flags(struct device *dev);
239
240 /**
241  * dev_pm_qos_constraints_destroy
242  * @dev: target device
243  *
244  * Called from the device PM subsystem on device removal under device_pm_lock().
245  */
246 void dev_pm_qos_constraints_destroy(struct device *dev)
247 {
248         struct dev_pm_qos *qos;
249         struct dev_pm_qos_request *req, *tmp;
250         struct pm_qos_constraints *c;
251         struct pm_qos_flags *f;
252
253         mutex_lock(&dev_pm_qos_sysfs_mtx);
254
255         /*
256          * If the device's PM QoS resume latency limit or PM QoS flags have been
257          * exposed to user space, they have to be hidden at this point.
258          */
259         pm_qos_sysfs_remove_resume_latency(dev);
260         pm_qos_sysfs_remove_flags(dev);
261
262         mutex_lock(&dev_pm_qos_mtx);
263
264         __dev_pm_qos_hide_latency_limit(dev);
265         __dev_pm_qos_hide_flags(dev);
266
267         qos = dev->power.qos;
268         if (!qos)
269                 goto out;
270
271         /* Flush the constraints lists for the device. */
272         c = &qos->resume_latency;
273         plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {
274                 /*
275                  * Update constraints list and call the notification
276                  * callbacks if needed
277                  */
278                 apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
279                 memset(req, 0, sizeof(*req));
280         }
281
282         c = &qos->latency_tolerance;
283         plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {
284                 apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
285                 memset(req, 0, sizeof(*req));
286         }
287
288         c = &qos->freq.min_freq;
289         plist_for_each_entry_safe(req, tmp, &c->list, data.freq.pnode) {
290                 apply_constraint(req, PM_QOS_REMOVE_REQ,
291                                  PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE);
292                 memset(req, 0, sizeof(*req));
293         }
294
295         c = &qos->freq.max_freq;
296         plist_for_each_entry_safe(req, tmp, &c->list, data.freq.pnode) {
297                 apply_constraint(req, PM_QOS_REMOVE_REQ,
298                                  PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
299                 memset(req, 0, sizeof(*req));
300         }
301
302         f = &qos->flags;
303         list_for_each_entry_safe(req, tmp, &f->list, data.flr.node) {
304                 apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
305                 memset(req, 0, sizeof(*req));
306         }
307
308         spin_lock_irq(&dev->power.lock);
309         dev->power.qos = ERR_PTR(-ENODEV);
310         spin_unlock_irq(&dev->power.lock);
311
312         kfree(qos->resume_latency.notifiers);
313         kfree(qos);
314
315  out:
316         mutex_unlock(&dev_pm_qos_mtx);
317
318         mutex_unlock(&dev_pm_qos_sysfs_mtx);
319 }
320
321 static bool dev_pm_qos_invalid_req_type(struct device *dev,
322                                         enum dev_pm_qos_req_type type)
323 {
324         return type == DEV_PM_QOS_LATENCY_TOLERANCE &&
325                !dev->power.set_latency_tolerance;
326 }
327
328 static int __dev_pm_qos_add_request(struct device *dev,
329                                     struct dev_pm_qos_request *req,
330                                     enum dev_pm_qos_req_type type, s32 value)
331 {
332         int ret = 0;
333
334         if (!dev || !req || dev_pm_qos_invalid_req_type(dev, type))
335                 return -EINVAL;
336
337         if (WARN(dev_pm_qos_request_active(req),
338                  "%s() called for already added request\n", __func__))
339                 return -EINVAL;
340
341         if (IS_ERR(dev->power.qos))
342                 ret = -ENODEV;
343         else if (!dev->power.qos)
344                 ret = dev_pm_qos_constraints_allocate(dev);
345
346         trace_dev_pm_qos_add_request(dev_name(dev), type, value);
347         if (ret)
348                 return ret;
349
350         req->dev = dev;
351         req->type = type;
352         if (req->type == DEV_PM_QOS_MIN_FREQUENCY)
353                 ret = freq_qos_add_request(&dev->power.qos->freq,
354                                            &req->data.freq,
355                                            FREQ_QOS_MIN, value);
356         else if (req->type == DEV_PM_QOS_MAX_FREQUENCY)
357                 ret = freq_qos_add_request(&dev->power.qos->freq,
358                                            &req->data.freq,
359                                            FREQ_QOS_MAX, value);
360         else
361                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
362
363         return ret;
364 }
365
366 /**
367  * dev_pm_qos_add_request - inserts new qos request into the list
368  * @dev: target device for the constraint
369  * @req: pointer to a preallocated handle
370  * @type: type of the request
371  * @value: defines the qos request
372  *
373  * This function inserts a new entry in the device constraints list of
374  * requested qos performance characteristics. It recomputes the aggregate
375  * QoS expectations of parameters and initializes the dev_pm_qos_request
376  * handle.  Caller needs to save this handle for later use in updates and
377  * removal.
378  *
379  * Returns 1 if the aggregated constraint value has changed,
380  * 0 if the aggregated constraint value has not changed,
381  * -EINVAL in case of wrong parameters, -ENOMEM if there's not enough memory
382  * to allocate for data structures, -ENODEV if the device has just been removed
383  * from the system.
384  *
385  * Callers should ensure that the target device is not RPM_SUSPENDED before
386  * using this function for requests of type DEV_PM_QOS_FLAGS.
387  */
388 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
389                            enum dev_pm_qos_req_type type, s32 value)
390 {
391         int ret;
392
393         mutex_lock(&dev_pm_qos_mtx);
394         ret = __dev_pm_qos_add_request(dev, req, type, value);
395         mutex_unlock(&dev_pm_qos_mtx);
396         return ret;
397 }
398 EXPORT_SYMBOL_GPL(dev_pm_qos_add_request);
399
400 /**
401  * __dev_pm_qos_update_request - Modify an existing device PM QoS request.
402  * @req : PM QoS request to modify.
403  * @new_value: New value to request.
404  */
405 static int __dev_pm_qos_update_request(struct dev_pm_qos_request *req,
406                                        s32 new_value)
407 {
408         s32 curr_value;
409         int ret = 0;
410
411         if (!req) /*guard against callers passing in null */
412                 return -EINVAL;
413
414         if (WARN(!dev_pm_qos_request_active(req),
415                  "%s() called for unknown object\n", __func__))
416                 return -EINVAL;
417
418         if (IS_ERR_OR_NULL(req->dev->power.qos))
419                 return -ENODEV;
420
421         switch(req->type) {
422         case DEV_PM_QOS_RESUME_LATENCY:
423         case DEV_PM_QOS_LATENCY_TOLERANCE:
424                 curr_value = req->data.pnode.prio;
425                 break;
426         case DEV_PM_QOS_MIN_FREQUENCY:
427         case DEV_PM_QOS_MAX_FREQUENCY:
428                 curr_value = req->data.freq.pnode.prio;
429                 break;
430         case DEV_PM_QOS_FLAGS:
431                 curr_value = req->data.flr.flags;
432                 break;
433         default:
434                 return -EINVAL;
435         }
436
437         trace_dev_pm_qos_update_request(dev_name(req->dev), req->type,
438                                         new_value);
439         if (curr_value != new_value)
440                 ret = apply_constraint(req, PM_QOS_UPDATE_REQ, new_value);
441
442         return ret;
443 }
444
445 /**
446  * dev_pm_qos_update_request - modifies an existing qos request
447  * @req : handle to list element holding a dev_pm_qos request to use
448  * @new_value: defines the qos request
449  *
450  * Updates an existing dev PM qos request along with updating the
451  * target value.
452  *
453  * Attempts are made to make this code callable on hot code paths.
454  *
455  * Returns 1 if the aggregated constraint value has changed,
456  * 0 if the aggregated constraint value has not changed,
457  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
458  * removed from the system
459  *
460  * Callers should ensure that the target device is not RPM_SUSPENDED before
461  * using this function for requests of type DEV_PM_QOS_FLAGS.
462  */
463 int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
464 {
465         int ret;
466
467         mutex_lock(&dev_pm_qos_mtx);
468         ret = __dev_pm_qos_update_request(req, new_value);
469         mutex_unlock(&dev_pm_qos_mtx);
470         return ret;
471 }
472 EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
473
474 static int __dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
475 {
476         int ret;
477
478         if (!req) /*guard against callers passing in null */
479                 return -EINVAL;
480
481         if (WARN(!dev_pm_qos_request_active(req),
482                  "%s() called for unknown object\n", __func__))
483                 return -EINVAL;
484
485         if (IS_ERR_OR_NULL(req->dev->power.qos))
486                 return -ENODEV;
487
488         trace_dev_pm_qos_remove_request(dev_name(req->dev), req->type,
489                                         PM_QOS_DEFAULT_VALUE);
490         ret = apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
491         memset(req, 0, sizeof(*req));
492         return ret;
493 }
494
495 /**
496  * dev_pm_qos_remove_request - modifies an existing qos request
497  * @req: handle to request list element
498  *
499  * Will remove pm qos request from the list of constraints and
500  * recompute the current target value. Call this on slow code paths.
501  *
502  * Returns 1 if the aggregated constraint value has changed,
503  * 0 if the aggregated constraint value has not changed,
504  * -EINVAL in case of wrong parameters, -ENODEV if the device has been
505  * removed from the system
506  *
507  * Callers should ensure that the target device is not RPM_SUSPENDED before
508  * using this function for requests of type DEV_PM_QOS_FLAGS.
509  */
510 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
511 {
512         int ret;
513
514         mutex_lock(&dev_pm_qos_mtx);
515         ret = __dev_pm_qos_remove_request(req);
516         mutex_unlock(&dev_pm_qos_mtx);
517         return ret;
518 }
519 EXPORT_SYMBOL_GPL(dev_pm_qos_remove_request);
520
521 /**
522  * dev_pm_qos_add_notifier - sets notification entry for changes to target value
523  * of per-device PM QoS constraints
524  *
525  * @dev: target device for the constraint
526  * @notifier: notifier block managed by caller.
527  * @type: request type.
528  *
529  * Will register the notifier into a notification chain that gets called
530  * upon changes to the target value for the device.
531  *
532  * If the device's constraints object doesn't exist when this routine is called,
533  * it will be created (or error code will be returned if that fails).
534  */
535 int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier,
536                             enum dev_pm_qos_req_type type)
537 {
538         int ret = 0;
539
540         mutex_lock(&dev_pm_qos_mtx);
541
542         if (IS_ERR(dev->power.qos))
543                 ret = -ENODEV;
544         else if (!dev->power.qos)
545                 ret = dev_pm_qos_constraints_allocate(dev);
546
547         if (ret)
548                 goto unlock;
549
550         switch (type) {
551         case DEV_PM_QOS_RESUME_LATENCY:
552                 ret = blocking_notifier_chain_register(dev->power.qos->resume_latency.notifiers,
553                                                        notifier);
554                 break;
555         case DEV_PM_QOS_MIN_FREQUENCY:
556                 ret = freq_qos_add_notifier(&dev->power.qos->freq,
557                                             FREQ_QOS_MIN, notifier);
558                 break;
559         case DEV_PM_QOS_MAX_FREQUENCY:
560                 ret = freq_qos_add_notifier(&dev->power.qos->freq,
561                                             FREQ_QOS_MAX, notifier);
562                 break;
563         default:
564                 WARN_ON(1);
565                 ret = -EINVAL;
566         }
567
568 unlock:
569         mutex_unlock(&dev_pm_qos_mtx);
570         return ret;
571 }
572 EXPORT_SYMBOL_GPL(dev_pm_qos_add_notifier);
573
574 /**
575  * dev_pm_qos_remove_notifier - deletes notification for changes to target value
576  * of per-device PM QoS constraints
577  *
578  * @dev: target device for the constraint
579  * @notifier: notifier block to be removed.
580  * @type: request type.
581  *
582  * Will remove the notifier from the notification chain that gets called
583  * upon changes to the target value.
584  */
585 int dev_pm_qos_remove_notifier(struct device *dev,
586                                struct notifier_block *notifier,
587                                enum dev_pm_qos_req_type type)
588 {
589         int ret = 0;
590
591         mutex_lock(&dev_pm_qos_mtx);
592
593         /* Silently return if the constraints object is not present. */
594         if (IS_ERR_OR_NULL(dev->power.qos))
595                 goto unlock;
596
597         switch (type) {
598         case DEV_PM_QOS_RESUME_LATENCY:
599                 ret = blocking_notifier_chain_unregister(dev->power.qos->resume_latency.notifiers,
600                                                          notifier);
601                 break;
602         case DEV_PM_QOS_MIN_FREQUENCY:
603                 ret = freq_qos_remove_notifier(&dev->power.qos->freq,
604                                                FREQ_QOS_MIN, notifier);
605                 break;
606         case DEV_PM_QOS_MAX_FREQUENCY:
607                 ret = freq_qos_remove_notifier(&dev->power.qos->freq,
608                                                FREQ_QOS_MAX, notifier);
609                 break;
610         default:
611                 WARN_ON(1);
612                 ret = -EINVAL;
613         }
614
615 unlock:
616         mutex_unlock(&dev_pm_qos_mtx);
617         return ret;
618 }
619 EXPORT_SYMBOL_GPL(dev_pm_qos_remove_notifier);
620
621 /**
622  * dev_pm_qos_add_ancestor_request - Add PM QoS request for device's ancestor.
623  * @dev: Device whose ancestor to add the request for.
624  * @req: Pointer to the preallocated handle.
625  * @type: Type of the request.
626  * @value: Constraint latency value.
627  */
628 int dev_pm_qos_add_ancestor_request(struct device *dev,
629                                     struct dev_pm_qos_request *req,
630                                     enum dev_pm_qos_req_type type, s32 value)
631 {
632         struct device *ancestor = dev->parent;
633         int ret = -ENODEV;
634
635         switch (type) {
636         case DEV_PM_QOS_RESUME_LATENCY:
637                 while (ancestor && !ancestor->power.ignore_children)
638                         ancestor = ancestor->parent;
639
640                 break;
641         case DEV_PM_QOS_LATENCY_TOLERANCE:
642                 while (ancestor && !ancestor->power.set_latency_tolerance)
643                         ancestor = ancestor->parent;
644
645                 break;
646         default:
647                 ancestor = NULL;
648         }
649         if (ancestor)
650                 ret = dev_pm_qos_add_request(ancestor, req, type, value);
651
652         if (ret < 0)
653                 req->dev = NULL;
654
655         return ret;
656 }
657 EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
658
659 static void __dev_pm_qos_drop_user_request(struct device *dev,
660                                            enum dev_pm_qos_req_type type)
661 {
662         struct dev_pm_qos_request *req = NULL;
663
664         switch(type) {
665         case DEV_PM_QOS_RESUME_LATENCY:
666                 req = dev->power.qos->resume_latency_req;
667                 dev->power.qos->resume_latency_req = NULL;
668                 break;
669         case DEV_PM_QOS_LATENCY_TOLERANCE:
670                 req = dev->power.qos->latency_tolerance_req;
671                 dev->power.qos->latency_tolerance_req = NULL;
672                 break;
673         case DEV_PM_QOS_FLAGS:
674                 req = dev->power.qos->flags_req;
675                 dev->power.qos->flags_req = NULL;
676                 break;
677         default:
678                 WARN_ON(1);
679                 return;
680         }
681         __dev_pm_qos_remove_request(req);
682         kfree(req);
683 }
684
685 static void dev_pm_qos_drop_user_request(struct device *dev,
686                                          enum dev_pm_qos_req_type type)
687 {
688         mutex_lock(&dev_pm_qos_mtx);
689         __dev_pm_qos_drop_user_request(dev, type);
690         mutex_unlock(&dev_pm_qos_mtx);
691 }
692
693 /**
694  * dev_pm_qos_expose_latency_limit - Expose PM QoS latency limit to user space.
695  * @dev: Device whose PM QoS latency limit is to be exposed to user space.
696  * @value: Initial value of the latency limit.
697  */
698 int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
699 {
700         struct dev_pm_qos_request *req;
701         int ret;
702
703         if (!device_is_registered(dev) || value < 0)
704                 return -EINVAL;
705
706         req = kzalloc(sizeof(*req), GFP_KERNEL);
707         if (!req)
708                 return -ENOMEM;
709
710         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_RESUME_LATENCY, value);
711         if (ret < 0) {
712                 kfree(req);
713                 return ret;
714         }
715
716         mutex_lock(&dev_pm_qos_sysfs_mtx);
717
718         mutex_lock(&dev_pm_qos_mtx);
719
720         if (IS_ERR_OR_NULL(dev->power.qos))
721                 ret = -ENODEV;
722         else if (dev->power.qos->resume_latency_req)
723                 ret = -EEXIST;
724
725         if (ret < 0) {
726                 __dev_pm_qos_remove_request(req);
727                 kfree(req);
728                 mutex_unlock(&dev_pm_qos_mtx);
729                 goto out;
730         }
731         dev->power.qos->resume_latency_req = req;
732
733         mutex_unlock(&dev_pm_qos_mtx);
734
735         ret = pm_qos_sysfs_add_resume_latency(dev);
736         if (ret)
737                 dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_RESUME_LATENCY);
738
739  out:
740         mutex_unlock(&dev_pm_qos_sysfs_mtx);
741         return ret;
742 }
743 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_limit);
744
745 static void __dev_pm_qos_hide_latency_limit(struct device *dev)
746 {
747         if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->resume_latency_req)
748                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_RESUME_LATENCY);
749 }
750
751 /**
752  * dev_pm_qos_hide_latency_limit - Hide PM QoS latency limit from user space.
753  * @dev: Device whose PM QoS latency limit is to be hidden from user space.
754  */
755 void dev_pm_qos_hide_latency_limit(struct device *dev)
756 {
757         mutex_lock(&dev_pm_qos_sysfs_mtx);
758
759         pm_qos_sysfs_remove_resume_latency(dev);
760
761         mutex_lock(&dev_pm_qos_mtx);
762         __dev_pm_qos_hide_latency_limit(dev);
763         mutex_unlock(&dev_pm_qos_mtx);
764
765         mutex_unlock(&dev_pm_qos_sysfs_mtx);
766 }
767 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_limit);
768
769 /**
770  * dev_pm_qos_expose_flags - Expose PM QoS flags of a device to user space.
771  * @dev: Device whose PM QoS flags are to be exposed to user space.
772  * @val: Initial values of the flags.
773  */
774 int dev_pm_qos_expose_flags(struct device *dev, s32 val)
775 {
776         struct dev_pm_qos_request *req;
777         int ret;
778
779         if (!device_is_registered(dev))
780                 return -EINVAL;
781
782         req = kzalloc(sizeof(*req), GFP_KERNEL);
783         if (!req)
784                 return -ENOMEM;
785
786         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_FLAGS, val);
787         if (ret < 0) {
788                 kfree(req);
789                 return ret;
790         }
791
792         pm_runtime_get_sync(dev);
793         mutex_lock(&dev_pm_qos_sysfs_mtx);
794
795         mutex_lock(&dev_pm_qos_mtx);
796
797         if (IS_ERR_OR_NULL(dev->power.qos))
798                 ret = -ENODEV;
799         else if (dev->power.qos->flags_req)
800                 ret = -EEXIST;
801
802         if (ret < 0) {
803                 __dev_pm_qos_remove_request(req);
804                 kfree(req);
805                 mutex_unlock(&dev_pm_qos_mtx);
806                 goto out;
807         }
808         dev->power.qos->flags_req = req;
809
810         mutex_unlock(&dev_pm_qos_mtx);
811
812         ret = pm_qos_sysfs_add_flags(dev);
813         if (ret)
814                 dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
815
816  out:
817         mutex_unlock(&dev_pm_qos_sysfs_mtx);
818         pm_runtime_put(dev);
819         return ret;
820 }
821 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_flags);
822
823 static void __dev_pm_qos_hide_flags(struct device *dev)
824 {
825         if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->flags_req)
826                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
827 }
828
829 /**
830  * dev_pm_qos_hide_flags - Hide PM QoS flags of a device from user space.
831  * @dev: Device whose PM QoS flags are to be hidden from user space.
832  */
833 void dev_pm_qos_hide_flags(struct device *dev)
834 {
835         pm_runtime_get_sync(dev);
836         mutex_lock(&dev_pm_qos_sysfs_mtx);
837
838         pm_qos_sysfs_remove_flags(dev);
839
840         mutex_lock(&dev_pm_qos_mtx);
841         __dev_pm_qos_hide_flags(dev);
842         mutex_unlock(&dev_pm_qos_mtx);
843
844         mutex_unlock(&dev_pm_qos_sysfs_mtx);
845         pm_runtime_put(dev);
846 }
847 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_flags);
848
849 /**
850  * dev_pm_qos_update_flags - Update PM QoS flags request owned by user space.
851  * @dev: Device to update the PM QoS flags request for.
852  * @mask: Flags to set/clear.
853  * @set: Whether to set or clear the flags (true means set).
854  */
855 int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set)
856 {
857         s32 value;
858         int ret;
859
860         pm_runtime_get_sync(dev);
861         mutex_lock(&dev_pm_qos_mtx);
862
863         if (IS_ERR_OR_NULL(dev->power.qos) || !dev->power.qos->flags_req) {
864                 ret = -EINVAL;
865                 goto out;
866         }
867
868         value = dev_pm_qos_requested_flags(dev);
869         if (set)
870                 value |= mask;
871         else
872                 value &= ~mask;
873
874         ret = __dev_pm_qos_update_request(dev->power.qos->flags_req, value);
875
876  out:
877         mutex_unlock(&dev_pm_qos_mtx);
878         pm_runtime_put(dev);
879         return ret;
880 }
881
882 /**
883  * dev_pm_qos_get_user_latency_tolerance - Get user space latency tolerance.
884  * @dev: Device to obtain the user space latency tolerance for.
885  */
886 s32 dev_pm_qos_get_user_latency_tolerance(struct device *dev)
887 {
888         s32 ret;
889
890         mutex_lock(&dev_pm_qos_mtx);
891         ret = IS_ERR_OR_NULL(dev->power.qos)
892                 || !dev->power.qos->latency_tolerance_req ?
893                         PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT :
894                         dev->power.qos->latency_tolerance_req->data.pnode.prio;
895         mutex_unlock(&dev_pm_qos_mtx);
896         return ret;
897 }
898
899 /**
900  * dev_pm_qos_update_user_latency_tolerance - Update user space latency tolerance.
901  * @dev: Device to update the user space latency tolerance for.
902  * @val: New user space latency tolerance for @dev (negative values disable).
903  */
904 int dev_pm_qos_update_user_latency_tolerance(struct device *dev, s32 val)
905 {
906         int ret;
907
908         mutex_lock(&dev_pm_qos_mtx);
909
910         if (IS_ERR_OR_NULL(dev->power.qos)
911             || !dev->power.qos->latency_tolerance_req) {
912                 struct dev_pm_qos_request *req;
913
914                 if (val < 0) {
915                         if (val == PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT)
916                                 ret = 0;
917                         else
918                                 ret = -EINVAL;
919                         goto out;
920                 }
921                 req = kzalloc(sizeof(*req), GFP_KERNEL);
922                 if (!req) {
923                         ret = -ENOMEM;
924                         goto out;
925                 }
926                 ret = __dev_pm_qos_add_request(dev, req, DEV_PM_QOS_LATENCY_TOLERANCE, val);
927                 if (ret < 0) {
928                         kfree(req);
929                         goto out;
930                 }
931                 dev->power.qos->latency_tolerance_req = req;
932         } else {
933                 if (val < 0) {
934                         __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY_TOLERANCE);
935                         ret = 0;
936                 } else {
937                         ret = __dev_pm_qos_update_request(dev->power.qos->latency_tolerance_req, val);
938                 }
939         }
940
941  out:
942         mutex_unlock(&dev_pm_qos_mtx);
943         return ret;
944 }
945 EXPORT_SYMBOL_GPL(dev_pm_qos_update_user_latency_tolerance);
946
947 /**
948  * dev_pm_qos_expose_latency_tolerance - Expose latency tolerance to userspace
949  * @dev: Device whose latency tolerance to expose
950  */
951 int dev_pm_qos_expose_latency_tolerance(struct device *dev)
952 {
953         int ret;
954
955         if (!dev->power.set_latency_tolerance)
956                 return -EINVAL;
957
958         mutex_lock(&dev_pm_qos_sysfs_mtx);
959         ret = pm_qos_sysfs_add_latency_tolerance(dev);
960         mutex_unlock(&dev_pm_qos_sysfs_mtx);
961
962         return ret;
963 }
964 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_tolerance);
965
966 /**
967  * dev_pm_qos_hide_latency_tolerance - Hide latency tolerance from userspace
968  * @dev: Device whose latency tolerance to hide
969  */
970 void dev_pm_qos_hide_latency_tolerance(struct device *dev)
971 {
972         mutex_lock(&dev_pm_qos_sysfs_mtx);
973         pm_qos_sysfs_remove_latency_tolerance(dev);
974         mutex_unlock(&dev_pm_qos_sysfs_mtx);
975
976         /* Remove the request from user space now */
977         pm_runtime_get_sync(dev);
978         dev_pm_qos_update_user_latency_tolerance(dev,
979                 PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT);
980         pm_runtime_put(dev);
981 }
982 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_tolerance);