// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Universal Flash Storage Host controller driver Core
 * Copyright (C) 2011-2013 Samsung India Software Operations
 * Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
 *
 * Authors:
 *      Santosh Yaraganavi <santosh.sy@samsung.com>
 *      Vinayak Holikatti <h.vinayak@samsung.com>
 */

#include <linux/async.h>
#include <linux/devfreq.h>
#include <linux/nls.h>
#include <linux/of.h>
#include <linux/bitfield.h>
#include <linux/blk-pm.h>
#include <linux/blkdev.h>
#include <scsi/scsi_driver.h>
#include "ufshcd.h"
#include "ufs_quirks.h"
#include "unipro.h"
#include "ufs-sysfs.h"
#include "ufs-debugfs.h"
#include "ufs_bsg.h"
#include "ufshcd-crypto.h"
#include <asm/unaligned.h>
#include "../sd.h"

#define CREATE_TRACE_POINTS
#include <trace/events/ufs.h>

#define UFSHCD_ENABLE_INTRS     (UTP_TRANSFER_REQ_COMPL |\
                                 UTP_TASK_REQ_COMPL |\
                                 UFSHCD_ERROR_MASK)
/* UIC command timeout, unit: ms */
#define UIC_CMD_TIMEOUT 500

/* NOP OUT retries waiting for NOP IN response */
#define NOP_OUT_RETRIES    10
/* Timeout after 50 msecs if NOP OUT hangs without response */
#define NOP_OUT_TIMEOUT    50 /* msecs */

/* Query request retries */
#define QUERY_REQ_RETRIES 3
/* Query request timeout */
#define QUERY_REQ_TIMEOUT 1500 /* 1.5 seconds */

/* Task management command timeout */
#define TM_CMD_TIMEOUT  100 /* msecs */

/* maximum number of retries for a general UIC command  */
#define UFS_UIC_COMMAND_RETRIES 3

/* maximum number of link-startup retries */
#define DME_LINKSTARTUP_RETRIES 3

/* Maximum retries for Hibern8 enter */
#define UIC_HIBERN8_ENTER_RETRIES 3

/* maximum number of reset retries before giving up */
#define MAX_HOST_RESET_RETRIES 5

/* Expose the flag value from utp_upiu_query.value */
#define MASK_QUERY_UPIU_FLAG_LOC 0xFF

/* Interrupt aggregation default timeout, unit: 40us */
#define INT_AGGR_DEF_TO 0x02

/* default delay of autosuspend: 2000 ms */
#define RPM_AUTOSUSPEND_DELAY_MS 2000

/* Default delay of RPM device flush delayed work */
#define RPM_DEV_FLUSH_RECHECK_WORK_DELAY_MS 5000

/* Default value of wait time before gating device ref clock */
#define UFSHCD_REF_CLK_GATING_WAIT_US 0xFF /* microsecs */

/* Polling time to wait for fDeviceInit */
#define FDEVICEINIT_COMPL_TIMEOUT 1500 /* millisecs */

#define wlun_dev_to_hba(dv) shost_priv(to_scsi_device(dv)->host)

#define ufshcd_toggle_vreg(_dev, _vreg, _on)                            \
        ({                                                              \
                int _ret;                                               \
                if (_on)                                                \
                        _ret = ufshcd_enable_vreg(_dev, _vreg);         \
                else                                                    \
                        _ret = ufshcd_disable_vreg(_dev, _vreg);        \
                _ret;                                                   \
        })

#define ufshcd_hex_dump(prefix_str, buf, len) do {                       \
        size_t __len = (len);                                            \
        print_hex_dump(KERN_ERR, prefix_str,                             \
                       __len > 4 ? DUMP_PREFIX_OFFSET : DUMP_PREFIX_NONE,\
                       16, 4, buf, __len, false);                        \
} while (0)

int ufshcd_dump_regs(struct ufs_hba *hba, size_t offset, size_t len,
                     const char *prefix)
{
        u32 *regs;
        size_t pos;

        if (offset % 4 != 0 || len % 4 != 0) /* keep readl happy */
                return -EINVAL;

        regs = kzalloc(len, GFP_ATOMIC);
        if (!regs)
                return -ENOMEM;

        for (pos = 0; pos < len; pos += 4)
                regs[pos / 4] = ufshcd_readl(hba, offset + pos);

        ufshcd_hex_dump(prefix, regs, len);
        kfree(regs);

        return 0;
}
EXPORT_SYMBOL_GPL(ufshcd_dump_regs);

enum {
        UFSHCD_MAX_CHANNEL      = 0,
        UFSHCD_MAX_ID           = 1,
        UFSHCD_CMD_PER_LUN      = 32,
        UFSHCD_CAN_QUEUE        = 32,
};

/* UFSHCD states */
enum {
        UFSHCD_STATE_RESET,
        UFSHCD_STATE_ERROR,
        UFSHCD_STATE_OPERATIONAL,
        UFSHCD_STATE_EH_SCHEDULED_FATAL,
        UFSHCD_STATE_EH_SCHEDULED_NON_FATAL,
};

/* UFSHCD error handling flags */
enum {
        UFSHCD_EH_IN_PROGRESS = (1 << 0),
};

/* UFSHCD UIC layer error flags */
enum {
        UFSHCD_UIC_DL_PA_INIT_ERROR = (1 << 0), /* Data link layer error */
        UFSHCD_UIC_DL_NAC_RECEIVED_ERROR = (1 << 1), /* Data link layer error */
        UFSHCD_UIC_DL_TCx_REPLAY_ERROR = (1 << 2), /* Data link layer error */
        UFSHCD_UIC_NL_ERROR = (1 << 3), /* Network layer error */
        UFSHCD_UIC_TL_ERROR = (1 << 4), /* Transport Layer error */
        UFSHCD_UIC_DME_ERROR = (1 << 5), /* DME error */
        UFSHCD_UIC_PA_GENERIC_ERROR = (1 << 6), /* Generic PA error */
};

#define ufshcd_set_eh_in_progress(h) \
        ((h)->eh_flags |= UFSHCD_EH_IN_PROGRESS)
#define ufshcd_eh_in_progress(h) \
        ((h)->eh_flags & UFSHCD_EH_IN_PROGRESS)
#define ufshcd_clear_eh_in_progress(h) \
        ((h)->eh_flags &= ~UFSHCD_EH_IN_PROGRESS)

struct ufs_pm_lvl_states ufs_pm_lvl_states[] = {
        [UFS_PM_LVL_0] = {UFS_ACTIVE_PWR_MODE, UIC_LINK_ACTIVE_STATE},
        [UFS_PM_LVL_1] = {UFS_ACTIVE_PWR_MODE, UIC_LINK_HIBERN8_STATE},
        [UFS_PM_LVL_2] = {UFS_SLEEP_PWR_MODE, UIC_LINK_ACTIVE_STATE},
        [UFS_PM_LVL_3] = {UFS_SLEEP_PWR_MODE, UIC_LINK_HIBERN8_STATE},
        [UFS_PM_LVL_4] = {UFS_POWERDOWN_PWR_MODE, UIC_LINK_HIBERN8_STATE},
        [UFS_PM_LVL_5] = {UFS_POWERDOWN_PWR_MODE, UIC_LINK_OFF_STATE},
        /*
         * For DeepSleep, the link is first put in hibern8 and then off.
         * Leaving the link in hibern8 is not supported.
         */
        [UFS_PM_LVL_6] = {UFS_DEEPSLEEP_PWR_MODE, UIC_LINK_OFF_STATE},
};

static inline enum ufs_dev_pwr_mode
ufs_get_pm_lvl_to_dev_pwr_mode(enum ufs_pm_level lvl)
{
        return ufs_pm_lvl_states[lvl].dev_state;
}

static inline enum uic_link_state
ufs_get_pm_lvl_to_link_pwr_state(enum ufs_pm_level lvl)
{
        return ufs_pm_lvl_states[lvl].link_state;
}

static inline enum ufs_pm_level
ufs_get_desired_pm_lvl_for_dev_link_state(enum ufs_dev_pwr_mode dev_state,
                                        enum uic_link_state link_state)
{
        enum ufs_pm_level lvl;

        for (lvl = UFS_PM_LVL_0; lvl < UFS_PM_LVL_MAX; lvl++) {
                if ((ufs_pm_lvl_states[lvl].dev_state == dev_state) &&
                        (ufs_pm_lvl_states[lvl].link_state == link_state))
                        return lvl;
        }

        /* if no match found, return the level 0 */
        return UFS_PM_LVL_0;
}

static struct ufs_dev_fix ufs_fixups[] = {
        /* UFS cards deviations table */
        UFS_FIX(UFS_VENDOR_MICRON, UFS_ANY_MODEL,
                UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM),
        UFS_FIX(UFS_VENDOR_SAMSUNG, UFS_ANY_MODEL,
                UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM |
                UFS_DEVICE_QUIRK_HOST_PA_TACTIVATE |
                UFS_DEVICE_QUIRK_RECOVERY_FROM_DL_NAC_ERRORS),
        UFS_FIX(UFS_VENDOR_SKHYNIX, UFS_ANY_MODEL,
                UFS_DEVICE_QUIRK_HOST_PA_SAVECONFIGTIME),
        UFS_FIX(UFS_VENDOR_SKHYNIX, "hB8aL1" /*H28U62301AMR*/,
                UFS_DEVICE_QUIRK_HOST_VS_DEBUGSAVECONFIGTIME),
        UFS_FIX(UFS_VENDOR_TOSHIBA, UFS_ANY_MODEL,
                UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM),
        UFS_FIX(UFS_VENDOR_TOSHIBA, "THGLF2G9C8KBADG",
                UFS_DEVICE_QUIRK_PA_TACTIVATE),
        UFS_FIX(UFS_VENDOR_TOSHIBA, "THGLF2G9D8KBADG",
                UFS_DEVICE_QUIRK_PA_TACTIVATE),
        END_FIX
};

static irqreturn_t ufshcd_tmc_handler(struct ufs_hba *hba);
static void ufshcd_async_scan(void *data, async_cookie_t cookie);
static int ufshcd_reset_and_restore(struct ufs_hba *hba);
static int ufshcd_eh_host_reset_handler(struct scsi_cmnd *cmd);
static int ufshcd_clear_tm_cmd(struct ufs_hba *hba, int tag);
static void ufshcd_hba_exit(struct ufs_hba *hba);
static int ufshcd_clear_ua_wluns(struct ufs_hba *hba);
static int ufshcd_probe_hba(struct ufs_hba *hba, bool async);
static int ufshcd_setup_clocks(struct ufs_hba *hba, bool on);
static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba);
static inline void ufshcd_add_delay_before_dme_cmd(struct ufs_hba *hba);
static int ufshcd_host_reset_and_restore(struct ufs_hba *hba);
static void ufshcd_resume_clkscaling(struct ufs_hba *hba);
static void ufshcd_suspend_clkscaling(struct ufs_hba *hba);
static void __ufshcd_suspend_clkscaling(struct ufs_hba *hba);
static int ufshcd_scale_clks(struct ufs_hba *hba, bool scale_up);
static irqreturn_t ufshcd_intr(int irq, void *__hba);
static int ufshcd_change_power_mode(struct ufs_hba *hba,
                             struct ufs_pa_layer_attr *pwr_mode);
static void ufshcd_schedule_eh_work(struct ufs_hba *hba);
static int ufshcd_setup_hba_vreg(struct ufs_hba *hba, bool on);
static int ufshcd_setup_vreg(struct ufs_hba *hba, bool on);
static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
                                         struct ufs_vreg *vreg);
static int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
static void ufshcd_wb_toggle_flush_during_h8(struct ufs_hba *hba, bool set);
static inline void ufshcd_wb_toggle_flush(struct ufs_hba *hba, bool enable);
static void ufshcd_hba_vreg_set_lpm(struct ufs_hba *hba);
static void ufshcd_hba_vreg_set_hpm(struct ufs_hba *hba);

static inline bool ufshcd_valid_tag(struct ufs_hba *hba, int tag)
{
        return tag >= 0 && tag < hba->nutrs;
}

static inline void ufshcd_enable_irq(struct ufs_hba *hba)
{
        if (!hba->is_irq_enabled) {
                enable_irq(hba->irq);
                hba->is_irq_enabled = true;
        }
}

static inline void ufshcd_disable_irq(struct ufs_hba *hba)
{
        if (hba->is_irq_enabled) {
                disable_irq(hba->irq);
                hba->is_irq_enabled = false;
        }
}

static inline void ufshcd_wb_config(struct ufs_hba *hba)
{
        if (!ufshcd_is_wb_allowed(hba))
                return;

        ufshcd_wb_toggle(hba, true);

        ufshcd_wb_toggle_flush_during_h8(hba, true);
        if (!(hba->quirks & UFSHCI_QUIRK_SKIP_MANUAL_WB_FLUSH_CTRL))
                ufshcd_wb_toggle_flush(hba, true);
}

static void ufshcd_scsi_unblock_requests(struct ufs_hba *hba)
{
        if (atomic_dec_and_test(&hba->scsi_block_reqs_cnt))
                scsi_unblock_requests(hba->host);
}

static void ufshcd_scsi_block_requests(struct ufs_hba *hba)
{
        if (atomic_inc_return(&hba->scsi_block_reqs_cnt) == 1)
                scsi_block_requests(hba->host);
}

static void ufshcd_add_cmd_upiu_trace(struct ufs_hba *hba, unsigned int tag,
                                      enum ufs_trace_str_t str_t)
{
        struct utp_upiu_req *rq = hba->lrb[tag].ucd_req_ptr;
        struct utp_upiu_header *header;

