block/blk-pm.c

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