block/blk-pm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include <linux/blk-mq.h>
   4 #include <linux/blk-pm.h>
   5 #include <linux/blkdev.h>
   6 #include <linux/pm_runtime.h>
   7 #include "blk-mq.h"
   8 #include "blk-mq-tag.h"
   9
  10 /**
  11  * blk_pm_runtime_init - Block layer runtime PM initialization routine
  12  * @q: the queue of the device
  13  * @dev: the device the queue belongs to
  14  *
  15  * Description:
  16  *    Initialize runtime-PM-related fields for @q and start auto suspend for
  17  *    @dev. Drivers that want to take advantage of request-based runtime PM
  18  *    should call this function after @dev has been initialized, and its
  19  *    request queue @q has been allocated, and runtime PM for it can not happen
  20  *    yet(either due to disabled/forbidden or its usage_count > 0). In most
  21  *    cases, driver should call this function before any I/O has taken place.
  22  *
  23  *    This function takes care of setting up using auto suspend for the device,
  24  *    the autosuspend delay is set to -1 to make runtime suspend impossible
  25  *    until an updated value is either set by user or by driver. Drivers do
  26  *    not need to touch other autosuspend settings.
  27  *
  28  *    The block layer runtime PM is request based, so only works for drivers
  29  *    that use request as their IO unit instead of those directly use bio's.
  30  */
  31 void blk_pm_runtime_init(struct request_queue *q, struct device *dev)
  32 {
  33         q->dev = dev;
  34         q->rpm_status = RPM_ACTIVE;
  35         pm_runtime_set_autosuspend_delay(q->dev, -1);
  36         pm_runtime_use_autosuspend(q->dev);
  37 }
  38 EXPORT_SYMBOL(blk_pm_runtime_init);
  39
  40 /**
  41  * blk_pre_runtime_suspend - Pre runtime suspend check
  42  * @q: the queue of the device
  43  *
  44  * Description:
  45  *    This function will check if runtime suspend is allowed for the device
  46  *    by examining if there are any requests pending in the queue. If there
  47  *    are requests pending, the device can not be runtime suspended; otherwise,
  48  *    the queue's status will be updated to SUSPENDING and the driver can
  49  *    proceed to suspend the device.
  50  *
  51  *    For the not allowed case, we mark last busy for the device so that
  52  *    runtime PM core will try to autosuspend it some time later.
  53  *
  54  *    This function should be called near the start of the device's
  55  *    runtime_suspend callback.
  56  *
  57  * Return:
  58  *    0         - OK to runtime suspend the device
  59  *    -EBUSY    - Device should not be runtime suspended
  60  */
  61 int blk_pre_runtime_suspend(struct request_queue *q)
  62 {
  63         int ret = 0;
  64
  65         if (!q->dev)
  66                 return ret;
  67
  68         WARN_ON_ONCE(q->rpm_status != RPM_ACTIVE);
  69
  70         spin_lock_irq(&q->queue_lock);
  71         q->rpm_status = RPM_SUSPENDING;
  72         spin_unlock_irq(&q->queue_lock);
  73
  74         /*
  75          * Increase the pm_only counter before checking whether any
  76          * non-PM blk_queue_enter() calls are in progress to avoid that any
  77          * new non-PM blk_queue_enter() calls succeed before the pm_only
  78          * counter is decreased again.
  79          */
  80         blk_set_pm_only(q);
  81         ret = -EBUSY;
  82         /* Switch q_usage_counter from per-cpu to atomic mode. */
  83         blk_freeze_queue_start(q);
  84         /*
  85          * Wait until atomic mode has been reached. Since that
  86          * involves calling call_rcu(), it is guaranteed that later
  87          * blk_queue_enter() calls see the pm-only state. See also
  88          * http://lwn.net/Articles/573497/.
  89          */
  90         percpu_ref_switch_to_atomic_sync(&q->q_usage_counter);
  91         if (percpu_ref_is_zero(&q->q_usage_counter))
  92                 ret = 0;
  93         /* Switch q_usage_counter back to per-cpu mode. */
  94         blk_mq_unfreeze_queue(q);
  95
  96         if (ret < 0) {
  97                 spin_lock_irq(&q->queue_lock);
  98                 q->rpm_status = RPM_ACTIVE;
  99                 pm_runtime_mark_last_busy(q->dev);
 100                 spin_unlock_irq(&q->queue_lock);
 101
 102                 blk_clear_pm_only(q);
 103         }
 104
 105         return ret;
 106 }
 107 EXPORT_SYMBOL(blk_pre_runtime_suspend);
 108
 109 /**
 110  * blk_post_runtime_suspend - Post runtime suspend processing
 111  * @q: the queue of the device
 112  * @err: return value of the device's runtime_suspend function
 113  *
 114  * Description:
 115  *    Update the queue's runtime status according to the return value of the
 116  *    device's runtime suspend function and mark last busy for the device so
 117  *    that PM core will try to auto suspend the device at a later time.
 118  *
 119  *    This function should be called near the end of the device's
 120  *    runtime_suspend callback.
 121  */
 122 void blk_post_runtime_suspend(struct request_queue *q, int err)
 123 {
 124         if (!q->dev)
 125                 return;
 126
 127         spin_lock_irq(&q->queue_lock);
 128         if (!err) {
 129                 q->rpm_status = RPM_SUSPENDED;
 130         } else {
 131                 q->rpm_status = RPM_ACTIVE;
 132                 pm_runtime_mark_last_busy(q->dev);
 133         }
 134         spin_unlock_irq(&q->queue_lock);
 135
 136         if (err)
 137                 blk_clear_pm_only(q);
 138 }
 139 EXPORT_SYMBOL(blk_post_runtime_suspend);
 140
 141 /**
 142  * blk_pre_runtime_resume - Pre runtime resume processing
 143  * @q: the queue of the device
 144  *
 145  * Description:
 146  *    Update the queue's runtime status to RESUMING in preparation for the
 147  *    runtime resume of the device.
 148  *
 149  *    This function should be called near the start of the device's
 150  *    runtime_resume callback.
 151  */
 152 void blk_pre_runtime_resume(struct request_queue *q)
 153 {
 154         if (!q->dev)
 155                 return;
 156
 157         spin_lock_irq(&q->queue_lock);
 158         q->rpm_status = RPM_RESUMING;
 159         spin_unlock_irq(&q->queue_lock);
 160 }
 161 EXPORT_SYMBOL(blk_pre_runtime_resume);
 162
 163 /**
 164  * blk_post_runtime_resume - Post runtime resume processing
 165  * @q: the queue of the device
 166  * @err: return value of the device's runtime_resume function
 167  *
 168  * Description:
 169  *    Update the queue's runtime status according to the return value of the
 170  *    device's runtime_resume function. If the resume was successful, call
 171  *    blk_set_runtime_active() to do the real work of restarting the queue.
 172  *
 173  *    This function should be called near the end of the device's
 174  *    runtime_resume callback.
 175  */
 176 void blk_post_runtime_resume(struct request_queue *q, int err)
 177 {
 178         if (!q->dev)
 179                 return;
 180         if (!err) {
 181                 blk_set_runtime_active(q);
 182         } else {
 183                 spin_lock_irq(&q->queue_lock);
 184                 q->rpm_status = RPM_SUSPENDED;
 185                 spin_unlock_irq(&q->queue_lock);
 186         }
 187 }
 188 EXPORT_SYMBOL(blk_post_runtime_resume);
 189
 190 /**
 191  * blk_set_runtime_active - Force runtime status of the queue to be active
 192  * @q: the queue of the device
 193  *
 194  * If the device is left runtime suspended during system suspend the resume
 195  * hook typically resumes the device and corrects runtime status
 196  * accordingly. However, that does not affect the queue runtime PM status
 197  * which is still "suspended". This prevents processing requests from the
 198  * queue.
 199  *
 200  * This function can be used in driver's resume hook to correct queue
 201  * runtime PM status and re-enable peeking requests from the queue. It
 202  * should be called before first request is added to the queue.
 203  *
 204  * This function is also called by blk_post_runtime_resume() for successful
 205  * runtime resumes.  It does everything necessary to restart the queue.
 206  */
 207 void blk_set_runtime_active(struct request_queue *q)
 208 {
 209         int old_status;
 210
 211         if (!q->dev)
 212                 return;
 213
 214         spin_lock_irq(&q->queue_lock);
 215         old_status = q->rpm_status;
 216         q->rpm_status = RPM_ACTIVE;
 217         pm_runtime_mark_last_busy(q->dev);
 218         pm_request_autosuspend(q->dev);
 219         spin_unlock_irq(&q->queue_lock);
 220
 221         if (old_status != RPM_ACTIVE)
 222                 blk_clear_pm_only(q);
 223 }
 224 EXPORT_SYMBOL(blk_set_runtime_active);