        if (!trace_ufshcd_upiu_enabled())
                return;

        if (str_t == UFS_CMD_SEND)
                header = &rq->header;
        else
                header = &hba->lrb[tag].ucd_rsp_ptr->header;

        trace_ufshcd_upiu(dev_name(hba->dev), str_t, header, &rq->sc.cdb,
                          UFS_TSF_CDB);
}

static void ufshcd_add_query_upiu_trace(struct ufs_hba *hba,
                                        enum ufs_trace_str_t str_t,
                                        struct utp_upiu_req *rq_rsp)
{
        if (!trace_ufshcd_upiu_enabled())
                return;

        trace_ufshcd_upiu(dev_name(hba->dev), str_t, &rq_rsp->header,
                          &rq_rsp->qr, UFS_TSF_OSF);
}

static void ufshcd_add_tm_upiu_trace(struct ufs_hba *hba, unsigned int tag,
                                     enum ufs_trace_str_t str_t)
{
        int off = (int)tag - hba->nutrs;
        struct utp_task_req_desc *descp = &hba->utmrdl_base_addr[off];

        if (!trace_ufshcd_upiu_enabled())
                return;

        if (str_t == UFS_TM_SEND)
                trace_ufshcd_upiu(dev_name(hba->dev), str_t,
                                  &descp->upiu_req.req_header,
                                  &descp->upiu_req.input_param1,
                                  UFS_TSF_TM_INPUT);
        else
                trace_ufshcd_upiu(dev_name(hba->dev), str_t,
                                  &descp->upiu_rsp.rsp_header,
                                  &descp->upiu_rsp.output_param1,
                                  UFS_TSF_TM_OUTPUT);
}

static void ufshcd_add_uic_command_trace(struct ufs_hba *hba,
                                         struct uic_command *ucmd,
                                         enum ufs_trace_str_t str_t)
{
        u32 cmd;

        if (!trace_ufshcd_uic_command_enabled())
                return;

        if (str_t == UFS_CMD_SEND)
                cmd = ucmd->command;
        else
                cmd = ufshcd_readl(hba, REG_UIC_COMMAND);

        trace_ufshcd_uic_command(dev_name(hba->dev), str_t, cmd,
                                 ufshcd_readl(hba, REG_UIC_COMMAND_ARG_1),
                                 ufshcd_readl(hba, REG_UIC_COMMAND_ARG_2),
                                 ufshcd_readl(hba, REG_UIC_COMMAND_ARG_3));
}

static void ufshcd_add_command_trace(struct ufs_hba *hba, unsigned int tag,
                                     enum ufs_trace_str_t str_t)
{
        u64 lba = -1;
        u8 opcode = 0, group_id = 0;
        u32 intr, doorbell;
        struct ufshcd_lrb *lrbp = &hba->lrb[tag];
        struct scsi_cmnd *cmd = lrbp->cmd;
        int transfer_len = -1;

        if (!cmd)
                return;

        if (!trace_ufshcd_command_enabled()) {
                /* trace UPIU W/O tracing command */
                ufshcd_add_cmd_upiu_trace(hba, tag, str_t);
                return;
        }

        /* trace UPIU also */
        ufshcd_add_cmd_upiu_trace(hba, tag, str_t);
        opcode = cmd->cmnd[0];
        lba = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request));

        if (opcode == READ_10 || opcode == WRITE_10) {
                /*
                 * Currently we only fully trace read(10) and write(10) commands
                 */
                transfer_len =
                       be32_to_cpu(lrbp->ucd_req_ptr->sc.exp_data_transfer_len);
                if (opcode == WRITE_10)
                        group_id = lrbp->cmd->cmnd[6];
        } else if (opcode == UNMAP) {
                /*
                 * The number of Bytes to be unmapped beginning with the lba.
                 */
                transfer_len = blk_rq_bytes(cmd->request);
        }

        intr = ufshcd_readl(hba, REG_INTERRUPT_STATUS);
        doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
        trace_ufshcd_command(dev_name(hba->dev), str_t, tag,
                        doorbell, transfer_len, intr, lba, opcode, group_id);
}

static void ufshcd_print_clk_freqs(struct ufs_hba *hba)
{
        struct ufs_clk_info *clki;
        struct list_head *head = &hba->clk_list_head;

        if (list_empty(head))
                return;

        list_for_each_entry(clki, head, list) {
                if (!IS_ERR_OR_NULL(clki->clk) && clki->min_freq &&
                                clki->max_freq)
                        dev_err(hba->dev, "clk: %s, rate: %u\n",
                                        clki->name, clki->curr_freq);
        }
}

static void ufshcd_print_evt(struct ufs_hba *hba, u32 id,
                             char *err_name)
{
        int i;
        bool found = false;
        struct ufs_event_hist *e;

        if (id >= UFS_EVT_CNT)
                return;

        e = &hba->ufs_stats.event[id];

        for (i = 0; i < UFS_EVENT_HIST_LENGTH; i++) {
                int p = (i + e->pos) % UFS_EVENT_HIST_LENGTH;

                if (e->tstamp[p] == 0)
                        continue;
                dev_err(hba->dev, "%s[%d] = 0x%x at %lld us\n", err_name, p,
                        e->val[p], ktime_to_us(e->tstamp[p]));
                found = true;
        }

        if (!found)
                dev_err(hba->dev, "No record of %s\n", err_name);
        else
                dev_err(hba->dev, "%s: total cnt=%llu\n", err_name, e->cnt);
}

static void ufshcd_print_evt_hist(struct ufs_hba *hba)
{
        ufshcd_dump_regs(hba, 0, UFSHCI_REG_SPACE_SIZE, "host_regs: ");

        ufshcd_print_evt(hba, UFS_EVT_PA_ERR, "pa_err");
        ufshcd_print_evt(hba, UFS_EVT_DL_ERR, "dl_err");
        ufshcd_print_evt(hba, UFS_EVT_NL_ERR, "nl_err");
        ufshcd_print_evt(hba, UFS_EVT_TL_ERR, "tl_err");
        ufshcd_print_evt(hba, UFS_EVT_DME_ERR, "dme_err");
        ufshcd_print_evt(hba, UFS_EVT_AUTO_HIBERN8_ERR,
                         "auto_hibern8_err");
        ufshcd_print_evt(hba, UFS_EVT_FATAL_ERR, "fatal_err");
        ufshcd_print_evt(hba, UFS_EVT_LINK_STARTUP_FAIL,
                         "link_startup_fail");
        ufshcd_print_evt(hba, UFS_EVT_RESUME_ERR, "resume_fail");
        ufshcd_print_evt(hba, UFS_EVT_SUSPEND_ERR,
                         "suspend_fail");
        ufshcd_print_evt(hba, UFS_EVT_DEV_RESET, "dev_reset");
        ufshcd_print_evt(hba, UFS_EVT_HOST_RESET, "host_reset");
        ufshcd_print_evt(hba, UFS_EVT_ABORT, "task_abort");

        ufshcd_vops_dbg_register_dump(hba);
}

static
void ufshcd_print_trs(struct ufs_hba *hba, unsigned long bitmap, bool pr_prdt)
{
        struct ufshcd_lrb *lrbp;
        int prdt_length;
        int tag;

        for_each_set_bit(tag, &bitmap, hba->nutrs) {
                lrbp = &hba->lrb[tag];

                dev_err(hba->dev, "UPIU[%d] - issue time %lld us\n",
                                tag, ktime_to_us(lrbp->issue_time_stamp));
                dev_err(hba->dev, "UPIU[%d] - complete time %lld us\n",
                                tag, ktime_to_us(lrbp->compl_time_stamp));
                dev_err(hba->dev,
                        "UPIU[%d] - Transfer Request Descriptor phys@0x%llx\n",
                        tag, (u64)lrbp->utrd_dma_addr);

                ufshcd_hex_dump("UPIU TRD: ", lrbp->utr_descriptor_ptr,
                                sizeof(struct utp_transfer_req_desc));
                dev_err(hba->dev, "UPIU[%d] - Request UPIU phys@0x%llx\n", tag,
                        (u64)lrbp->ucd_req_dma_addr);
                ufshcd_hex_dump("UPIU REQ: ", lrbp->ucd_req_ptr,
                                sizeof(struct utp_upiu_req));
                dev_err(hba->dev, "UPIU[%d] - Response UPIU phys@0x%llx\n", tag,
                        (u64)lrbp->ucd_rsp_dma_addr);
                ufshcd_hex_dump("UPIU RSP: ", lrbp->ucd_rsp_ptr,
                                sizeof(struct utp_upiu_rsp));

                prdt_length = le16_to_cpu(
                        lrbp->utr_descriptor_ptr->prd_table_length);
                if (hba->quirks & UFSHCD_QUIRK_PRDT_BYTE_GRAN)
                        prdt_length /= sizeof(struct ufshcd_sg_entry);

                dev_err(hba->dev,
                        "UPIU[%d] - PRDT - %d entries  phys@0x%llx\n",
                        tag, prdt_length,
                        (u64)lrbp->ucd_prdt_dma_addr);

                if (pr_prdt)
                        ufshcd_hex_dump("UPIU PRDT: ", lrbp->ucd_prdt_ptr,
                                sizeof(struct ufshcd_sg_entry) * prdt_length);
        }
}

static void ufshcd_print_tmrs(struct ufs_hba *hba, unsigned long bitmap)
{
        int tag;

        for_each_set_bit(tag, &bitmap, hba->nutmrs) {
                struct utp_task_req_desc *tmrdp = &hba->utmrdl_base_addr[tag];

                dev_err(hba->dev, "TM[%d] - Task Management Header\n", tag);
                ufshcd_hex_dump("", tmrdp, sizeof(*tmrdp));
        }
}

static void ufshcd_print_host_state(struct ufs_hba *hba)
{
        struct scsi_device *sdev_ufs = hba->sdev_ufs_device;

        dev_err(hba->dev, "UFS Host state=%d\n", hba->ufshcd_state);
        dev_err(hba->dev, "outstanding reqs=0x%lx tasks=0x%lx\n",
                hba->outstanding_reqs, hba->outstanding_tasks);
        dev_err(hba->dev, "saved_err=0x%x, saved_uic_err=0x%x\n",
                hba->saved_err, hba->saved_uic_err);
        dev_err(hba->dev, "Device power mode=%d, UIC link state=%d\n",
                hba->curr_dev_pwr_mode, hba->uic_link_state);
        dev_err(hba->dev, "PM in progress=%d, sys. suspended=%d\n",
                hba->pm_op_in_progress, hba->is_sys_suspended);
        dev_err(hba->dev, "Auto BKOPS=%d, Host self-block=%d\n",
                hba->auto_bkops_enabled, hba->host->host_self_blocked);
        dev_err(hba->dev, "Clk gate=%d\n", hba->clk_gating.state);
        dev_err(hba->dev,
                "last_hibern8_exit_tstamp at %lld us, hibern8_exit_cnt=%d\n",
                ktime_to_us(hba->ufs_stats.last_hibern8_exit_tstamp),
                hba->ufs_stats.hibern8_exit_cnt);
        dev_err(hba->dev, "last intr at %lld us, last intr status=0x%x\n",
                ktime_to_us(hba->ufs_stats.last_intr_ts),
                hba->ufs_stats.last_intr_status);
        dev_err(hba->dev, "error handling flags=0x%x, req. abort count=%d\n",
                hba->eh_flags, hba->req_abort_count);
        dev_err(hba->dev, "hba->ufs_version=0x%x, Host capabilities=0x%x, caps=0x%x\n",
                hba->ufs_version, hba->capabilities, hba->caps);
        dev_err(hba->dev, "quirks=0x%x, dev. quirks=0x%x\n", hba->quirks,
                hba->dev_quirks);
        if (sdev_ufs)
                dev_err(hba->dev, "UFS dev info: %.8s %.16s rev %.4s\n",
                        sdev_ufs->vendor, sdev_ufs->model, sdev_ufs->rev);

        ufshcd_print_clk_freqs(hba);
}

/**
 * ufshcd_print_pwr_info - print power params as saved in hba
 * power info
 * @hba: per-adapter instance
 */
static void ufshcd_print_pwr_info(struct ufs_hba *hba)
{
        static const char * const names[] = {
                "INVALID MODE",
                "FAST MODE",
                "SLOW_MODE",
                "INVALID MODE",
                "FASTAUTO_MODE",
                "SLOWAUTO_MODE",
                "INVALID MODE",
        };

        dev_err(hba->dev, "%s:[RX, TX]: gear=[%d, %d], lane[%d, %d], pwr[%s, %s], rate = %d\n",
                 __func__,
                 hba->pwr_info.gear_rx, hba->pwr_info.gear_tx,
                 hba->pwr_info.lane_rx, hba->pwr_info.lane_tx,
                 names[hba->pwr_info.pwr_rx],
                 names[hba->pwr_info.pwr_tx],
                 hba->pwr_info.hs_rate);
}

static void ufshcd_device_reset(struct ufs_hba *hba)
{
        int err;

        err = ufshcd_vops_device_reset(hba);

        if (!err) {
                ufshcd_set_ufs_dev_active(hba);
                if (ufshcd_is_wb_allowed(hba)) {
                        hba->dev_info.wb_enabled = false;
                        hba->dev_info.wb_buf_flush_enabled = false;
                }
        }
        if (err != -EOPNOTSUPP)
                ufshcd_update_evt_hist(hba, UFS_EVT_DEV_RESET, err);
}

