192 lines · c
1// SPDX-License-Identifier: GPL-2.02 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 routine10 * @q: the queue of the device11 * @dev: the device the queue belongs to12 *13 * Description:14 * Initialize runtime-PM-related fields for @q and start auto suspend for15 * @dev. Drivers that want to take advantage of request-based runtime PM16 * should call this function after @dev has been initialized, and its17 * request queue @q has been allocated, and runtime PM for it can not happen18 * yet(either due to disabled/forbidden or its usage_count > 0). In most19 * 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 impossible23 * until an updated value is either set by user or by driver. Drivers do24 * not need to touch other autosuspend settings.25 *26 * The block layer runtime PM is request based, so only works for drivers27 * that use request as their IO unit instead of those directly use bio's.28 */29void 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}36EXPORT_SYMBOL(blk_pm_runtime_init);37 38/**39 * blk_pre_runtime_suspend - Pre runtime suspend check40 * @q: the queue of the device41 *42 * Description:43 * This function will check if runtime suspend is allowed for the device44 * by examining if there are any requests pending in the queue. If there45 * are requests pending, the device can not be runtime suspended; otherwise,46 * the queue's status will be updated to SUSPENDING and the driver can47 * proceed to suspend the device.48 *49 * For the not allowed case, we mark last busy for the device so that50 * runtime PM core will try to autosuspend it some time later.51 *52 * This function should be called near the start of the device's53 * runtime_suspend callback.54 *55 * Return:56 * 0 - OK to runtime suspend the device57 * -EBUSY - Device should not be runtime suspended58 */59int 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 any74 * non-PM blk_queue_enter() calls are in progress to avoid that any75 * new non-PM blk_queue_enter() calls succeed before the pm_only76 * 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 that84 * involves calling call_rcu(), it is guaranteed that later85 * blk_queue_enter() calls see the pm-only state. See also86 * 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}105EXPORT_SYMBOL(blk_pre_runtime_suspend);106 107/**108 * blk_post_runtime_suspend - Post runtime suspend processing109 * @q: the queue of the device110 * @err: return value of the device's runtime_suspend function111 *112 * Description:113 * Update the queue's runtime status according to the return value of the114 * device's runtime suspend function and mark last busy for the device so115 * 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's118 * runtime_suspend callback.119 */120void 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}137EXPORT_SYMBOL(blk_post_runtime_suspend);138 139/**140 * blk_pre_runtime_resume - Pre runtime resume processing141 * @q: the queue of the device142 *143 * Description:144 * Update the queue's runtime status to RESUMING in preparation for the145 * runtime resume of the device.146 *147 * This function should be called near the start of the device's148 * runtime_resume callback.149 */150void 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}159EXPORT_SYMBOL(blk_pre_runtime_resume);160 161/**162 * blk_post_runtime_resume - Post runtime resume processing163 * @q: the queue of the device164 *165 * Description:166 * Restart the queue of a runtime suspended device. It does this regardless167 * of whether the device's runtime-resume succeeded; even if it failed the168 * driver or error handler will need to communicate with the device.169 *170 * This function should be called near the end of the device's171 * runtime_resume callback to correct queue runtime PM status and re-enable172 * peeking requests from the queue.173 */174void blk_post_runtime_resume(struct request_queue *q)175{176 int old_status;177 178 if (!q->dev)179 return;180 181 spin_lock_irq(&q->queue_lock);182 old_status = q->rpm_status;183 q->rpm_status = RPM_ACTIVE;184 pm_runtime_mark_last_busy(q->dev);185 pm_request_autosuspend(q->dev);186 spin_unlock_irq(&q->queue_lock);187 188 if (old_status != RPM_ACTIVE)189 blk_clear_pm_only(q);190}191EXPORT_SYMBOL(blk_post_runtime_resume);192