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