void ufshcd_delay_us(unsigned long us, unsigned long tolerance)
{
        if (!us)
                return;

        if (us < 10)
                udelay(us);
        else
                usleep_range(us, us + tolerance);
}
EXPORT_SYMBOL_GPL(ufshcd_delay_us);

/**
 * ufshcd_wait_for_register - wait for register value to change
 * @hba: per-adapter interface
 * @reg: mmio register offset
 * @mask: mask to apply to the read register value
 * @val: value to wait for
 * @interval_us: polling interval in microseconds
 * @timeout_ms: timeout in milliseconds
 *
 * Return:
 * -ETIMEDOUT on error, zero on success.
 */
int ufshcd_wait_for_register(struct ufs_hba *hba, u32 reg, u32 mask,
                                u32 val, unsigned long interval_us,
                                unsigned long timeout_ms)
{
        int err = 0;
        unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);

        /* ignore bits that we don't intend to wait on */
        val = val & mask;

        while ((ufshcd_readl(hba, reg) & mask) != val) {
                usleep_range(interval_us, interval_us + 50);
                if (time_after(jiffies, timeout)) {
                        if ((ufshcd_readl(hba, reg) & mask) != val)
                                err = -ETIMEDOUT;
                        break;
                }
        }

        return err;
}

/**
 * ufshcd_get_intr_mask - Get the interrupt bit mask
 * @hba: Pointer to adapter instance
 *
 * Returns interrupt bit mask per version
 */
static inline u32 ufshcd_get_intr_mask(struct ufs_hba *hba)
{
        if (hba->ufs_version == ufshci_version(1, 0))
                return INTERRUPT_MASK_ALL_VER_10;
        if (hba->ufs_version <= ufshci_version(2, 0))
                return INTERRUPT_MASK_ALL_VER_11;

        return INTERRUPT_MASK_ALL_VER_21;
}

/**
 * ufshcd_get_ufs_version - Get the UFS version supported by the HBA
 * @hba: Pointer to adapter instance
 *
 * Returns UFSHCI version supported by the controller
 */
static inline u32 ufshcd_get_ufs_version(struct ufs_hba *hba)
{
        u32 ufshci_ver;

        if (hba->quirks & UFSHCD_QUIRK_BROKEN_UFS_HCI_VERSION)
                ufshci_ver = ufshcd_vops_get_ufs_hci_version(hba);
        else
                ufshci_ver = ufshcd_readl(hba, REG_UFS_VERSION);

        /*
         * UFSHCI v1.x uses a different version scheme, in order
         * to allow the use of comparisons with the ufshci_version
         * function, we convert it to the same scheme as ufs 2.0+.
         */
        if (ufshci_ver & 0x00010000)
                return ufshci_version(1, ufshci_ver & 0x00000100);

        return ufshci_ver;
}

/**
 * ufshcd_is_device_present - Check if any device connected to
 *                            the host controller
 * @hba: pointer to adapter instance
 *
 * Returns true if device present, false if no device detected
 */
static inline bool ufshcd_is_device_present(struct ufs_hba *hba)
{
        return (ufshcd_readl(hba, REG_CONTROLLER_STATUS) &
                                                DEVICE_PRESENT) ? true : false;
}

/**
 * ufshcd_get_tr_ocs - Get the UTRD Overall Command Status
 * @lrbp: pointer to local command reference block
 *
 * This function is used to get the OCS field from UTRD
 * Returns the OCS field in the UTRD
 */
static inline int ufshcd_get_tr_ocs(struct ufshcd_lrb *lrbp)
{
        return le32_to_cpu(lrbp->utr_descriptor_ptr->header.dword_2) & MASK_OCS;
}

/**
 * ufshcd_utrl_clear - Clear a bit in UTRLCLR register
 * @hba: per adapter instance
 * @pos: position of the bit to be cleared
 */
static inline void ufshcd_utrl_clear(struct ufs_hba *hba, u32 pos)
{
        if (hba->quirks & UFSHCI_QUIRK_BROKEN_REQ_LIST_CLR)
                ufshcd_writel(hba, (1 << pos), REG_UTP_TRANSFER_REQ_LIST_CLEAR);
        else
                ufshcd_writel(hba, ~(1 << pos),
                                REG_UTP_TRANSFER_REQ_LIST_CLEAR);
}

/**
 * ufshcd_utmrl_clear - Clear a bit in UTRMLCLR register
 * @hba: per adapter instance
 * @pos: position of the bit to be cleared
 */
static inline void ufshcd_utmrl_clear(struct ufs_hba *hba, u32 pos)
{
        if (hba->quirks & UFSHCI_QUIRK_BROKEN_REQ_LIST_CLR)
                ufshcd_writel(hba, (1 << pos), REG_UTP_TASK_REQ_LIST_CLEAR);
        else
                ufshcd_writel(hba, ~(1 << pos), REG_UTP_TASK_REQ_LIST_CLEAR);
}

/**
 * ufshcd_outstanding_req_clear - Clear a bit in outstanding request field
 * @hba: per adapter instance
 * @tag: position of the bit to be cleared
 */
static inline void ufshcd_outstanding_req_clear(struct ufs_hba *hba, int tag)
{
        clear_bit(tag, &hba->outstanding_reqs);
}

/**
 * ufshcd_get_lists_status - Check UCRDY, UTRLRDY and UTMRLRDY
 * @reg: Register value of host controller status
 *
 * Returns integer, 0 on Success and positive value if failed
 */
static inline int ufshcd_get_lists_status(u32 reg)
{
        return !((reg & UFSHCD_STATUS_READY) == UFSHCD_STATUS_READY);
}

/**
 * ufshcd_get_uic_cmd_result - Get the UIC command result
 * @hba: Pointer to adapter instance
 *
 * This function gets the result of UIC command completion
 * Returns 0 on success, non zero value on error
 */
static inline int ufshcd_get_uic_cmd_result(struct ufs_hba *hba)
{
        return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_2) &
               MASK_UIC_COMMAND_RESULT;
}

/**
 * ufshcd_get_dme_attr_val - Get the value of attribute returned by UIC command
 * @hba: Pointer to adapter instance
 *
 * This function gets UIC command argument3
 * Returns 0 on success, non zero value on error
 */
static inline u32 ufshcd_get_dme_attr_val(struct ufs_hba *hba)
{
        return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_3);
}

/**
 * ufshcd_get_req_rsp - returns the TR response transaction type
 * @ucd_rsp_ptr: pointer to response UPIU
 */
static inline int
ufshcd_get_req_rsp(struct utp_upiu_rsp *ucd_rsp_ptr)
{
        return be32_to_cpu(ucd_rsp_ptr->header.dword_0) >> 24;
}

/**
 * ufshcd_get_rsp_upiu_result - Get the result from response UPIU
 * @ucd_rsp_ptr: pointer to response UPIU
 *
 * This function gets the response status and scsi_status from response UPIU
 * Returns the response result code.
 */
static inline int
ufshcd_get_rsp_upiu_result(struct utp_upiu_rsp *ucd_rsp_ptr)
{
        return be32_to_cpu(ucd_rsp_ptr->header.dword_1) & MASK_RSP_UPIU_RESULT;
}

/*
 * ufshcd_get_rsp_upiu_data_seg_len - Get the data segment length
 *                              from response UPIU
 * @ucd_rsp_ptr: pointer to response UPIU
 *
 * Return the data segment length.
 */
static inline unsigned int
ufshcd_get_rsp_upiu_data_seg_len(struct utp_upiu_rsp *ucd_rsp_ptr)
{
        return be32_to_cpu(ucd_rsp_ptr->header.dword_2) &
                MASK_RSP_UPIU_DATA_SEG_LEN;
}

/**
 * ufshcd_is_exception_event - Check if the device raised an exception event
 * @ucd_rsp_ptr: pointer to response UPIU
 *
 * The function checks if the device raised an exception event indicated in
 * the Device Information field of response UPIU.
 *
 * Returns true if exception is raised, false otherwise.
 */
static inline bool ufshcd_is_exception_event(struct utp_upiu_rsp *ucd_rsp_ptr)
{
        return be32_to_cpu(ucd_rsp_ptr->header.dword_2) &
                        MASK_RSP_EXCEPTION_EVENT ? true : false;
}

/**
 * ufshcd_reset_intr_aggr - Reset interrupt aggregation values.
 * @hba: per adapter instance
 */
static inline void
ufshcd_reset_intr_aggr(struct ufs_hba *hba)
{
        ufshcd_writel(hba, INT_AGGR_ENABLE |
                      INT_AGGR_COUNTER_AND_TIMER_RESET,
                      REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL);
}

/**
 * ufshcd_config_intr_aggr - Configure interrupt aggregation values.
 * @hba: per adapter instance
 * @cnt: Interrupt aggregation counter threshold
 * @tmout: Interrupt aggregation timeout value
 */
static inline void
ufshcd_config_intr_aggr(struct ufs_hba *hba, u8 cnt, u8 tmout)
{
        ufshcd_writel(hba, INT_AGGR_ENABLE | INT_AGGR_PARAM_WRITE |
                      INT_AGGR_COUNTER_THLD_VAL(cnt) |
                      INT_AGGR_TIMEOUT_VAL(tmout),
                      REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL);
}

/**
 * ufshcd_disable_intr_aggr - Disables interrupt aggregation.
 * @hba: per adapter instance
 */
static inline void ufshcd_disable_intr_aggr(struct ufs_hba *hba)
{
        ufshcd_writel(hba, 0, REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL);
}

/**
 * ufshcd_enable_run_stop_reg - Enable run-stop registers,
 *                      When run-stop registers are set to 1, it indicates the
 *                      host controller that it can process the requests
 * @hba: per adapter instance
 */
static void ufshcd_enable_run_stop_reg(struct ufs_hba *hba)
{
        ufshcd_writel(hba, UTP_TASK_REQ_LIST_RUN_STOP_BIT,
                      REG_UTP_TASK_REQ_LIST_RUN_STOP);
        ufshcd_writel(hba, UTP_TRANSFER_REQ_LIST_RUN_STOP_BIT,
                      REG_UTP_TRANSFER_REQ_LIST_RUN_STOP);
}

/**
 * ufshcd_hba_start - Start controller initialization sequence
 * @hba: per adapter instance
 */
static inline void ufshcd_hba_start(struct ufs_hba *hba)
{
        u32 val = CONTROLLER_ENABLE;

        if (ufshcd_crypto_enable(hba))
                val |= CRYPTO_GENERAL_ENABLE;

        ufshcd_writel(hba, val, REG_CONTROLLER_ENABLE);
}

/**
 * ufshcd_is_hba_active - Get controller state
 * @hba: per adapter instance
 *
 * Returns false if controller is active, true otherwise
 */
static inline bool ufshcd_is_hba_active(struct ufs_hba *hba)
{
        return (ufshcd_readl(hba, REG_CONTROLLER_ENABLE) & CONTROLLER_ENABLE)
                ? false : true;
}

u32 ufshcd_get_local_unipro_ver(struct ufs_hba *hba)
{
        /* HCI version 1.0 and 1.1 supports UniPro 1.41 */
        if (hba->ufs_version <= ufshci_version(1, 1))
                return UFS_UNIPRO_VER_1_41;
        else
                return UFS_UNIPRO_VER_1_6;
}
EXPORT_SYMBOL(ufshcd_get_local_unipro_ver);

static bool ufshcd_is_unipro_pa_params_tuning_req(struct ufs_hba *hba)
{
        /*
         * If both host and device support UniPro ver1.6 or later, PA layer
         * parameters tuning happens during link startup itself.
         *
         * We can manually tune PA layer parameters if either host or device
         * doesn't support UniPro ver 1.6 or later. But to keep manual tuning
         * logic simple, we will only do manual tuning if local unipro version
         * doesn't support ver1.6 or later.
         */
        if (ufshcd_get_local_unipro_ver(hba) < UFS_UNIPRO_VER_1_6)
                return true;
        else
                return false;
}

/**
 * ufshcd_set_clk_freq - set UFS controller clock frequencies
 * @hba: per adapter instance
 * @scale_up: If True, set max possible frequency othewise set low frequency
 *
 * Returns 0 if successful
 * Returns < 0 for any other errors
 */
static int ufshcd_set_clk_freq(struct ufs_hba *hba, bool scale_up)
{
        int ret = 0;
        struct ufs_clk_info *clki;
        struct list_head *head = &hba->clk_list_head;

        if (list_empty(head))
                goto out;

        list_for_each_entry(clki, head, list) {
                if (!IS_ERR_OR_NULL(clki->clk)) {
                        if (scale_up && clki->max_freq) {
                                if (clki->curr_freq == clki->max_freq)
                                        continue;

                                ret = clk_set_rate(clki->clk, clki->max_freq);
                                if (ret) {
                                        dev_err(hba->dev, "%s: %s clk set rate(%dHz) failed, %d\n",
                                                __func__, clki->name,
                                                clki->max_freq, ret);
                                        break;
                                }
                                trace_ufshcd_clk_scaling(dev_name(hba->dev),
                                                "scaled up", clki->name,
                                                clki->curr_freq,
                                                clki->max_freq);

                                clki->curr_freq = clki->max_freq;

                        } else if (!scale_up && clki->min_freq) {
                                if (clki->curr_freq == clki->min_freq)
                                        continue;

                                ret = clk_set_rate(clki->clk, clki->min_freq);
                                if (ret) {
                                        dev_err(hba->dev, "%s: %s clk set rate(%dHz) failed, %d\n",
                                                __func__, clki->name,
                                                clki->min_freq, ret);
                                        break;
                                }
                                trace_ufshcd_clk_scaling(dev_name(hba->dev),
                                                "scaled down", clki->name,
                                                clki->curr_freq,
                                                clki->min_freq);
                                clki->curr_freq = clki->min_freq;
                        }
                }
                dev_dbg(hba->dev, "%s: clk: %s, rate: %lu\n", __func__,
                                clki->name, clk_get_rate(clki->clk));
        }

out:
        return ret;
}

