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