// SPDX-License-Identifier: GPL-2.0

#include <linux/blk-mq.h>
#include <linux/blk-pm.h>
#include <linux/blkdev.h>
#include <linux/pm_runtime.h>
#include "blk-mq.h"
#include "blk-mq-tag.h"

/**
 * blk_pm_runtime_init - Block layer runtime PM initialization routine
 * @q: the queue of the device
 * @dev: the device the queue belongs to
 *
 * Description:
 *    Initialize runtime-PM-related fields for @q and start auto suspend for
 *    @dev. Drivers that want to take advantage of request-based runtime PM
 *    should call this function after @dev has been initialized, and its
 *    request queue @q has been allocated, and runtime PM for it can not happen
 *    yet(either due to disabled/forbidden or its usage_count > 0). In most
 *    cases, driver should call this function before any I/O has taken place.
 *
 *    This function takes care of setting up using auto suspend for the device,
 *    the autosuspend delay is set to -1 to make runtime suspend impossible
 *    until an updated value is either set by user or by driver. Drivers do
 *    not need to touch other autosuspend settings.
 *
 *    The block layer runtime PM is request based, so only works for drivers
 *    that use request as their IO unit instead of those directly use bio's.
 */
void blk_pm_runtime_init(struct request_queue *q, struct device *dev)
{
        q->dev = dev;
        q->rpm_status = RPM_ACTIVE;
        pm_runtime_set_autosuspend_delay(q->dev, -1);
        pm_runtime_use_autosuspend(q->dev);
}
EXPORT_SYMBOL(blk_pm_runtime_init);

/**
 * blk_pre_runtime_suspend - Pre runtime suspend check
 * @q: the queue of the device
 *
 * Description:
 *    This function will check if runtime suspend is allowed for the device
 *    by examining if there are any requests pending in the queue. If there
 *    are requests pending, the device can not be runtime suspended; otherwise,
 *    the queue's status will be updated to SUSPENDING and the driver can
 *    proceed to suspend the device.
 *
 *    For the not allowed case, we mark last busy for the device so that
 *    runtime PM core will try to autosuspend it some time later.
 *
 *    This function should be called near the start of the device's
 *    runtime_suspend callback.
 *
 * Return:
 *    0         - OK to runtime suspend the device
 *    -EBUSY    - Device should not be runtime suspended
 */
int blk_pre_runtime_suspend(struct request_queue *q)
{
        int ret = 0;

        if (!q->dev)
                return ret;

        WARN_ON_ONCE(q->rpm_status != RPM_ACTIVE);

        spin_lock_irq(&q->queue_lock);
        q->rpm_status = RPM_SUSPENDING;
        spin_unlock_irq(&q->queue_lock);

        /*
         * Increase the pm_only counter before checking whether any
         * non-PM blk_queue_enter() calls are in progress to avoid that any
         * new non-PM blk_queue_enter() calls succeed before the pm_only
         * counter is decreased again.
         */
        blk_set_pm_only(q);
        ret = -EBUSY;
        /* Switch q_usage_counter from per-cpu to atomic mode. */
        blk_freeze_queue_start(q);
        /*
         * Wait until atomic mode has been reached. Since that
         * involves calling call_rcu(), it is guaranteed that later
         * blk_queue_enter() calls see the pm-only state. See also
         * http://lwn.net/Articles/573497/.
         */
        percpu_ref_switch_to_atomic_sync(&q->q_usage_counter);
        if (percpu_ref_is_zero(&q->q_usage_counter))
                ret = 0;
        /* Switch q_usage_counter back to per-cpu mode. */
        blk_mq_unfreeze_queue(q);

        if (ret < 0) {
                spin_lock_irq(&q->queue_lock);
                q->rpm_status = RPM_ACTIVE;
                pm_runtime_mark_last_busy(q->dev);
                spin_unlock_irq(&q->queue_lock);

                blk_clear_pm_only(q);
        }

        return ret;
}
EXPORT_SYMBOL(blk_pre_runtime_suspend);

/**
 * blk_post_runtime_suspend - Post runtime suspend processing
 * @q: the queue of the device
 * @err: return value of the device's runtime_suspend function
 *
 * Description:
 *    Update the queue's runtime status according to the return value of the
 *    device's runtime suspend function and mark last busy for the device so
 *    that PM core will try to auto suspend the device at a later time.
 *
 *    This function should be called near the end of the device's
 *    runtime_suspend callback.
 */
void blk_post_runtime_suspend(struct request_queue *q, int err)
{
        if (!q->dev)
                return;

        spin_lock_irq(&q->queue_lock);
        if (!err) {
                q->rpm_status = RPM_SUSPENDED;
        } else {
                q->rpm_status = RPM_ACTIVE;
                pm_runtime_mark_last_busy(q->dev);
        }
        spin_unlock_irq(&q->queue_lock);

        if (err)
                blk_clear_pm_only(q);
}
EXPORT_SYMBOL(blk_post_runtime_suspend);

/**
 * blk_pre_runtime_resume - Pre runtime resume processing
 * @q: the queue of the device
 *
 * Description:
 *    Update the queue's runtime status to RESUMING in preparation for the
 *    runtime resume of the device.
 *
 *    This function should be called near the start of the device's
 *    runtime_resume callback.
 */
void blk_pre_runtime_resume(struct request_queue *q)
{
        if (!q->dev)
                return;

        spin_lock_irq(&q->queue_lock);
        q->rpm_status = RPM_RESUMING;
        spin_unlock_irq(&q->queue_lock);
}
EXPORT_SYMBOL(blk_pre_runtime_resume);

/**
 * blk_post_runtime_resume - Post runtime resume processing
 * @q: the queue of the device
 * @err: return value of the device's runtime_resume function
 *
 * Description:
 *    Update the queue's runtime status according to the return value of the
 *    device's runtime_resume function. If the resume was successful, call
 *    blk_set_runtime_active() to do the real work of restarting the queue.
 *
 *    This function should be called near the end of the device's
 *    runtime_resume callback.
 */
void blk_post_runtime_resume(struct request_queue *q, int err)
{
        if (!q->dev)
                return;
        if (!err) {
                blk_set_runtime_active(q);
        } else {
                spin_lock_irq(&q->queue_lock);
                q->rpm_status = RPM_SUSPENDED;
                spin_unlock_irq(&q->queue_lock);
        }
}
EXPORT_SYMBOL(blk_post_runtime_resume);

/**
 * blk_set_runtime_active - Force runtime status of the queue to be active
 * @q: the queue of the device
 *
 * If the device is left runtime suspended during system suspend the resume
 * hook typically resumes the device and corrects runtime status
 * accordingly. However, that does not affect the queue runtime PM status
 * which is still "suspended". This prevents processing requests from the
 * queue.
 *
 * This function can be used in driver's resume hook to correct queue
 * runtime PM status and re-enable peeking requests from the queue. It
 * should be called before first request is added to the queue.
 *
 * This function is also called by blk_post_runtime_resume() for successful
 * runtime resumes.  It does everything necessary to restart the queue.
 */
void blk_set_runtime_active(struct request_queue *q)
{
        int old_status;

        if (!q->dev)
                return;

        spin_lock_irq(&q->queue_lock);
        old_status = q->rpm_status;
        q->rpm_status = RPM_ACTIVE;
        pm_runtime_mark_last_busy(q->dev);
        pm_request_autosuspend(q->dev);
        spin_unlock_irq(&q->queue_lock);

        if (old_status != RPM_ACTIVE)
                blk_clear_pm_only(q);
}
EXPORT_SYMBOL(blk_set_runtime_active);