/**
 * ufshcd_scale_clks - scale up or scale down UFS controller clocks
 * @hba: per adapter instance
 * @scale_up: True if scaling up and false if scaling down
 *
 * Returns 0 if successful
 * Returns < 0 for any other errors
 */
static int ufshcd_scale_clks(struct ufs_hba *hba, bool scale_up)
{
        int ret = 0;
        ktime_t start = ktime_get();

        ret = ufshcd_vops_clk_scale_notify(hba, scale_up, PRE_CHANGE);
        if (ret)
                goto out;

        ret = ufshcd_set_clk_freq(hba, scale_up);
        if (ret)
                goto out;

        ret = ufshcd_vops_clk_scale_notify(hba, scale_up, POST_CHANGE);
        if (ret)
                ufshcd_set_clk_freq(hba, !scale_up);

out:
        trace_ufshcd_profile_clk_scaling(dev_name(hba->dev),
                        (scale_up ? "up" : "down"),
                        ktime_to_us(ktime_sub(ktime_get(), start)), ret);
        return ret;
}

/**
 * ufshcd_is_devfreq_scaling_required - check if scaling is required or not
 * @hba: per adapter instance
 * @scale_up: True if scaling up and false if scaling down
 *
 * Returns true if scaling is required, false otherwise.
 */
static bool ufshcd_is_devfreq_scaling_required(struct ufs_hba *hba,
                                               bool scale_up)
{
        struct ufs_clk_info *clki;
        struct list_head *head = &hba->clk_list_head;

        if (list_empty(head))
                return false;

        list_for_each_entry(clki, head, list) {
                if (!IS_ERR_OR_NULL(clki->clk)) {
                        if (scale_up && clki->max_freq) {
                                if (clki->curr_freq == clki->max_freq)
                                        continue;
                                return true;
                        } else if (!scale_up && clki->min_freq) {
                                if (clki->curr_freq == clki->min_freq)
                                        continue;
                                return true;
                        }
                }
        }

        return false;
}

static int ufshcd_wait_for_doorbell_clr(struct ufs_hba *hba,
                                        u64 wait_timeout_us)
{
        unsigned long flags;
        int ret = 0;
        u32 tm_doorbell;
        u32 tr_doorbell;
        bool timeout = false, do_last_check = false;
        ktime_t start;

        ufshcd_hold(hba, false);
        spin_lock_irqsave(hba->host->host_lock, flags);
        /*
         * Wait for all the outstanding tasks/transfer requests.
         * Verify by checking the doorbell registers are clear.
         */
        start = ktime_get();
        do {
                if (hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL) {
                        ret = -EBUSY;
                        goto out;
                }

                tm_doorbell = ufshcd_readl(hba, REG_UTP_TASK_REQ_DOOR_BELL);
                tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
                if (!tm_doorbell && !tr_doorbell) {
                        timeout = false;
                        break;
                } else if (do_last_check) {
                        break;
                }

                spin_unlock_irqrestore(hba->host->host_lock, flags);
                schedule();
                if (ktime_to_us(ktime_sub(ktime_get(), start)) >
                    wait_timeout_us) {
                        timeout = true;
                        /*
                         * We might have scheduled out for long time so make
                         * sure to check if doorbells are cleared by this time
                         * or not.
                         */
                        do_last_check = true;
                }
                spin_lock_irqsave(hba->host->host_lock, flags);
        } while (tm_doorbell || tr_doorbell);

        if (timeout) {
                dev_err(hba->dev,
                        "%s: timedout waiting for doorbell to clear (tm=0x%x, tr=0x%x)\n",
                        __func__, tm_doorbell, tr_doorbell);
                ret = -EBUSY;
        }
out:
        spin_unlock_irqrestore(hba->host->host_lock, flags);
        ufshcd_release(hba);
        return ret;
}

/**
 * ufshcd_scale_gear - scale up/down UFS gear
 * @hba: per adapter instance
 * @scale_up: True for scaling up gear and false for scaling down
 *
 * Returns 0 for success,
 * Returns -EBUSY if scaling can't happen at this time
 * Returns non-zero for any other errors
 */
static int ufshcd_scale_gear(struct ufs_hba *hba, bool scale_up)
{
        int ret = 0;
        struct ufs_pa_layer_attr new_pwr_info;

        if (scale_up) {
                memcpy(&new_pwr_info, &hba->clk_scaling.saved_pwr_info.info,
                       sizeof(struct ufs_pa_layer_attr));
        } else {
                memcpy(&new_pwr_info, &hba->pwr_info,
                       sizeof(struct ufs_pa_layer_attr));

                if (hba->pwr_info.gear_tx > hba->clk_scaling.min_gear ||
                    hba->pwr_info.gear_rx > hba->clk_scaling.min_gear) {
                        /* save the current power mode */
                        memcpy(&hba->clk_scaling.saved_pwr_info.info,
                                &hba->pwr_info,
                                sizeof(struct ufs_pa_layer_attr));

                        /* scale down gear */
                        new_pwr_info.gear_tx = hba->clk_scaling.min_gear;
                        new_pwr_info.gear_rx = hba->clk_scaling.min_gear;
                }
        }

        /* check if the power mode needs to be changed or not? */
        ret = ufshcd_config_pwr_mode(hba, &new_pwr_info);
        if (ret)
                dev_err(hba->dev, "%s: failed err %d, old gear: (tx %d rx %d), new gear: (tx %d rx %d)",
                        __func__, ret,
                        hba->pwr_info.gear_tx, hba->pwr_info.gear_rx,
                        new_pwr_info.gear_tx, new_pwr_info.gear_rx);

        return ret;
}

static int ufshcd_clock_scaling_prepare(struct ufs_hba *hba)
{
        #define DOORBELL_CLR_TOUT_US            (1000 * 1000) /* 1 sec */
        int ret = 0;
        /*
         * make sure that there are no outstanding requests when
         * clock scaling is in progress
         */
        ufshcd_scsi_block_requests(hba);
        down_write(&hba->clk_scaling_lock);

        if (!hba->clk_scaling.is_allowed ||
            ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US)) {
                ret = -EBUSY;
                up_write(&hba->clk_scaling_lock);
                ufshcd_scsi_unblock_requests(hba);
                goto out;
        }

        /* let's not get into low power until clock scaling is completed */
        ufshcd_hold(hba, false);

out:
        return ret;
}

static void ufshcd_clock_scaling_unprepare(struct ufs_hba *hba, bool writelock)
{
        if (writelock)
                up_write(&hba->clk_scaling_lock);
        else
                up_read(&hba->clk_scaling_lock);
        ufshcd_scsi_unblock_requests(hba);
        ufshcd_release(hba);
}

/**
 * ufshcd_devfreq_scale - scale up/down UFS clocks and gear
 * @hba: per adapter instance
 * @scale_up: True for scaling up and false for scalin down
 *
 * Returns 0 for success,
 * Returns -EBUSY if scaling can't happen at this time
 * Returns non-zero for any other errors
 */
static int ufshcd_devfreq_scale(struct ufs_hba *hba, bool scale_up)
{
        int ret = 0;
        bool is_writelock = true;

        ret = ufshcd_clock_scaling_prepare(hba);
        if (ret)
                return ret;

        /* scale down the gear before scaling down clocks */
        if (!scale_up) {
                ret = ufshcd_scale_gear(hba, false);
                if (ret)
                        goto out_unprepare;
        }

        ret = ufshcd_scale_clks(hba, scale_up);
        if (ret) {
                if (!scale_up)
                        ufshcd_scale_gear(hba, true);
                goto out_unprepare;
        }

        /* scale up the gear after scaling up clocks */
        if (scale_up) {
                ret = ufshcd_scale_gear(hba, true);
                if (ret) {
                        ufshcd_scale_clks(hba, false);
                        goto out_unprepare;
                }
        }

        /* Enable Write Booster if we have scaled up else disable it */
        downgrade_write(&hba->clk_scaling_lock);
        is_writelock = false;
        ufshcd_wb_toggle(hba, scale_up);

out_unprepare:
        ufshcd_clock_scaling_unprepare(hba, is_writelock);
        return ret;
}

static void ufshcd_clk_scaling_suspend_work(struct work_struct *work)
{
        struct ufs_hba *hba = container_of(work, struct ufs_hba,
                                           clk_scaling.suspend_work);
        unsigned long irq_flags;

        spin_lock_irqsave(hba->host->host_lock, irq_flags);
        if (hba->clk_scaling.active_reqs || hba->clk_scaling.is_suspended) {
                spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
                return;
        }
        hba->clk_scaling.is_suspended = true;
        spin_unlock_irqrestore(hba->host->host_lock, irq_flags);

        __ufshcd_suspend_clkscaling(hba);
}

static void ufshcd_clk_scaling_resume_work(struct work_struct *work)
{
        struct ufs_hba *hba = container_of(work, struct ufs_hba,
                                           clk_scaling.resume_work);
        unsigned long irq_flags;

        spin_lock_irqsave(hba->host->host_lock, irq_flags);
        if (!hba->clk_scaling.is_suspended) {
                spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
                return;
        }
        hba->clk_scaling.is_suspended = false;
        spin_unlock_irqrestore(hba->host->host_lock, irq_flags);

        devfreq_resume_device(hba->devfreq);
}

static int ufshcd_devfreq_target(struct device *dev,
                                unsigned long *freq, u32 flags)
{
        int ret = 0;
        struct ufs_hba *hba = dev_get_drvdata(dev);
        ktime_t start;
        bool scale_up, sched_clk_scaling_suspend_work = false;
        struct list_head *clk_list = &hba->clk_list_head;
        struct ufs_clk_info *clki;
        unsigned long irq_flags;

        if (!ufshcd_is_clkscaling_supported(hba))
                return -EINVAL;

        clki = list_first_entry(&hba->clk_list_head, struct ufs_clk_info, list);
        /* Override with the closest supported frequency */
        *freq = (unsigned long) clk_round_rate(clki->clk, *freq);
        spin_lock_irqsave(hba->host->host_lock, irq_flags);
        if (ufshcd_eh_in_progress(hba)) {
                spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
                return 0;
        }

        if (!hba->clk_scaling.active_reqs)
                sched_clk_scaling_suspend_work = true;

        if (list_empty(clk_list)) {
                spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
                goto out;
        }

        /* Decide based on the rounded-off frequency and update */
        scale_up = (*freq == clki->max_freq) ? true : false;
        if (!scale_up)
                *freq = clki->min_freq;
        /* Update the frequency */
        if (!ufshcd_is_devfreq_scaling_required(hba, scale_up)) {
                spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
                ret = 0;
                goto out; /* no state change required */
        }
        spin_unlock_irqrestore(hba->host->host_lock, irq_flags);

        start = ktime_get();
        ret = ufshcd_devfreq_scale(hba, scale_up);

        trace_ufshcd_profile_clk_scaling(dev_name(hba->dev),
                (scale_up ? "up" : "down"),
                ktime_to_us(ktime_sub(ktime_get(), start)), ret);

out:
        if (sched_clk_scaling_suspend_work)
                queue_work(hba->clk_scaling.workq,
                           &hba->clk_scaling.suspend_work);

        return ret;
}

static bool ufshcd_is_busy(struct request *req, void *priv, bool reserved)
{
        int *busy = priv;

        WARN_ON_ONCE(reserved);
        (*busy)++;
        return false;
}

/* Whether or not any tag is in use by a request that is in progress. */
static bool ufshcd_any_tag_in_use(struct ufs_hba *hba)
{
        struct request_queue *q = hba->cmd_queue;
        int busy = 0;

        blk_mq_tagset_busy_iter(q->tag_set, ufshcd_is_busy, &busy);
        return busy;
}

static int ufshcd_devfreq_get_dev_status(struct device *dev,
                struct devfreq_dev_status *stat)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);
        struct ufs_clk_scaling *scaling = &hba->clk_scaling;
        unsigned long flags;
        struct list_head *clk_list = &hba->clk_list_head;
        struct ufs_clk_info *clki;
        ktime_t curr_t;

        if (!ufshcd_is_clkscaling_supported(hba))
                return -EINVAL;

        memset(stat, 0, sizeof(*stat));

        spin_lock_irqsave(hba->host->host_lock, flags);
        curr_t = ktime_get();
        if (!scaling->window_start_t)
                goto start_window;

        clki = list_first_entry(clk_list, struct ufs_clk_info, list);
        /*
         * If current frequency is 0, then the ondemand governor considers
         * there's no initial frequency set. And it always requests to set
         * to max. frequency.
         */
        stat->current_frequency = clki->curr_freq;
        if (scaling->is_busy_started)
                scaling->tot_busy_t += ktime_us_delta(curr_t,
                                scaling->busy_start_t);

        stat->total_time = ktime_us_delta(curr_t, scaling->window_start_t);
        stat->busy_time = scaling->tot_busy_t;
start_window:
        scaling->window_start_t = curr_t;
        scaling->tot_busy_t = 0;

        if (hba->outstanding_reqs) {
                scaling->busy_start_t = curr_t;
                scaling->is_busy_started = true;
        } else {
                scaling->busy_start_t = 0;
                scaling->is_busy_started = false;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);
        return 0;
}

