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