static int ufshcd_devfreq_init(struct ufs_hba *hba)
{
        struct list_head *clk_list = &hba->clk_list_head;
        struct ufs_clk_info *clki;
        struct devfreq *devfreq;
        int ret;

        /* Skip devfreq if we don't have any clocks in the list */
        if (list_empty(clk_list))
                return 0;

        clki = list_first_entry(clk_list, struct ufs_clk_info, list);
        dev_pm_opp_add(hba->dev, clki->min_freq, 0);
        dev_pm_opp_add(hba->dev, clki->max_freq, 0);

        ufshcd_vops_config_scaling_param(hba, &hba->vps->devfreq_profile,
                                         &hba->vps->ondemand_data);
        devfreq = devfreq_add_device(hba->dev,
                        &hba->vps->devfreq_profile,
                        DEVFREQ_GOV_SIMPLE_ONDEMAND,
                        &hba->vps->ondemand_data);
        if (IS_ERR(devfreq)) {
                ret = PTR_ERR(devfreq);
                dev_err(hba->dev, "Unable to register with devfreq %d\n", ret);

                dev_pm_opp_remove(hba->dev, clki->min_freq);
                dev_pm_opp_remove(hba->dev, clki->max_freq);
                return ret;
        }

        hba->devfreq = devfreq;

        return 0;
}

static void ufshcd_devfreq_remove(struct ufs_hba *hba)
{
        struct list_head *clk_list = &hba->clk_list_head;
        struct ufs_clk_info *clki;

        if (!hba->devfreq)
                return;

        devfreq_remove_device(hba->devfreq);
        hba->devfreq = NULL;

        clki = list_first_entry(clk_list, struct ufs_clk_info, list);
        dev_pm_opp_remove(hba->dev, clki->min_freq);
        dev_pm_opp_remove(hba->dev, clki->max_freq);
}

static void __ufshcd_suspend_clkscaling(struct ufs_hba *hba)
{
        unsigned long flags;

        devfreq_suspend_device(hba->devfreq);
        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->clk_scaling.window_start_t = 0;
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}

static void ufshcd_suspend_clkscaling(struct ufs_hba *hba)
{
        unsigned long flags;
        bool suspend = false;

        cancel_work_sync(&hba->clk_scaling.suspend_work);
        cancel_work_sync(&hba->clk_scaling.resume_work);

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (!hba->clk_scaling.is_suspended) {
                suspend = true;
                hba->clk_scaling.is_suspended = true;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);

        if (suspend)
                __ufshcd_suspend_clkscaling(hba);
}

static void ufshcd_resume_clkscaling(struct ufs_hba *hba)
{
        unsigned long flags;
        bool resume = false;

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (hba->clk_scaling.is_suspended) {
                resume = true;
                hba->clk_scaling.is_suspended = false;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);

        if (resume)
                devfreq_resume_device(hba->devfreq);
}

static ssize_t ufshcd_clkscale_enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%d\n", hba->clk_scaling.is_enabled);
}

static ssize_t ufshcd_clkscale_enable_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);
        u32 value;
        int err = 0;

        if (kstrtou32(buf, 0, &value))
                return -EINVAL;

        down(&hba->host_sem);
        if (!ufshcd_is_user_access_allowed(hba)) {
                err = -EBUSY;
                goto out;
        }

        value = !!value;
        if (value == hba->clk_scaling.is_enabled)
                goto out;

        ufshcd_rpm_get_sync(hba);
        ufshcd_hold(hba, false);

        hba->clk_scaling.is_enabled = value;

        if (value) {
                ufshcd_resume_clkscaling(hba);
        } else {
                ufshcd_suspend_clkscaling(hba);
                err = ufshcd_devfreq_scale(hba, true);
                if (err)
                        dev_err(hba->dev, "%s: failed to scale clocks up %d\n",
                                        __func__, err);
        }

        ufshcd_release(hba);
        ufshcd_rpm_put_sync(hba);
out:
        up(&hba->host_sem);
        return err ? err : count;
}

static void ufshcd_init_clk_scaling_sysfs(struct ufs_hba *hba)
{
        hba->clk_scaling.enable_attr.show = ufshcd_clkscale_enable_show;
        hba->clk_scaling.enable_attr.store = ufshcd_clkscale_enable_store;
        sysfs_attr_init(&hba->clk_scaling.enable_attr.attr);
        hba->clk_scaling.enable_attr.attr.name = "clkscale_enable";
        hba->clk_scaling.enable_attr.attr.mode = 0644;
        if (device_create_file(hba->dev, &hba->clk_scaling.enable_attr))
                dev_err(hba->dev, "Failed to create sysfs for clkscale_enable\n");
}

static void ufshcd_remove_clk_scaling_sysfs(struct ufs_hba *hba)
{
        if (hba->clk_scaling.enable_attr.attr.name)
                device_remove_file(hba->dev, &hba->clk_scaling.enable_attr);
}

static void ufshcd_init_clk_scaling(struct ufs_hba *hba)
{
        char wq_name[sizeof("ufs_clkscaling_00")];

        if (!ufshcd_is_clkscaling_supported(hba))
                return;

        if (!hba->clk_scaling.min_gear)
                hba->clk_scaling.min_gear = UFS_HS_G1;

        INIT_WORK(&hba->clk_scaling.suspend_work,
                  ufshcd_clk_scaling_suspend_work);
        INIT_WORK(&hba->clk_scaling.resume_work,
                  ufshcd_clk_scaling_resume_work);

        snprintf(wq_name, sizeof(wq_name), "ufs_clkscaling_%d",
                 hba->host->host_no);
        hba->clk_scaling.workq = create_singlethread_workqueue(wq_name);

        hba->clk_scaling.is_initialized = true;
}

static void ufshcd_exit_clk_scaling(struct ufs_hba *hba)
{
        if (!hba->clk_scaling.is_initialized)
                return;

        ufshcd_remove_clk_scaling_sysfs(hba);
        destroy_workqueue(hba->clk_scaling.workq);
        ufshcd_devfreq_remove(hba);
        hba->clk_scaling.is_initialized = false;
}

static void ufshcd_ungate_work(struct work_struct *work)
{
        int ret;
        unsigned long flags;
        struct ufs_hba *hba = container_of(work, struct ufs_hba,
                        clk_gating.ungate_work);

        cancel_delayed_work_sync(&hba->clk_gating.gate_work);

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (hba->clk_gating.state == CLKS_ON) {
                spin_unlock_irqrestore(hba->host->host_lock, flags);
                goto unblock_reqs;
        }

        spin_unlock_irqrestore(hba->host->host_lock, flags);
        ufshcd_hba_vreg_set_hpm(hba);
        ufshcd_setup_clocks(hba, true);

        ufshcd_enable_irq(hba);

        /* Exit from hibern8 */
        if (ufshcd_can_hibern8_during_gating(hba)) {
                /* Prevent gating in this path */
                hba->clk_gating.is_suspended = true;
                if (ufshcd_is_link_hibern8(hba)) {
                        ret = ufshcd_uic_hibern8_exit(hba);
                        if (ret)
                                dev_err(hba->dev, "%s: hibern8 exit failed %d\n",
                                        __func__, ret);
                        else
                                ufshcd_set_link_active(hba);
                }
                hba->clk_gating.is_suspended = false;
        }
unblock_reqs:
        ufshcd_scsi_unblock_requests(hba);
}

/**
 * ufshcd_hold - Enable clocks that were gated earlier due to ufshcd_release.
 * Also, exit from hibern8 mode and set the link as active.
 * @hba: per adapter instance
 * @async: This indicates whether caller should ungate clocks asynchronously.
 */
int ufshcd_hold(struct ufs_hba *hba, bool async)
{
        int rc = 0;
        bool flush_result;
        unsigned long flags;

        if (!ufshcd_is_clkgating_allowed(hba))
                goto out;
        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->clk_gating.active_reqs++;

start:
        switch (hba->clk_gating.state) {
        case CLKS_ON:
                /*
                 * Wait for the ungate work to complete if in progress.
                 * Though the clocks may be in ON state, the link could
                 * still be in hibner8 state if hibern8 is allowed
                 * during clock gating.
                 * Make sure we exit hibern8 state also in addition to
                 * clocks being ON.
                 */
                if (ufshcd_can_hibern8_during_gating(hba) &&
                    ufshcd_is_link_hibern8(hba)) {
                        if (async) {
                                rc = -EAGAIN;
                                hba->clk_gating.active_reqs--;
                                break;
                        }
                        spin_unlock_irqrestore(hba->host->host_lock, flags);
                        flush_result = flush_work(&hba->clk_gating.ungate_work);
                        if (hba->clk_gating.is_suspended && !flush_result)
                                goto out;
                        spin_lock_irqsave(hba->host->host_lock, flags);
                        goto start;
                }
                break;
        case REQ_CLKS_OFF:
                if (cancel_delayed_work(&hba->clk_gating.gate_work)) {
                        hba->clk_gating.state = CLKS_ON;
                        trace_ufshcd_clk_gating(dev_name(hba->dev),
                                                hba->clk_gating.state);
                        break;
                }
                /*
                 * If we are here, it means gating work is either done or
                 * currently running. Hence, fall through to cancel gating
                 * work and to enable clocks.
                 */
                fallthrough;
        case CLKS_OFF:
                hba->clk_gating.state = REQ_CLKS_ON;
                trace_ufshcd_clk_gating(dev_name(hba->dev),
                                        hba->clk_gating.state);
                if (queue_work(hba->clk_gating.clk_gating_workq,
                               &hba->clk_gating.ungate_work))
                        ufshcd_scsi_block_requests(hba);
                /*
                 * fall through to check if we should wait for this
                 * work to be done or not.
                 */
                fallthrough;
        case REQ_CLKS_ON:
                if (async) {
                        rc = -EAGAIN;
                        hba->clk_gating.active_reqs--;
                        break;
                }

                spin_unlock_irqrestore(hba->host->host_lock, flags);
                flush_work(&hba->clk_gating.ungate_work);
                /* Make sure state is CLKS_ON before returning */
                spin_lock_irqsave(hba->host->host_lock, flags);
                goto start;
        default:
                dev_err(hba->dev, "%s: clk gating is in invalid state %d\n",
                                __func__, hba->clk_gating.state);
                break;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);
out:
        return rc;
}
EXPORT_SYMBOL_GPL(ufshcd_hold);

static void ufshcd_gate_work(struct work_struct *work)
{
        struct ufs_hba *hba = container_of(work, struct ufs_hba,
                        clk_gating.gate_work.work);
        unsigned long flags;
        int ret;

        spin_lock_irqsave(hba->host->host_lock, flags);
        /*
         * In case you are here to cancel this work the gating state
         * would be marked as REQ_CLKS_ON. In this case save time by
         * skipping the gating work and exit after changing the clock
         * state to CLKS_ON.
         */
        if (hba->clk_gating.is_suspended ||
                (hba->clk_gating.state != REQ_CLKS_OFF)) {
                hba->clk_gating.state = CLKS_ON;
                trace_ufshcd_clk_gating(dev_name(hba->dev),
                                        hba->clk_gating.state);
                goto rel_lock;
        }

        if (hba->clk_gating.active_reqs
                || hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL
                || ufshcd_any_tag_in_use(hba) || hba->outstanding_tasks
                || hba->active_uic_cmd || hba->uic_async_done)
                goto rel_lock;

        spin_unlock_irqrestore(hba->host->host_lock, flags);

        /* put the link into hibern8 mode before turning off clocks */
        if (ufshcd_can_hibern8_during_gating(hba)) {
                ret = ufshcd_uic_hibern8_enter(hba);
                if (ret) {
                        hba->clk_gating.state = CLKS_ON;
                        dev_err(hba->dev, "%s: hibern8 enter failed %d\n",
                                        __func__, ret);
                        trace_ufshcd_clk_gating(dev_name(hba->dev),
                                                hba->clk_gating.state);
                        goto out;
                }
                ufshcd_set_link_hibern8(hba);
        }

        ufshcd_disable_irq(hba);

        ufshcd_setup_clocks(hba, false);

        /* Put the host controller in low power mode if possible */
        ufshcd_hba_vreg_set_lpm(hba);
        /*
         * In case you are here to cancel this work the gating state
         * would be marked as REQ_CLKS_ON. In this case keep the state
         * as REQ_CLKS_ON which would anyway imply that clocks are off
         * and a request to turn them on is pending. By doing this way,
         * we keep the state machine in tact and this would ultimately
         * prevent from doing cancel work multiple times when there are
         * new requests arriving before the current cancel work is done.
         */
        spin_lock_irqsave(hba->host->host_lock, flags);
        if (hba->clk_gating.state == REQ_CLKS_OFF) {
                hba->clk_gating.state = CLKS_OFF;
                trace_ufshcd_clk_gating(dev_name(hba->dev),
                                        hba->clk_gating.state);
        }
rel_lock:
        spin_unlock_irqrestore(hba->host->host_lock, flags);
out:
        return;
}

/* host lock must be held before calling this variant */
static void __ufshcd_release(struct ufs_hba *hba)
{
        if (!ufshcd_is_clkgating_allowed(hba))
                return;

        hba->clk_gating.active_reqs--;

        if (hba->clk_gating.active_reqs || hba->clk_gating.is_suspended ||
            hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL ||
            hba->outstanding_tasks ||
            hba->active_uic_cmd || hba->uic_async_done ||
            hba->clk_gating.state == CLKS_OFF)
                return;

        hba->clk_gating.state = REQ_CLKS_OFF;
        trace_ufshcd_clk_gating(dev_name(hba->dev), hba->clk_gating.state);
        queue_delayed_work(hba->clk_gating.clk_gating_workq,
                           &hba->clk_gating.gate_work,
                           msecs_to_jiffies(hba->clk_gating.delay_ms));
}

void ufshcd_release(struct ufs_hba *hba)
{
        unsigned long flags;

        spin_lock_irqsave(hba->host->host_lock, flags);
        __ufshcd_release(hba);
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}
EXPORT_SYMBOL_GPL(ufshcd_release);

static ssize_t ufshcd_clkgate_delay_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%lu\n", hba->clk_gating.delay_ms);
}

static ssize_t ufshcd_clkgate_delay_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);
        unsigned long flags, value;

        if (kstrtoul(buf, 0, &value))
                return -EINVAL;

        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->clk_gating.delay_ms = value;
        spin_unlock_irqrestore(hba->host->host_lock, flags);
        return count;
}

static ssize_t ufshcd_clkgate_enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);

        return sysfs_emit(buf, "%d\n", hba->clk_gating.is_enabled);
}

static ssize_t ufshcd_clkgate_enable_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
{
        struct ufs_hba *hba = dev_get_drvdata(dev);
        unsigned long flags;
        u32 value;

        if (kstrtou32(buf, 0, &value))
                return -EINVAL;

        value = !!value;

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (value == hba->clk_gating.is_enabled)
                goto out;

        if (value)
                __ufshcd_release(hba);
        else
                hba->clk_gating.active_reqs++;

        hba->clk_gating.is_enabled = value;
out:
        spin_unlock_irqrestore(hba->host->host_lock, flags);
        return count;
}

static void ufshcd_init_clk_gating_sysfs(struct ufs_hba *hba)
{
        hba->clk_gating.delay_attr.show = ufshcd_clkgate_delay_show;
        hba->clk_gating.delay_attr.store = ufshcd_clkgate_delay_store;
        sysfs_attr_init(&hba->clk_gating.delay_attr.attr);
        hba->clk_gating.delay_attr.attr.name = "clkgate_delay_ms";
        hba->clk_gating.delay_attr.attr.mode = 0644;
        if (device_create_file(hba->dev, &hba->clk_gating.delay_attr))
                dev_err(hba->dev, "Failed to create sysfs for clkgate_delay\n");

        hba->clk_gating.enable_attr.show = ufshcd_clkgate_enable_show;
        hba->clk_gating.enable_attr.store = ufshcd_clkgate_enable_store;
        sysfs_attr_init(&hba->clk_gating.enable_attr.attr);
        hba->clk_gating.enable_attr.attr.name = "clkgate_enable";
        hba->clk_gating.enable_attr.attr.mode = 0644;
        if (device_create_file(hba->dev, &hba->clk_gating.enable_attr))
                dev_err(hba->dev, "Failed to create sysfs for clkgate_enable\n");
}

static void ufshcd_remove_clk_gating_sysfs(struct ufs_hba *hba)
{
        if (hba->clk_gating.delay_attr.attr.name)
                device_remove_file(hba->dev, &hba->clk_gating.delay_attr);
        if (hba->clk_gating.enable_attr.attr.name)
                device_remove_file(hba->dev, &hba->clk_gating.enable_attr);
}

static void ufshcd_init_clk_gating(struct ufs_hba *hba)
{
        char wq_name[sizeof("ufs_clk_gating_00")];

        if (!ufshcd_is_clkgating_allowed(hba))
                return;

        hba->clk_gating.state = CLKS_ON;

        hba->clk_gating.delay_ms = 150;
        INIT_DELAYED_WORK(&hba->clk_gating.gate_work, ufshcd_gate_work);
        INIT_WORK(&hba->clk_gating.ungate_work, ufshcd_ungate_work);

        snprintf(wq_name, ARRAY_SIZE(wq_name), "ufs_clk_gating_%d",
                 hba->host->host_no);
        hba->clk_gating.clk_gating_workq = alloc_ordered_workqueue(wq_name,
                                        WQ_MEM_RECLAIM | WQ_HIGHPRI);

        ufshcd_init_clk_gating_sysfs(hba);

        hba->clk_gating.is_enabled = true;
        hba->clk_gating.is_initialized = true;
}

static void ufshcd_exit_clk_gating(struct ufs_hba *hba)
{
        if (!hba->clk_gating.is_initialized)
                return;
        ufshcd_remove_clk_gating_sysfs(hba);
        cancel_work_sync(&hba->clk_gating.ungate_work);
        cancel_delayed_work_sync(&hba->clk_gating.gate_work);
        destroy_workqueue(hba->clk_gating.clk_gating_workq);
        hba->clk_gating.is_initialized = false;
}

/* Must be called with host lock acquired */
static void ufshcd_clk_scaling_start_busy(struct ufs_hba *hba)
{
        bool queue_resume_work = false;
        ktime_t curr_t = ktime_get();
        unsigned long flags;

        if (!ufshcd_is_clkscaling_supported(hba))
                return;

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (!hba->clk_scaling.active_reqs++)
                queue_resume_work = true;

        if (!hba->clk_scaling.is_enabled || hba->pm_op_in_progress) {
                spin_unlock_irqrestore(hba->host->host_lock, flags);
                return;
        }

        if (queue_resume_work)
                queue_work(hba->clk_scaling.workq,
                           &hba->clk_scaling.resume_work);

        if (!hba->clk_scaling.window_start_t) {
                hba->clk_scaling.window_start_t = curr_t;
                hba->clk_scaling.tot_busy_t = 0;
                hba->clk_scaling.is_busy_started = false;
        }

        if (!hba->clk_scaling.is_busy_started) {
                hba->clk_scaling.busy_start_t = curr_t;
                hba->clk_scaling.is_busy_started = true;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}

static void ufshcd_clk_scaling_update_busy(struct ufs_hba *hba)
{
        struct ufs_clk_scaling *scaling = &hba->clk_scaling;
        unsigned long flags;

        if (!ufshcd_is_clkscaling_supported(hba))
                return;

        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->clk_scaling.active_reqs--;
        if (!hba->outstanding_reqs && scaling->is_busy_started) {
                scaling->tot_busy_t += ktime_to_us(ktime_sub(ktime_get(),
                                        scaling->busy_start_t));
                scaling->busy_start_t = 0;
                scaling->is_busy_started = false;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}

static inline int ufshcd_monitor_opcode2dir(u8 opcode)
{
        if (opcode == READ_6 || opcode == READ_10 || opcode == READ_16)
                return READ;
        else if (opcode == WRITE_6 || opcode == WRITE_10 || opcode == WRITE_16)
                return WRITE;
        else
                return -EINVAL;
}

static inline bool ufshcd_should_inform_monitor(struct ufs_hba *hba,
                                                struct ufshcd_lrb *lrbp)
{
        struct ufs_hba_monitor *m = &hba->monitor;

        return (m->enabled && lrbp && lrbp->cmd &&
                (!m->chunk_size || m->chunk_size == lrbp->cmd->sdb.length) &&
                ktime_before(hba->monitor.enabled_ts, lrbp->issue_time_stamp));
}

static void ufshcd_start_monitor(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        int dir = ufshcd_monitor_opcode2dir(*lrbp->cmd->cmnd);
        unsigned long flags;

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (dir >= 0 && hba->monitor.nr_queued[dir]++ == 0)
                hba->monitor.busy_start_ts[dir] = ktime_get();
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}

static void ufshcd_update_monitor(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        int dir = ufshcd_monitor_opcode2dir(*lrbp->cmd->cmnd);
        unsigned long flags;

        spin_lock_irqsave(hba->host->host_lock, flags);
        if (dir >= 0 && hba->monitor.nr_queued[dir] > 0) {
                struct request *req = lrbp->cmd->request;
                struct ufs_hba_monitor *m = &hba->monitor;
                ktime_t now, inc, lat;

                now = lrbp->compl_time_stamp;
                inc = ktime_sub(now, m->busy_start_ts[dir]);
                m->total_busy[dir] = ktime_add(m->total_busy[dir], inc);
                m->nr_sec_rw[dir] += blk_rq_sectors(req);

                /* Update latencies */
                m->nr_req[dir]++;
                lat = ktime_sub(now, lrbp->issue_time_stamp);
                m->lat_sum[dir] += lat;
                if (m->lat_max[dir] < lat || !m->lat_max[dir])
                        m->lat_max[dir] = lat;
                if (m->lat_min[dir] > lat || !m->lat_min[dir])
                        m->lat_min[dir] = lat;

                m->nr_queued[dir]--;
                /* Push forward the busy start of monitor */
                m->busy_start_ts[dir] = now;
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);
}

/**
 * ufshcd_send_command - Send SCSI or device management commands
 * @hba: per adapter instance
 * @task_tag: Task tag of the command
 */
static inline
void ufshcd_send_command(struct ufs_hba *hba, unsigned int task_tag)
{
        struct ufshcd_lrb *lrbp = &hba->lrb[task_tag];

        lrbp->issue_time_stamp = ktime_get();
        lrbp->compl_time_stamp = ktime_set(0, 0);
        ufshcd_vops_setup_xfer_req(hba, task_tag, (lrbp->cmd ? true : false));
        ufshcd_add_command_trace(hba, task_tag, UFS_CMD_SEND);
        ufshcd_clk_scaling_start_busy(hba);
        if (unlikely(ufshcd_should_inform_monitor(hba, lrbp)))
                ufshcd_start_monitor(hba, lrbp);
        if (ufshcd_has_utrlcnr(hba)) {
                set_bit(task_tag, &hba->outstanding_reqs);
                ufshcd_writel(hba, 1 << task_tag,
                              REG_UTP_TRANSFER_REQ_DOOR_BELL);
        } else {
                unsigned long flags;

                spin_lock_irqsave(hba->host->host_lock, flags);
                set_bit(task_tag, &hba->outstanding_reqs);
                ufshcd_writel(hba, 1 << task_tag,
                              REG_UTP_TRANSFER_REQ_DOOR_BELL);
                spin_unlock_irqrestore(hba->host->host_lock, flags);
        }
        /* Make sure that doorbell is committed immediately */
        wmb();
}

/**
 * ufshcd_copy_sense_data - Copy sense data in case of check condition
 * @lrbp: pointer to local reference block
 */
static inline void ufshcd_copy_sense_data(struct ufshcd_lrb *lrbp)
{
        int len;
        if (lrbp->sense_buffer &&
            ufshcd_get_rsp_upiu_data_seg_len(lrbp->ucd_rsp_ptr)) {
                int len_to_copy;

                len = be16_to_cpu(lrbp->ucd_rsp_ptr->sr.sense_data_len);
                len_to_copy = min_t(int, UFS_SENSE_SIZE, len);

                memcpy(lrbp->sense_buffer, lrbp->ucd_rsp_ptr->sr.sense_data,
                       len_to_copy);
        }
}

/**
 * ufshcd_copy_query_response() - Copy the Query Response and the data
 * descriptor
 * @hba: per adapter instance
 * @lrbp: pointer to local reference block
 */
static
int ufshcd_copy_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        struct ufs_query_res *query_res = &hba->dev_cmd.query.response;

        memcpy(&query_res->upiu_res, &lrbp->ucd_rsp_ptr->qr, QUERY_OSF_SIZE);

        /* Get the descriptor */
        if (hba->dev_cmd.query.descriptor &&
            lrbp->ucd_rsp_ptr->qr.opcode == UPIU_QUERY_OPCODE_READ_DESC) {
                u8 *descp = (u8 *)lrbp->ucd_rsp_ptr +
                                GENERAL_UPIU_REQUEST_SIZE;
                u16 resp_len;
                u16 buf_len;

                /* data segment length */
                resp_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2) &
                                                MASK_QUERY_DATA_SEG_LEN;
                buf_len = be16_to_cpu(
                                hba->dev_cmd.query.request.upiu_req.length);
                if (likely(buf_len >= resp_len)) {
                        memcpy(hba->dev_cmd.query.descriptor, descp, resp_len);
                } else {
                        dev_warn(hba->dev,
                                 "%s: rsp size %d is bigger than buffer size %d",
                                 __func__, resp_len, buf_len);
                        return -EINVAL;
                }
        }

        return 0;
}

/**
 * ufshcd_hba_capabilities - Read controller capabilities
 * @hba: per adapter instance
 *
 * Return: 0 on success, negative on error.
 */
static inline int ufshcd_hba_capabilities(struct ufs_hba *hba)
{
        int err;

        hba->capabilities = ufshcd_readl(hba, REG_CONTROLLER_CAPABILITIES);

        /* nutrs and nutmrs are 0 based values */
        hba->nutrs = (hba->capabilities & MASK_TRANSFER_REQUESTS_SLOTS) + 1;
        hba->nutmrs =
        ((hba->capabilities & MASK_TASK_MANAGEMENT_REQUEST_SLOTS) >> 16) + 1;

        /* Read crypto capabilities */
        err = ufshcd_hba_init_crypto_capabilities(hba);
        if (err)
                dev_err(hba->dev, "crypto setup failed\n");

        return err;
}

/**
 * ufshcd_ready_for_uic_cmd - Check if controller is ready
 *                            to accept UIC commands
 * @hba: per adapter instance
 * Return true on success, else false
 */
static inline bool ufshcd_ready_for_uic_cmd(struct ufs_hba *hba)
{
        if (ufshcd_readl(hba, REG_CONTROLLER_STATUS) & UIC_COMMAND_READY)
                return true;
        else
                return false;
}

/**
 * ufshcd_get_upmcrs - Get the power mode change request status
 * @hba: Pointer to adapter instance
 *
 * This function gets the UPMCRS field of HCS register
 * Returns value of UPMCRS field
 */
static inline u8 ufshcd_get_upmcrs(struct ufs_hba *hba)
{
        return (ufshcd_readl(hba, REG_CONTROLLER_STATUS) >> 8) & 0x7;
}

/**
 * ufshcd_dispatch_uic_cmd - Dispatch UIC commands to unipro layers
 * @hba: per adapter instance
 * @uic_cmd: UIC command
 *
 * Mutex must be held.
 */
static inline void
ufshcd_dispatch_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
{
        WARN_ON(hba->active_uic_cmd);

        hba->active_uic_cmd = uic_cmd;

        /* Write Args */
        ufshcd_writel(hba, uic_cmd->argument1, REG_UIC_COMMAND_ARG_1);
        ufshcd_writel(hba, uic_cmd->argument2, REG_UIC_COMMAND_ARG_2);
        ufshcd_writel(hba, uic_cmd->argument3, REG_UIC_COMMAND_ARG_3);

        ufshcd_add_uic_command_trace(hba, uic_cmd, UFS_CMD_SEND);

        /* Write UIC Cmd */
        ufshcd_writel(hba, uic_cmd->command & COMMAND_OPCODE_MASK,
                      REG_UIC_COMMAND);
}

/**
 * ufshcd_wait_for_uic_cmd - Wait complectioin of UIC command
 * @hba: per adapter instance
 * @uic_cmd: UIC command
 *
 * Must be called with mutex held.
 * Returns 0 only if success.
 */
static int
ufshcd_wait_for_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
{
        int ret;
        unsigned long flags;

        if (wait_for_completion_timeout(&uic_cmd->done,
                                        msecs_to_jiffies(UIC_CMD_TIMEOUT))) {
                ret = uic_cmd->argument2 & MASK_UIC_COMMAND_RESULT;
        } else {
                ret = -ETIMEDOUT;
                dev_err(hba->dev,
                        "uic cmd 0x%x with arg3 0x%x completion timeout\n",
                        uic_cmd->command, uic_cmd->argument3);

                if (!uic_cmd->cmd_active) {
                        dev_err(hba->dev, "%s: UIC cmd has been completed, return the result\n",
                                __func__);
                        ret = uic_cmd->argument2 & MASK_UIC_COMMAND_RESULT;
                }
        }

        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->active_uic_cmd = NULL;
        spin_unlock_irqrestore(hba->host->host_lock, flags);

        return ret;
}

/**
 * __ufshcd_send_uic_cmd - Send UIC commands and retrieve the result
 * @hba: per adapter instance
 * @uic_cmd: UIC command
 * @completion: initialize the completion only if this is set to true
 *
 * Identical to ufshcd_send_uic_cmd() expect mutex. Must be called
 * with mutex held and host_lock locked.
 * Returns 0 only if success.
 */
static int
__ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd,
                      bool completion)
{
        if (!ufshcd_ready_for_uic_cmd(hba)) {
                dev_err(hba->dev,
                        "Controller not ready to accept UIC commands\n");
                return -EIO;
        }

        if (completion)
                init_completion(&uic_cmd->done);

        uic_cmd->cmd_active = 1;
        ufshcd_dispatch_uic_cmd(hba, uic_cmd);

        return 0;
}

/**
 * ufshcd_send_uic_cmd - Send UIC commands and retrieve the result
 * @hba: per adapter instance
 * @uic_cmd: UIC command
 *
 * Returns 0 only if success.
 */
int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
{
        int ret;
        unsigned long flags;

        ufshcd_hold(hba, false);
        mutex_lock(&hba->uic_cmd_mutex);
        ufshcd_add_delay_before_dme_cmd(hba);

        spin_lock_irqsave(hba->host->host_lock, flags);
        ret = __ufshcd_send_uic_cmd(hba, uic_cmd, true);
        spin_unlock_irqrestore(hba->host->host_lock, flags);
        if (!ret)
                ret = ufshcd_wait_for_uic_cmd(hba, uic_cmd);

        mutex_unlock(&hba->uic_cmd_mutex);

        ufshcd_release(hba);
        return ret;
}

/**
 * ufshcd_map_sg - Map scatter-gather list to prdt
 * @hba: per adapter instance
 * @lrbp: pointer to local reference block
 *
 * Returns 0 in case of success, non-zero value in case of failure
 */
static int ufshcd_map_sg(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        struct ufshcd_sg_entry *prd_table;
        struct scatterlist *sg;
        struct scsi_cmnd *cmd;
        int sg_segments;
        int i;

        cmd = lrbp->cmd;
        sg_segments = scsi_dma_map(cmd);
        if (sg_segments < 0)
                return sg_segments;

        if (sg_segments) {

                if (hba->quirks & UFSHCD_QUIRK_PRDT_BYTE_GRAN)
                        lrbp->utr_descriptor_ptr->prd_table_length =
                                cpu_to_le16((sg_segments *
                                        sizeof(struct ufshcd_sg_entry)));
                else
                        lrbp->utr_descriptor_ptr->prd_table_length =
                                cpu_to_le16((u16) (sg_segments));

                prd_table = (struct ufshcd_sg_entry *)lrbp->ucd_prdt_ptr;

                scsi_for_each_sg(cmd, sg, sg_segments, i) {
                        prd_table[i].size  =
                                cpu_to_le32(((u32) sg_dma_len(sg))-1);
                        prd_table[i].base_addr =
                                cpu_to_le32(lower_32_bits(sg->dma_address));
                        prd_table[i].upper_addr =
                                cpu_to_le32(upper_32_bits(sg->dma_address));
                        prd_table[i].reserved = 0;
                }
        } else {
                lrbp->utr_descriptor_ptr->prd_table_length = 0;
        }

        return 0;
}

/**
 * ufshcd_enable_intr - enable interrupts
 * @hba: per adapter instance
 * @intrs: interrupt bits
 */
static void ufshcd_enable_intr(struct ufs_hba *hba, u32 intrs)
{
        u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE);

        if (hba->ufs_version == ufshci_version(1, 0)) {
                u32 rw;
                rw = set & INTERRUPT_MASK_RW_VER_10;
                set = rw | ((set ^ intrs) & intrs);
        } else {
                set |= intrs;
        }

        ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE);
}

/**
 * ufshcd_disable_intr - disable interrupts
 * @hba: per adapter instance
 * @intrs: interrupt bits
 */
static void ufshcd_disable_intr(struct ufs_hba *hba, u32 intrs)
{
        u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE);

        if (hba->ufs_version == ufshci_version(1, 0)) {
                u32 rw;
                rw = (set & INTERRUPT_MASK_RW_VER_10) &
                        ~(intrs & INTERRUPT_MASK_RW_VER_10);
                set = rw | ((set & intrs) & ~INTERRUPT_MASK_RW_VER_10);

        } else {
                set &= ~intrs;
        }

        ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE);
}

/**
 * ufshcd_prepare_req_desc_hdr() - Fills the requests header
 * descriptor according to request
 * @lrbp: pointer to local reference block
 * @upiu_flags: flags required in the header
 * @cmd_dir: requests data direction
 */
static void ufshcd_prepare_req_desc_hdr(struct ufshcd_lrb *lrbp,
                        u8 *upiu_flags, enum dma_data_direction cmd_dir)
{
        struct utp_transfer_req_desc *req_desc = lrbp->utr_descriptor_ptr;
        u32 data_direction;
        u32 dword_0;
        u32 dword_1 = 0;
        u32 dword_3 = 0;

        if (cmd_dir == DMA_FROM_DEVICE) {
                data_direction = UTP_DEVICE_TO_HOST;
                *upiu_flags = UPIU_CMD_FLAGS_READ;
        } else if (cmd_dir == DMA_TO_DEVICE) {
                data_direction = UTP_HOST_TO_DEVICE;
                *upiu_flags = UPIU_CMD_FLAGS_WRITE;
        } else {
                data_direction = UTP_NO_DATA_TRANSFER;
                *upiu_flags = UPIU_CMD_FLAGS_NONE;
        }

        dword_0 = data_direction | (lrbp->command_type
                                << UPIU_COMMAND_TYPE_OFFSET);
        if (lrbp->intr_cmd)
                dword_0 |= UTP_REQ_DESC_INT_CMD;

        /* Prepare crypto related dwords */
        ufshcd_prepare_req_desc_hdr_crypto(lrbp, &dword_0, &dword_1, &dword_3);

        /* Transfer request descriptor header fields */
        req_desc->header.dword_0 = cpu_to_le32(dword_0);
        req_desc->header.dword_1 = cpu_to_le32(dword_1);
        /*
         * assigning invalid value for command status. Controller
         * updates OCS on command completion, with the command
         * status
         */
        req_desc->header.dword_2 =
                cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
        req_desc->header.dword_3 = cpu_to_le32(dword_3);

        req_desc->prd_table_length = 0;
}

/**
 * ufshcd_prepare_utp_scsi_cmd_upiu() - fills the utp_transfer_req_desc,
 * for scsi commands
 * @lrbp: local reference block pointer
 * @upiu_flags: flags
 */
static
void ufshcd_prepare_utp_scsi_cmd_upiu(struct ufshcd_lrb *lrbp, u8 upiu_flags)
{
        struct scsi_cmnd *cmd = lrbp->cmd;
        struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
        unsigned short cdb_len;

        /* command descriptor fields */
        ucd_req_ptr->header.dword_0 = UPIU_HEADER_DWORD(
                                UPIU_TRANSACTION_COMMAND, upiu_flags,
                                lrbp->lun, lrbp->task_tag);
        ucd_req_ptr->header.dword_1 = UPIU_HEADER_DWORD(
                                UPIU_COMMAND_SET_TYPE_SCSI, 0, 0, 0);

        /* Total EHS length and Data segment length will be zero */
        ucd_req_ptr->header.dword_2 = 0;

        ucd_req_ptr->sc.exp_data_transfer_len = cpu_to_be32(cmd->sdb.length);

        cdb_len = min_t(unsigned short, cmd->cmd_len, UFS_CDB_SIZE);
        memset(ucd_req_ptr->sc.cdb, 0, UFS_CDB_SIZE);
        memcpy(ucd_req_ptr->sc.cdb, cmd->cmnd, cdb_len);

        memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
}

/**
 * ufshcd_prepare_utp_query_req_upiu() - fills the utp_transfer_req_desc,
 * for query requsts
 * @hba: UFS hba
 * @lrbp: local reference block pointer
 * @upiu_flags: flags
 */
static void ufshcd_prepare_utp_query_req_upiu(struct ufs_hba *hba,
                                struct ufshcd_lrb *lrbp, u8 upiu_flags)
{
        struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
        struct ufs_query *query = &hba->dev_cmd.query;
        u16 len = be16_to_cpu(query->request.upiu_req.length);

        /* Query request header */
        ucd_req_ptr->header.dword_0 = UPIU_HEADER_DWORD(
                        UPIU_TRANSACTION_QUERY_REQ, upiu_flags,
                        lrbp->lun, lrbp->task_tag);
        ucd_req_ptr->header.dword_1 = UPIU_HEADER_DWORD(
                        0, query->request.query_func, 0, 0);

        /* Data segment length only need for WRITE_DESC */
        if (query->request.upiu_req.opcode == UPIU_QUERY_OPCODE_WRITE_DESC)
                ucd_req_ptr->header.dword_2 =
                        UPIU_HEADER_DWORD(0, 0, (len >> 8), (u8)len);
        else
                ucd_req_ptr->header.dword_2 = 0;

        /* Copy the Query Request buffer as is */
        memcpy(&ucd_req_ptr->qr, &query->request.upiu_req,
                        QUERY_OSF_SIZE);

        /* Copy the Descriptor */
        if (query->request.upiu_req.opcode == UPIU_QUERY_OPCODE_WRITE_DESC)
                memcpy(ucd_req_ptr + 1, query->descriptor, len);

        memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
}

static inline void ufshcd_prepare_utp_nop_upiu(struct ufshcd_lrb *lrbp)
{
        struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;

        memset(ucd_req_ptr, 0, sizeof(struct utp_upiu_req));

        /* command descriptor fields */
        ucd_req_ptr->header.dword_0 =
                UPIU_HEADER_DWORD(
                        UPIU_TRANSACTION_NOP_OUT, 0, 0, lrbp->task_tag);
        /* clear rest of the fields of basic header */
        ucd_req_ptr->header.dword_1 = 0;
        ucd_req_ptr->header.dword_2 = 0;

        memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
}

/**
 * ufshcd_compose_devman_upiu - UFS Protocol Information Unit(UPIU)
 *                           for Device Management Purposes
 * @hba: per adapter instance
 * @lrbp: pointer to local reference block
 */
static int ufshcd_compose_devman_upiu(struct ufs_hba *hba,
                                      struct ufshcd_lrb *lrbp)
{
        u8 upiu_flags;
        int ret = 0;

        if (hba->ufs_version <= ufshci_version(1, 1))
                lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
        else
                lrbp->command_type = UTP_CMD_TYPE_UFS_STORAGE;

        ufshcd_prepare_req_desc_hdr(lrbp, &upiu_flags, DMA_NONE);
        if (hba->dev_cmd.type == DEV_CMD_TYPE_QUERY)
                ufshcd_prepare_utp_query_req_upiu(hba, lrbp, upiu_flags);
        else if (hba->dev_cmd.type == DEV_CMD_TYPE_NOP)
                ufshcd_prepare_utp_nop_upiu(lrbp);
        else
                ret = -EINVAL;

        return ret;
}

/**
 * ufshcd_comp_scsi_upiu - UFS Protocol Information Unit(UPIU)
 *                         for SCSI Purposes
 * @hba: per adapter instance
 * @lrbp: pointer to local reference block
 */
static int ufshcd_comp_scsi_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        u8 upiu_flags;
        int ret = 0;

        if (hba->ufs_version <= ufshci_version(1, 1))
                lrbp->command_type = UTP_CMD_TYPE_SCSI;
        else
                lrbp->command_type = UTP_CMD_TYPE_UFS_STORAGE;

        if (likely(lrbp->cmd)) {
                ufshcd_prepare_req_desc_hdr(lrbp, &upiu_flags,
                                                lrbp->cmd->sc_data_direction);
                ufshcd_prepare_utp_scsi_cmd_upiu(lrbp, upiu_flags);
        } else {
                ret = -EINVAL;
        }

        return ret;
}

/**
 * ufshcd_upiu_wlun_to_scsi_wlun - maps UPIU W-LUN id to SCSI W-LUN ID
 * @upiu_wlun_id: UPIU W-LUN id
 *
 * Returns SCSI W-LUN id
 */
static inline u16 ufshcd_upiu_wlun_to_scsi_wlun(u8 upiu_wlun_id)
{
        return (upiu_wlun_id & ~UFS_UPIU_WLUN_ID) | SCSI_W_LUN_BASE;
}

static inline bool is_rpmb_wlun(struct scsi_device *sdev)
{
        return sdev->lun == ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_RPMB_WLUN);
}

static inline bool is_device_wlun(struct scsi_device *sdev)
{
        return sdev->lun ==
                ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_UFS_DEVICE_WLUN);
}

static void ufshcd_init_lrb(struct ufs_hba *hba, struct ufshcd_lrb *lrb, int i)
{
        struct utp_transfer_cmd_desc *cmd_descp = hba->ucdl_base_addr;
        struct utp_transfer_req_desc *utrdlp = hba->utrdl_base_addr;
        dma_addr_t cmd_desc_element_addr = hba->ucdl_dma_addr +
                i * sizeof(struct utp_transfer_cmd_desc);
        u16 response_offset = offsetof(struct utp_transfer_cmd_desc,
                                       response_upiu);
        u16 prdt_offset = offsetof(struct utp_transfer_cmd_desc, prd_table);

        lrb->utr_descriptor_ptr = utrdlp + i;
        lrb->utrd_dma_addr = hba->utrdl_dma_addr +
                i * sizeof(struct utp_transfer_req_desc);
        lrb->ucd_req_ptr = (struct utp_upiu_req *)(cmd_descp + i);
        lrb->ucd_req_dma_addr = cmd_desc_element_addr;
        lrb->ucd_rsp_ptr = (struct utp_upiu_rsp *)cmd_descp[i].response_upiu;
        lrb->ucd_rsp_dma_addr = cmd_desc_element_addr + response_offset;
        lrb->ucd_prdt_ptr = (struct ufshcd_sg_entry *)cmd_descp[i].prd_table;
        lrb->ucd_prdt_dma_addr = cmd_desc_element_addr + prdt_offset;
}

/**
 * ufshcd_queuecommand - main entry point for SCSI requests
 * @host: SCSI host pointer
 * @cmd: command from SCSI Midlayer
 *
 * Returns 0 for success, non-zero in case of failure
 */
static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
{
        struct ufshcd_lrb *lrbp;
        struct ufs_hba *hba;
        int tag;
        int err = 0;

        hba = shost_priv(host);

        tag = cmd->request->tag;
        if (!ufshcd_valid_tag(hba, tag)) {
                dev_err(hba->dev,
                        "%s: invalid command tag %d: cmd=0x%p, cmd->request=0x%p",
                        __func__, tag, cmd, cmd->request);
                BUG();
        }

        if (!down_read_trylock(&hba->clk_scaling_lock))
                return SCSI_MLQUEUE_HOST_BUSY;

        switch (hba->ufshcd_state) {
        case UFSHCD_STATE_OPERATIONAL:
        case UFSHCD_STATE_EH_SCHEDULED_NON_FATAL:
                break;
        case UFSHCD_STATE_EH_SCHEDULED_FATAL:
                /*
                 * pm_runtime_get_sync() is used at error handling preparation
                 * stage. If a scsi cmd, e.g. the SSU cmd, is sent from hba's
                 * PM ops, it can never be finished if we let SCSI layer keep
                 * retrying it, which gets err handler stuck forever. Neither
                 * can we let the scsi cmd pass through, because UFS is in bad
                 * state, the scsi cmd may eventually time out, which will get
                 * err handler blocked for too long. So, just fail the scsi cmd
                 * sent from PM ops, err handler can recover PM error anyways.
                 */
                if (hba->pm_op_in_progress) {
                        hba->force_reset = true;
                        set_host_byte(cmd, DID_BAD_TARGET);
                        cmd->scsi_done(cmd);
                        goto out;
                }
                fallthrough;
        case UFSHCD_STATE_RESET:
                err = SCSI_MLQUEUE_HOST_BUSY;
                goto out;
        case UFSHCD_STATE_ERROR:
                set_host_byte(cmd, DID_ERROR);
                cmd->scsi_done(cmd);
                goto out;
        default:
                dev_WARN_ONCE(hba->dev, 1, "%s: invalid state %d\n",
                                __func__, hba->ufshcd_state);
                set_host_byte(cmd, DID_BAD_TARGET);
                cmd->scsi_done(cmd);
                goto out;
        }

        hba->req_abort_count = 0;

        err = ufshcd_hold(hba, true);
        if (err) {
                err = SCSI_MLQUEUE_HOST_BUSY;
                goto out;
        }
        WARN_ON(ufshcd_is_clkgating_allowed(hba) &&
                (hba->clk_gating.state != CLKS_ON));

        if (unlikely(test_bit(tag, &hba->outstanding_reqs))) {
                if (hba->pm_op_in_progress)
                        set_host_byte(cmd, DID_BAD_TARGET);
                else
                        err = SCSI_MLQUEUE_HOST_BUSY;
                ufshcd_release(hba);
                goto out;
        }

        lrbp = &hba->lrb[tag];
        WARN_ON(lrbp->cmd);
        lrbp->cmd = cmd;
        lrbp->sense_bufflen = UFS_SENSE_SIZE;
        lrbp->sense_buffer = cmd->sense_buffer;
        lrbp->task_tag = tag;
        lrbp->lun = ufshcd_scsi_to_upiu_lun(cmd->device->lun);
        lrbp->intr_cmd = !ufshcd_is_intr_aggr_allowed(hba) ? true : false;

        ufshcd_prepare_lrbp_crypto(cmd->request, lrbp);

        lrbp->req_abort_skip = false;

        ufshcd_comp_scsi_upiu(hba, lrbp);

        err = ufshcd_map_sg(hba, lrbp);
        if (err) {
                lrbp->cmd = NULL;
                ufshcd_release(hba);
                goto out;
        }
        /* Make sure descriptors are ready before ringing the doorbell */
        wmb();

        ufshcd_send_command(hba, tag);
out:
        up_read(&hba->clk_scaling_lock);
        return err;
}

static int ufshcd_compose_dev_cmd(struct ufs_hba *hba,
                struct ufshcd_lrb *lrbp, enum dev_cmd_type cmd_type, int tag)
{
        lrbp->cmd = NULL;
        lrbp->sense_bufflen = 0;
        lrbp->sense_buffer = NULL;
        lrbp->task_tag = tag;
        lrbp->lun = 0; /* device management cmd is not specific to any LUN */
        lrbp->intr_cmd = true; /* No interrupt aggregation */
        ufshcd_prepare_lrbp_crypto(NULL, lrbp);
        hba->dev_cmd.type = cmd_type;

        return ufshcd_compose_devman_upiu(hba, lrbp);
}

static int
ufshcd_clear_cmd(struct ufs_hba *hba, int tag)
{
        int err = 0;
        unsigned long flags;
        u32 mask = 1 << tag;

        /* clear outstanding transaction before retry */
        spin_lock_irqsave(hba->host->host_lock, flags);
        ufshcd_utrl_clear(hba, tag);
        spin_unlock_irqrestore(hba->host->host_lock, flags);

        /*
         * wait for h/w to clear corresponding bit in door-bell.
         * max. wait is 1 sec.
         */
        err = ufshcd_wait_for_register(hba,
                        REG_UTP_TRANSFER_REQ_DOOR_BELL,
                        mask, ~mask, 1000, 1000);

        return err;
}

static int
ufshcd_check_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        struct ufs_query_res *query_res = &hba->dev_cmd.query.response;

        /* Get the UPIU response */
        query_res->response = ufshcd_get_rsp_upiu_result(lrbp->ucd_rsp_ptr) >>
                                UPIU_RSP_CODE_OFFSET;
        return query_res->response;
}

/**
 * ufshcd_dev_cmd_completion() - handles device management command responses
 * @hba: per adapter instance
 * @lrbp: pointer to local reference block
 */
static int
ufshcd_dev_cmd_completion(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
{
        int resp;
        int err = 0;

        hba->ufs_stats.last_hibern8_exit_tstamp = ktime_set(0, 0);
        resp = ufshcd_get_req_rsp(lrbp->ucd_rsp_ptr);

        switch (resp) {
        case UPIU_TRANSACTION_NOP_IN:
                if (hba->dev_cmd.type != DEV_CMD_TYPE_NOP) {
                        err = -EINVAL;
                        dev_err(hba->dev, "%s: unexpected response %x\n",
                                        __func__, resp);
                }
                break;
        case UPIU_TRANSACTION_QUERY_RSP:
                err = ufshcd_check_query_response(hba, lrbp);
                if (!err)
                        err = ufshcd_copy_query_response(hba, lrbp);
                break;
        case UPIU_TRANSACTION_REJECT_UPIU:
                /* TODO: handle Reject UPIU Response */
                err = -EPERM;
                dev_err(hba->dev, "%s: Reject UPIU not fully implemented\n",
                                __func__);
                break;
        default:
                err = -EINVAL;
                dev_err(hba->dev, "%s: Invalid device management cmd response: %x\n",
                                __func__, resp);
                break;
        }

        return err;
}

static int ufshcd_wait_for_dev_cmd(struct ufs_hba *hba,
                struct ufshcd_lrb *lrbp, int max_timeout)
{
        int err = 0;
        unsigned long time_left;
        unsigned long flags;

        time_left = wait_for_completion_timeout(hba->dev_cmd.complete,
                        msecs_to_jiffies(max_timeout));

        /* Make sure descriptors are ready before ringing the doorbell */
        wmb();
        spin_lock_irqsave(hba->host->host_lock, flags);
        hba->dev_cmd.complete = NULL;
        if (likely(time_left)) {
                err = ufshcd_get_tr_ocs(lrbp);
                if (!err)
                        err = ufshcd_dev_cmd_completion(hba, lrbp);
        }
        spin_unlock_irqrestore(hba->host->host_lock, flags);

        if (!time_left) {
                err = -ETIMEDOUT;
                dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
                        __func__, lrbp->task_tag);
                if (!ufshcd_clear_cmd(hba, lrbp->task_tag))
                        /* successfully cleared the command, retry if needed */
                        err = -EAGAIN;
                /*
                 * in case of an error, after clearing the doorbell,
                 * we also need to clear the outstanding_request
                 * field in hba
                 */
                ufshcd_outstanding_req_clear(hba, lrbp->task_tag);
        }

        return err;
}

/**
 * ufshcd_exec_dev_cmd - API for sending device management requests
 * @hba: UFS hba
 * @cmd_type: specifies the type (NOP, Query...)
 * @timeout: timeout in milliseconds
 *
 * NOTE: Since there is only one available tag for device management commands,
 * it is expected you hold the hba->dev_cmd.lock mutex.
 */
static int ufshcd_exec_dev_cmd(struct ufs_hba *hba,
                enum dev_cmd_type cmd_type, int timeout)
{
        struct request_queue *q = hba->cmd_queue;
        struct request *req;
        struct ufshcd_lrb *lrbp;
        int err;
        int tag;
        struct completion wait;

        down_read(&hba->clk_scaling_lock);

        /*
         * Get free slot, sleep if slots are unavailable.
         * Even though we use wait_event() which sleeps indefinitely,
         * the maximum wait time is bounded by SCSI request timeout.
         */
        req = blk_get_request(q, REQ_OP_DRV_OUT, 0);
        if (IS_ERR(req)) {
                err = PTR_ERR(req);
                goto out_unlock;
        }
        tag = req->tag;
        WARN_ON_ONCE(!ufshcd_valid_tag(hba, tag));
        /* Set the timeout such that the SCSI error handler is not activated. */
        req->timeout = msecs_to_jiffies(2 * timeout);
        blk_mq_start_request(req);

        if (unlikely(test_bit(tag, &hba->outstanding_reqs))) {
                err = -EBUSY;
                goto out;
        }

        init_completion(&wait);
        lrbp = &hba->lrb[tag];
        WARN_ON(lrbp->cmd);
        err = ufshcd_compose_dev_cmd(hba, lrbp, cmd_type, tag);
        if (unlikely(err))
                goto out;

        hba->dev_cmd.complete = &wait;

        ufshcd_add_query_upiu_trace(hba, UFS_QUERY_SEND, lrbp->ucd_req_ptr);
        /* Make sure descriptors are ready before ringing the doorbell */
        wmb();

        ufshcd_send_command(hba, tag);
        err = ufshcd_wait_for_dev_cmd(hba, lrbp, timeout);
        ufshcd_add_query_upiu_trace(hba, err ? UFS_QUERY_ERR : UFS_QUERY_COMP,
                                    (struct utp_upiu_req *)lrbp->ucd_rsp_ptr);

out:
        blk_put_request(req);