2020-06-05 20:05:19 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2012-02-29 06:41:50 +00:00
|
|
|
/*
|
2013-02-25 16:14:33 +00:00
|
|
|
* Universal Flash Storage Host controller driver Core
|
2013-02-25 16:14:32 +00:00
|
|
|
* Copyright (C) 2011-2013 Samsung India Software Operations
|
2016-02-01 13:02:37 +00:00
|
|
|
* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
2013-02-25 16:14:32 +00:00
|
|
|
* Authors:
|
|
|
|
* Santosh Yaraganavi <santosh.sy@samsung.com>
|
|
|
|
* Vinayak Holikatti <h.vinayak@samsung.com>
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
#include <linux/async.h>
|
2014-09-25 12:32:34 +00:00
|
|
|
#include <linux/devfreq.h>
|
2016-03-10 15:37:09 +00:00
|
|
|
#include <linux/nls.h>
|
2016-03-10 15:37:05 +00:00
|
|
|
#include <linux/of.h>
|
2018-03-20 13:07:38 +00:00
|
|
|
#include <linux/bitfield.h>
|
2020-03-26 01:09:59 +00:00
|
|
|
#include <linux/blk-pm.h>
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
#include <linux/blkdev.h>
|
2013-02-25 16:14:33 +00:00
|
|
|
#include "ufshcd.h"
|
2016-03-10 15:37:10 +00:00
|
|
|
#include "ufs_quirks.h"
|
2013-08-31 16:10:22 +00:00
|
|
|
#include "unipro.h"
|
2018-02-15 12:14:01 +00:00
|
|
|
#include "ufs-sysfs.h"
|
scsi: ufs: Add a bsg endpoint that supports UPIUs
For now, just provide an API to allocate and remove ufs-bsg node. We
will use this framework to manage ufs devices by sending UPIU
transactions.
For the time being, implements an empty bsg_request() - will add some
more functionality in coming patches.
Nonetheless, we reveal here the protocol we are planning to use: UFS
Transport Protocol Transactions. UFS transactions consist of packets
called UFS Protocol Information Units (UPIU).
There are UPIU’s defined for UFS SCSI commands, responses, data in and
data out, task management, utility functions, vendor functions,
transaction synchronization and control, and more.
By using UPIUs, we get access to the most fine-grained internals of this
protocol, and able to communicate with the device in ways, that are
sometimes beyond the capacity of the ufs driver.
Moreover and as a result, our core structure - ufs_bsg_node has a pretty
lean structure: using upiu transactions that contains the outmost
detailed info, so we don't really need complex constructs to support it.
Signed-off-by: Avri Altman <avri.altman@wdc.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Bart Van Assche <Bart.VanAssche@wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-10-07 14:30:35 +00:00
|
|
|
#include "ufs_bsg.h"
|
2020-07-06 20:04:14 +00:00
|
|
|
#include "ufshcd-crypto.h"
|
2020-04-22 21:41:42 +00:00
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <linux/blkdev.h>
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-12-23 02:39:51 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/ufs.h>
|
|
|
|
|
2013-06-26 17:09:27 +00:00
|
|
|
#define UFSHCD_ENABLE_INTRS (UTP_TRANSFER_REQ_COMPL |\
|
|
|
|
UTP_TASK_REQ_COMPL |\
|
|
|
|
UFSHCD_ERROR_MASK)
|
2013-06-26 17:09:29 +00:00
|
|
|
/* UIC command timeout, unit: ms */
|
|
|
|
#define UIC_CMD_TIMEOUT 500
|
2013-06-26 17:09:27 +00:00
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/* NOP OUT retries waiting for NOP IN response */
|
|
|
|
#define NOP_OUT_RETRIES 10
|
|
|
|
/* Timeout after 30 msecs if NOP OUT hangs without response */
|
|
|
|
#define NOP_OUT_TIMEOUT 30 /* msecs */
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/* Query request retries */
|
2016-11-24 00:31:52 +00:00
|
|
|
#define QUERY_REQ_RETRIES 3
|
2013-07-29 19:05:58 +00:00
|
|
|
/* Query request timeout */
|
2016-11-24 00:31:52 +00:00
|
|
|
#define QUERY_REQ_TIMEOUT 1500 /* 1.5 seconds */
|
2013-07-29 19:05:58 +00:00
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
/* Task management command timeout */
|
|
|
|
#define TM_CMD_TIMEOUT 100 /* msecs */
|
|
|
|
|
2016-02-01 13:02:43 +00:00
|
|
|
/* maximum number of retries for a general UIC command */
|
|
|
|
#define UFS_UIC_COMMAND_RETRIES 3
|
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
/* maximum number of link-startup retries */
|
|
|
|
#define DME_LINKSTARTUP_RETRIES 3
|
|
|
|
|
2016-02-01 13:02:44 +00:00
|
|
|
/* Maximum retries for Hibern8 enter */
|
|
|
|
#define UIC_HIBERN8_ENTER_RETRIES 3
|
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
/* maximum number of reset retries before giving up */
|
|
|
|
#define MAX_HOST_RESET_RETRIES 5
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/* Expose the flag value from utp_upiu_query.value */
|
|
|
|
#define MASK_QUERY_UPIU_FLAG_LOC 0xFF
|
|
|
|
|
2013-08-31 16:10:20 +00:00
|
|
|
/* Interrupt aggregation default timeout, unit: 40us */
|
|
|
|
#define INT_AGGR_DEF_TO 0x02
|
|
|
|
|
2019-09-16 15:56:50 +00:00
|
|
|
/* default delay of autosuspend: 2000 ms */
|
|
|
|
#define RPM_AUTOSUSPEND_DELAY_MS 2000
|
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
/* Default delay of RPM device flush delayed work */
|
|
|
|
#define RPM_DEV_FLUSH_RECHECK_WORK_DELAY_MS 5000
|
|
|
|
|
2020-02-11 03:40:49 +00:00
|
|
|
/* Default value of wait time before gating device ref clock */
|
|
|
|
#define UFSHCD_REF_CLK_GATING_WAIT_US 0xFF /* microsecs */
|
|
|
|
|
2020-08-10 10:02:27 +00:00
|
|
|
/* Polling time to wait for fDeviceInit */
|
|
|
|
#define FDEVICEINIT_COMPL_TIMEOUT 1500 /* millisecs */
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
#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; \
|
|
|
|
})
|
|
|
|
|
2018-06-14 08:14:09 +00:00
|
|
|
#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)
|
|
|
|
{
|
2019-01-22 17:29:22 +00:00
|
|
|
u32 *regs;
|
|
|
|
size_t pos;
|
|
|
|
|
|
|
|
if (offset % 4 != 0 || len % 4 != 0) /* keep readl happy */
|
|
|
|
return -EINVAL;
|
2018-06-14 08:14:09 +00:00
|
|
|
|
2019-11-15 06:09:27 +00:00
|
|
|
regs = kzalloc(len, GFP_ATOMIC);
|
2018-06-14 08:14:09 +00:00
|
|
|
if (!regs)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2019-01-22 17:29:22 +00:00
|
|
|
for (pos = 0; pos < len; pos += 4)
|
|
|
|
regs[pos / 4] = ufshcd_readl(hba, offset + pos);
|
|
|
|
|
2018-06-14 08:14:09 +00:00
|
|
|
ufshcd_hex_dump(prefix, regs, len);
|
|
|
|
kfree(regs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_dump_regs);
|
2016-12-23 02:39:42 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
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,
|
2014-05-26 05:29:14 +00:00
|
|
|
UFSHCD_STATE_OPERATIONAL,
|
scsi: ufs: Fix a race condition between error handler and runtime PM ops
The current IRQ handler blocks SCSI requests before scheduling eh_work,
when error handler calls pm_runtime_get_sync, if ufshcd_suspend/resume
sends a SCSI cmd, most likely the SSU cmd, since SCSI requests are blocked,
pm_runtime_get_sync() will never return because ufshcd_suspend/resume is
blocked by the SCSI cmd.
- In queuecommand path, hba->ufshcd_state check and ufshcd_send_command
should stay under the same spin lock. This is to make sure that no more
commands leak into doorbell after hba->ufshcd_state is changed.
- Don't block SCSI requests before error handler starts to run, let error
handler block SCSI requests when it is ready to start error recovery.
- Don't let SCSI layer keep requeuing the SCSI cmds sent from HBA runtime
PM ops, let them pass or fail them. Let them pass if eh_work is
scheduled due to non-fatal errors. Fail them if eh_work is scheduled due
to fatal errors, otherwise the cmds may eventually time out since UFS is
in bad state, which gets error handler blocked for too long. If we fail
the SCSI cmds sent from HBA runtime PM ops, HBA runtime PM ops fails
too, but it does not hurt since error handler can recover HBA runtime PM
error.
Link: https://lore.kernel.org/r/1596975355-39813-9-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:54 +00:00
|
|
|
UFSHCD_STATE_EH_SCHEDULED_FATAL,
|
|
|
|
UFSHCD_STATE_EH_SCHEDULED_NON_FATAL,
|
2014-05-26 05:29:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* UFSHCD error handling flags */
|
|
|
|
enum {
|
|
|
|
UFSHCD_EH_IN_PROGRESS = (1 << 0),
|
2012-02-29 06:41:50 +00:00
|
|
|
};
|
|
|
|
|
2014-05-26 05:29:15 +00:00
|
|
|
/* UFSHCD UIC layer error flags */
|
|
|
|
enum {
|
|
|
|
UFSHCD_UIC_DL_PA_INIT_ERROR = (1 << 0), /* Data link layer error */
|
2016-03-10 15:37:12 +00:00
|
|
|
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 */
|
2014-05-26 05:29:15 +00:00
|
|
|
};
|
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
#define ufshcd_set_eh_in_progress(h) \
|
2017-03-28 13:49:26 +00:00
|
|
|
((h)->eh_flags |= UFSHCD_EH_IN_PROGRESS)
|
2014-05-26 05:29:14 +00:00
|
|
|
#define ufshcd_eh_in_progress(h) \
|
2017-03-28 13:49:26 +00:00
|
|
|
((h)->eh_flags & UFSHCD_EH_IN_PROGRESS)
|
2014-05-26 05:29:14 +00:00
|
|
|
#define ufshcd_clear_eh_in_progress(h) \
|
2017-03-28 13:49:26 +00:00
|
|
|
((h)->eh_flags &= ~UFSHCD_EH_IN_PROGRESS)
|
2014-05-26 05:29:14 +00:00
|
|
|
|
2018-02-15 12:14:01 +00:00
|
|
|
struct ufs_pm_lvl_states ufs_pm_lvl_states[] = {
|
2014-09-25 12:32:30 +00:00
|
|
|
{UFS_ACTIVE_PWR_MODE, UIC_LINK_ACTIVE_STATE},
|
|
|
|
{UFS_ACTIVE_PWR_MODE, UIC_LINK_HIBERN8_STATE},
|
|
|
|
{UFS_SLEEP_PWR_MODE, UIC_LINK_ACTIVE_STATE},
|
|
|
|
{UFS_SLEEP_PWR_MODE, UIC_LINK_HIBERN8_STATE},
|
|
|
|
{UFS_POWERDOWN_PWR_MODE, UIC_LINK_HIBERN8_STATE},
|
|
|
|
{UFS_POWERDOWN_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;
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:41:11 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-12-06 03:25:32 +00:00
|
|
|
static struct ufs_dev_fix ufs_fixups[] = {
|
|
|
|
/* UFS cards deviations table */
|
2020-06-12 01:26:24 +00:00
|
|
|
UFS_FIX(UFS_VENDOR_MICRON, UFS_ANY_MODEL,
|
|
|
|
UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM),
|
2016-12-06 03:25:32 +00:00
|
|
|
UFS_FIX(UFS_VENDOR_SAMSUNG, UFS_ANY_MODEL,
|
2020-06-12 01:26:25 +00:00
|
|
|
UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM |
|
|
|
|
UFS_DEVICE_QUIRK_HOST_PA_TACTIVATE |
|
2016-12-06 03:25:32 +00:00
|
|
|
UFS_DEVICE_QUIRK_RECOVERY_FROM_DL_NAC_ERRORS),
|
2020-06-12 01:26:25 +00:00
|
|
|
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),
|
2016-12-06 03:25:32 +00:00
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_tmc_handler(struct ufs_hba *hba);
|
2014-05-26 05:29:14 +00:00
|
|
|
static void ufshcd_async_scan(void *data, async_cookie_t cookie);
|
2014-05-26 05:29:15 +00:00
|
|
|
static int ufshcd_reset_and_restore(struct ufs_hba *hba);
|
2016-12-23 02:40:07 +00:00
|
|
|
static int ufshcd_eh_host_reset_handler(struct scsi_cmnd *cmd);
|
2014-05-26 05:29:15 +00:00
|
|
|
static int ufshcd_clear_tm_cmd(struct ufs_hba *hba, int tag);
|
2014-09-25 12:32:26 +00:00
|
|
|
static void ufshcd_hba_exit(struct ufs_hba *hba);
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
static int ufshcd_probe_hba(struct ufs_hba *hba, bool async);
|
2014-09-25 12:32:32 +00:00
|
|
|
static int __ufshcd_setup_clocks(struct ufs_hba *hba, bool on,
|
|
|
|
bool skip_ref_clk);
|
|
|
|
static int ufshcd_setup_clocks(struct ufs_hba *hba, bool on);
|
|
|
|
static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba);
|
2015-03-31 14:37:14 +00:00
|
|
|
static inline void ufshcd_add_delay_before_dme_cmd(struct ufs_hba *hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_host_reset_and_restore(struct ufs_hba *hba);
|
2016-12-23 02:40:50 +00:00
|
|
|
static void ufshcd_resume_clkscaling(struct ufs_hba *hba);
|
|
|
|
static void ufshcd_suspend_clkscaling(struct ufs_hba *hba);
|
2017-02-04 00:57:39 +00:00
|
|
|
static void __ufshcd_suspend_clkscaling(struct ufs_hba *hba);
|
2016-12-23 02:40:50 +00:00
|
|
|
static int ufshcd_scale_clks(struct ufs_hba *hba, bool scale_up);
|
2014-09-25 12:32:30 +00:00
|
|
|
static irqreturn_t ufshcd_intr(int irq, void *__hba);
|
2015-05-17 15:55:03 +00:00
|
|
|
static int ufshcd_change_power_mode(struct ufs_hba *hba,
|
|
|
|
struct ufs_pa_layer_attr *pwr_mode);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
static void ufshcd_schedule_eh_work(struct ufs_hba *hba);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
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);
|
2020-04-22 21:41:42 +00:00
|
|
|
static int ufshcd_wb_buf_flush_enable(struct ufs_hba *hba);
|
|
|
|
static int ufshcd_wb_buf_flush_disable(struct ufs_hba *hba);
|
|
|
|
static int ufshcd_wb_ctrl(struct ufs_hba *hba, bool enable);
|
|
|
|
static int 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);
|
|
|
|
|
2016-02-01 13:02:39 +00:00
|
|
|
static inline bool ufshcd_valid_tag(struct ufs_hba *hba, int tag)
|
|
|
|
{
|
|
|
|
return tag >= 0 && tag < hba->nutrs;
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2019-12-05 02:14:46 +00:00
|
|
|
static inline void ufshcd_enable_irq(struct ufs_hba *hba)
|
2014-09-25 12:32:30 +00:00
|
|
|
{
|
|
|
|
if (!hba->is_irq_enabled) {
|
2019-12-05 02:14:46 +00:00
|
|
|
enable_irq(hba->irq);
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->is_irq_enabled = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ufshcd_disable_irq(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (hba->is_irq_enabled) {
|
2019-12-05 02:14:46 +00:00
|
|
|
disable_irq(hba->irq);
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->is_irq_enabled = false;
|
|
|
|
}
|
|
|
|
}
|
2014-05-26 05:29:14 +00:00
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
static inline void ufshcd_wb_config(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2020-05-08 08:01:15 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba))
|
2020-04-22 21:41:42 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
ret = ufshcd_wb_ctrl(hba, true);
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev, "%s: Enable WB failed: %d\n", __func__, ret);
|
|
|
|
else
|
|
|
|
dev_info(hba->dev, "%s: Write Booster Configured\n", __func__);
|
|
|
|
ret = ufshcd_wb_toggle_flush_during_h8(hba, true);
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev, "%s: En WB flush during H8: failed: %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
ufshcd_wb_toggle_flush(hba, true);
|
|
|
|
}
|
|
|
|
|
2018-05-03 11:07:18 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-03-28 09:42:18 +00:00
|
|
|
static void ufshcd_add_cmd_upiu_trace(struct ufs_hba *hba, unsigned int tag,
|
|
|
|
const char *str)
|
|
|
|
{
|
|
|
|
struct utp_upiu_req *rq = hba->lrb[tag].ucd_req_ptr;
|
|
|
|
|
|
|
|
trace_ufshcd_upiu(dev_name(hba->dev), str, &rq->header, &rq->sc.cdb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_add_query_upiu_trace(struct ufs_hba *hba, unsigned int tag,
|
|
|
|
const char *str)
|
|
|
|
{
|
|
|
|
struct utp_upiu_req *rq = hba->lrb[tag].ucd_req_ptr;
|
|
|
|
|
|
|
|
trace_ufshcd_upiu(dev_name(hba->dev), str, &rq->header, &rq->qr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_add_tm_upiu_trace(struct ufs_hba *hba, unsigned int tag,
|
|
|
|
const char *str)
|
|
|
|
{
|
|
|
|
int off = (int)tag - hba->nutrs;
|
2018-10-07 14:30:32 +00:00
|
|
|
struct utp_task_req_desc *descp = &hba->utmrdl_base_addr[off];
|
2018-03-28 09:42:18 +00:00
|
|
|
|
2018-10-07 14:30:32 +00:00
|
|
|
trace_ufshcd_upiu(dev_name(hba->dev), str, &descp->req_header,
|
|
|
|
&descp->input_param1);
|
2018-03-28 09:42:18 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 07:22:35 +00:00
|
|
|
static void ufshcd_add_uic_command_trace(struct ufs_hba *hba,
|
|
|
|
struct uic_command *ucmd,
|
|
|
|
const char *str)
|
|
|
|
{
|
|
|
|
u32 cmd;
|
|
|
|
|
|
|
|
if (!trace_ufshcd_uic_command_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!strcmp(str, "send"))
|
|
|
|
cmd = ucmd->command;
|
|
|
|
else
|
|
|
|
cmd = ufshcd_readl(hba, REG_UIC_COMMAND);
|
|
|
|
|
|
|
|
trace_ufshcd_uic_command(dev_name(hba->dev), str, 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));
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:42:03 +00:00
|
|
|
static void ufshcd_add_command_trace(struct ufs_hba *hba,
|
|
|
|
unsigned int tag, const char *str)
|
|
|
|
{
|
|
|
|
sector_t lba = -1;
|
|
|
|
u8 opcode = 0;
|
|
|
|
u32 intr, doorbell;
|
2018-08-05 13:26:23 +00:00
|
|
|
struct ufshcd_lrb *lrbp = &hba->lrb[tag];
|
2019-12-24 22:02:44 +00:00
|
|
|
struct scsi_cmnd *cmd = lrbp->cmd;
|
2016-12-23 02:42:03 +00:00
|
|
|
int transfer_len = -1;
|
|
|
|
|
2018-08-05 13:26:23 +00:00
|
|
|
if (!trace_ufshcd_command_enabled()) {
|
|
|
|
/* trace UPIU W/O tracing command */
|
2019-12-24 22:02:44 +00:00
|
|
|
if (cmd)
|
2018-08-05 13:26:23 +00:00
|
|
|
ufshcd_add_cmd_upiu_trace(hba, tag, str);
|
2016-12-23 02:42:03 +00:00
|
|
|
return;
|
2018-08-05 13:26:23 +00:00
|
|
|
}
|
2016-12-23 02:42:03 +00:00
|
|
|
|
2019-12-24 22:02:44 +00:00
|
|
|
if (cmd) { /* data phase exists */
|
2018-08-05 13:26:23 +00:00
|
|
|
/* trace UPIU also */
|
|
|
|
ufshcd_add_cmd_upiu_trace(hba, tag, str);
|
2019-12-24 22:02:44 +00:00
|
|
|
opcode = cmd->cmnd[0];
|
2016-12-23 02:42:03 +00:00
|
|
|
if ((opcode == READ_10) || (opcode == WRITE_10)) {
|
|
|
|
/*
|
|
|
|
* Currently we only fully trace read(10) and write(10)
|
|
|
|
* commands
|
|
|
|
*/
|
2019-12-24 22:02:44 +00:00
|
|
|
if (cmd->request && cmd->request->bio)
|
|
|
|
lba = cmd->request->bio->bi_iter.bi_sector;
|
2016-12-23 02:42:03 +00:00
|
|
|
transfer_len = be32_to_cpu(
|
|
|
|
lrbp->ucd_req_ptr->sc.exp_data_transfer_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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, tag,
|
|
|
|
doorbell, transfer_len, intr, lba, opcode);
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
static void ufshcd_print_clk_freqs(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct ufs_clk_info *clki;
|
|
|
|
struct list_head *head = &hba->clk_list_head;
|
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
if (list_empty(head))
|
2016-12-23 02:42:18 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-10 13:38:18 +00:00
|
|
|
static void ufshcd_print_err_hist(struct ufs_hba *hba,
|
|
|
|
struct ufs_err_reg_hist *err_hist,
|
|
|
|
char *err_name)
|
2016-12-23 02:42:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
2019-01-28 14:04:26 +00:00
|
|
|
bool found = false;
|
2016-12-23 02:42:18 +00:00
|
|
|
|
2019-07-10 13:38:18 +00:00
|
|
|
for (i = 0; i < UFS_ERR_REG_HIST_LENGTH; i++) {
|
|
|
|
int p = (i + err_hist->pos) % UFS_ERR_REG_HIST_LENGTH;
|
2016-12-23 02:42:18 +00:00
|
|
|
|
2020-01-04 14:26:06 +00:00
|
|
|
if (err_hist->tstamp[p] == 0)
|
2016-12-23 02:42:18 +00:00
|
|
|
continue;
|
2019-07-10 13:38:20 +00:00
|
|
|
dev_err(hba->dev, "%s[%d] = 0x%x at %lld us\n", err_name, p,
|
2016-12-23 02:42:18 +00:00
|
|
|
err_hist->reg[p], ktime_to_us(err_hist->tstamp[p]));
|
2019-01-28 14:04:26 +00:00
|
|
|
found = true;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2019-01-28 14:04:26 +00:00
|
|
|
|
|
|
|
if (!found)
|
2020-01-04 14:26:08 +00:00
|
|
|
dev_err(hba->dev, "No record of %s\n", err_name);
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
|
|
|
|
2016-12-23 02:39:42 +00:00
|
|
|
static void ufshcd_print_host_regs(struct ufs_hba *hba)
|
|
|
|
{
|
2018-06-14 08:14:09 +00:00
|
|
|
ufshcd_dump_regs(hba, 0, UFSHCI_REG_SPACE_SIZE, "host_regs: ");
|
2016-12-23 02:42:18 +00:00
|
|
|
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.pa_err, "pa_err");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.dl_err, "dl_err");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.nl_err, "nl_err");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.tl_err, "tl_err");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.dme_err, "dme_err");
|
2019-07-10 13:38:19 +00:00
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.auto_hibern8_err,
|
|
|
|
"auto_hibern8_err");
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.fatal_err, "fatal_err");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.link_startup_err,
|
|
|
|
"link_startup_fail");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.resume_err, "resume_fail");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.suspend_err,
|
|
|
|
"suspend_fail");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.dev_reset, "dev_reset");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.host_reset, "host_reset");
|
|
|
|
ufshcd_print_err_hist(hba, &hba->ufs_stats.task_abort, "task_abort");
|
2016-12-23 02:42:18 +00:00
|
|
|
|
2019-12-24 13:01:06 +00:00
|
|
|
ufshcd_vops_dbg_register_dump(hba);
|
2016-12-23 02:39:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void ufshcd_print_trs(struct ufs_hba *hba, unsigned long bitmap, bool pr_prdt)
|
|
|
|
{
|
|
|
|
struct ufshcd_lrb *lrbp;
|
2017-02-04 00:56:50 +00:00
|
|
|
int prdt_length;
|
2016-12-23 02:39:42 +00:00
|
|
|
int tag;
|
|
|
|
|
|
|
|
for_each_set_bit(tag, &bitmap, hba->nutrs) {
|
|
|
|
lrbp = &hba->lrb[tag];
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "UPIU[%d] - issue time %lld us\n",
|
|
|
|
tag, ktime_to_us(lrbp->issue_time_stamp));
|
2017-09-27 02:06:06 +00:00
|
|
|
dev_err(hba->dev, "UPIU[%d] - complete time %lld us\n",
|
|
|
|
tag, ktime_to_us(lrbp->compl_time_stamp));
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev,
|
|
|
|
"UPIU[%d] - Transfer Request Descriptor phys@0x%llx\n",
|
|
|
|
tag, (u64)lrbp->utrd_dma_addr);
|
|
|
|
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_hex_dump("UPIU TRD: ", lrbp->utr_descriptor_ptr,
|
|
|
|
sizeof(struct utp_transfer_req_desc));
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "UPIU[%d] - Request UPIU phys@0x%llx\n", tag,
|
|
|
|
(u64)lrbp->ucd_req_dma_addr);
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_hex_dump("UPIU REQ: ", lrbp->ucd_req_ptr,
|
|
|
|
sizeof(struct utp_upiu_req));
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "UPIU[%d] - Response UPIU phys@0x%llx\n", tag,
|
|
|
|
(u64)lrbp->ucd_rsp_dma_addr);
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_hex_dump("UPIU RSP: ", lrbp->ucd_rsp_ptr,
|
|
|
|
sizeof(struct utp_upiu_rsp));
|
|
|
|
|
2017-02-04 00:56:50 +00:00
|
|
|
prdt_length = le16_to_cpu(
|
|
|
|
lrbp->utr_descriptor_ptr->prd_table_length);
|
|
|
|
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)
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_hex_dump("UPIU PRDT: ", lrbp->ucd_prdt_ptr,
|
2017-02-04 00:56:50 +00:00
|
|
|
sizeof(struct ufshcd_sg_entry) * prdt_length);
|
2016-12-23 02:39:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_print_tmrs(struct ufs_hba *hba, unsigned long bitmap)
|
|
|
|
{
|
|
|
|
int tag;
|
|
|
|
|
|
|
|
for_each_set_bit(tag, &bitmap, hba->nutmrs) {
|
2018-10-07 14:30:32 +00:00
|
|
|
struct utp_task_req_desc *tmrdp = &hba->utmrdl_base_addr[tag];
|
|
|
|
|
2016-12-23 02:39:42 +00:00
|
|
|
dev_err(hba->dev, "TM[%d] - Task Management Header\n", tag);
|
2018-10-07 14:30:32 +00:00
|
|
|
ufshcd_hex_dump("", tmrdp, sizeof(*tmrdp));
|
2016-12-23 02:39:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:28 +00:00
|
|
|
static void ufshcd_print_host_state(struct ufs_hba *hba)
|
|
|
|
{
|
2020-08-09 12:15:50 +00:00
|
|
|
struct scsi_device *sdev_ufs = hba->sdev_ufs_device;
|
|
|
|
|
2017-02-04 00:57:28 +00:00
|
|
|
dev_err(hba->dev, "UFS Host state=%d\n", hba->ufshcd_state);
|
2019-12-09 18:13:08 +00:00
|
|
|
dev_err(hba->dev, "outstanding reqs=0x%lx tasks=0x%lx\n",
|
|
|
|
hba->outstanding_reqs, hba->outstanding_tasks);
|
2017-02-04 00:57:28 +00:00
|
|
|
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);
|
2020-08-09 12:15:50 +00:00
|
|
|
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);
|
2017-02-04 00:57:28 +00:00
|
|
|
dev_err(hba->dev, "error handling flags=0x%x, req. abort count=%d\n",
|
|
|
|
hba->eh_flags, hba->req_abort_count);
|
2020-08-09 12:15:50 +00:00
|
|
|
dev_err(hba->dev, "hba->ufs_version=0x%x, Host capabilities=0x%x, caps=0x%x\n",
|
|
|
|
hba->ufs_version, hba->capabilities, hba->caps);
|
2017-02-04 00:57:28 +00:00
|
|
|
dev_err(hba->dev, "quirks=0x%x, dev. quirks=0x%x\n", hba->quirks,
|
|
|
|
hba->dev_quirks);
|
2020-08-09 12:15:50 +00:00
|
|
|
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);
|
2017-02-04 00:57:28 +00:00
|
|
|
}
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2020-03-18 10:40:12 +00:00
|
|
|
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);
|
|
|
|
|
2020-05-07 22:27:50 +00:00
|
|
|
/**
|
2013-07-29 19:05:57 +00:00
|
|
|
* ufshcd_wait_for_register - wait for register value to change
|
2020-05-07 22:27:50 +00:00
|
|
|
* @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
|
2013-07-29 19:05:57 +00:00
|
|
|
*
|
2020-05-07 22:27:50 +00:00
|
|
|
* Return:
|
|
|
|
* -ETIMEDOUT on error, zero on success.
|
2013-07-29 19:05:57 +00:00
|
|
|
*/
|
2016-03-10 15:37:08 +00:00
|
|
|
int ufshcd_wait_for_register(struct ufs_hba *hba, u32 reg, u32 mask,
|
|
|
|
u32 val, unsigned long interval_us,
|
2020-05-07 22:27:50 +00:00
|
|
|
unsigned long timeout_ms)
|
2013-07-29 19:05:57 +00:00
|
|
|
{
|
|
|
|
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) {
|
2020-05-07 22:27:50 +00:00
|
|
|
usleep_range(interval_us, interval_us + 50);
|
2013-07-29 19:05:57 +00:00
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
if ((ufshcd_readl(hba, reg) & mask) != val)
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-06-26 17:09:27 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_get_intr_mask - Get the interrupt bit mask
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: Pointer to adapter instance
|
2013-06-26 17:09:27 +00:00
|
|
|
*
|
|
|
|
* Returns interrupt bit mask per version
|
|
|
|
*/
|
|
|
|
static inline u32 ufshcd_get_intr_mask(struct ufs_hba *hba)
|
|
|
|
{
|
2016-12-06 03:25:02 +00:00
|
|
|
u32 intr_mask = 0;
|
|
|
|
|
|
|
|
switch (hba->ufs_version) {
|
|
|
|
case UFSHCI_VERSION_10:
|
|
|
|
intr_mask = INTERRUPT_MASK_ALL_VER_10;
|
|
|
|
break;
|
|
|
|
case UFSHCI_VERSION_11:
|
|
|
|
case UFSHCI_VERSION_20:
|
|
|
|
intr_mask = INTERRUPT_MASK_ALL_VER_11;
|
|
|
|
break;
|
|
|
|
case UFSHCI_VERSION_21:
|
|
|
|
default:
|
|
|
|
intr_mask = INTERRUPT_MASK_ALL_VER_21;
|
2017-03-23 10:49:04 +00:00
|
|
|
break;
|
2016-12-06 03:25:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return intr_mask;
|
2013-06-26 17:09:27 +00:00
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_get_ufs_version - Get the UFS version supported by the HBA
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: Pointer to adapter instance
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
|
|
|
* Returns UFSHCI version supported by the controller
|
|
|
|
*/
|
|
|
|
static inline u32 ufshcd_get_ufs_version(struct ufs_hba *hba)
|
|
|
|
{
|
2015-10-28 11:15:48 +00:00
|
|
|
if (hba->quirks & UFSHCD_QUIRK_BROKEN_UFS_HCI_VERSION)
|
|
|
|
return ufshcd_vops_get_ufs_hci_version(hba);
|
2015-05-17 15:55:05 +00:00
|
|
|
|
2013-06-26 17:09:26 +00:00
|
|
|
return ufshcd_readl(hba, REG_UFS_VERSION);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_is_device_present - Check if any device connected to
|
|
|
|
* the host controller
|
2014-09-25 12:32:21 +00:00
|
|
|
* @hba: pointer to adapter instance
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
2017-03-28 13:49:24 +00:00
|
|
|
* Returns true if device present, false if no device detected
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2017-03-28 13:49:24 +00:00
|
|
|
static inline bool ufshcd_is_device_present(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2014-09-25 12:32:21 +00:00
|
|
|
return (ufshcd_readl(hba, REG_CONTROLLER_STATUS) &
|
2017-03-28 13:49:24 +00:00
|
|
|
DEVICE_PRESENT) ? true : false;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_get_tr_ocs - Get the UTRD Overall Command Status
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: pointer to local command reference block
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
|
|
|
* 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)
|
|
|
|
{
|
2014-05-26 05:29:10 +00:00
|
|
|
return le32_to_cpu(lrbp->utr_descriptor_ptr->header.dword_2) & MASK_OCS;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2020-05-28 01:16:49 +00:00
|
|
|
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);
|
2018-05-06 10:14:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2020-05-28 01:16:49 +00:00
|
|
|
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);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:40 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2017-04-26 17:28:58 +00:00
|
|
|
return !((reg & UFSHCD_STATUS_READY) == UFSHCD_STATUS_READY);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2013-06-26 17:09:26 +00:00
|
|
|
return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_2) &
|
2012-02-29 06:41:50 +00:00
|
|
|
MASK_UIC_COMMAND_RESULT;
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:21 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2013-07-29 19:05:57 +00:00
|
|
|
* ufshcd_get_req_rsp - returns the TR response transaction type
|
2012-02-29 06:41:50 +00:00
|
|
|
* @ucd_rsp_ptr: pointer to response UPIU
|
|
|
|
*/
|
|
|
|
static inline int
|
2013-07-29 19:05:57 +00:00
|
|
|
ufshcd_get_req_rsp(struct utp_upiu_rsp *ucd_rsp_ptr)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-07-29 19:05:57 +00:00
|
|
|
return be32_to_cpu(ucd_rsp_ptr->header.dword_0) >> 24;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:19 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2013-08-31 16:10:20 +00:00
|
|
|
* ufshcd_reset_intr_aggr - Reset interrupt aggregation values.
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
*/
|
|
|
|
static inline void
|
2013-08-31 16:10:20 +00:00
|
|
|
ufshcd_reset_intr_aggr(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-08-31 16:10:20 +00:00
|
|
|
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);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 15:54:57 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2013-06-26 17:09:26 +00:00
|
|
|
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);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_hba_start - Start controller initialization sequence
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*/
|
|
|
|
static inline void ufshcd_hba_start(struct ufs_hba *hba)
|
|
|
|
{
|
2020-07-06 20:04:14 +00:00
|
|
|
u32 val = CONTROLLER_ENABLE;
|
|
|
|
|
|
|
|
if (ufshcd_crypto_enable(hba))
|
|
|
|
val |= CRYPTO_GENERAL_ENABLE;
|
|
|
|
|
|
|
|
ufshcd_writel(hba, val, REG_CONTROLLER_ENABLE);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_is_hba_active - Get controller state
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
2017-03-28 13:49:24 +00:00
|
|
|
* Returns false if controller is active, true otherwise
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2017-03-28 13:49:24 +00:00
|
|
|
static inline bool ufshcd_is_hba_active(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2017-03-28 13:49:25 +00:00
|
|
|
return (ufshcd_readl(hba, REG_CONTROLLER_ENABLE) & CONTROLLER_ENABLE)
|
|
|
|
? false : true;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:16 +00:00
|
|
|
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_10) ||
|
|
|
|
(hba->ufs_version == UFSHCI_VERSION_11))
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-03-26 09:25:40 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
2017-02-04 00:57:02 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ufs_clk_info *clki;
|
|
|
|
struct list_head *head = &hba->clk_list_head;
|
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
if (list_empty(head))
|
2017-02-04 00:57:02 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2020-03-26 09:25:40 +00:00
|
|
|
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;
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
ret = ufshcd_vops_clk_scale_notify(hba, scale_up, POST_CHANGE);
|
2020-03-26 09:25:40 +00:00
|
|
|
if (ret)
|
|
|
|
ufshcd_set_clk_freq(hba, !scale_up);
|
2017-02-04 00:57:02 +00:00
|
|
|
|
|
|
|
out:
|
2020-03-26 09:25:40 +00:00
|
|
|
trace_ufshcd_profile_clk_scaling(dev_name(hba->dev),
|
2017-02-04 00:57:02 +00:00
|
|
|
(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;
|
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
if (list_empty(head))
|
2017-02-04 00:57:02 +00:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
#define UFS_MIN_GEAR_TO_SCALE_DOWN UFS_HS_G1
|
|
|
|
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 > UFS_MIN_GEAR_TO_SCALE_DOWN
|
|
|
|
|| hba->pwr_info.gear_rx > UFS_MIN_GEAR_TO_SCALE_DOWN) {
|
|
|
|
/* 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 = UFS_MIN_GEAR_TO_SCALE_DOWN;
|
|
|
|
new_pwr_info.gear_rx = UFS_MIN_GEAR_TO_SCALE_DOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if the power mode needs to be changed or not? */
|
2020-02-12 05:38:28 +00:00
|
|
|
ret = ufshcd_config_pwr_mode(hba, &new_pwr_info);
|
2017-02-04 00:57:02 +00:00
|
|
|
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
|
|
|
|
*/
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_block_requests(hba);
|
2017-02-04 00:57:02 +00:00
|
|
|
down_write(&hba->clk_scaling_lock);
|
|
|
|
if (ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US)) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
up_write(&hba->clk_scaling_lock);
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_unblock_requests(hba);
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_clock_scaling_unprepare(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
up_write(&hba->clk_scaling_lock);
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_unblock_requests(hba);
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
/* let's not get into low power until clock scaling is completed */
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
ret = ufshcd_clock_scaling_prepare(hba);
|
|
|
|
if (ret)
|
2020-03-26 09:25:40 +00:00
|
|
|
goto out;
|
2017-02-04 00:57:02 +00:00
|
|
|
|
|
|
|
/* scale down the gear before scaling down clocks */
|
|
|
|
if (!scale_up) {
|
|
|
|
ret = ufshcd_scale_gear(hba, false);
|
|
|
|
if (ret)
|
2020-03-26 09:25:40 +00:00
|
|
|
goto out_unprepare;
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = ufshcd_scale_clks(hba, scale_up);
|
|
|
|
if (ret) {
|
|
|
|
if (!scale_up)
|
|
|
|
ufshcd_scale_gear(hba, true);
|
2020-03-26 09:25:40 +00:00
|
|
|
goto out_unprepare;
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* scale up the gear after scaling up clocks */
|
|
|
|
if (scale_up) {
|
|
|
|
ret = ufshcd_scale_gear(hba, true);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret) {
|
2017-02-04 00:57:02 +00:00
|
|
|
ufshcd_scale_clks(hba, false);
|
2020-04-22 21:41:42 +00:00
|
|
|
goto out_unprepare;
|
|
|
|
}
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
/* Enable Write Booster if we have scaled up else disable it */
|
|
|
|
up_write(&hba->clk_scaling_lock);
|
|
|
|
ufshcd_wb_ctrl(hba, scale_up);
|
|
|
|
down_write(&hba->clk_scaling_lock);
|
|
|
|
|
2020-03-26 09:25:40 +00:00
|
|
|
out_unprepare:
|
2017-02-04 00:57:02 +00:00
|
|
|
ufshcd_clock_scaling_unprepare(hba);
|
2020-03-26 09:25:40 +00:00
|
|
|
out:
|
2017-02-04 00:57:39 +00:00
|
|
|
ufshcd_release(hba);
|
2017-02-04 00:57:02 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
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;
|
2017-02-04 00:57:39 +00:00
|
|
|
bool scale_up, sched_clk_scaling_suspend_work = false;
|
2018-05-18 06:26:37 +00:00
|
|
|
struct list_head *clk_list = &hba->clk_list_head;
|
|
|
|
struct ufs_clk_info *clki;
|
2017-02-04 00:57:02 +00:00
|
|
|
unsigned long irq_flags;
|
|
|
|
|
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2020-03-25 18:29:00 +00:00
|
|
|
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);
|
2017-02-04 00:57:02 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
if (!hba->clk_scaling.active_reqs)
|
|
|
|
sched_clk_scaling_suspend_work = true;
|
|
|
|
|
2018-05-18 06:26:37 +00:00
|
|
|
if (list_empty(clk_list)) {
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, irq_flags);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-03-25 18:29:00 +00:00
|
|
|
/* Decide based on the rounded-off frequency and update */
|
2018-05-18 06:26:37 +00:00
|
|
|
scale_up = (*freq == clki->max_freq) ? true : false;
|
2020-03-25 18:29:00 +00:00
|
|
|
if (!scale_up)
|
|
|
|
*freq = clki->min_freq;
|
|
|
|
/* Update the frequency */
|
2017-02-04 00:57:39 +00:00
|
|
|
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 */
|
2017-02-04 00:57:02 +00:00
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
out:
|
|
|
|
if (sched_clk_scaling_suspend_work)
|
|
|
|
queue_work(hba->clk_scaling.workq,
|
|
|
|
&hba->clk_scaling.suspend_work);
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-12-09 18:13:08 +00:00
|
|
|
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;
|
|
|
|
}
|
2017-02-04 00:57:02 +00:00
|
|
|
|
|
|
|
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;
|
2020-03-25 18:29:00 +00:00
|
|
|
struct list_head *clk_list = &hba->clk_list_head;
|
|
|
|
struct ufs_clk_info *clki;
|
2020-06-11 10:10:43 +00:00
|
|
|
ktime_t curr_t;
|
2017-02-04 00:57:02 +00:00
|
|
|
|
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memset(stat, 0, sizeof(*stat));
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2020-06-11 10:10:43 +00:00
|
|
|
curr_t = ktime_get();
|
2017-02-04 00:57:02 +00:00
|
|
|
if (!scaling->window_start_t)
|
|
|
|
goto start_window;
|
|
|
|
|
2020-03-25 18:29:00 +00:00
|
|
|
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;
|
2017-02-04 00:57:02 +00:00
|
|
|
if (scaling->is_busy_started)
|
2020-06-11 10:10:43 +00:00
|
|
|
scaling->tot_busy_t += ktime_us_delta(curr_t,
|
|
|
|
scaling->busy_start_t);
|
2017-02-04 00:57:02 +00:00
|
|
|
|
2020-06-11 10:10:43 +00:00
|
|
|
stat->total_time = ktime_us_delta(curr_t, scaling->window_start_t);
|
2017-02-04 00:57:02 +00:00
|
|
|
stat->busy_time = scaling->tot_busy_t;
|
|
|
|
start_window:
|
2020-06-11 10:10:43 +00:00
|
|
|
scaling->window_start_t = curr_t;
|
2017-02-04 00:57:02 +00:00
|
|
|
scaling->tot_busy_t = 0;
|
|
|
|
|
|
|
|
if (hba->outstanding_reqs) {
|
2020-06-11 10:10:43 +00:00
|
|
|
scaling->busy_start_t = curr_t;
|
2017-02-04 00:57:02 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-05-18 06:26:36 +00:00
|
|
|
static int ufshcd_devfreq_init(struct ufs_hba *hba)
|
|
|
|
{
|
2018-05-18 06:26:37 +00:00
|
|
|
struct list_head *clk_list = &hba->clk_list_head;
|
|
|
|
struct ufs_clk_info *clki;
|
2018-05-18 06:26:36 +00:00
|
|
|
struct devfreq *devfreq;
|
|
|
|
int ret;
|
|
|
|
|
2018-05-18 06:26:37 +00:00
|
|
|
/* 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);
|
|
|
|
|
2020-05-09 09:37:13 +00:00
|
|
|
ufshcd_vops_config_scaling_param(hba, &hba->vps->devfreq_profile,
|
|
|
|
&hba->vps->ondemand_data);
|
2018-05-18 06:26:37 +00:00
|
|
|
devfreq = devfreq_add_device(hba->dev,
|
2020-05-09 09:37:13 +00:00
|
|
|
&hba->vps->devfreq_profile,
|
2018-05-18 06:26:36 +00:00
|
|
|
DEVFREQ_GOV_SIMPLE_ONDEMAND,
|
2020-05-09 09:37:13 +00:00
|
|
|
&hba->vps->ondemand_data);
|
2018-05-18 06:26:36 +00:00
|
|
|
if (IS_ERR(devfreq)) {
|
|
|
|
ret = PTR_ERR(devfreq);
|
|
|
|
dev_err(hba->dev, "Unable to register with devfreq %d\n", ret);
|
2018-05-18 06:26:37 +00:00
|
|
|
|
|
|
|
dev_pm_opp_remove(hba->dev, clki->min_freq);
|
|
|
|
dev_pm_opp_remove(hba->dev, clki->max_freq);
|
2018-05-18 06:26:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->devfreq = devfreq;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-18 06:26:37 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
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);
|
|
|
|
}
|
2017-02-04 00:57:02 +00:00
|
|
|
|
2016-10-18 00:10:00 +00:00
|
|
|
static void ufshcd_suspend_clkscaling(struct ufs_hba *hba)
|
|
|
|
{
|
2017-02-04 00:57:39 +00:00
|
|
|
unsigned long flags;
|
|
|
|
bool suspend = false;
|
|
|
|
|
2016-12-23 02:40:50 +00:00
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return;
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
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);
|
2016-10-18 00:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_resume_clkscaling(struct ufs_hba *hba)
|
|
|
|
{
|
2017-02-04 00:57:39 +00:00
|
|
|
unsigned long flags;
|
|
|
|
bool resume = false;
|
|
|
|
|
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return;
|
|
|
|
|
|
|
|
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);
|
2016-12-23 02:40:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 snprintf(buf, PAGE_SIZE, "%d\n", hba->clk_scaling.is_allowed);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (kstrtou32(buf, 0, &value))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
value = !!value;
|
|
|
|
if (value == hba->clk_scaling.is_allowed)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pm_runtime_get_sync(hba->dev);
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
cancel_work_sync(&hba->clk_scaling.suspend_work);
|
|
|
|
cancel_work_sync(&hba->clk_scaling.resume_work);
|
|
|
|
|
|
|
|
hba->clk_scaling.is_allowed = value;
|
|
|
|
|
2016-12-23 02:40:50 +00:00
|
|
|
if (value) {
|
|
|
|
ufshcd_resume_clkscaling(hba);
|
|
|
|
} else {
|
|
|
|
ufshcd_suspend_clkscaling(hba);
|
2017-02-04 00:57:02 +00:00
|
|
|
err = ufshcd_devfreq_scale(hba, true);
|
2016-12-23 02:40:50 +00:00
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: failed to scale clocks up %d\n",
|
|
|
|
__func__, err);
|
|
|
|
}
|
|
|
|
|
|
|
|
ufshcd_release(hba);
|
|
|
|
pm_runtime_put_sync(hba->dev);
|
|
|
|
out:
|
|
|
|
return count;
|
2016-10-18 00:10:00 +00:00
|
|
|
}
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
static void ufshcd_clkscaling_init_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");
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
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_setup_clocks(hba, true);
|
|
|
|
|
2019-12-07 12:22:01 +00:00
|
|
|
ufshcd_enable_irq(hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
/* 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:
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_unblock_requests(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!ufshcd_is_clkgating_allowed(hba))
|
|
|
|
goto out;
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
hba->clk_gating.active_reqs++;
|
|
|
|
|
2014-09-25 12:32:34 +00:00
|
|
|
start:
|
2014-09-25 12:32:32 +00:00
|
|
|
switch (hba->clk_gating.state) {
|
|
|
|
case CLKS_ON:
|
2016-10-18 00:10:53 +00:00
|
|
|
/*
|
|
|
|
* 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)) {
|
2020-02-11 03:40:48 +00:00
|
|
|
if (async) {
|
|
|
|
rc = -EAGAIN;
|
|
|
|
hba->clk_gating.active_reqs--;
|
|
|
|
break;
|
|
|
|
}
|
2016-10-18 00:10:53 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
flush_work(&hba->clk_gating.ungate_work);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
goto start;
|
|
|
|
}
|
2014-09-25 12:32:32 +00:00
|
|
|
break;
|
|
|
|
case REQ_CLKS_OFF:
|
|
|
|
if (cancel_delayed_work(&hba->clk_gating.gate_work)) {
|
|
|
|
hba->clk_gating.state = CLKS_ON;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
2014-09-25 12:32:32 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
2017-03-28 13:49:26 +00:00
|
|
|
* If we are here, it means gating work is either done or
|
2014-09-25 12:32:32 +00:00
|
|
|
* currently running. Hence, fall through to cancel gating
|
|
|
|
* work and to enable clocks.
|
|
|
|
*/
|
2018-11-26 08:10:34 +00:00
|
|
|
/* fallthrough */
|
2014-09-25 12:32:32 +00:00
|
|
|
case CLKS_OFF:
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_block_requests(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.state = REQ_CLKS_ON;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
2018-05-03 11:07:22 +00:00
|
|
|
queue_work(hba->clk_gating.clk_gating_workq,
|
|
|
|
&hba->clk_gating.ungate_work);
|
2014-09-25 12:32:32 +00:00
|
|
|
/*
|
|
|
|
* fall through to check if we should wait for this
|
|
|
|
* work to be done or not.
|
|
|
|
*/
|
2018-11-26 08:10:34 +00:00
|
|
|
/* fallthrough */
|
2014-09-25 12:32:32 +00:00
|
|
|
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 */
|
2014-09-25 12:32:34 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2014-09-25 12:32:32 +00:00
|
|
|
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;
|
|
|
|
}
|
2015-10-28 11:15:50 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_hold);
|
2014-09-25 12:32:32 +00:00
|
|
|
|
|
|
|
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;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:32 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2016-10-18 00:11:07 +00:00
|
|
|
/*
|
|
|
|
* 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 ||
|
2019-11-15 06:09:29 +00:00
|
|
|
(hba->clk_gating.state != REQ_CLKS_OFF)) {
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.state = CLKS_ON;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
2014-09-25 12:32:32 +00:00
|
|
|
goto rel_lock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hba->clk_gating.active_reqs
|
|
|
|
|| hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL
|
2019-12-09 18:13:08 +00:00
|
|
|
|| ufshcd_any_tag_in_use(hba) || hba->outstanding_tasks
|
2014-09-25 12:32:32 +00:00
|
|
|
|| 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)) {
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
ret = ufshcd_uic_hibern8_enter(hba);
|
|
|
|
if (ret) {
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.state = CLKS_ON;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
dev_err(hba->dev, "%s: hibern8 enter failed %d\n",
|
|
|
|
__func__, ret);
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
2014-09-25 12:32:32 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ufshcd_set_link_hibern8(hba);
|
|
|
|
}
|
|
|
|
|
2019-12-07 12:22:01 +00:00
|
|
|
ufshcd_disable_irq(hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
if (!ufshcd_is_link_active(hba))
|
|
|
|
ufshcd_setup_clocks(hba, false);
|
|
|
|
else
|
|
|
|
/* If link is active, device ref_clk can't be switched off */
|
|
|
|
__ufshcd_setup_clocks(hba, false, true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
2016-12-23 02:39:51 +00:00
|
|
|
if (hba->clk_gating.state == REQ_CLKS_OFF) {
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.state = CLKS_OFF;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
|
|
|
}
|
2014-09-25 12:32:32 +00:00
|
|
|
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--;
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (hba->clk_gating.active_reqs || hba->clk_gating.is_suspended ||
|
|
|
|
hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL ||
|
|
|
|
ufshcd_any_tag_in_use(hba) || hba->outstanding_tasks ||
|
|
|
|
hba->active_uic_cmd || hba->uic_async_done)
|
2014-09-25 12:32:32 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
hba->clk_gating.state = REQ_CLKS_OFF;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev), hba->clk_gating.state);
|
2018-10-05 17:27:32 +00:00
|
|
|
queue_delayed_work(hba->clk_gating.clk_gating_workq,
|
|
|
|
&hba->clk_gating.gate_work,
|
|
|
|
msecs_to_jiffies(hba->clk_gating.delay_ms));
|
2014-09-25 12:32:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2015-10-28 11:15:50 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_release);
|
2014-09-25 12:32:32 +00:00
|
|
|
|
|
|
|
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 snprintf(buf, PAGE_SIZE, "%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;
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:40:39 +00:00
|
|
|
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 snprintf(buf, PAGE_SIZE, "%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;
|
|
|
|
if (value == hba->clk_gating.is_enabled)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
ufshcd_release(hba);
|
|
|
|
} else {
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
hba->clk_gating.active_reqs++;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->clk_gating.is_enabled = value;
|
|
|
|
out:
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2018-08-07 17:47:39 +00:00
|
|
|
static void ufshcd_init_clk_scaling(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
char wq_name[sizeof("ufs_clkscaling_00")];
|
|
|
|
|
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
ufshcd_clkscaling_init_sysfs(hba);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_exit_clk_scaling(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
|
|
|
return;
|
|
|
|
|
|
|
|
destroy_workqueue(hba->clk_scaling.workq);
|
|
|
|
ufshcd_devfreq_remove(hba);
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
static void ufshcd_init_clk_gating(struct ufs_hba *hba)
|
|
|
|
{
|
2018-05-03 11:07:22 +00:00
|
|
|
char wq_name[sizeof("ufs_clk_gating_00")];
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
if (!ufshcd_is_clkgating_allowed(hba))
|
|
|
|
return;
|
|
|
|
|
2020-08-09 12:15:47 +00:00
|
|
|
hba->clk_gating.state = CLKS_ON;
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
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);
|
|
|
|
|
2018-05-03 11:07:22 +00:00
|
|
|
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);
|
|
|
|
|
2016-12-23 02:40:39 +00:00
|
|
|
hba->clk_gating.is_enabled = true;
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
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";
|
2016-12-23 02:40:39 +00:00
|
|
|
hba->clk_gating.delay_attr.attr.mode = 0644;
|
2014-09-25 12:32:32 +00:00
|
|
|
if (device_create_file(hba->dev, &hba->clk_gating.delay_attr))
|
|
|
|
dev_err(hba->dev, "Failed to create sysfs for clkgate_delay\n");
|
2016-12-23 02:40:39 +00:00
|
|
|
|
|
|
|
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");
|
2014-09-25 12:32:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_exit_clk_gating(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (!ufshcd_is_clkgating_allowed(hba))
|
|
|
|
return;
|
|
|
|
device_remove_file(hba->dev, &hba->clk_gating.delay_attr);
|
2016-12-23 02:40:39 +00:00
|
|
|
device_remove_file(hba->dev, &hba->clk_gating.enable_attr);
|
2014-11-24 05:24:18 +00:00
|
|
|
cancel_work_sync(&hba->clk_gating.ungate_work);
|
|
|
|
cancel_delayed_work_sync(&hba->clk_gating.gate_work);
|
2018-05-03 11:07:22 +00:00
|
|
|
destroy_workqueue(hba->clk_gating.clk_gating_workq);
|
2014-09-25 12:32:32 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:34 +00:00
|
|
|
/* Must be called with host lock acquired */
|
|
|
|
static void ufshcd_clk_scaling_start_busy(struct ufs_hba *hba)
|
|
|
|
{
|
2017-02-04 00:57:39 +00:00
|
|
|
bool queue_resume_work = false;
|
2020-06-11 10:10:43 +00:00
|
|
|
ktime_t curr_t = ktime_get();
|
2017-02-04 00:57:39 +00:00
|
|
|
|
2016-12-23 02:40:50 +00:00
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
2014-09-25 12:32:34 +00:00
|
|
|
return;
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
if (!hba->clk_scaling.active_reqs++)
|
|
|
|
queue_resume_work = true;
|
|
|
|
|
|
|
|
if (!hba->clk_scaling.is_allowed || hba->pm_op_in_progress)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (queue_resume_work)
|
|
|
|
queue_work(hba->clk_scaling.workq,
|
|
|
|
&hba->clk_scaling.resume_work);
|
|
|
|
|
|
|
|
if (!hba->clk_scaling.window_start_t) {
|
2020-06-11 10:10:43 +00:00
|
|
|
hba->clk_scaling.window_start_t = curr_t;
|
2017-02-04 00:57:39 +00:00
|
|
|
hba->clk_scaling.tot_busy_t = 0;
|
|
|
|
hba->clk_scaling.is_busy_started = false;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:34 +00:00
|
|
|
if (!hba->clk_scaling.is_busy_started) {
|
2020-06-11 10:10:43 +00:00
|
|
|
hba->clk_scaling.busy_start_t = curr_t;
|
2014-09-25 12:32:34 +00:00
|
|
|
hba->clk_scaling.is_busy_started = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_clk_scaling_update_busy(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct ufs_clk_scaling *scaling = &hba->clk_scaling;
|
|
|
|
|
2016-12-23 02:40:50 +00:00
|
|
|
if (!ufshcd_is_clkscaling_supported(hba))
|
2014-09-25 12:32:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (!hba->outstanding_reqs && scaling->is_busy_started) {
|
|
|
|
scaling->tot_busy_t += ktime_to_us(ktime_sub(ktime_get(),
|
|
|
|
scaling->busy_start_t));
|
2016-12-25 11:30:41 +00:00
|
|
|
scaling->busy_start_t = 0;
|
2014-09-25 12:32:34 +00:00
|
|
|
scaling->is_busy_started = false;
|
|
|
|
}
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2020-07-06 06:07:07 +00:00
|
|
|
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));
|
2019-12-24 22:02:46 +00:00
|
|
|
ufshcd_add_command_trace(hba, task_tag, "send");
|
2014-09-25 12:32:34 +00:00
|
|
|
ufshcd_clk_scaling_start_busy(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
__set_bit(task_tag, &hba->outstanding_reqs);
|
2013-06-26 17:09:26 +00:00
|
|
|
ufshcd_writel(hba, 1 << task_tag, REG_UTP_TRANSFER_REQ_DOOR_BELL);
|
2016-10-18 00:09:36 +00:00
|
|
|
/* Make sure that doorbell is committed immediately */
|
|
|
|
wmb();
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_copy_sense_data - Copy sense data in case of check condition
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: pointer to local reference block
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
|
|
|
static inline void ufshcd_copy_sense_data(struct ufshcd_lrb *lrbp)
|
|
|
|
{
|
|
|
|
int len;
|
2013-08-31 16:10:19 +00:00
|
|
|
if (lrbp->sense_buffer &&
|
|
|
|
ufshcd_get_rsp_upiu_data_seg_len(lrbp->ucd_rsp_ptr)) {
|
2016-10-18 00:09:24 +00:00
|
|
|
int len_to_copy;
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
len = be16_to_cpu(lrbp->ucd_rsp_ptr->sr.sense_data_len);
|
2018-11-22 18:04:56 +00:00
|
|
|
len_to_copy = min_t(int, UFS_SENSE_SIZE, len);
|
2016-10-18 00:09:24 +00:00
|
|
|
|
2018-11-22 18:04:56 +00:00
|
|
|
memcpy(lrbp->sense_buffer, lrbp->ucd_rsp_ptr->sr.sense_data,
|
|
|
|
len_to_copy);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_copy_query_response() - Copy the Query Response and the data
|
|
|
|
* descriptor
|
|
|
|
* @hba: per adapter instance
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: pointer to local reference block
|
2013-07-29 19:05:58 +00:00
|
|
|
*/
|
|
|
|
static
|
2014-06-29 06:40:18 +00:00
|
|
|
int ufshcd_copy_query_response(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
|
2013-07-29 19:05:58 +00:00
|
|
|
{
|
|
|
|
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 */
|
2019-05-21 08:24:22 +00:00
|
|
|
if (hba->dev_cmd.query.descriptor &&
|
|
|
|
lrbp->ucd_rsp_ptr->qr.opcode == UPIU_QUERY_OPCODE_READ_DESC) {
|
2014-06-29 06:40:17 +00:00
|
|
|
u8 *descp = (u8 *)lrbp->ucd_rsp_ptr +
|
2013-07-29 19:05:58 +00:00
|
|
|
GENERAL_UPIU_REQUEST_SIZE;
|
2014-06-29 06:40:18 +00:00
|
|
|
u16 resp_len;
|
|
|
|
u16 buf_len;
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
/* data segment length */
|
2014-06-29 06:40:18 +00:00
|
|
|
resp_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2) &
|
2013-07-29 19:05:58 +00:00
|
|
|
MASK_QUERY_DATA_SEG_LEN;
|
2014-07-23 06:31:12 +00:00
|
|
|
buf_len = be16_to_cpu(
|
|
|
|
hba->dev_cmd.query.request.upiu_req.length);
|
2014-06-29 06:40:18 +00:00
|
|
|
if (likely(buf_len >= resp_len)) {
|
|
|
|
memcpy(hba->dev_cmd.query.descriptor, descp, resp_len);
|
|
|
|
} else {
|
|
|
|
dev_warn(hba->dev,
|
2019-11-12 22:34:35 +00:00
|
|
|
"%s: rsp size %d is bigger than buffer size %d",
|
|
|
|
__func__, resp_len, buf_len);
|
2014-06-29 06:40:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-07-29 19:05:58 +00:00
|
|
|
}
|
2014-06-29 06:40:18 +00:00
|
|
|
|
|
|
|
return 0;
|
2013-07-29 19:05:58 +00:00
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_hba_capabilities - Read controller capabilities
|
|
|
|
* @hba: per adapter instance
|
2020-07-06 20:04:14 +00:00
|
|
|
*
|
|
|
|
* Return: 0 on success, negative on error.
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2020-07-06 20:04:14 +00:00
|
|
|
static inline int ufshcd_hba_capabilities(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2020-07-06 20:04:14 +00:00
|
|
|
int err;
|
|
|
|
|
2013-06-26 17:09:26 +00:00
|
|
|
hba->capabilities = ufshcd_readl(hba, REG_CONTROLLER_CAPABILITIES);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
/* 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;
|
2020-07-06 20:04:14 +00:00
|
|
|
|
|
|
|
/* Read crypto capabilities */
|
|
|
|
err = ufshcd_hba_init_crypto_capabilities(hba);
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "crypto setup failed\n");
|
|
|
|
|
|
|
|
return err;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-06-26 17:09:29 +00:00
|
|
|
* ufshcd_ready_for_uic_cmd - Check if controller is ready
|
|
|
|
* to accept UIC commands
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
2013-06-26 17:09:29 +00:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_dispatch_uic_cmd - Dispatch UIC commands to unipro layers
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @uic_cmd: UIC command
|
|
|
|
*
|
|
|
|
* Mutex must be held.
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
|
|
|
static inline void
|
2013-06-26 17:09:29 +00:00
|
|
|
ufshcd_dispatch_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-06-26 17:09:29 +00:00
|
|
|
WARN_ON(hba->active_uic_cmd);
|
|
|
|
|
|
|
|
hba->active_uic_cmd = uic_cmd;
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* Write Args */
|
2013-06-26 17:09:29 +00:00
|
|
|
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);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2020-06-15 07:22:35 +00:00
|
|
|
ufshcd_add_uic_command_trace(hba, uic_cmd, "send");
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* Write UIC Cmd */
|
2013-06-26 17:09:29 +00:00
|
|
|
ufshcd_writel(hba, uic_cmd->command & COMMAND_OPCODE_MASK,
|
2013-06-26 17:09:26 +00:00
|
|
|
REG_UIC_COMMAND);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_wait_for_uic_cmd - Wait complectioin of UIC command
|
|
|
|
* @hba: per adapter instance
|
2018-03-01 23:07:20 +00:00
|
|
|
* @uic_cmd: UIC command
|
2013-06-26 17:09:29 +00:00
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
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
|
2016-02-01 13:02:47 +00:00
|
|
|
* @completion: initialize the completion only if this is set to true
|
2013-06-26 17:09:29 +00:00
|
|
|
*
|
|
|
|
* Identical to ufshcd_send_uic_cmd() expect mutex. Must be called
|
2014-09-25 12:32:30 +00:00
|
|
|
* with mutex held and host_lock locked.
|
2013-06-26 17:09:29 +00:00
|
|
|
* Returns 0 only if success.
|
|
|
|
*/
|
|
|
|
static int
|
2016-02-01 13:02:47 +00:00
|
|
|
__ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd,
|
|
|
|
bool completion)
|
2013-06-26 17:09:29 +00:00
|
|
|
{
|
|
|
|
if (!ufshcd_ready_for_uic_cmd(hba)) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"Controller not ready to accept UIC commands\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:47 +00:00
|
|
|
if (completion)
|
|
|
|
init_completion(&uic_cmd->done);
|
2013-06-26 17:09:29 +00:00
|
|
|
|
|
|
|
ufshcd_dispatch_uic_cmd(hba, uic_cmd);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
return 0;
|
2013-06-26 17:09:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_send_uic_cmd - Send UIC commands and retrieve the result
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @uic_cmd: UIC command
|
|
|
|
*
|
|
|
|
* Returns 0 only if success.
|
|
|
|
*/
|
2018-10-07 14:30:39 +00:00
|
|
|
int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd)
|
2013-06-26 17:09:29 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
unsigned long flags;
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2013-06-26 17:09:29 +00:00
|
|
|
mutex_lock(&hba->uic_cmd_mutex);
|
2015-03-31 14:37:14 +00:00
|
|
|
ufshcd_add_delay_before_dme_cmd(hba);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2016-02-01 13:02:47 +00:00
|
|
|
ret = __ufshcd_send_uic_cmd(hba, uic_cmd, true);
|
2014-09-25 12:32:30 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
if (!ret)
|
|
|
|
ret = ufshcd_wait_for_uic_cmd(hba, uic_cmd);
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
mutex_unlock(&hba->uic_cmd_mutex);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2013-06-26 17:09:29 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_map_sg - Map scatter-gather list to prdt
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
* @lrbp: pointer to local reference block
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
|
|
|
* Returns 0 in case of success, non-zero value in case of failure
|
|
|
|
*/
|
2016-11-22 08:06:59 +00:00
|
|
|
static int ufshcd_map_sg(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
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) {
|
2020-05-28 01:16:52 +00:00
|
|
|
|
|
|
|
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));
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
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));
|
2016-02-01 13:02:37 +00:00
|
|
|
prd_table[i].reserved = 0;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
lrbp->utr_descriptor_ptr->prd_table_length = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-06-26 17:09:27 +00:00
|
|
|
* ufshcd_enable_intr - enable interrupts
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
2013-06-26 17:09:27 +00:00
|
|
|
* @intrs: interrupt bits
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2013-06-26 17:09:27 +00:00
|
|
|
static void ufshcd_enable_intr(struct ufs_hba *hba, u32 intrs)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-06-26 17:09:27 +00:00
|
|
|
u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE);
|
|
|
|
|
|
|
|
if (hba->ufs_version == UFSHCI_VERSION_10) {
|
|
|
|
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_10) {
|
|
|
|
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;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2013-06-26 17:09:27 +00:00
|
|
|
|
|
|
|
ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/**
|
|
|
|
* 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,
|
2020-07-06 12:39:36 +00:00
|
|
|
u8 *upiu_flags, enum dma_data_direction cmd_dir)
|
2013-07-29 19:05:57 +00:00
|
|
|
{
|
|
|
|
struct utp_transfer_req_desc *req_desc = lrbp->utr_descriptor_ptr;
|
|
|
|
u32 data_direction;
|
|
|
|
u32 dword_0;
|
2020-07-06 20:04:14 +00:00
|
|
|
u32 dword_1 = 0;
|
|
|
|
u32 dword_3 = 0;
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2020-07-06 20:04:14 +00:00
|
|
|
/* Prepare crypto related dwords */
|
|
|
|
ufshcd_prepare_req_desc_hdr_crypto(lrbp, &dword_0, &dword_1, &dword_3);
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/* Transfer request descriptor header fields */
|
|
|
|
req_desc->header.dword_0 = cpu_to_le32(dword_0);
|
2020-07-06 20:04:14 +00:00
|
|
|
req_desc->header.dword_1 = cpu_to_le32(dword_1);
|
2013-07-29 19:05:57 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2020-07-06 20:04:14 +00:00
|
|
|
req_desc->header.dword_3 = cpu_to_le32(dword_3);
|
2016-02-01 13:02:38 +00:00
|
|
|
|
|
|
|
req_desc->prd_table_length = 0;
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_prepare_utp_scsi_cmd_upiu() - fills the utp_transfer_req_desc,
|
|
|
|
* for scsi commands
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: local reference block pointer
|
|
|
|
* @upiu_flags: flags
|
2013-07-29 19:05:57 +00:00
|
|
|
*/
|
|
|
|
static
|
2020-07-06 12:39:36 +00:00
|
|
|
void ufshcd_prepare_utp_scsi_cmd_upiu(struct ufshcd_lrb *lrbp, u8 upiu_flags)
|
2013-07-29 19:05:57 +00:00
|
|
|
{
|
2019-12-24 22:02:45 +00:00
|
|
|
struct scsi_cmnd *cmd = lrbp->cmd;
|
2013-07-29 19:05:57 +00:00
|
|
|
struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
|
2016-02-01 13:02:37 +00:00
|
|
|
unsigned short cdb_len;
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2019-12-24 22:02:45 +00:00
|
|
|
ucd_req_ptr->sc.exp_data_transfer_len = cpu_to_be32(cmd->sdb.length);
|
2013-07-29 19:05:57 +00:00
|
|
|
|
2019-12-24 22:02:45 +00:00
|
|
|
cdb_len = min_t(unsigned short, cmd->cmd_len, UFS_CDB_SIZE);
|
2018-10-07 14:30:34 +00:00
|
|
|
memset(ucd_req_ptr->sc.cdb, 0, UFS_CDB_SIZE);
|
2019-12-24 22:02:45 +00:00
|
|
|
memcpy(ucd_req_ptr->sc.cdb, cmd->cmnd, cdb_len);
|
2016-02-01 13:02:37 +00:00
|
|
|
|
|
|
|
memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/**
|
|
|
|
* 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,
|
2020-07-06 12:39:36 +00:00
|
|
|
struct ufshcd_lrb *lrbp, u8 upiu_flags)
|
2013-07-29 19:05:58 +00:00
|
|
|
{
|
|
|
|
struct utp_upiu_req *ucd_req_ptr = lrbp->ucd_req_ptr;
|
|
|
|
struct ufs_query *query = &hba->dev_cmd.query;
|
2014-05-26 05:29:10 +00:00
|
|
|
u16 len = be16_to_cpu(query->request.upiu_req.length);
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2016-08-25 09:39:19 +00:00
|
|
|
/* 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;
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
/* Copy the Query Request buffer as is */
|
|
|
|
memcpy(&ucd_req_ptr->qr, &query->request.upiu_req,
|
|
|
|
QUERY_OSF_SIZE);
|
|
|
|
|
|
|
|
/* Copy the Descriptor */
|
2014-06-29 06:40:18 +00:00
|
|
|
if (query->request.upiu_req.opcode == UPIU_QUERY_OPCODE_WRITE_DESC)
|
2018-10-07 14:30:36 +00:00
|
|
|
memcpy(ucd_req_ptr + 1, query->descriptor, len);
|
2014-06-29 06:40:18 +00:00
|
|
|
|
2016-02-01 13:02:38 +00:00
|
|
|
memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
|
2013-07-29 19:05:58 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
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);
|
2016-02-01 13:02:38 +00:00
|
|
|
/* 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));
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2020-08-14 09:50:33 +00:00
|
|
|
* ufshcd_compose_devman_upiu - UFS Protocol Information Unit(UPIU)
|
2016-05-11 11:21:27 +00:00
|
|
|
* for Device Management Purposes
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
* @lrbp: pointer to local reference block
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2020-08-14 09:50:33 +00:00
|
|
|
static int ufshcd_compose_devman_upiu(struct ufs_hba *hba,
|
|
|
|
struct ufshcd_lrb *lrbp)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2020-07-06 12:39:36 +00:00
|
|
|
u8 upiu_flags;
|
2013-07-29 19:05:57 +00:00
|
|
|
int ret = 0;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2017-09-06 09:58:39 +00:00
|
|
|
if ((hba->ufs_version == UFSHCI_VERSION_10) ||
|
|
|
|
(hba->ufs_version == UFSHCI_VERSION_11))
|
2016-05-11 11:21:27 +00:00
|
|
|
lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
|
2017-09-06 09:58:39 +00:00
|
|
|
else
|
|
|
|
lrbp->command_type = UTP_CMD_TYPE_UFS_STORAGE;
|
2016-05-11 11:21:27 +00:00
|
|
|
|
|
|
|
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
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
* @lrbp: pointer to local reference block
|
2016-05-11 11:21:27 +00:00
|
|
|
*/
|
|
|
|
static int ufshcd_comp_scsi_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
|
|
|
|
{
|
2020-07-06 12:39:36 +00:00
|
|
|
u8 upiu_flags;
|
2016-05-11 11:21:27 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2017-09-06 09:58:39 +00:00
|
|
|
if ((hba->ufs_version == UFSHCI_VERSION_10) ||
|
|
|
|
(hba->ufs_version == UFSHCI_VERSION_11))
|
2016-05-11 11:21:27 +00:00
|
|
|
lrbp->command_type = UTP_CMD_TYPE_SCSI;
|
2017-09-06 09:58:39 +00:00
|
|
|
else
|
|
|
|
lrbp->command_type = UTP_CMD_TYPE_UFS_STORAGE;
|
2016-05-11 11:21:27 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
return ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:28 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_upiu_wlun_to_scsi_wlun - maps UPIU W-LUN id to SCSI W-LUN ID
|
2018-03-01 23:07:20 +00:00
|
|
|
* @upiu_wlun_id: UPIU W-LUN id
|
2014-09-25 12:32:28 +00:00
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2020-01-23 03:56:35 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_queuecommand - main entry point for SCSI requests
|
2018-03-01 23:07:20 +00:00
|
|
|
* @host: SCSI host pointer
|
2012-02-29 06:41:50 +00:00
|
|
|
* @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;
|
|
|
|
unsigned long flags;
|
|
|
|
int tag;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
hba = shost_priv(host);
|
|
|
|
|
|
|
|
tag = cmd->request->tag;
|
2016-02-01 13:02:39 +00:00
|
|
|
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();
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
if (!down_read_trylock(&hba->clk_scaling_lock))
|
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
|
2017-02-04 00:56:50 +00:00
|
|
|
hba->req_abort_count = 0;
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
err = ufshcd_hold(hba, true);
|
|
|
|
if (err) {
|
|
|
|
err = SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-08-09 12:15:47 +00:00
|
|
|
WARN_ON(ufshcd_is_clkgating_allowed(hba) &&
|
|
|
|
(hba->clk_gating.state != CLKS_ON));
|
2014-09-25 12:32:32 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
lrbp = &hba->lrb[tag];
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
WARN_ON(lrbp->cmd);
|
2012-02-29 06:41:50 +00:00
|
|
|
lrbp->cmd = cmd;
|
2018-11-22 18:04:56 +00:00
|
|
|
lrbp->sense_bufflen = UFS_SENSE_SIZE;
|
2012-02-29 06:41:50 +00:00
|
|
|
lrbp->sense_buffer = cmd->sense_buffer;
|
|
|
|
lrbp->task_tag = tag;
|
2014-09-25 12:32:29 +00:00
|
|
|
lrbp->lun = ufshcd_scsi_to_upiu_lun(cmd->device->lun);
|
2015-05-17 15:54:57 +00:00
|
|
|
lrbp->intr_cmd = !ufshcd_is_intr_aggr_allowed(hba) ? true : false;
|
2020-07-06 20:04:14 +00:00
|
|
|
|
|
|
|
ufshcd_prepare_lrbp_crypto(cmd->request, lrbp);
|
|
|
|
|
2017-02-04 00:56:40 +00:00
|
|
|
lrbp->req_abort_skip = false;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-05-11 11:21:27 +00:00
|
|
|
ufshcd_comp_scsi_upiu(hba, lrbp);
|
|
|
|
|
2016-11-22 08:06:59 +00:00
|
|
|
err = ufshcd_map_sg(hba, lrbp);
|
2013-07-29 19:05:57 +00:00
|
|
|
if (err) {
|
|
|
|
lrbp->cmd = NULL;
|
2019-12-05 02:14:33 +00:00
|
|
|
ufshcd_release(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out;
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
2016-10-18 00:09:36 +00:00
|
|
|
/* Make sure descriptors are ready before ringing the doorbell */
|
|
|
|
wmb();
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Fix a race condition between error handler and runtime PM ops
The current IRQ handler blocks SCSI requests before scheduling eh_work,
when error handler calls pm_runtime_get_sync, if ufshcd_suspend/resume
sends a SCSI cmd, most likely the SSU cmd, since SCSI requests are blocked,
pm_runtime_get_sync() will never return because ufshcd_suspend/resume is
blocked by the SCSI cmd.
- In queuecommand path, hba->ufshcd_state check and ufshcd_send_command
should stay under the same spin lock. This is to make sure that no more
commands leak into doorbell after hba->ufshcd_state is changed.
- Don't block SCSI requests before error handler starts to run, let error
handler block SCSI requests when it is ready to start error recovery.
- Don't let SCSI layer keep requeuing the SCSI cmds sent from HBA runtime
PM ops, let them pass or fail them. Let them pass if eh_work is
scheduled due to non-fatal errors. Fail them if eh_work is scheduled due
to fatal errors, otherwise the cmds may eventually time out since UFS is
in bad state, which gets error handler blocked for too long. If we fail
the SCSI cmds sent from HBA runtime PM ops, HBA runtime PM ops fails
too, but it does not hurt since error handler can recover HBA runtime PM
error.
Link: https://lore.kernel.org/r/1596975355-39813-9-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:54 +00:00
|
|
|
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);
|
|
|
|
goto out_compl_cmd;
|
|
|
|
}
|
|
|
|
fallthrough;
|
|
|
|
case UFSHCD_STATE_RESET:
|
|
|
|
err = SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
goto out_compl_cmd;
|
|
|
|
case UFSHCD_STATE_ERROR:
|
|
|
|
set_host_byte(cmd, DID_ERROR);
|
|
|
|
goto out_compl_cmd;
|
|
|
|
default:
|
|
|
|
dev_WARN_ONCE(hba->dev, 1, "%s: invalid state %d\n",
|
|
|
|
__func__, hba->ufshcd_state);
|
|
|
|
set_host_byte(cmd, DID_BAD_TARGET);
|
|
|
|
goto out_compl_cmd;
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
ufshcd_send_command(hba, tag);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
scsi: ufs: Fix a race condition between error handler and runtime PM ops
The current IRQ handler blocks SCSI requests before scheduling eh_work,
when error handler calls pm_runtime_get_sync, if ufshcd_suspend/resume
sends a SCSI cmd, most likely the SSU cmd, since SCSI requests are blocked,
pm_runtime_get_sync() will never return because ufshcd_suspend/resume is
blocked by the SCSI cmd.
- In queuecommand path, hba->ufshcd_state check and ufshcd_send_command
should stay under the same spin lock. This is to make sure that no more
commands leak into doorbell after hba->ufshcd_state is changed.
- Don't block SCSI requests before error handler starts to run, let error
handler block SCSI requests when it is ready to start error recovery.
- Don't let SCSI layer keep requeuing the SCSI cmds sent from HBA runtime
PM ops, let them pass or fail them. Let them pass if eh_work is
scheduled due to non-fatal errors. Fail them if eh_work is scheduled due
to fatal errors, otherwise the cmds may eventually time out since UFS is
in bad state, which gets error handler blocked for too long. If we fail
the SCSI cmds sent from HBA runtime PM ops, HBA runtime PM ops fails
too, but it does not hurt since error handler can recover HBA runtime PM
error.
Link: https://lore.kernel.org/r/1596975355-39813-9-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:54 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
out_compl_cmd:
|
|
|
|
scsi_dma_unmap(lrbp->cmd);
|
|
|
|
lrbp->cmd = NULL;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
ufshcd_release(hba);
|
|
|
|
if (!err)
|
|
|
|
cmd->scsi_done(cmd);
|
2012-02-29 06:41:50 +00:00
|
|
|
out:
|
2017-02-04 00:57:02 +00:00
|
|
|
up_read(&hba->clk_scaling_lock);
|
2012-02-29 06:41:50 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
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 */
|
2020-07-06 20:04:14 +00:00
|
|
|
ufshcd_prepare_lrbp_crypto(NULL, lrbp);
|
2013-07-29 19:05:57 +00:00
|
|
|
hba->dev_cmd.type = cmd_type;
|
|
|
|
|
2020-08-14 09:50:33 +00:00
|
|
|
return ufshcd_compose_devman_upiu(hba, lrbp);
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 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,
|
2020-05-07 22:27:50 +00:00
|
|
|
mask, ~mask, 1000, 1000);
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-06-29 06:40:18 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
hba->ufs_stats.last_hibern8_exit_tstamp = ktime_set(0, 0);
|
2013-07-29 19:05:57 +00:00
|
|
|
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;
|
2013-07-29 19:05:58 +00:00
|
|
|
case UPIU_TRANSACTION_QUERY_RSP:
|
2014-06-29 06:40:18 +00:00
|
|
|
err = ufshcd_check_query_response(hba, lrbp);
|
|
|
|
if (!err)
|
|
|
|
err = ufshcd_copy_query_response(hba, lrbp);
|
2013-07-29 19:05:58 +00:00
|
|
|
break;
|
2013-07-29 19:05:57 +00:00
|
|
|
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));
|
|
|
|
|
2016-10-18 00:09:36 +00:00
|
|
|
/* Make sure descriptors are ready before ringing the doorbell */
|
|
|
|
wmb();
|
2013-07-29 19:05:57 +00:00
|
|
|
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;
|
2016-02-01 13:02:40 +00:00
|
|
|
dev_dbg(hba->dev, "%s: dev_cmd request timedout, tag %d\n",
|
|
|
|
__func__, lrbp->task_tag);
|
2013-07-29 19:05:57 +00:00
|
|
|
if (!ufshcd_clear_cmd(hba, lrbp->task_tag))
|
2016-02-01 13:02:40 +00:00
|
|
|
/* successfully cleared the command, retry if needed */
|
2013-07-29 19:05:57 +00:00
|
|
|
err = -EAGAIN;
|
2016-02-01 13:02:40 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2013-07-29 19:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_exec_dev_cmd - API for sending device management requests
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: UFS hba
|
|
|
|
* @cmd_type: specifies the type (NOP, Query...)
|
|
|
|
* @timeout: time in seconds
|
2013-07-29 19:05:57 +00:00
|
|
|
*
|
2013-07-29 19:05:58 +00:00
|
|
|
* NOTE: Since there is only one available tag for device management commands,
|
|
|
|
* it is expected you hold the hba->dev_cmd.lock mutex.
|
2013-07-29 19:05:57 +00:00
|
|
|
*/
|
|
|
|
static int ufshcd_exec_dev_cmd(struct ufs_hba *hba,
|
|
|
|
enum dev_cmd_type cmd_type, int timeout)
|
|
|
|
{
|
2019-12-09 18:13:08 +00:00
|
|
|
struct request_queue *q = hba->cmd_queue;
|
|
|
|
struct request *req;
|
2013-07-29 19:05:57 +00:00
|
|
|
struct ufshcd_lrb *lrbp;
|
|
|
|
int err;
|
|
|
|
int tag;
|
|
|
|
struct completion wait;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
down_read(&hba->clk_scaling_lock);
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2019-12-09 18:13:08 +00:00
|
|
|
req = blk_get_request(q, REQ_OP_DRV_OUT, 0);
|
2019-12-13 10:48:28 +00:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2019-12-09 18:13:08 +00:00
|
|
|
tag = req->tag;
|
|
|
|
WARN_ON_ONCE(!ufshcd_valid_tag(hba, tag));
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
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_put_tag;
|
|
|
|
|
|
|
|
hba->dev_cmd.complete = &wait;
|
|
|
|
|
2018-03-28 09:42:18 +00:00
|
|
|
ufshcd_add_query_upiu_trace(hba, tag, "query_send");
|
2016-02-01 13:02:49 +00:00
|
|
|
/* Make sure descriptors are ready before ringing the doorbell */
|
|
|
|
wmb();
|
2013-07-29 19:05:57 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
ufshcd_send_command(hba, tag);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
err = ufshcd_wait_for_dev_cmd(hba, lrbp, timeout);
|
|
|
|
|
2018-03-28 09:42:18 +00:00
|
|
|
ufshcd_add_query_upiu_trace(hba, tag,
|
|
|
|
err ? "query_complete_err" : "query_complete");
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
out_put_tag:
|
2019-12-09 18:13:08 +00:00
|
|
|
blk_put_request(req);
|
2019-12-13 10:48:28 +00:00
|
|
|
out_unlock:
|
2017-02-04 00:57:02 +00:00
|
|
|
up_read(&hba->clk_scaling_lock);
|
2013-07-29 19:05:57 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-06-29 06:40:17 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_init_query() - init the query response and request parameters
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @request: address of the request pointer to be initialized
|
|
|
|
* @response: address of the response pointer to be initialized
|
|
|
|
* @opcode: operation to perform
|
|
|
|
* @idn: flag idn to access
|
|
|
|
* @index: LU number to access
|
|
|
|
* @selector: query/flag/descriptor further identification
|
|
|
|
*/
|
|
|
|
static inline void ufshcd_init_query(struct ufs_hba *hba,
|
|
|
|
struct ufs_query_req **request, struct ufs_query_res **response,
|
|
|
|
enum query_opcode opcode, u8 idn, u8 index, u8 selector)
|
|
|
|
{
|
|
|
|
*request = &hba->dev_cmd.query.request;
|
|
|
|
*response = &hba->dev_cmd.query.response;
|
|
|
|
memset(*request, 0, sizeof(struct ufs_query_req));
|
|
|
|
memset(*response, 0, sizeof(struct ufs_query_res));
|
|
|
|
(*request)->upiu_req.opcode = opcode;
|
|
|
|
(*request)->upiu_req.idn = idn;
|
|
|
|
(*request)->upiu_req.index = index;
|
|
|
|
(*request)->upiu_req.selector = selector;
|
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:46 +00:00
|
|
|
static int ufshcd_query_flag_retry(struct ufs_hba *hba,
|
2020-05-08 08:01:12 +00:00
|
|
|
enum query_opcode opcode, enum flag_idn idn, u8 index, bool *flag_res)
|
2016-02-01 13:02:46 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int retries;
|
|
|
|
|
|
|
|
for (retries = 0; retries < QUERY_REQ_RETRIES; retries++) {
|
2020-05-08 08:01:12 +00:00
|
|
|
ret = ufshcd_query_flag(hba, opcode, idn, index, flag_res);
|
2016-02-01 13:02:46 +00:00
|
|
|
if (ret)
|
|
|
|
dev_dbg(hba->dev,
|
|
|
|
"%s: failed with error %d, retries %d\n",
|
|
|
|
__func__, ret, retries);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: query attribute, opcode %d, idn %d, failed with error %d after %d retires\n",
|
|
|
|
__func__, opcode, idn, ret, retries);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_query_flag() - API function for sending flag query requests
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @opcode: flag query to perform
|
|
|
|
* @idn: flag idn to access
|
2020-05-08 08:01:12 +00:00
|
|
|
* @index: flag index to access
|
2018-03-01 23:07:20 +00:00
|
|
|
* @flag_res: the flag value after the query request completes
|
2013-07-29 19:05:58 +00:00
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure
|
|
|
|
*/
|
2016-02-01 13:02:46 +00:00
|
|
|
int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
|
2020-05-08 08:01:12 +00:00
|
|
|
enum flag_idn idn, u8 index, bool *flag_res)
|
2013-07-29 19:05:58 +00:00
|
|
|
{
|
2014-06-29 06:40:17 +00:00
|
|
|
struct ufs_query_req *request = NULL;
|
|
|
|
struct ufs_query_res *response = NULL;
|
2020-05-08 08:01:12 +00:00
|
|
|
int err, selector = 0;
|
2016-02-01 13:02:41 +00:00
|
|
|
int timeout = QUERY_REQ_TIMEOUT;
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
BUG_ON(!hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2013-07-29 19:05:58 +00:00
|
|
|
mutex_lock(&hba->dev_cmd.lock);
|
2014-06-29 06:40:17 +00:00
|
|
|
ufshcd_init_query(hba, &request, &response, opcode, idn, index,
|
|
|
|
selector);
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
switch (opcode) {
|
|
|
|
case UPIU_QUERY_OPCODE_SET_FLAG:
|
|
|
|
case UPIU_QUERY_OPCODE_CLEAR_FLAG:
|
|
|
|
case UPIU_QUERY_OPCODE_TOGGLE_FLAG:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
|
|
|
|
break;
|
|
|
|
case UPIU_QUERY_OPCODE_READ_FLAG:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
|
|
|
|
if (!flag_res) {
|
|
|
|
/* No dummy reads */
|
|
|
|
dev_err(hba->dev, "%s: Invalid argument for read request\n",
|
|
|
|
__func__);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Expected query flag opcode but got = %d\n",
|
|
|
|
__func__, opcode);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:41 +00:00
|
|
|
err = ufshcd_exec_dev_cmd(hba, DEV_CMD_TYPE_QUERY, timeout);
|
2013-07-29 19:05:58 +00:00
|
|
|
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Sending flag query for idn %d failed, err = %d\n",
|
|
|
|
__func__, idn, err);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flag_res)
|
2014-05-26 05:29:10 +00:00
|
|
|
*flag_res = (be32_to_cpu(response->upiu_res.value) &
|
2013-07-29 19:05:58 +00:00
|
|
|
MASK_QUERY_UPIU_FLAG_LOC) & 0x1;
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&hba->dev_cmd.lock);
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2013-07-29 19:05:58 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_query_attr - API function for sending attribute requests
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @opcode: attribute opcode
|
|
|
|
* @idn: attribute idn to access
|
|
|
|
* @index: index field
|
|
|
|
* @selector: selector field
|
|
|
|
* @attr_val: the attribute value after the query request completes
|
2013-07-29 19:05:59 +00:00
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure
|
|
|
|
*/
|
2018-02-15 12:14:11 +00:00
|
|
|
int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
|
|
|
|
enum attr_idn idn, u8 index, u8 selector, u32 *attr_val)
|
2013-07-29 19:05:59 +00:00
|
|
|
{
|
2014-06-29 06:40:17 +00:00
|
|
|
struct ufs_query_req *request = NULL;
|
|
|
|
struct ufs_query_res *response = NULL;
|
2013-07-29 19:05:59 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
BUG_ON(!hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2013-07-29 19:05:59 +00:00
|
|
|
if (!attr_val) {
|
|
|
|
dev_err(hba->dev, "%s: attribute value required for opcode 0x%x\n",
|
|
|
|
__func__, opcode);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&hba->dev_cmd.lock);
|
2014-06-29 06:40:17 +00:00
|
|
|
ufshcd_init_query(hba, &request, &response, opcode, idn, index,
|
|
|
|
selector);
|
2013-07-29 19:05:59 +00:00
|
|
|
|
|
|
|
switch (opcode) {
|
|
|
|
case UPIU_QUERY_OPCODE_WRITE_ATTR:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
|
2014-05-26 05:29:10 +00:00
|
|
|
request->upiu_req.value = cpu_to_be32(*attr_val);
|
2013-07-29 19:05:59 +00:00
|
|
|
break;
|
|
|
|
case UPIU_QUERY_OPCODE_READ_ATTR:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(hba->dev, "%s: Expected query attr opcode but got = 0x%.2x\n",
|
|
|
|
__func__, opcode);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-06-29 06:40:17 +00:00
|
|
|
err = ufshcd_exec_dev_cmd(hba, DEV_CMD_TYPE_QUERY, QUERY_REQ_TIMEOUT);
|
2013-07-29 19:05:59 +00:00
|
|
|
|
|
|
|
if (err) {
|
2016-11-24 00:31:18 +00:00
|
|
|
dev_err(hba->dev, "%s: opcode 0x%.2x for idn %d failed, index %d, err = %d\n",
|
|
|
|
__func__, opcode, idn, index, err);
|
2013-07-29 19:05:59 +00:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:10 +00:00
|
|
|
*attr_val = be32_to_cpu(response->upiu_res.value);
|
2013-07-29 19:05:59 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&hba->dev_cmd.lock);
|
|
|
|
out:
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2013-07-29 19:05:59 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_query_attr_retry() - API function for sending query
|
|
|
|
* attribute with retries
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @opcode: attribute opcode
|
|
|
|
* @idn: attribute idn to access
|
|
|
|
* @index: index field
|
|
|
|
* @selector: selector field
|
|
|
|
* @attr_val: the attribute value after the query request
|
|
|
|
* completes
|
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_query_attr_retry(struct ufs_hba *hba,
|
|
|
|
enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector,
|
|
|
|
u32 *attr_val)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 retries;
|
|
|
|
|
2019-12-24 22:02:43 +00:00
|
|
|
for (retries = QUERY_REQ_RETRIES; retries > 0; retries--) {
|
2016-02-01 13:02:50 +00:00
|
|
|
ret = ufshcd_query_attr(hba, opcode, idn, index,
|
|
|
|
selector, attr_val);
|
|
|
|
if (ret)
|
|
|
|
dev_dbg(hba->dev, "%s: failed with error %d, retries %d\n",
|
|
|
|
__func__, ret, retries);
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: query attribute, idn %d, failed with error %d after %d retires\n",
|
|
|
|
__func__, idn, ret, QUERY_REQ_RETRIES);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:14 +00:00
|
|
|
static int __ufshcd_query_descriptor(struct ufs_hba *hba,
|
2014-06-29 06:40:17 +00:00
|
|
|
enum query_opcode opcode, enum desc_idn idn, u8 index,
|
|
|
|
u8 selector, u8 *desc_buf, int *buf_len)
|
|
|
|
{
|
|
|
|
struct ufs_query_req *request = NULL;
|
|
|
|
struct ufs_query_res *response = NULL;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
BUG_ON(!hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2014-06-29 06:40:17 +00:00
|
|
|
if (!desc_buf) {
|
|
|
|
dev_err(hba->dev, "%s: descriptor buffer required for opcode 0x%x\n",
|
|
|
|
__func__, opcode);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-02-23 09:05:30 +00:00
|
|
|
if (*buf_len < QUERY_DESC_MIN_SIZE || *buf_len > QUERY_DESC_MAX_SIZE) {
|
2014-06-29 06:40:17 +00:00
|
|
|
dev_err(hba->dev, "%s: descriptor buffer size (%d) is out of range\n",
|
|
|
|
__func__, *buf_len);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&hba->dev_cmd.lock);
|
|
|
|
ufshcd_init_query(hba, &request, &response, opcode, idn, index,
|
|
|
|
selector);
|
|
|
|
hba->dev_cmd.query.descriptor = desc_buf;
|
2014-07-23 06:31:12 +00:00
|
|
|
request->upiu_req.length = cpu_to_be16(*buf_len);
|
2014-06-29 06:40:17 +00:00
|
|
|
|
|
|
|
switch (opcode) {
|
|
|
|
case UPIU_QUERY_OPCODE_WRITE_DESC:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
|
|
|
|
break;
|
|
|
|
case UPIU_QUERY_OPCODE_READ_DESC:
|
|
|
|
request->query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Expected query descriptor opcode but got = 0x%.2x\n",
|
|
|
|
__func__, opcode);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = ufshcd_exec_dev_cmd(hba, DEV_CMD_TYPE_QUERY, QUERY_REQ_TIMEOUT);
|
|
|
|
|
|
|
|
if (err) {
|
2016-11-24 00:31:18 +00:00
|
|
|
dev_err(hba->dev, "%s: opcode 0x%.2x for idn %d failed, index %d, err = %d\n",
|
|
|
|
__func__, opcode, idn, index, err);
|
2014-06-29 06:40:17 +00:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-07-23 06:31:12 +00:00
|
|
|
*buf_len = be16_to_cpu(response->upiu_res.length);
|
2014-06-29 06:40:17 +00:00
|
|
|
|
|
|
|
out_unlock:
|
scsi: ufs: fix potential bug which ends in system hang
In function __ufshcd_query_descriptor(), in the event of an error
happening, we directly goto out_unlock and forget to invaliate
hba->dev_cmd.query.descriptor pointer. This results in this pointer still
valid in ufshcd_copy_query_response() for other query requests which go
through ufshcd_exec_raw_upiu_cmd(). This will cause __memcpy() crash and
system hangs. Log as shown below:
Unable to handle kernel paging request at virtual address
ffff000012233c40
Mem abort info:
ESR = 0x96000047
Exception class = DABT (current EL), IL = 32 bits
SET = 0, FnV = 0
EA = 0, S1PTW = 0
Data abort info:
ISV = 0, ISS = 0x00000047
CM = 0, WnR = 1
swapper pgtable: 4k pages, 48-bit VAs, pgdp = 0000000028cc735c
[ffff000012233c40] pgd=00000000bffff003, pud=00000000bfffe003,
pmd=00000000ba8b8003, pte=0000000000000000
Internal error: Oops: 96000047 [#2] PREEMPT SMP
...
Call trace:
__memcpy+0x74/0x180
ufshcd_issue_devman_upiu_cmd+0x250/0x3c0
ufshcd_exec_raw_upiu_cmd+0xfc/0x1a8
ufs_bsg_request+0x178/0x3b0
bsg_queue_rq+0xc0/0x118
blk_mq_dispatch_rq_list+0xb0/0x538
blk_mq_sched_dispatch_requests+0x18c/0x1d8
__blk_mq_run_hw_queue+0xb4/0x118
blk_mq_run_work_fn+0x28/0x38
process_one_work+0x1ec/0x470
worker_thread+0x48/0x458
kthread+0x130/0x138
ret_from_fork+0x10/0x1c
Code: 540000ab a8c12027 a88120c7 a8c12027 (a88120c7)
---[ end trace 793e1eb5dff69f2d ]---
note: kworker/0:2H[2054] exited with preempt_count 1
This patch is to move "descriptor = NULL" down to below the label
"out_unlock".
Fixes: d44a5f98bb49b2(ufs: query descriptor API)
Link: https://lore.kernel.org/r/20191112223436.27449-3-huobean@gmail.com
Reviewed-by: Alim Akhtar <alim.akhtar@samsung.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-11-12 22:34:36 +00:00
|
|
|
hba->dev_cmd.query.descriptor = NULL;
|
2014-06-29 06:40:17 +00:00
|
|
|
mutex_unlock(&hba->dev_cmd.lock);
|
|
|
|
out:
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2014-06-29 06:40:17 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:14 +00:00
|
|
|
/**
|
2018-03-01 23:07:20 +00:00
|
|
|
* ufshcd_query_descriptor_retry - API function for sending descriptor requests
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @opcode: attribute opcode
|
|
|
|
* @idn: attribute idn to access
|
|
|
|
* @index: index field
|
|
|
|
* @selector: selector field
|
|
|
|
* @desc_buf: the buffer that contains the descriptor
|
|
|
|
* @buf_len: length parameter passed to the device
|
2016-03-10 15:37:14 +00:00
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure.
|
|
|
|
* The buf_len parameter will contain, on return, the length parameter
|
|
|
|
* received on the response.
|
|
|
|
*/
|
2018-02-15 12:14:07 +00:00
|
|
|
int ufshcd_query_descriptor_retry(struct ufs_hba *hba,
|
|
|
|
enum query_opcode opcode,
|
|
|
|
enum desc_idn idn, u8 index,
|
|
|
|
u8 selector,
|
|
|
|
u8 *desc_buf, int *buf_len)
|
2016-03-10 15:37:14 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int retries;
|
|
|
|
|
|
|
|
for (retries = QUERY_REQ_RETRIES; retries > 0; retries--) {
|
|
|
|
err = __ufshcd_query_descriptor(hba, opcode, idn, index,
|
|
|
|
selector, desc_buf, buf_len);
|
|
|
|
if (!err || err == -EINVAL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-02-23 09:05:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_map_desc_id_to_length - map descriptor IDN to its length
|
|
|
|
* @hba: Pointer to adapter instance
|
|
|
|
* @desc_id: descriptor idn value
|
|
|
|
* @desc_len: mapped desc length (out)
|
|
|
|
*/
|
2020-06-03 09:19:58 +00:00
|
|
|
void ufshcd_map_desc_id_to_length(struct ufs_hba *hba, enum desc_idn desc_id,
|
|
|
|
int *desc_len)
|
2017-02-23 09:05:30 +00:00
|
|
|
{
|
2020-06-03 09:19:58 +00:00
|
|
|
if (desc_id >= QUERY_DESC_IDN_MAX || desc_id == QUERY_DESC_IDN_RFU_0 ||
|
|
|
|
desc_id == QUERY_DESC_IDN_RFU_1)
|
2017-02-23 09:05:30 +00:00
|
|
|
*desc_len = 0;
|
2020-06-03 09:19:58 +00:00
|
|
|
else
|
|
|
|
*desc_len = hba->desc_size[desc_id];
|
2017-02-23 09:05:30 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_map_desc_id_to_length);
|
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
static void ufshcd_update_desc_length(struct ufs_hba *hba,
|
2020-06-03 09:19:59 +00:00
|
|
|
enum desc_idn desc_id, int desc_index,
|
2020-06-03 09:19:58 +00:00
|
|
|
unsigned char desc_len)
|
|
|
|
{
|
|
|
|
if (hba->desc_size[desc_id] == QUERY_DESC_MAX_SIZE &&
|
2020-06-03 09:19:59 +00:00
|
|
|
desc_id != QUERY_DESC_IDN_STRING && desc_index != UFS_RPMB_UNIT)
|
|
|
|
/* For UFS 3.1, the normal unit descriptor is 10 bytes larger
|
|
|
|
* than the RPMB unit, however, both descriptors share the same
|
|
|
|
* desc_idn, to cover both unit descriptors with one length, we
|
|
|
|
* choose the normal unit descriptor length by desc_index.
|
|
|
|
*/
|
2020-06-03 09:19:58 +00:00
|
|
|
hba->desc_size[desc_id] = desc_len;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:25 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_read_desc_param - read the specified descriptor parameter
|
|
|
|
* @hba: Pointer to adapter instance
|
|
|
|
* @desc_id: descriptor idn value
|
|
|
|
* @desc_index: descriptor index
|
|
|
|
* @param_offset: offset of the parameter to read
|
|
|
|
* @param_read_buf: pointer to buffer where parameter would be read
|
|
|
|
* @param_size: sizeof(param_read_buf)
|
|
|
|
*
|
|
|
|
* Return 0 in case of success, non-zero otherwise
|
|
|
|
*/
|
2018-02-15 12:14:02 +00:00
|
|
|
int ufshcd_read_desc_param(struct ufs_hba *hba,
|
|
|
|
enum desc_idn desc_id,
|
|
|
|
int desc_index,
|
|
|
|
u8 param_offset,
|
|
|
|
u8 *param_read_buf,
|
|
|
|
u8 param_size)
|
2014-09-25 12:32:25 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 *desc_buf;
|
2017-02-23 09:05:30 +00:00
|
|
|
int buff_len;
|
2014-09-25 12:32:25 +00:00
|
|
|
bool is_kmalloc = true;
|
|
|
|
|
2017-02-23 09:05:30 +00:00
|
|
|
/* Safety check */
|
|
|
|
if (desc_id >= QUERY_DESC_IDN_MAX || !param_size)
|
2014-09-25 12:32:25 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
/* Get the length of descriptor */
|
|
|
|
ufshcd_map_desc_id_to_length(hba, desc_id, &buff_len);
|
|
|
|
if (!buff_len) {
|
|
|
|
dev_err(hba->dev, "%s: Failed to get desc length", __func__);
|
|
|
|
return -EINVAL;
|
2017-02-23 09:05:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether we need temp memory */
|
|
|
|
if (param_offset != 0 || param_size < buff_len) {
|
2014-09-25 12:32:25 +00:00
|
|
|
desc_buf = kmalloc(buff_len, GFP_KERNEL);
|
|
|
|
if (!desc_buf)
|
|
|
|
return -ENOMEM;
|
2017-02-23 09:05:30 +00:00
|
|
|
} else {
|
|
|
|
desc_buf = param_read_buf;
|
|
|
|
is_kmalloc = false;
|
2014-09-25 12:32:25 +00:00
|
|
|
}
|
|
|
|
|
2017-02-23 09:05:30 +00:00
|
|
|
/* Request for full descriptor */
|
2016-03-10 15:37:14 +00:00
|
|
|
ret = ufshcd_query_descriptor_retry(hba, UPIU_QUERY_OPCODE_READ_DESC,
|
2017-02-23 09:05:30 +00:00
|
|
|
desc_id, desc_index, 0,
|
|
|
|
desc_buf, &buff_len);
|
2014-09-25 12:32:25 +00:00
|
|
|
|
2016-11-24 00:31:41 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s: Failed reading descriptor. desc_id %d, desc_index %d, param_offset %d, ret %d",
|
|
|
|
__func__, desc_id, desc_index, param_offset, ret);
|
2014-09-25 12:32:25 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-11-24 00:31:41 +00:00
|
|
|
/* Sanity check */
|
|
|
|
if (desc_buf[QUERY_DESC_DESC_TYPE_OFFSET] != desc_id) {
|
|
|
|
dev_err(hba->dev, "%s: invalid desc_id %d in descriptor header",
|
|
|
|
__func__, desc_buf[QUERY_DESC_DESC_TYPE_OFFSET]);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
/* Update descriptor length */
|
|
|
|
buff_len = desc_buf[QUERY_DESC_LENGTH_OFFSET];
|
2020-06-03 09:19:59 +00:00
|
|
|
ufshcd_update_desc_length(hba, desc_id, desc_index, buff_len);
|
2020-06-03 09:19:58 +00:00
|
|
|
|
2017-02-23 09:05:30 +00:00
|
|
|
/* Check wherher we will not copy more data, than available */
|
2020-06-03 09:19:57 +00:00
|
|
|
if (is_kmalloc && (param_offset + param_size) > buff_len)
|
|
|
|
param_size = buff_len - param_offset;
|
2016-11-24 00:31:41 +00:00
|
|
|
|
2014-09-25 12:32:25 +00:00
|
|
|
if (is_kmalloc)
|
|
|
|
memcpy(param_read_buf, &desc_buf[param_offset], param_size);
|
|
|
|
out:
|
|
|
|
if (is_kmalloc)
|
|
|
|
kfree(desc_buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
/**
|
|
|
|
* struct uc_string_id - unicode string
|
|
|
|
*
|
|
|
|
* @len: size of this descriptor inclusive
|
|
|
|
* @type: descriptor type
|
|
|
|
* @uc: unicode string character
|
|
|
|
*/
|
|
|
|
struct uc_string_id {
|
|
|
|
u8 len;
|
|
|
|
u8 type;
|
2020-05-07 19:25:50 +00:00
|
|
|
wchar_t uc[];
|
2019-07-30 05:55:17 +00:00
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* replace non-printable or non-ASCII characters with spaces */
|
|
|
|
static inline char ufshcd_remove_non_printable(u8 ch)
|
|
|
|
{
|
|
|
|
return (ch >= 0x20 && ch <= 0x7e) ? ch : ' ';
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:09 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_read_string_desc - read string descriptor
|
|
|
|
* @hba: pointer to adapter instance
|
|
|
|
* @desc_index: descriptor index
|
2019-07-30 05:55:17 +00:00
|
|
|
* @buf: pointer to buffer where descriptor would be read,
|
|
|
|
* the caller should free the memory.
|
2016-03-10 15:37:09 +00:00
|
|
|
* @ascii: if true convert from unicode to ascii characters
|
2019-07-30 05:55:17 +00:00
|
|
|
* null terminated string.
|
2016-03-10 15:37:09 +00:00
|
|
|
*
|
2019-07-30 05:55:17 +00:00
|
|
|
* Return:
|
|
|
|
* * string size on success.
|
|
|
|
* * -ENOMEM: on allocation failure
|
|
|
|
* * -EINVAL: on a wrong parameter
|
2016-03-10 15:37:09 +00:00
|
|
|
*/
|
2019-07-30 05:55:17 +00:00
|
|
|
int ufshcd_read_string_desc(struct ufs_hba *hba, u8 desc_index,
|
|
|
|
u8 **buf, bool ascii)
|
2016-03-10 15:37:09 +00:00
|
|
|
{
|
2019-07-30 05:55:17 +00:00
|
|
|
struct uc_string_id *uc_str;
|
|
|
|
u8 *str;
|
|
|
|
int ret;
|
2016-03-10 15:37:09 +00:00
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
if (!buf)
|
|
|
|
return -EINVAL;
|
2016-03-10 15:37:09 +00:00
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
uc_str = kzalloc(QUERY_DESC_MAX_SIZE, GFP_KERNEL);
|
|
|
|
if (!uc_str)
|
|
|
|
return -ENOMEM;
|
2016-03-10 15:37:09 +00:00
|
|
|
|
2020-06-03 09:19:56 +00:00
|
|
|
ret = ufshcd_read_desc_param(hba, QUERY_DESC_IDN_STRING, desc_index, 0,
|
|
|
|
(u8 *)uc_str, QUERY_DESC_MAX_SIZE);
|
2019-07-30 05:55:17 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(hba->dev, "Reading String Desc failed after %d retries. err = %d\n",
|
|
|
|
QUERY_REQ_RETRIES, ret);
|
|
|
|
str = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (uc_str->len <= QUERY_DESC_HDR_SIZE) {
|
|
|
|
dev_dbg(hba->dev, "String Desc is of zero length\n");
|
|
|
|
str = NULL;
|
|
|
|
ret = 0;
|
2016-03-10 15:37:09 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ascii) {
|
2019-07-30 05:55:17 +00:00
|
|
|
ssize_t ascii_len;
|
2016-03-10 15:37:09 +00:00
|
|
|
int i;
|
|
|
|
/* remove header and divide by 2 to move from UTF16 to UTF8 */
|
2019-07-30 05:55:17 +00:00
|
|
|
ascii_len = (uc_str->len - QUERY_DESC_HDR_SIZE) / 2 + 1;
|
|
|
|
str = kzalloc(ascii_len, GFP_KERNEL);
|
|
|
|
if (!str) {
|
|
|
|
ret = -ENOMEM;
|
2016-06-25 04:35:22 +00:00
|
|
|
goto out;
|
2016-03-10 15:37:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the descriptor contains string in UTF16 format
|
|
|
|
* we need to convert to utf-8 so it can be displayed
|
|
|
|
*/
|
2019-07-30 05:55:17 +00:00
|
|
|
ret = utf16s_to_utf8s(uc_str->uc,
|
|
|
|
uc_str->len - QUERY_DESC_HDR_SIZE,
|
|
|
|
UTF16_BIG_ENDIAN, str, ascii_len);
|
2016-03-10 15:37:09 +00:00
|
|
|
|
|
|
|
/* replace non-printable or non-ASCII characters with spaces */
|
2019-07-30 05:55:17 +00:00
|
|
|
for (i = 0; i < ret; i++)
|
|
|
|
str[i] = ufshcd_remove_non_printable(str[i]);
|
2016-03-10 15:37:09 +00:00
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
str[ret++] = '\0';
|
|
|
|
|
|
|
|
} else {
|
2019-08-31 12:44:24 +00:00
|
|
|
str = kmemdup(uc_str, uc_str->len, GFP_KERNEL);
|
2019-07-30 05:55:17 +00:00
|
|
|
if (!str) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = uc_str->len;
|
2016-03-10 15:37:09 +00:00
|
|
|
}
|
|
|
|
out:
|
2019-07-30 05:55:17 +00:00
|
|
|
*buf = str;
|
|
|
|
kfree(uc_str);
|
|
|
|
return ret;
|
2016-03-10 15:37:09 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:25 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_read_unit_desc_param - read the specified unit descriptor parameter
|
|
|
|
* @hba: Pointer to adapter instance
|
|
|
|
* @lun: lun id
|
|
|
|
* @param_offset: offset of the parameter to read
|
|
|
|
* @param_read_buf: pointer to buffer where parameter would be read
|
|
|
|
* @param_size: sizeof(param_read_buf)
|
|
|
|
*
|
|
|
|
* Return 0 in case of success, non-zero otherwise
|
|
|
|
*/
|
|
|
|
static inline int ufshcd_read_unit_desc_param(struct ufs_hba *hba,
|
|
|
|
int lun,
|
|
|
|
enum unit_desc_param param_offset,
|
|
|
|
u8 *param_read_buf,
|
|
|
|
u32 param_size)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Unit descriptors are only available for general purpose LUs (LUN id
|
|
|
|
* from 0 to 7) and RPMB Well known LU.
|
|
|
|
*/
|
2020-01-20 13:08:20 +00:00
|
|
|
if (!ufs_is_valid_unit_desc_lun(&hba->dev_info, lun))
|
2014-09-25 12:32:25 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return ufshcd_read_desc_param(hba, QUERY_DESC_IDN_UNIT, lun,
|
|
|
|
param_offset, param_read_buf, param_size);
|
|
|
|
}
|
|
|
|
|
2020-02-11 03:40:49 +00:00
|
|
|
static int ufshcd_get_ref_clk_gating_wait(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
u32 gating_wait = UFSHCD_REF_CLK_GATING_WAIT_US;
|
|
|
|
|
|
|
|
if (hba->dev_info.wspecversion >= 0x300) {
|
|
|
|
err = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
|
|
|
QUERY_ATTR_IDN_REF_CLK_GATING_WAIT_TIME, 0, 0,
|
|
|
|
&gating_wait);
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "Failed reading bRefClkGatingWait. err = %d, use default %uus\n",
|
|
|
|
err, gating_wait);
|
|
|
|
|
|
|
|
if (gating_wait == 0) {
|
|
|
|
gating_wait = UFSHCD_REF_CLK_GATING_WAIT_US;
|
|
|
|
dev_err(hba->dev, "Undefined ref clk gating wait time, use default %uus\n",
|
|
|
|
gating_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->dev_info.clk_gating_wait_us = gating_wait;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_memory_alloc - allocate memory for host memory space data structures
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* 1. Allocate DMA memory for Command Descriptor array
|
|
|
|
* Each command descriptor consist of Command UPIU, Response UPIU and PRDT
|
|
|
|
* 2. Allocate DMA memory for UTP Transfer Request Descriptor List (UTRDL).
|
|
|
|
* 3. Allocate DMA memory for UTP Task Management Request Descriptor List
|
|
|
|
* (UTMRDL)
|
|
|
|
* 4. Allocate memory for local reference block(lrb).
|
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_memory_alloc(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
size_t utmrdl_size, utrdl_size, ucdl_size;
|
|
|
|
|
|
|
|
/* Allocate memory for UTP command descriptors */
|
|
|
|
ucdl_size = (sizeof(struct utp_transfer_cmd_desc) * hba->nutrs);
|
2013-06-27 04:31:54 +00:00
|
|
|
hba->ucdl_base_addr = dmam_alloc_coherent(hba->dev,
|
|
|
|
ucdl_size,
|
|
|
|
&hba->ucdl_dma_addr,
|
|
|
|
GFP_KERNEL);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* UFSHCI requires UTP command descriptor to be 128 byte aligned.
|
|
|
|
* make sure hba->ucdl_dma_addr is aligned to PAGE_SIZE
|
|
|
|
* if hba->ucdl_dma_addr is aligned to PAGE_SIZE, then it will
|
|
|
|
* be aligned to 128 bytes as well
|
|
|
|
*/
|
|
|
|
if (!hba->ucdl_base_addr ||
|
|
|
|
WARN_ON(hba->ucdl_dma_addr & (PAGE_SIZE - 1))) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2012-02-29 06:41:50 +00:00
|
|
|
"Command Descriptor Memory allocation failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate memory for UTP Transfer descriptors
|
|
|
|
* UFSHCI requires 1024 byte alignment of UTRD
|
|
|
|
*/
|
|
|
|
utrdl_size = (sizeof(struct utp_transfer_req_desc) * hba->nutrs);
|
2013-06-27 04:31:54 +00:00
|
|
|
hba->utrdl_base_addr = dmam_alloc_coherent(hba->dev,
|
|
|
|
utrdl_size,
|
|
|
|
&hba->utrdl_dma_addr,
|
|
|
|
GFP_KERNEL);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (!hba->utrdl_base_addr ||
|
|
|
|
WARN_ON(hba->utrdl_dma_addr & (PAGE_SIZE - 1))) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2012-02-29 06:41:50 +00:00
|
|
|
"Transfer Descriptor Memory allocation failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate memory for UTP Task Management descriptors
|
|
|
|
* UFSHCI requires 1024 byte alignment of UTMRD
|
|
|
|
*/
|
|
|
|
utmrdl_size = sizeof(struct utp_task_req_desc) * hba->nutmrs;
|
2013-06-27 04:31:54 +00:00
|
|
|
hba->utmrdl_base_addr = dmam_alloc_coherent(hba->dev,
|
|
|
|
utmrdl_size,
|
|
|
|
&hba->utmrdl_dma_addr,
|
|
|
|
GFP_KERNEL);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (!hba->utmrdl_base_addr ||
|
|
|
|
WARN_ON(hba->utmrdl_dma_addr & (PAGE_SIZE - 1))) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2012-02-29 06:41:50 +00:00
|
|
|
"Task Management Descriptor Memory allocation failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate memory for local reference block */
|
treewide: devm_kzalloc() -> devm_kcalloc()
The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
This patch replaces cases of:
devm_kzalloc(handle, a * b, gfp)
with:
devm_kcalloc(handle, a * b, gfp)
as well as handling cases of:
devm_kzalloc(handle, a * b * c, gfp)
with:
devm_kzalloc(handle, array3_size(a, b, c), gfp)
as it's slightly less ugly than:
devm_kcalloc(handle, array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
devm_kzalloc(handle, 4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
Some manual whitespace fixes were needed in this patch, as Coccinelle
really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
expression HANDLE;
type TYPE;
expression THING, E;
@@
(
devm_kzalloc(HANDLE,
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
devm_kzalloc(HANDLE,
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression HANDLE;
expression COUNT;
typedef u8;
typedef __u8;
@@
(
devm_kzalloc(HANDLE,
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(char) * COUNT
+ COUNT
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
expression HANDLE;
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
expression HANDLE;
identifier SIZE, COUNT;
@@
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression HANDLE;
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression HANDLE;
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
devm_kzalloc(HANDLE,
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
expression HANDLE;
identifier STRIDE, SIZE, COUNT;
@@
(
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
devm_kzalloc(HANDLE,
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression HANDLE;
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE,
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
devm_kzalloc(HANDLE,
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression HANDLE;
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
|
devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
|
devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
|
devm_kzalloc(HANDLE, C1 * C2, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * E2
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- (E1) * (E2)
+ E1, E2
, ...)
|
- devm_kzalloc
+ devm_kcalloc
(HANDLE,
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:07:58 +00:00
|
|
|
hba->lrb = devm_kcalloc(hba->dev,
|
|
|
|
hba->nutrs, sizeof(struct ufshcd_lrb),
|
2013-06-27 04:31:54 +00:00
|
|
|
GFP_KERNEL);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (!hba->lrb) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev, "LRB Memory allocation failed\n");
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_host_memory_configure - configure local reference block with
|
|
|
|
* memory offsets
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Configure Host memory space
|
|
|
|
* 1. Update Corresponding UTRD.UCDBA and UTRD.UCDBAU with UCD DMA
|
|
|
|
* address.
|
|
|
|
* 2. Update each UTRD with Response UPIU offset, Response UPIU length
|
|
|
|
* and PRDT offset.
|
|
|
|
* 3. Save the corresponding addresses of UTRD, UCD.CMD, UCD.RSP and UCD.PRDT
|
|
|
|
* into local reference block.
|
|
|
|
*/
|
|
|
|
static void ufshcd_host_memory_configure(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct utp_transfer_req_desc *utrdlp;
|
|
|
|
dma_addr_t cmd_desc_dma_addr;
|
|
|
|
dma_addr_t cmd_desc_element_addr;
|
|
|
|
u16 response_offset;
|
|
|
|
u16 prdt_offset;
|
|
|
|
int cmd_desc_size;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
utrdlp = hba->utrdl_base_addr;
|
|
|
|
|
|
|
|
response_offset =
|
|
|
|
offsetof(struct utp_transfer_cmd_desc, response_upiu);
|
|
|
|
prdt_offset =
|
|
|
|
offsetof(struct utp_transfer_cmd_desc, prd_table);
|
|
|
|
|
|
|
|
cmd_desc_size = sizeof(struct utp_transfer_cmd_desc);
|
|
|
|
cmd_desc_dma_addr = hba->ucdl_dma_addr;
|
|
|
|
|
|
|
|
for (i = 0; i < hba->nutrs; i++) {
|
|
|
|
/* Configure UTRD with command descriptor base address */
|
|
|
|
cmd_desc_element_addr =
|
|
|
|
(cmd_desc_dma_addr + (cmd_desc_size * i));
|
|
|
|
utrdlp[i].command_desc_base_addr_lo =
|
|
|
|
cpu_to_le32(lower_32_bits(cmd_desc_element_addr));
|
|
|
|
utrdlp[i].command_desc_base_addr_hi =
|
|
|
|
cpu_to_le32(upper_32_bits(cmd_desc_element_addr));
|
|
|
|
|
|
|
|
/* Response upiu and prdt offset should be in double words */
|
2020-05-28 01:16:52 +00:00
|
|
|
if (hba->quirks & UFSHCD_QUIRK_PRDT_BYTE_GRAN) {
|
|
|
|
utrdlp[i].response_upiu_offset =
|
|
|
|
cpu_to_le16(response_offset);
|
|
|
|
utrdlp[i].prd_table_offset =
|
|
|
|
cpu_to_le16(prdt_offset);
|
|
|
|
utrdlp[i].response_upiu_length =
|
|
|
|
cpu_to_le16(ALIGNED_UPIU_SIZE);
|
|
|
|
} else {
|
|
|
|
utrdlp[i].response_upiu_offset =
|
|
|
|
cpu_to_le16(response_offset >> 2);
|
|
|
|
utrdlp[i].prd_table_offset =
|
|
|
|
cpu_to_le16(prdt_offset >> 2);
|
|
|
|
utrdlp[i].response_upiu_length =
|
|
|
|
cpu_to_le16(ALIGNED_UPIU_SIZE >> 2);
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2020-01-23 03:56:35 +00:00
|
|
|
ufshcd_init_lrb(hba, &hba->lrb[i], i);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_dme_link_startup - Notify Unipro to perform link startup
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* UIC_CMD_DME_LINK_STARTUP command must be issued to Unipro layer,
|
|
|
|
* in order to initialize the Unipro link startup procedure.
|
|
|
|
* Once the Unipro links are up, the device connected to the controller
|
|
|
|
* is detected.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_dme_link_startup(struct ufs_hba *hba)
|
|
|
|
{
|
2013-06-26 17:09:29 +00:00
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
int ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
uic_cmd.command = UIC_CMD_DME_LINK_STARTUP;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
|
|
|
|
if (ret)
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_dbg(hba->dev,
|
2013-06-26 17:09:29 +00:00
|
|
|
"dme-link-startup: error code %d\n", ret);
|
|
|
|
return ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2020-05-28 01:16:51 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_dme_reset - UIC command for DME_RESET
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* DME_RESET command is issued in order to reset UniPro stack.
|
|
|
|
* This function now deals with cold reset.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_dme_reset(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
uic_cmd.command = UIC_CMD_DME_RESET;
|
|
|
|
|
|
|
|
ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"dme-reset: error code %d\n", ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_dme_enable - UIC command for DME_ENABLE
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* DME_ENABLE command is issued in order to enable UniPro stack.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_dme_enable(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
uic_cmd.command = UIC_CMD_DME_ENABLE;
|
|
|
|
|
|
|
|
ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"dme-reset: error code %d\n", ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2015-03-31 14:37:14 +00:00
|
|
|
static inline void ufshcd_add_delay_before_dme_cmd(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
#define MIN_DELAY_BEFORE_DME_CMDS_US 1000
|
|
|
|
unsigned long min_sleep_time_us;
|
|
|
|
|
|
|
|
if (!(hba->quirks & UFSHCD_QUIRK_DELAY_BEFORE_DME_CMDS))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* last_dme_cmd_tstamp will be 0 only for 1st call to
|
|
|
|
* this function
|
|
|
|
*/
|
|
|
|
if (unlikely(!ktime_to_us(hba->last_dme_cmd_tstamp))) {
|
|
|
|
min_sleep_time_us = MIN_DELAY_BEFORE_DME_CMDS_US;
|
|
|
|
} else {
|
|
|
|
unsigned long delta =
|
|
|
|
(unsigned long) ktime_to_us(
|
|
|
|
ktime_sub(ktime_get(),
|
|
|
|
hba->last_dme_cmd_tstamp));
|
|
|
|
|
|
|
|
if (delta < MIN_DELAY_BEFORE_DME_CMDS_US)
|
|
|
|
min_sleep_time_us =
|
|
|
|
MIN_DELAY_BEFORE_DME_CMDS_US - delta;
|
|
|
|
else
|
|
|
|
return; /* no more delay required */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow sleep for extra 50us if needed */
|
|
|
|
usleep_range(min_sleep_time_us, min_sleep_time_us + 50);
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:21 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_dme_set_attr - UIC command for DME_SET, DME_PEER_SET
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @attr_sel: uic command argument1
|
|
|
|
* @attr_set: attribute set type as uic command argument2
|
|
|
|
* @mib_val: setting value as uic command argument3
|
|
|
|
* @peer: indicate whether peer or local
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
int ufshcd_dme_set_attr(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u8 attr_set, u32 mib_val, u8 peer)
|
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
static const char *const action[] = {
|
|
|
|
"dme-set",
|
|
|
|
"dme-peer-set"
|
|
|
|
};
|
|
|
|
const char *set = action[!!peer];
|
|
|
|
int ret;
|
2016-02-01 13:02:43 +00:00
|
|
|
int retries = UFS_UIC_COMMAND_RETRIES;
|
2013-08-31 16:10:21 +00:00
|
|
|
|
|
|
|
uic_cmd.command = peer ?
|
|
|
|
UIC_CMD_DME_PEER_SET : UIC_CMD_DME_SET;
|
|
|
|
uic_cmd.argument1 = attr_sel;
|
|
|
|
uic_cmd.argument2 = UIC_ARG_ATTR_TYPE(attr_set);
|
|
|
|
uic_cmd.argument3 = mib_val;
|
|
|
|
|
2016-02-01 13:02:43 +00:00
|
|
|
do {
|
|
|
|
/* for peer attributes we retry upon failure */
|
|
|
|
ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
|
|
|
|
if (ret)
|
|
|
|
dev_dbg(hba->dev, "%s: attr-id 0x%x val 0x%x error code %d\n",
|
|
|
|
set, UIC_GET_ATTR_ID(attr_sel), mib_val, ret);
|
|
|
|
} while (ret && peer && --retries);
|
|
|
|
|
2016-11-24 00:32:49 +00:00
|
|
|
if (ret)
|
2016-02-01 13:02:43 +00:00
|
|
|
dev_err(hba->dev, "%s: attr-id 0x%x val 0x%x failed %d retries\n",
|
2016-11-24 00:32:49 +00:00
|
|
|
set, UIC_GET_ATTR_ID(attr_sel), mib_val,
|
|
|
|
UFS_UIC_COMMAND_RETRIES - retries);
|
2013-08-31 16:10:21 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_dme_set_attr);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_dme_get_attr - UIC command for DME_GET, DME_PEER_GET
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @attr_sel: uic command argument1
|
|
|
|
* @mib_val: the value of the attribute as returned by the UIC command
|
|
|
|
* @peer: indicate whether peer or local
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
int ufshcd_dme_get_attr(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 *mib_val, u8 peer)
|
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
static const char *const action[] = {
|
|
|
|
"dme-get",
|
|
|
|
"dme-peer-get"
|
|
|
|
};
|
|
|
|
const char *get = action[!!peer];
|
|
|
|
int ret;
|
2016-02-01 13:02:43 +00:00
|
|
|
int retries = UFS_UIC_COMMAND_RETRIES;
|
2015-05-17 15:55:03 +00:00
|
|
|
struct ufs_pa_layer_attr orig_pwr_info;
|
|
|
|
struct ufs_pa_layer_attr temp_pwr_info;
|
|
|
|
bool pwr_mode_change = false;
|
|
|
|
|
|
|
|
if (peer && (hba->quirks & UFSHCD_QUIRK_DME_PEER_ACCESS_AUTO_MODE)) {
|
|
|
|
orig_pwr_info = hba->pwr_info;
|
|
|
|
temp_pwr_info = orig_pwr_info;
|
|
|
|
|
|
|
|
if (orig_pwr_info.pwr_tx == FAST_MODE ||
|
|
|
|
orig_pwr_info.pwr_rx == FAST_MODE) {
|
|
|
|
temp_pwr_info.pwr_tx = FASTAUTO_MODE;
|
|
|
|
temp_pwr_info.pwr_rx = FASTAUTO_MODE;
|
|
|
|
pwr_mode_change = true;
|
|
|
|
} else if (orig_pwr_info.pwr_tx == SLOW_MODE ||
|
|
|
|
orig_pwr_info.pwr_rx == SLOW_MODE) {
|
|
|
|
temp_pwr_info.pwr_tx = SLOWAUTO_MODE;
|
|
|
|
temp_pwr_info.pwr_rx = SLOWAUTO_MODE;
|
|
|
|
pwr_mode_change = true;
|
|
|
|
}
|
|
|
|
if (pwr_mode_change) {
|
|
|
|
ret = ufshcd_change_power_mode(hba, &temp_pwr_info);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2013-08-31 16:10:21 +00:00
|
|
|
|
|
|
|
uic_cmd.command = peer ?
|
|
|
|
UIC_CMD_DME_PEER_GET : UIC_CMD_DME_GET;
|
|
|
|
uic_cmd.argument1 = attr_sel;
|
|
|
|
|
2016-02-01 13:02:43 +00:00
|
|
|
do {
|
|
|
|
/* for peer attributes we retry upon failure */
|
|
|
|
ret = ufshcd_send_uic_cmd(hba, &uic_cmd);
|
|
|
|
if (ret)
|
|
|
|
dev_dbg(hba->dev, "%s: attr-id 0x%x error code %d\n",
|
|
|
|
get, UIC_GET_ATTR_ID(attr_sel), ret);
|
|
|
|
} while (ret && peer && --retries);
|
|
|
|
|
2016-11-24 00:32:49 +00:00
|
|
|
if (ret)
|
2016-02-01 13:02:43 +00:00
|
|
|
dev_err(hba->dev, "%s: attr-id 0x%x failed %d retries\n",
|
2016-11-24 00:32:49 +00:00
|
|
|
get, UIC_GET_ATTR_ID(attr_sel),
|
|
|
|
UFS_UIC_COMMAND_RETRIES - retries);
|
2013-08-31 16:10:21 +00:00
|
|
|
|
2016-02-01 13:02:43 +00:00
|
|
|
if (mib_val && !ret)
|
2013-08-31 16:10:21 +00:00
|
|
|
*mib_val = uic_cmd.argument3;
|
2015-05-17 15:55:03 +00:00
|
|
|
|
|
|
|
if (peer && (hba->quirks & UFSHCD_QUIRK_DME_PEER_ACCESS_AUTO_MODE)
|
|
|
|
&& pwr_mode_change)
|
|
|
|
ufshcd_change_power_mode(hba, &orig_pwr_info);
|
2013-08-31 16:10:21 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_dme_get_attr);
|
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
/**
|
2014-09-25 12:32:30 +00:00
|
|
|
* ufshcd_uic_pwr_ctrl - executes UIC commands (which affects the link power
|
|
|
|
* state) and waits for it to take effect.
|
|
|
|
*
|
2013-08-31 16:10:22 +00:00
|
|
|
* @hba: per adapter instance
|
2014-09-25 12:32:30 +00:00
|
|
|
* @cmd: UIC command to execute
|
|
|
|
*
|
|
|
|
* DME operations like DME_SET(PA_PWRMODE), DME_HIBERNATE_ENTER &
|
|
|
|
* DME_HIBERNATE_EXIT commands take some time to take its effect on both host
|
|
|
|
* and device UniPro link and hence it's final completion would be indicated by
|
|
|
|
* dedicated status bits in Interrupt Status register (UPMS, UHES, UHXS) in
|
|
|
|
* addition to normal UIC command completion Status (UCCS). This function only
|
|
|
|
* returns after the relevant status bits indicate the completion.
|
2013-08-31 16:10:22 +00:00
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_uic_pwr_ctrl(struct ufs_hba *hba, struct uic_command *cmd)
|
2013-08-31 16:10:22 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
struct completion uic_async_done;
|
2013-08-31 16:10:22 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u8 status;
|
|
|
|
int ret;
|
2016-02-01 13:02:47 +00:00
|
|
|
bool reenable_intr = false;
|
2013-08-31 16:10:22 +00:00
|
|
|
|
|
|
|
mutex_lock(&hba->uic_cmd_mutex);
|
2014-09-25 12:32:30 +00:00
|
|
|
init_completion(&uic_async_done);
|
2015-03-31 14:37:14 +00:00
|
|
|
ufshcd_add_delay_before_dme_cmd(hba);
|
2013-08-31 16:10:22 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (ufshcd_is_link_broken(hba)) {
|
|
|
|
ret = -ENOLINK;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->uic_async_done = &uic_async_done;
|
2016-02-01 13:02:47 +00:00
|
|
|
if (ufshcd_readl(hba, REG_INTERRUPT_ENABLE) & UIC_COMMAND_COMPL) {
|
|
|
|
ufshcd_disable_intr(hba, UIC_COMMAND_COMPL);
|
|
|
|
/*
|
|
|
|
* Make sure UIC command completion interrupt is disabled before
|
|
|
|
* issuing UIC command.
|
|
|
|
*/
|
|
|
|
wmb();
|
|
|
|
reenable_intr = true;
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
2016-02-01 13:02:47 +00:00
|
|
|
ret = __ufshcd_send_uic_cmd(hba, cmd, false);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2014-09-25 12:32:30 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"pwr ctrl cmd 0x%x with mode 0x%x uic error %d\n",
|
|
|
|
cmd->command, cmd->argument3, ret);
|
2013-08-31 16:10:22 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if (!wait_for_completion_timeout(hba->uic_async_done,
|
2013-08-31 16:10:22 +00:00
|
|
|
msecs_to_jiffies(UIC_CMD_TIMEOUT))) {
|
|
|
|
dev_err(hba->dev,
|
2014-09-25 12:32:30 +00:00
|
|
|
"pwr ctrl cmd 0x%x with mode 0x%x completion timeout\n",
|
|
|
|
cmd->command, cmd->argument3);
|
2013-08-31 16:10:22 +00:00
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = ufshcd_get_upmcrs(hba);
|
|
|
|
if (status != PWR_LOCAL) {
|
|
|
|
dev_err(hba->dev,
|
2017-09-19 08:50:30 +00:00
|
|
|
"pwr ctrl cmd 0x%x failed, host upmcrs:0x%x\n",
|
2014-09-25 12:32:30 +00:00
|
|
|
cmd->command, status);
|
2013-08-31 16:10:22 +00:00
|
|
|
ret = (status != PWR_OK) ? status : -1;
|
|
|
|
}
|
|
|
|
out:
|
2017-02-04 00:58:24 +00:00
|
|
|
if (ret) {
|
|
|
|
ufshcd_print_host_state(hba);
|
|
|
|
ufshcd_print_pwr_info(hba);
|
|
|
|
ufshcd_print_host_regs(hba);
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2016-02-01 13:02:47 +00:00
|
|
|
hba->active_uic_cmd = NULL;
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->uic_async_done = NULL;
|
2016-02-01 13:02:47 +00:00
|
|
|
if (reenable_intr)
|
|
|
|
ufshcd_enable_intr(hba, UIC_COMMAND_COMPL);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (ret) {
|
|
|
|
ufshcd_set_link_broken(hba);
|
|
|
|
ufshcd_schedule_eh_work(hba);
|
|
|
|
}
|
|
|
|
out_unlock:
|
2013-08-31 16:10:22 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
mutex_unlock(&hba->uic_cmd_mutex);
|
2014-09-25 12:32:32 +00:00
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_uic_change_pwr_mode - Perform the UIC power mode chage
|
|
|
|
* using DME_SET primitives.
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @mode: powr mode value
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_uic_change_pwr_mode(struct ufs_hba *hba, u8 mode)
|
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
2014-09-25 12:32:32 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2015-05-17 15:55:01 +00:00
|
|
|
if (hba->quirks & UFSHCD_QUIRK_BROKEN_PA_RXHSUNTERMCAP) {
|
|
|
|
ret = ufshcd_dme_set(hba,
|
|
|
|
UIC_ARG_MIB_SEL(PA_RXHSUNTERMCAP, 0), 1);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s: failed to enable PA_RXHSUNTERMCAP ret %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
uic_cmd.command = UIC_CMD_DME_SET;
|
|
|
|
uic_cmd.argument1 = UIC_ARG_MIB(PA_PWRMODE);
|
|
|
|
uic_cmd.argument3 = mode;
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
|
|
|
|
ufshcd_release(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2015-05-17 15:55:01 +00:00
|
|
|
out:
|
2014-09-25 12:32:32 +00:00
|
|
|
return ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-27 09:53:28 +00:00
|
|
|
int ufshcd_link_recovery(struct ufs_hba *hba)
|
2016-02-01 13:02:45 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_RESET;
|
|
|
|
ufshcd_set_eh_in_progress(hba);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2019-11-15 06:09:24 +00:00
|
|
|
/* Reset the attached device */
|
|
|
|
ufshcd_vops_device_reset(hba);
|
|
|
|
|
2016-02-01 13:02:45 +00:00
|
|
|
ret = ufshcd_host_reset_and_restore(hba);
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
if (ret)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_ERROR;
|
|
|
|
ufshcd_clear_eh_in_progress(hba);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev, "%s: link recovery failed, err %d",
|
|
|
|
__func__, ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2020-03-27 09:53:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_link_recovery);
|
2016-02-01 13:02:45 +00:00
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba)
|
2014-09-25 12:32:30 +00:00
|
|
|
{
|
2016-02-01 13:02:44 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
struct uic_command uic_cmd = {0};
|
2016-12-23 02:41:48 +00:00
|
|
|
ktime_t start = ktime_get();
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2016-11-10 12:17:43 +00:00
|
|
|
ufshcd_vops_hibern8_notify(hba, UIC_CMD_DME_HIBER_ENTER, PRE_CHANGE);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
uic_cmd.command = UIC_CMD_DME_HIBER_ENTER;
|
2016-02-01 13:02:44 +00:00
|
|
|
ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
|
2016-12-23 02:41:48 +00:00
|
|
|
trace_ufshcd_profile_hibern8(dev_name(hba->dev), "enter",
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)), ret);
|
2016-02-01 13:02:44 +00:00
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (ret)
|
2016-02-01 13:02:44 +00:00
|
|
|
dev_err(hba->dev, "%s: hibern8 enter failed. ret = %d\n",
|
|
|
|
__func__, ret);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
else
|
2016-11-10 12:17:43 +00:00
|
|
|
ufshcd_vops_hibern8_notify(hba, UIC_CMD_DME_HIBER_ENTER,
|
|
|
|
POST_CHANGE);
|
2016-02-01 13:02:45 +00:00
|
|
|
|
2016-02-01 13:02:44 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-01-17 03:51:07 +00:00
|
|
|
int ufshcd_uic_hibern8_exit(struct ufs_hba *hba)
|
2014-09-25 12:32:30 +00:00
|
|
|
{
|
|
|
|
struct uic_command uic_cmd = {0};
|
|
|
|
int ret;
|
2016-12-23 02:41:48 +00:00
|
|
|
ktime_t start = ktime_get();
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2016-11-10 12:17:43 +00:00
|
|
|
ufshcd_vops_hibern8_notify(hba, UIC_CMD_DME_HIBER_EXIT, PRE_CHANGE);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
uic_cmd.command = UIC_CMD_DME_HIBER_EXIT;
|
|
|
|
ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
|
2016-12-23 02:41:48 +00:00
|
|
|
trace_ufshcd_profile_hibern8(dev_name(hba->dev), "exit",
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)), ret);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if (ret) {
|
2016-02-01 13:02:45 +00:00
|
|
|
dev_err(hba->dev, "%s: hibern8 exit failed. ret = %d\n",
|
|
|
|
__func__, ret);
|
2016-12-23 02:42:18 +00:00
|
|
|
} else {
|
2016-11-10 12:17:43 +00:00
|
|
|
ufshcd_vops_hibern8_notify(hba, UIC_CMD_DME_HIBER_EXIT,
|
|
|
|
POST_CHANGE);
|
2016-12-23 02:42:18 +00:00
|
|
|
hba->ufs_stats.last_hibern8_exit_tstamp = ktime_get();
|
|
|
|
hba->ufs_stats.hibern8_exit_cnt++;
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2020-01-17 03:51:07 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_uic_hibern8_exit);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2019-12-30 05:32:28 +00:00
|
|
|
void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2020-03-05 08:53:07 +00:00
|
|
|
bool update = false;
|
2019-12-30 05:32:28 +00:00
|
|
|
|
2020-03-05 08:53:07 +00:00
|
|
|
if (!ufshcd_is_auto_hibern8_supported(hba))
|
2019-12-30 05:32:28 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2020-03-05 08:53:07 +00:00
|
|
|
if (hba->ahit != ahit) {
|
|
|
|
hba->ahit = ahit;
|
|
|
|
update = true;
|
|
|
|
}
|
2019-12-30 05:32:28 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2020-03-05 08:53:07 +00:00
|
|
|
|
|
|
|
if (update && !pm_runtime_suspended(hba->dev)) {
|
|
|
|
pm_runtime_get_sync(hba->dev);
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
ufshcd_auto_hibern8_enable(hba);
|
|
|
|
ufshcd_release(hba);
|
|
|
|
pm_runtime_put(hba->dev);
|
|
|
|
}
|
2019-12-30 05:32:28 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_auto_hibern8_update);
|
|
|
|
|
2019-11-15 06:09:26 +00:00
|
|
|
void ufshcd_auto_hibern8_enable(struct ufs_hba *hba)
|
2018-03-20 13:07:38 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2019-05-21 06:44:52 +00:00
|
|
|
if (!ufshcd_is_auto_hibern8_supported(hba) || !hba->ahit)
|
2018-03-20 13:07:38 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
ufshcd_writel(hba, hba->ahit, REG_AUTO_HIBERNATE_IDLE_TIMER);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-10-23 10:25:13 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_init_pwr_info - setting the POR (power on reset)
|
|
|
|
* values in hba power info
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*/
|
|
|
|
static void ufshcd_init_pwr_info(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
hba->pwr_info.gear_rx = UFS_PWM_G1;
|
|
|
|
hba->pwr_info.gear_tx = UFS_PWM_G1;
|
|
|
|
hba->pwr_info.lane_rx = 1;
|
|
|
|
hba->pwr_info.lane_tx = 1;
|
|
|
|
hba->pwr_info.pwr_rx = SLOWAUTO_MODE;
|
|
|
|
hba->pwr_info.pwr_tx = SLOWAUTO_MODE;
|
|
|
|
hba->pwr_info.hs_rate = 0;
|
|
|
|
}
|
|
|
|
|
2013-08-31 16:10:24 +00:00
|
|
|
/**
|
2014-09-25 12:32:31 +00:00
|
|
|
* ufshcd_get_max_pwr_mode - reads the max power mode negotiated with device
|
|
|
|
* @hba: per-adapter instance
|
2013-08-31 16:10:24 +00:00
|
|
|
*/
|
2014-09-25 12:32:31 +00:00
|
|
|
static int ufshcd_get_max_pwr_mode(struct ufs_hba *hba)
|
2013-08-31 16:10:24 +00:00
|
|
|
{
|
2014-09-25 12:32:31 +00:00
|
|
|
struct ufs_pa_layer_attr *pwr_info = &hba->max_pwr_info.info;
|
|
|
|
|
|
|
|
if (hba->max_pwr_info.is_valid)
|
|
|
|
return 0;
|
|
|
|
|
2016-11-24 00:33:19 +00:00
|
|
|
pwr_info->pwr_tx = FAST_MODE;
|
|
|
|
pwr_info->pwr_rx = FAST_MODE;
|
2014-09-25 12:32:31 +00:00
|
|
|
pwr_info->hs_rate = PA_HS_MODE_B;
|
2013-08-31 16:10:24 +00:00
|
|
|
|
|
|
|
/* Get the connected lane count */
|
2014-09-25 12:32:31 +00:00
|
|
|
ufshcd_dme_get(hba, UIC_ARG_MIB(PA_CONNECTEDRXDATALANES),
|
|
|
|
&pwr_info->lane_rx);
|
|
|
|
ufshcd_dme_get(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES),
|
|
|
|
&pwr_info->lane_tx);
|
|
|
|
|
|
|
|
if (!pwr_info->lane_rx || !pwr_info->lane_tx) {
|
|
|
|
dev_err(hba->dev, "%s: invalid connected lanes value. rx=%d, tx=%d\n",
|
|
|
|
__func__,
|
|
|
|
pwr_info->lane_rx,
|
|
|
|
pwr_info->lane_tx);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-08-31 16:10:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First, get the maximum gears of HS speed.
|
|
|
|
* If a zero value, it means there is no HSGEAR capability.
|
|
|
|
* Then, get the maximum gears of PWM speed.
|
|
|
|
*/
|
2014-09-25 12:32:31 +00:00
|
|
|
ufshcd_dme_get(hba, UIC_ARG_MIB(PA_MAXRXHSGEAR), &pwr_info->gear_rx);
|
|
|
|
if (!pwr_info->gear_rx) {
|
|
|
|
ufshcd_dme_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR),
|
|
|
|
&pwr_info->gear_rx);
|
|
|
|
if (!pwr_info->gear_rx) {
|
|
|
|
dev_err(hba->dev, "%s: invalid max pwm rx gear read = %d\n",
|
|
|
|
__func__, pwr_info->gear_rx);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-11-24 00:33:19 +00:00
|
|
|
pwr_info->pwr_rx = SLOW_MODE;
|
2013-08-31 16:10:24 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:31 +00:00
|
|
|
ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXHSGEAR),
|
|
|
|
&pwr_info->gear_tx);
|
|
|
|
if (!pwr_info->gear_tx) {
|
2013-08-31 16:10:24 +00:00
|
|
|
ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR),
|
2014-09-25 12:32:31 +00:00
|
|
|
&pwr_info->gear_tx);
|
|
|
|
if (!pwr_info->gear_tx) {
|
|
|
|
dev_err(hba->dev, "%s: invalid max pwm tx gear read = %d\n",
|
|
|
|
__func__, pwr_info->gear_tx);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-11-24 00:33:19 +00:00
|
|
|
pwr_info->pwr_tx = SLOW_MODE;
|
2014-09-25 12:32:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
hba->max_pwr_info.is_valid = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_change_power_mode(struct ufs_hba *hba,
|
|
|
|
struct ufs_pa_layer_attr *pwr_mode)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* if already configured to the requested pwr_mode */
|
|
|
|
if (pwr_mode->gear_rx == hba->pwr_info.gear_rx &&
|
|
|
|
pwr_mode->gear_tx == hba->pwr_info.gear_tx &&
|
|
|
|
pwr_mode->lane_rx == hba->pwr_info.lane_rx &&
|
|
|
|
pwr_mode->lane_tx == hba->pwr_info.lane_tx &&
|
|
|
|
pwr_mode->pwr_rx == hba->pwr_info.pwr_rx &&
|
|
|
|
pwr_mode->pwr_tx == hba->pwr_info.pwr_tx &&
|
|
|
|
pwr_mode->hs_rate == hba->pwr_info.hs_rate) {
|
|
|
|
dev_dbg(hba->dev, "%s: power already configured\n", __func__);
|
|
|
|
return 0;
|
2013-08-31 16:10:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure attributes for power mode change with below.
|
|
|
|
* - PA_RXGEAR, PA_ACTIVERXDATALANES, PA_RXTERMINATION,
|
|
|
|
* - PA_TXGEAR, PA_ACTIVETXDATALANES, PA_TXTERMINATION,
|
|
|
|
* - PA_HSSERIES
|
|
|
|
*/
|
2014-09-25 12:32:31 +00:00
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_RXGEAR), pwr_mode->gear_rx);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_ACTIVERXDATALANES),
|
|
|
|
pwr_mode->lane_rx);
|
|
|
|
if (pwr_mode->pwr_rx == FASTAUTO_MODE ||
|
|
|
|
pwr_mode->pwr_rx == FAST_MODE)
|
2013-08-31 16:10:24 +00:00
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_RXTERMINATION), TRUE);
|
2014-09-25 12:32:31 +00:00
|
|
|
else
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_RXTERMINATION), FALSE);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
2014-09-25 12:32:31 +00:00
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TXGEAR), pwr_mode->gear_tx);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_ACTIVETXDATALANES),
|
|
|
|
pwr_mode->lane_tx);
|
|
|
|
if (pwr_mode->pwr_tx == FASTAUTO_MODE ||
|
|
|
|
pwr_mode->pwr_tx == FAST_MODE)
|
2013-08-31 16:10:24 +00:00
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TXTERMINATION), TRUE);
|
2014-09-25 12:32:31 +00:00
|
|
|
else
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TXTERMINATION), FALSE);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
2014-09-25 12:32:31 +00:00
|
|
|
if (pwr_mode->pwr_rx == FASTAUTO_MODE ||
|
|
|
|
pwr_mode->pwr_tx == FASTAUTO_MODE ||
|
|
|
|
pwr_mode->pwr_rx == FAST_MODE ||
|
|
|
|
pwr_mode->pwr_tx == FAST_MODE)
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_HSSERIES),
|
|
|
|
pwr_mode->hs_rate);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
2019-12-05 02:14:42 +00:00
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA0),
|
|
|
|
DL_FC0ProtectionTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA1),
|
|
|
|
DL_TC0ReplayTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA2),
|
|
|
|
DL_AFC0ReqTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA3),
|
|
|
|
DL_FC1ProtectionTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA4),
|
|
|
|
DL_TC1ReplayTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_PWRMODEUSERDATA5),
|
|
|
|
DL_AFC1ReqTimeOutVal_Default);
|
|
|
|
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(DME_LocalFC0ProtectionTimeOutVal),
|
|
|
|
DL_FC0ProtectionTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(DME_LocalTC0ReplayTimeOutVal),
|
|
|
|
DL_TC0ReplayTimeOutVal_Default);
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(DME_LocalAFC0ReqTimeOutVal),
|
|
|
|
DL_AFC0ReqTimeOutVal_Default);
|
|
|
|
|
2014-09-25 12:32:31 +00:00
|
|
|
ret = ufshcd_uic_change_pwr_mode(hba, pwr_mode->pwr_rx << 4
|
|
|
|
| pwr_mode->pwr_tx);
|
|
|
|
|
|
|
|
if (ret) {
|
2013-08-31 16:10:24 +00:00
|
|
|
dev_err(hba->dev,
|
2014-09-25 12:32:31 +00:00
|
|
|
"%s: power mode change failed %d\n", __func__, ret);
|
|
|
|
} else {
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_pwr_change_notify(hba, POST_CHANGE, NULL,
|
|
|
|
pwr_mode);
|
2014-09-25 12:32:31 +00:00
|
|
|
|
|
|
|
memcpy(&hba->pwr_info, pwr_mode,
|
|
|
|
sizeof(struct ufs_pa_layer_attr));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_config_pwr_mode - configure a new power mode
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @desired_pwr_mode: desired power configuration
|
|
|
|
*/
|
2018-05-06 10:14:18 +00:00
|
|
|
int ufshcd_config_pwr_mode(struct ufs_hba *hba,
|
2014-09-25 12:32:31 +00:00
|
|
|
struct ufs_pa_layer_attr *desired_pwr_mode)
|
|
|
|
{
|
|
|
|
struct ufs_pa_layer_attr final_params = { 0 };
|
|
|
|
int ret;
|
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
ret = ufshcd_vops_pwr_change_notify(hba, PRE_CHANGE,
|
|
|
|
desired_pwr_mode, &final_params);
|
|
|
|
|
|
|
|
if (ret)
|
2014-09-25 12:32:31 +00:00
|
|
|
memcpy(&final_params, desired_pwr_mode, sizeof(final_params));
|
|
|
|
|
|
|
|
ret = ufshcd_change_power_mode(hba, &final_params);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2018-05-06 10:14:18 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_config_pwr_mode);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_complete_dev_init() - checks device readiness
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per-adapter instance
|
2013-07-29 19:05:58 +00:00
|
|
|
*
|
|
|
|
* Set fDeviceInit flag and poll until device toggles it.
|
|
|
|
*/
|
|
|
|
static int ufshcd_complete_dev_init(struct ufs_hba *hba)
|
|
|
|
{
|
2016-02-01 13:02:46 +00:00
|
|
|
int err;
|
2020-04-26 09:43:05 +00:00
|
|
|
bool flag_res = true;
|
2020-08-10 10:02:27 +00:00
|
|
|
ktime_t timeout;
|
2013-07-29 19:05:58 +00:00
|
|
|
|
2016-02-01 13:02:46 +00:00
|
|
|
err = ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_SET_FLAG,
|
2020-05-08 08:01:12 +00:00
|
|
|
QUERY_FLAG_IDN_FDEVICEINIT, 0, NULL);
|
2013-07-29 19:05:58 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s setting fDeviceInit flag failed with error %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-08-10 10:02:27 +00:00
|
|
|
/* Poll fDeviceInit flag to be cleared */
|
|
|
|
timeout = ktime_add_ms(ktime_get(), FDEVICEINIT_COMPL_TIMEOUT);
|
|
|
|
do {
|
|
|
|
err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,
|
|
|
|
QUERY_FLAG_IDN_FDEVICEINIT, 0, &flag_res);
|
|
|
|
if (!flag_res)
|
|
|
|
break;
|
|
|
|
usleep_range(5000, 10000);
|
|
|
|
} while (ktime_before(ktime_get(), timeout));
|
2016-02-01 13:02:46 +00:00
|
|
|
|
2020-08-10 10:02:27 +00:00
|
|
|
if (err) {
|
2013-07-29 19:05:58 +00:00
|
|
|
dev_err(hba->dev,
|
2020-08-10 10:02:27 +00:00
|
|
|
"%s reading fDeviceInit flag failed with error %d\n",
|
|
|
|
__func__, err);
|
|
|
|
} else if (flag_res) {
|
2013-07-29 19:05:58 +00:00
|
|
|
dev_err(hba->dev,
|
2020-08-10 10:02:27 +00:00
|
|
|
"%s fDeviceInit was not cleared by the device\n",
|
|
|
|
__func__);
|
|
|
|
err = -EBUSY;
|
|
|
|
}
|
2013-07-29 19:05:58 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_make_hba_operational - Make UFS controller operational
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* To bring UFS host controller to operational state,
|
2014-09-25 12:32:21 +00:00
|
|
|
* 1. Enable required interrupts
|
|
|
|
* 2. Configure interrupt aggregation
|
2016-02-01 13:02:48 +00:00
|
|
|
* 3. Program UTRL and UTMRL base address
|
2014-09-25 12:32:21 +00:00
|
|
|
* 4. Configure run-stop-registers
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
2020-01-17 03:51:07 +00:00
|
|
|
int ufshcd_make_hba_operational(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
u32 reg;
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/* Enable required interrupts */
|
|
|
|
ufshcd_enable_intr(hba, UFSHCD_ENABLE_INTRS);
|
|
|
|
|
|
|
|
/* Configure interrupt aggregation */
|
2015-05-17 15:54:57 +00:00
|
|
|
if (ufshcd_is_intr_aggr_allowed(hba))
|
|
|
|
ufshcd_config_intr_aggr(hba, hba->nutrs - 1, INT_AGGR_DEF_TO);
|
|
|
|
else
|
|
|
|
ufshcd_disable_intr_aggr(hba);
|
2013-06-26 17:09:29 +00:00
|
|
|
|
|
|
|
/* Configure UTRL and UTMRL base address registers */
|
|
|
|
ufshcd_writel(hba, lower_32_bits(hba->utrdl_dma_addr),
|
|
|
|
REG_UTP_TRANSFER_REQ_LIST_BASE_L);
|
|
|
|
ufshcd_writel(hba, upper_32_bits(hba->utrdl_dma_addr),
|
|
|
|
REG_UTP_TRANSFER_REQ_LIST_BASE_H);
|
|
|
|
ufshcd_writel(hba, lower_32_bits(hba->utmrdl_dma_addr),
|
|
|
|
REG_UTP_TASK_REQ_LIST_BASE_L);
|
|
|
|
ufshcd_writel(hba, upper_32_bits(hba->utmrdl_dma_addr),
|
|
|
|
REG_UTP_TASK_REQ_LIST_BASE_H);
|
|
|
|
|
2016-02-01 13:02:48 +00:00
|
|
|
/*
|
|
|
|
* Make sure base address and interrupt setup are updated before
|
|
|
|
* enabling the run/stop registers below.
|
|
|
|
*/
|
|
|
|
wmb();
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/*
|
|
|
|
* UCRDY, UTMRLDY and UTRLRDY bits must be 1
|
|
|
|
*/
|
2014-09-25 12:32:21 +00:00
|
|
|
reg = ufshcd_readl(hba, REG_CONTROLLER_STATUS);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (!(ufshcd_get_lists_status(reg))) {
|
|
|
|
ufshcd_enable_run_stop_reg(hba);
|
|
|
|
} else {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2012-02-29 06:41:50 +00:00
|
|
|
"Host controller not ready to process requests");
|
|
|
|
err = -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2020-01-17 03:51:07 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_make_hba_operational);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-03-10 15:37:08 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_hba_stop - Send controller to reset state
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*/
|
2020-05-07 22:27:50 +00:00
|
|
|
static inline void ufshcd_hba_stop(struct ufs_hba *hba)
|
2016-03-10 15:37:08 +00:00
|
|
|
{
|
2020-05-07 22:27:50 +00:00
|
|
|
unsigned long flags;
|
2016-03-10 15:37:08 +00:00
|
|
|
int err;
|
|
|
|
|
2020-05-07 22:27:50 +00:00
|
|
|
/*
|
|
|
|
* Obtain the host lock to prevent that the controller is disabled
|
|
|
|
* while the UFS interrupt handler is active on another CPU.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2016-03-10 15:37:08 +00:00
|
|
|
ufshcd_writel(hba, CONTROLLER_DISABLE, REG_CONTROLLER_ENABLE);
|
2020-05-07 22:27:50 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2016-03-10 15:37:08 +00:00
|
|
|
err = ufshcd_wait_for_register(hba, REG_CONTROLLER_ENABLE,
|
|
|
|
CONTROLLER_ENABLE, CONTROLLER_DISABLE,
|
2020-05-07 22:27:50 +00:00
|
|
|
10, 1);
|
2016-03-10 15:37:08 +00:00
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: Controller disable failed\n", __func__);
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2020-05-28 01:16:51 +00:00
|
|
|
* ufshcd_hba_execute_hce - initialize the controller
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* The controller resets itself and controller firmware initialization
|
|
|
|
* sequence kicks off. When controller is ready it will set
|
|
|
|
* the Host Controller Enable bit to 1.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
2020-05-28 01:16:51 +00:00
|
|
|
static int ufshcd_hba_execute_hce(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
int retry;
|
|
|
|
|
2016-03-10 15:37:08 +00:00
|
|
|
if (!ufshcd_is_hba_active(hba))
|
2012-02-29 06:41:50 +00:00
|
|
|
/* change controller state to "reset state" */
|
2020-05-07 22:27:50 +00:00
|
|
|
ufshcd_hba_stop(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* UniPro link is disabled at this point */
|
|
|
|
ufshcd_set_link_off(hba);
|
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_hce_enable_notify(hba, PRE_CHANGE);
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* start controller initialization sequence */
|
|
|
|
ufshcd_hba_start(hba);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To initialize a UFS host controller HCE bit must be set to 1.
|
|
|
|
* During initialization the HCE bit value changes from 1->0->1.
|
|
|
|
* When the host controller completes initialization sequence
|
|
|
|
* it sets the value of HCE bit to 1. The same HCE bit is read back
|
|
|
|
* to check if the controller has completed initialization sequence.
|
|
|
|
* So without this delay the value HCE = 1, set in the previous
|
|
|
|
* instruction might be read back.
|
|
|
|
* This delay can be changed based on the controller.
|
|
|
|
*/
|
2020-05-09 09:37:13 +00:00
|
|
|
ufshcd_delay_us(hba->vps->hba_enable_delay_us, 100);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
/* wait for the host controller to complete initialization */
|
2020-03-18 10:40:15 +00:00
|
|
|
retry = 50;
|
2012-02-29 06:41:50 +00:00
|
|
|
while (ufshcd_is_hba_active(hba)) {
|
|
|
|
if (retry) {
|
|
|
|
retry--;
|
|
|
|
} else {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2012-02-29 06:41:50 +00:00
|
|
|
"Controller enable failed\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2020-03-18 10:40:15 +00:00
|
|
|
usleep_range(1000, 1100);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
/* enable UIC related interrupts */
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_enable_intr(hba, UFSHCD_UIC_MASK);
|
2014-09-25 12:32:26 +00:00
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_hce_enable_notify(hba, POST_CHANGE);
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2020-05-28 01:16:51 +00:00
|
|
|
|
|
|
|
int ufshcd_hba_enable(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (hba->quirks & UFSHCI_QUIRK_BROKEN_HCE) {
|
|
|
|
ufshcd_set_link_off(hba);
|
|
|
|
ufshcd_vops_hce_enable_notify(hba, PRE_CHANGE);
|
|
|
|
|
|
|
|
/* enable UIC related interrupts */
|
|
|
|
ufshcd_enable_intr(hba, UFSHCD_UIC_MASK);
|
|
|
|
ret = ufshcd_dme_reset(hba);
|
|
|
|
if (!ret) {
|
|
|
|
ret = ufshcd_dme_enable(hba);
|
|
|
|
if (!ret)
|
|
|
|
ufshcd_vops_hce_enable_notify(hba, POST_CHANGE);
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"Host controller enable failed with non-hce\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = ufshcd_hba_execute_hce(hba);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2020-01-17 03:51:07 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_hba_enable);
|
|
|
|
|
2015-05-17 15:54:59 +00:00
|
|
|
static int ufshcd_disable_tx_lcc(struct ufs_hba *hba, bool peer)
|
|
|
|
{
|
2020-03-18 10:40:10 +00:00
|
|
|
int tx_lanes = 0, i, err = 0;
|
2015-05-17 15:54:59 +00:00
|
|
|
|
|
|
|
if (!peer)
|
|
|
|
ufshcd_dme_get(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES),
|
|
|
|
&tx_lanes);
|
|
|
|
else
|
|
|
|
ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES),
|
|
|
|
&tx_lanes);
|
|
|
|
for (i = 0; i < tx_lanes; i++) {
|
|
|
|
if (!peer)
|
|
|
|
err = ufshcd_dme_set(hba,
|
|
|
|
UIC_ARG_MIB_SEL(TX_LCC_ENABLE,
|
|
|
|
UIC_ARG_MPHY_TX_GEN_SEL_INDEX(i)),
|
|
|
|
0);
|
|
|
|
else
|
|
|
|
err = ufshcd_dme_peer_set(hba,
|
|
|
|
UIC_ARG_MIB_SEL(TX_LCC_ENABLE,
|
|
|
|
UIC_ARG_MPHY_TX_GEN_SEL_INDEX(i)),
|
|
|
|
0);
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: TX LCC Disable failed, peer = %d, lane = %d, err = %d",
|
|
|
|
__func__, peer, i, err);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_disable_device_tx_lcc(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return ufshcd_disable_tx_lcc(hba, true);
|
|
|
|
}
|
|
|
|
|
2020-01-04 14:26:07 +00:00
|
|
|
void ufshcd_update_reg_hist(struct ufs_err_reg_hist *reg_hist,
|
|
|
|
u32 reg)
|
2019-07-10 13:38:21 +00:00
|
|
|
{
|
|
|
|
reg_hist->reg[reg_hist->pos] = reg;
|
|
|
|
reg_hist->tstamp[reg_hist->pos] = ktime_get();
|
|
|
|
reg_hist->pos = (reg_hist->pos + 1) % UFS_ERR_REG_HIST_LENGTH;
|
|
|
|
}
|
2020-01-04 14:26:07 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_update_reg_hist);
|
2019-07-10 13:38:21 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2013-06-26 17:09:29 +00:00
|
|
|
* ufshcd_link_startup - Initialize unipro link startup
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
2013-06-26 17:09:29 +00:00
|
|
|
* Returns 0 for success, non-zero in case of failure
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2013-06-26 17:09:29 +00:00
|
|
|
static int ufshcd_link_startup(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-06-26 17:09:29 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:26 +00:00
|
|
|
int retries = DME_LINKSTARTUP_RETRIES;
|
2016-11-24 00:32:20 +00:00
|
|
|
bool link_startup_again = false;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-11-24 00:32:20 +00:00
|
|
|
/*
|
|
|
|
* If UFS device isn't active then we will have to issue link startup
|
|
|
|
* 2 times to make sure the device state move to active.
|
|
|
|
*/
|
|
|
|
if (!ufshcd_is_ufs_dev_active(hba))
|
|
|
|
link_startup_again = true;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-11-24 00:32:20 +00:00
|
|
|
link_startup:
|
2014-09-25 12:32:26 +00:00
|
|
|
do {
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_link_startup_notify(hba, PRE_CHANGE);
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
ret = ufshcd_dme_link_startup(hba);
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
/* check if device is detected by inter-connect layer */
|
|
|
|
if (!ret && !ufshcd_is_device_present(hba)) {
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.link_startup_err,
|
|
|
|
0);
|
2014-09-25 12:32:26 +00:00
|
|
|
dev_err(hba->dev, "%s: Device not present\n", __func__);
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
/*
|
|
|
|
* DME link lost indication is only received when link is up,
|
|
|
|
* but we can't be sure if the link is up until link startup
|
|
|
|
* succeeds. So reset the local Uni-Pro and try again.
|
|
|
|
*/
|
2019-07-10 13:38:21 +00:00
|
|
|
if (ret && ufshcd_hba_enable(hba)) {
|
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.link_startup_err,
|
|
|
|
(u32)ret);
|
2014-09-25 12:32:26 +00:00
|
|
|
goto out;
|
2019-07-10 13:38:21 +00:00
|
|
|
}
|
2014-09-25 12:32:26 +00:00
|
|
|
} while (ret && retries--);
|
|
|
|
|
2019-07-10 13:38:21 +00:00
|
|
|
if (ret) {
|
2014-09-25 12:32:26 +00:00
|
|
|
/* failed to get the link up... retire */
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.link_startup_err,
|
|
|
|
(u32)ret);
|
2014-09-25 12:32:21 +00:00
|
|
|
goto out;
|
2019-07-10 13:38:21 +00:00
|
|
|
}
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2016-11-24 00:32:20 +00:00
|
|
|
if (link_startup_again) {
|
|
|
|
link_startup_again = false;
|
|
|
|
retries = DME_LINKSTARTUP_RETRIES;
|
|
|
|
goto link_startup;
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:41:33 +00:00
|
|
|
/* Mark that link is up in PWM-G1, 1-lane, SLOW-AUTO mode */
|
|
|
|
ufshcd_init_pwr_info(hba);
|
|
|
|
ufshcd_print_pwr_info(hba);
|
|
|
|
|
2015-05-17 15:54:59 +00:00
|
|
|
if (hba->quirks & UFSHCD_QUIRK_BROKEN_LCC) {
|
|
|
|
ret = ufshcd_disable_device_tx_lcc(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
/* Include any host controller configuration via UIC commands */
|
2015-10-28 11:15:48 +00:00
|
|
|
ret = ufshcd_vops_link_startup_notify(hba, POST_CHANGE);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
ret = ufshcd_make_hba_operational(hba);
|
2013-06-26 17:09:29 +00:00
|
|
|
out:
|
2017-02-04 00:58:24 +00:00
|
|
|
if (ret) {
|
2013-06-26 17:09:29 +00:00
|
|
|
dev_err(hba->dev, "link startup failed %d\n", ret);
|
2017-02-04 00:58:24 +00:00
|
|
|
ufshcd_print_host_state(hba);
|
|
|
|
ufshcd_print_pwr_info(hba);
|
|
|
|
ufshcd_print_host_regs(hba);
|
|
|
|
}
|
2013-06-26 17:09:29 +00:00
|
|
|
return ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_verify_dev_init() - Verify device initialization
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Send NOP OUT UPIU and wait for NOP IN response to check whether the
|
|
|
|
* device Transport Protocol (UTP) layer is ready after a reset.
|
|
|
|
* If the UTP layer at the device side is not initialized, it may
|
|
|
|
* not respond with NOP IN UPIU within timeout of %NOP_OUT_TIMEOUT
|
|
|
|
* and we retry sending NOP OUT for %NOP_OUT_RETRIES iterations.
|
|
|
|
*/
|
|
|
|
static int ufshcd_verify_dev_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
int retries;
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2013-07-29 19:05:57 +00:00
|
|
|
mutex_lock(&hba->dev_cmd.lock);
|
|
|
|
for (retries = NOP_OUT_RETRIES; retries > 0; retries--) {
|
|
|
|
err = ufshcd_exec_dev_cmd(hba, DEV_CMD_TYPE_NOP,
|
|
|
|
NOP_OUT_TIMEOUT);
|
|
|
|
|
|
|
|
if (!err || err == -ETIMEDOUT)
|
|
|
|
break;
|
|
|
|
|
|
|
|
dev_dbg(hba->dev, "%s: error %d retrying\n", __func__, err);
|
|
|
|
}
|
|
|
|
mutex_unlock(&hba->dev_cmd.lock);
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: NOP OUT failed %d\n", __func__, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:29 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_set_queue_depth - set lun queue depth
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
*
|
|
|
|
* Read bLUQueueDepth value and activate scsi tagged command
|
|
|
|
* queueing. For WLUN, queue depth is set to 1. For best-effort
|
|
|
|
* cases (bLUQueueDepth = 0) the queue depth is set to a maximum
|
|
|
|
* value that host can queue.
|
|
|
|
*/
|
|
|
|
static void ufshcd_set_queue_depth(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u8 lun_qdepth;
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
|
|
|
|
hba = shost_priv(sdev->host);
|
|
|
|
|
|
|
|
lun_qdepth = hba->nutrs;
|
2017-03-29 06:19:21 +00:00
|
|
|
ret = ufshcd_read_unit_desc_param(hba,
|
|
|
|
ufshcd_scsi_to_upiu_lun(sdev->lun),
|
|
|
|
UNIT_DESC_PARAM_LU_Q_DEPTH,
|
|
|
|
&lun_qdepth,
|
|
|
|
sizeof(lun_qdepth));
|
2014-09-25 12:32:29 +00:00
|
|
|
|
|
|
|
/* Some WLUN doesn't support unit descriptor */
|
|
|
|
if (ret == -EOPNOTSUPP)
|
|
|
|
lun_qdepth = 1;
|
|
|
|
else if (!lun_qdepth)
|
|
|
|
/* eventually, we can figure out the real queue depth */
|
|
|
|
lun_qdepth = hba->nutrs;
|
|
|
|
else
|
|
|
|
lun_qdepth = min_t(int, lun_qdepth, hba->nutrs);
|
|
|
|
|
|
|
|
dev_dbg(hba->dev, "%s: activate tcq with queue depth %d\n",
|
|
|
|
__func__, lun_qdepth);
|
2014-11-13 14:08:42 +00:00
|
|
|
scsi_change_queue_depth(sdev, lun_qdepth);
|
2014-09-25 12:32:29 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* ufshcd_get_lu_wp - returns the "b_lu_write_protect" from UNIT DESCRIPTOR
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @lun: UFS device lun id
|
|
|
|
* @b_lu_write_protect: pointer to buffer to hold the LU's write protect info
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and b_lu_write_protect status would be returned
|
|
|
|
* @b_lu_write_protect parameter.
|
|
|
|
* Returns -ENOTSUPP if reading b_lu_write_protect is not supported.
|
|
|
|
* Returns -EINVAL in case of invalid parameters passed to this function.
|
|
|
|
*/
|
|
|
|
static int ufshcd_get_lu_wp(struct ufs_hba *hba,
|
|
|
|
u8 lun,
|
|
|
|
u8 *b_lu_write_protect)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!b_lu_write_protect)
|
|
|
|
ret = -EINVAL;
|
|
|
|
/*
|
|
|
|
* According to UFS device spec, RPMB LU can't be write
|
|
|
|
* protected so skip reading bLUWriteProtect parameter for
|
|
|
|
* it. For other W-LUs, UNIT DESCRIPTOR is not available.
|
|
|
|
*/
|
2020-01-20 13:08:20 +00:00
|
|
|
else if (lun >= hba->dev_info.max_lu_supported)
|
2014-09-25 12:32:30 +00:00
|
|
|
ret = -ENOTSUPP;
|
|
|
|
else
|
|
|
|
ret = ufshcd_read_unit_desc_param(hba,
|
|
|
|
lun,
|
|
|
|
UNIT_DESC_PARAM_LU_WR_PROTECT,
|
|
|
|
b_lu_write_protect,
|
|
|
|
sizeof(*b_lu_write_protect));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_get_lu_power_on_wp_status - get LU's power on write protect
|
|
|
|
* status
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static inline void ufshcd_get_lu_power_on_wp_status(struct ufs_hba *hba,
|
|
|
|
struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
if (hba->dev_info.f_power_on_wp_en &&
|
|
|
|
!hba->dev_info.is_lu_power_on_wp) {
|
|
|
|
u8 b_lu_write_protect;
|
|
|
|
|
|
|
|
if (!ufshcd_get_lu_wp(hba, ufshcd_scsi_to_upiu_lun(sdev->lun),
|
|
|
|
&b_lu_write_protect) &&
|
|
|
|
(b_lu_write_protect == UFS_LU_POWER_ON_WP))
|
|
|
|
hba->dev_info.is_lu_power_on_wp = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_slave_alloc - handle initial SCSI device configurations
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
*
|
|
|
|
* Returns success
|
|
|
|
*/
|
|
|
|
static int ufshcd_slave_alloc(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
|
|
|
|
hba = shost_priv(sdev->host);
|
|
|
|
|
|
|
|
/* Mode sense(6) is not supported by UFS, so use Mode sense(10) */
|
|
|
|
sdev->use_10_for_ms = 1;
|
2019-12-05 02:14:30 +00:00
|
|
|
|
|
|
|
/* DBD field should be set to 1 in mode sense(10) */
|
|
|
|
sdev->set_dbd_for_ms = 1;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-05-26 05:29:15 +00:00
|
|
|
/* allow SCSI layer to restart the device in case of errors */
|
|
|
|
sdev->allow_restart = 1;
|
2014-06-29 06:40:20 +00:00
|
|
|
|
2014-07-01 09:22:38 +00:00
|
|
|
/* REPORT SUPPORTED OPERATION CODES is not supported */
|
|
|
|
sdev->no_report_opcodes = 1;
|
|
|
|
|
2018-01-24 04:22:35 +00:00
|
|
|
/* WRITE_SAME command is not supported */
|
|
|
|
sdev->no_write_same = 1;
|
2014-05-26 05:29:15 +00:00
|
|
|
|
2014-09-25 12:32:29 +00:00
|
|
|
ufshcd_set_queue_depth(sdev);
|
2014-06-29 06:40:20 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_get_lu_power_on_wp_status(hba, sdev);
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-29 06:40:20 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_change_queue_depth - change queue depth
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
* @depth: required depth to set
|
|
|
|
*
|
2014-11-13 14:08:42 +00:00
|
|
|
* Change queue depth and make sure the max. limits are not crossed.
|
2014-06-29 06:40:20 +00:00
|
|
|
*/
|
2014-11-13 14:08:42 +00:00
|
|
|
static int ufshcd_change_queue_depth(struct scsi_device *sdev, int depth)
|
2014-06-29 06:40:20 +00:00
|
|
|
{
|
|
|
|
struct ufs_hba *hba = shost_priv(sdev->host);
|
|
|
|
|
|
|
|
if (depth > hba->nutrs)
|
|
|
|
depth = hba->nutrs;
|
2014-11-13 14:08:42 +00:00
|
|
|
return scsi_change_queue_depth(sdev, depth);
|
2014-06-29 06:40:20 +00:00
|
|
|
}
|
|
|
|
|
2014-07-01 14:00:32 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_slave_configure - adjust SCSI device configurations
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
*/
|
|
|
|
static int ufshcd_slave_configure(struct scsi_device *sdev)
|
|
|
|
{
|
2019-09-16 15:56:50 +00:00
|
|
|
struct ufs_hba *hba = shost_priv(sdev->host);
|
2014-07-01 14:00:32 +00:00
|
|
|
struct request_queue *q = sdev->request_queue;
|
|
|
|
|
|
|
|
blk_queue_update_dma_pad(q, PRDT_DATA_BYTE_COUNT_PAD - 1);
|
2019-09-16 15:56:50 +00:00
|
|
|
|
|
|
|
if (ufshcd_is_rpm_autosuspend_allowed(hba))
|
|
|
|
sdev->rpm_autosuspend = 1;
|
|
|
|
|
2020-07-06 20:04:14 +00:00
|
|
|
ufshcd_crypto_setup_rq_keyslot_manager(hba, q);
|
|
|
|
|
2014-07-01 14:00:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_slave_destroy - remove SCSI device configurations
|
|
|
|
* @sdev: pointer to SCSI device
|
|
|
|
*/
|
|
|
|
static void ufshcd_slave_destroy(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
|
|
|
|
hba = shost_priv(sdev->host);
|
2014-09-25 12:32:29 +00:00
|
|
|
/* Drop the reference as it won't be needed anymore */
|
2014-10-23 10:25:12 +00:00
|
|
|
if (ufshcd_scsi_to_upiu_lun(sdev->lun) == UFS_UPIU_UFS_DEVICE_WLUN) {
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2014-09-25 12:32:29 +00:00
|
|
|
hba->sdev_ufs_device = NULL;
|
2014-10-23 10:25:12 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_scsi_cmd_status - Update SCSI command result based on SCSI status
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: pointer to local reference block of completed command
|
2012-02-29 06:41:50 +00:00
|
|
|
* @scsi_status: SCSI command status
|
|
|
|
*
|
|
|
|
* Returns value base on SCSI command status
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
ufshcd_scsi_cmd_status(struct ufshcd_lrb *lrbp, int scsi_status)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
switch (scsi_status) {
|
|
|
|
case SAM_STAT_CHECK_CONDITION:
|
2013-08-31 16:10:19 +00:00
|
|
|
ufshcd_copy_sense_data(lrbp);
|
2018-11-26 08:10:34 +00:00
|
|
|
/* fallthrough */
|
2013-08-31 16:10:19 +00:00
|
|
|
case SAM_STAT_GOOD:
|
2012-02-29 06:41:50 +00:00
|
|
|
result |= DID_OK << 16 |
|
|
|
|
COMMAND_COMPLETE << 8 |
|
2013-08-31 16:10:19 +00:00
|
|
|
scsi_status;
|
2012-02-29 06:41:50 +00:00
|
|
|
break;
|
|
|
|
case SAM_STAT_TASK_SET_FULL:
|
2013-08-31 16:10:19 +00:00
|
|
|
case SAM_STAT_BUSY:
|
2012-02-29 06:41:50 +00:00
|
|
|
case SAM_STAT_TASK_ABORTED:
|
2013-08-31 16:10:19 +00:00
|
|
|
ufshcd_copy_sense_data(lrbp);
|
|
|
|
result |= scsi_status;
|
2012-02-29 06:41:50 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result |= DID_ERROR << 16;
|
|
|
|
break;
|
|
|
|
} /* end of switch */
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_transfer_rsp_status - Get overall status of the response
|
|
|
|
* @hba: per adapter instance
|
2018-03-01 23:07:20 +00:00
|
|
|
* @lrbp: pointer to local reference block of completed command
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
|
|
|
* Returns result of the command to notify SCSI midlayer
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
ufshcd_transfer_rsp_status(struct ufs_hba *hba, struct ufshcd_lrb *lrbp)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
int scsi_status;
|
|
|
|
int ocs;
|
|
|
|
|
|
|
|
/* overall command status of utrd */
|
|
|
|
ocs = ufshcd_get_tr_ocs(lrbp);
|
|
|
|
|
2020-05-28 01:16:53 +00:00
|
|
|
if (hba->quirks & UFSHCD_QUIRK_BROKEN_OCS_FATAL_ERROR) {
|
|
|
|
if (be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_1) &
|
|
|
|
MASK_RSP_UPIU_RESULT)
|
|
|
|
ocs = OCS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
switch (ocs) {
|
|
|
|
case OCS_SUCCESS:
|
2013-07-29 19:05:57 +00:00
|
|
|
result = ufshcd_get_req_rsp(lrbp->ucd_rsp_ptr);
|
2016-12-23 02:42:18 +00:00
|
|
|
hba->ufs_stats.last_hibern8_exit_tstamp = ktime_set(0, 0);
|
2013-07-29 19:05:57 +00:00
|
|
|
switch (result) {
|
|
|
|
case UPIU_TRANSACTION_RESPONSE:
|
|
|
|
/*
|
|
|
|
* get the response UPIU result to extract
|
|
|
|
* the SCSI command status
|
|
|
|
*/
|
|
|
|
result = ufshcd_get_rsp_upiu_result(lrbp->ucd_rsp_ptr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get the result based on SCSI status response
|
|
|
|
* to notify the SCSI midlayer of the command status
|
|
|
|
*/
|
|
|
|
scsi_status = result & MASK_SCSI_STATUS;
|
|
|
|
result = ufshcd_scsi_cmd_status(lrbp, scsi_status);
|
2013-07-29 19:05:59 +00:00
|
|
|
|
2016-02-01 13:02:42 +00:00
|
|
|
/*
|
|
|
|
* Currently we are only supporting BKOPs exception
|
|
|
|
* events hence we can ignore BKOPs exception event
|
|
|
|
* during power management callbacks. BKOPs exception
|
|
|
|
* event is not expected to be raised in runtime suspend
|
|
|
|
* callback as it allows the urgent bkops.
|
|
|
|
* During system suspend, we are anyway forcefully
|
|
|
|
* disabling the bkops and if urgent bkops is needed
|
|
|
|
* it will be enabled on system resume. Long term
|
|
|
|
* solution could be to abort the system suspend if
|
|
|
|
* UFS device needs urgent BKOPs.
|
|
|
|
*/
|
|
|
|
if (!hba->pm_op_in_progress &&
|
2020-02-11 03:40:44 +00:00
|
|
|
ufshcd_is_exception_event(lrbp->ucd_rsp_ptr) &&
|
|
|
|
schedule_work(&hba->eeh_work)) {
|
|
|
|
/*
|
|
|
|
* Prevent suspend once eeh_work is scheduled
|
|
|
|
* to avoid deadlock between ufshcd_suspend
|
|
|
|
* and exception event handler.
|
|
|
|
*/
|
|
|
|
pm_runtime_get_noresume(hba->dev);
|
|
|
|
}
|
2013-07-29 19:05:57 +00:00
|
|
|
break;
|
|
|
|
case UPIU_TRANSACTION_REJECT_UPIU:
|
|
|
|
/* TODO: handle Reject UPIU Response */
|
|
|
|
result = DID_ERROR << 16;
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2013-07-29 19:05:57 +00:00
|
|
|
"Reject UPIU not fully implemented\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"Unexpected request response code = %x\n",
|
|
|
|
result);
|
2019-04-15 12:23:38 +00:00
|
|
|
result = DID_ERROR << 16;
|
2012-02-29 06:41:50 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case OCS_ABORTED:
|
|
|
|
result |= DID_ABORT << 16;
|
|
|
|
break;
|
2014-05-26 05:29:15 +00:00
|
|
|
case OCS_INVALID_COMMAND_STATUS:
|
|
|
|
result |= DID_REQUEUE << 16;
|
|
|
|
break;
|
2012-02-29 06:41:50 +00:00
|
|
|
case OCS_INVALID_CMD_TABLE_ATTR:
|
|
|
|
case OCS_INVALID_PRDT_ATTR:
|
|
|
|
case OCS_MISMATCH_DATA_BUF_SIZE:
|
|
|
|
case OCS_MISMATCH_RESP_UPIU_SIZE:
|
|
|
|
case OCS_PEER_COMM_FAILURE:
|
|
|
|
case OCS_FATAL_ERROR:
|
2020-07-06 20:04:12 +00:00
|
|
|
case OCS_DEVICE_FATAL_ERROR:
|
|
|
|
case OCS_INVALID_CRYPTO_CONFIG:
|
|
|
|
case OCS_GENERAL_CRYPTO_ERROR:
|
2012-02-29 06:41:50 +00:00
|
|
|
default:
|
|
|
|
result |= DID_ERROR << 16;
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev,
|
2016-12-23 02:42:18 +00:00
|
|
|
"OCS error from controller = %x for tag %d\n",
|
|
|
|
ocs, lrbp->task_tag);
|
|
|
|
ufshcd_print_host_regs(hba);
|
2017-02-04 00:57:28 +00:00
|
|
|
ufshcd_print_host_state(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
break;
|
|
|
|
} /* end of switch */
|
|
|
|
|
scsi: ufs: Complete pending requests in host reset and restore path
In UFS host reset and restore path, before probe, we stop and start the
host controller once. After host controller is stopped, the pending
requests, if any, are cleared from the doorbell, but no completion IRQ
would be raised due to the hba is stopped. These pending requests shall be
completed along with the first NOP_OUT command (as it is the first command
which can raise a transfer completion IRQ) sent during probe. Since the
OCSs of these pending requests are not SUCCESS (because they are not yet
literally finished), their UPIUs shall be dumped. When there are multiple
pending requests, the UPIU dump can be overwhelming and may lead to
stability issues because it is in atomic context. Therefore, before probe,
complete these pending requests right after host controller is stopped and
silence the UPIU dump from them.
Link: https://lore.kernel.org/r/1574751214-8321-5-git-send-email-cang@qti.qualcomm.com
Reviewed-by: Alim Akhtar <alim.akhtar@samsung.com>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-11-26 06:53:33 +00:00
|
|
|
if ((host_byte(result) != DID_OK) && !hba->silence_err_logs)
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_print_trs(hba, 1 << lrbp->task_tag, true);
|
2012-02-29 06:41:50 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_uic_cmd_compl - handle completion of uic command
|
|
|
|
* @hba: per adapter instance
|
2013-08-31 16:10:22 +00:00
|
|
|
* @intr_status: interrupt status generated by the controller
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2013-06-26 17:09:29 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_uic_cmd_compl(struct ufs_hba *hba, u32 intr_status)
|
2013-06-26 17:09:29 +00:00
|
|
|
{
|
2019-11-15 06:09:28 +00:00
|
|
|
irqreturn_t retval = IRQ_NONE;
|
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
if ((intr_status & UIC_COMMAND_COMPL) && hba->active_uic_cmd) {
|
2013-06-26 17:09:29 +00:00
|
|
|
hba->active_uic_cmd->argument2 |=
|
|
|
|
ufshcd_get_uic_cmd_result(hba);
|
2013-08-31 16:10:21 +00:00
|
|
|
hba->active_uic_cmd->argument3 =
|
|
|
|
ufshcd_get_dme_attr_val(hba);
|
2013-06-26 17:09:29 +00:00
|
|
|
complete(&hba->active_uic_cmd->done);
|
2019-11-15 06:09:28 +00:00
|
|
|
retval = IRQ_HANDLED;
|
2013-06-26 17:09:29 +00:00
|
|
|
}
|
2013-08-31 16:10:22 +00:00
|
|
|
|
2019-11-15 06:09:28 +00:00
|
|
|
if ((intr_status & UFSHCD_UIC_PWR_MASK) && hba->uic_async_done) {
|
2014-09-25 12:32:30 +00:00
|
|
|
complete(hba->uic_async_done);
|
2019-11-15 06:09:28 +00:00
|
|
|
retval = IRQ_HANDLED;
|
|
|
|
}
|
2020-06-15 07:22:35 +00:00
|
|
|
|
|
|
|
if (retval == IRQ_HANDLED)
|
|
|
|
ufshcd_add_uic_command_trace(hba, hba->active_uic_cmd,
|
|
|
|
"complete");
|
2019-11-15 06:09:28 +00:00
|
|
|
return retval;
|
2013-06-26 17:09:29 +00:00
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2016-03-10 15:37:12 +00:00
|
|
|
* __ufshcd_transfer_req_compl - handle SCSI and query command completion
|
2012-02-29 06:41:50 +00:00
|
|
|
* @hba: per adapter instance
|
2016-03-10 15:37:12 +00:00
|
|
|
* @completed_reqs: requests to complete
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2016-03-10 15:37:12 +00:00
|
|
|
static void __ufshcd_transfer_req_compl(struct ufs_hba *hba,
|
|
|
|
unsigned long completed_reqs)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2013-07-29 19:05:57 +00:00
|
|
|
struct ufshcd_lrb *lrbp;
|
|
|
|
struct scsi_cmnd *cmd;
|
2012-02-29 06:41:50 +00:00
|
|
|
int result;
|
|
|
|
int index;
|
2014-07-01 09:22:37 +00:00
|
|
|
|
|
|
|
for_each_set_bit(index, &completed_reqs, hba->nutrs) {
|
|
|
|
lrbp = &hba->lrb[index];
|
2020-07-06 06:07:06 +00:00
|
|
|
lrbp->compl_time_stamp = ktime_get();
|
2014-07-01 09:22:37 +00:00
|
|
|
cmd = lrbp->cmd;
|
|
|
|
if (cmd) {
|
2016-12-23 02:42:03 +00:00
|
|
|
ufshcd_add_command_trace(hba, index, "complete");
|
2014-07-01 09:22:37 +00:00
|
|
|
result = ufshcd_transfer_rsp_status(hba, lrbp);
|
|
|
|
scsi_dma_unmap(cmd);
|
|
|
|
cmd->result = result;
|
|
|
|
/* Mark completed command as NULL in LRB */
|
|
|
|
lrbp->cmd = NULL;
|
|
|
|
/* Do not touch lrbp after scsi done */
|
|
|
|
cmd->scsi_done(cmd);
|
2014-09-25 12:32:32 +00:00
|
|
|
__ufshcd_release(hba);
|
2016-05-11 11:21:27 +00:00
|
|
|
} else if (lrbp->command_type == UTP_CMD_TYPE_DEV_MANAGE ||
|
|
|
|
lrbp->command_type == UTP_CMD_TYPE_UFS_STORAGE) {
|
2016-12-23 02:42:03 +00:00
|
|
|
if (hba->dev_cmd.complete) {
|
|
|
|
ufshcd_add_command_trace(hba, index,
|
|
|
|
"dev_complete");
|
2014-07-01 09:22:37 +00:00
|
|
|
complete(hba->dev_cmd.complete);
|
2016-12-23 02:42:03 +00:00
|
|
|
}
|
2014-07-01 09:22:37 +00:00
|
|
|
}
|
2017-02-04 00:57:39 +00:00
|
|
|
if (ufshcd_is_clkscaling_supported(hba))
|
|
|
|
hba->clk_scaling.active_reqs--;
|
2014-07-01 09:22:37 +00:00
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
/* clear corresponding bits of completed commands */
|
|
|
|
hba->outstanding_reqs ^= completed_reqs;
|
|
|
|
|
2014-09-25 12:32:34 +00:00
|
|
|
ufshcd_clk_scaling_update_busy(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:12 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_transfer_req_compl - handle SCSI and query command completion
|
|
|
|
* @hba: per adapter instance
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2016-03-10 15:37:12 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_transfer_req_compl(struct ufs_hba *hba)
|
2016-03-10 15:37:12 +00:00
|
|
|
{
|
|
|
|
unsigned long completed_reqs;
|
|
|
|
u32 tr_doorbell;
|
|
|
|
|
|
|
|
/* Resetting interrupt aggregation counters first and reading the
|
|
|
|
* DOOR_BELL afterward allows us to handle all the completed requests.
|
|
|
|
* In order to prevent other interrupts starvation the DB is read once
|
|
|
|
* after reset. The down side of this solution is the possibility of
|
|
|
|
* false interrupt if device completes another request after resetting
|
|
|
|
* aggregation and before reading the DB.
|
|
|
|
*/
|
2020-05-28 01:16:50 +00:00
|
|
|
if (ufshcd_is_intr_aggr_allowed(hba) &&
|
|
|
|
!(hba->quirks & UFSHCI_QUIRK_SKIP_RESET_INTR_AGGR))
|
2016-03-10 15:37:12 +00:00
|
|
|
ufshcd_reset_intr_aggr(hba);
|
|
|
|
|
|
|
|
tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
|
|
|
|
completed_reqs = tr_doorbell ^ hba->outstanding_reqs;
|
|
|
|
|
2019-11-15 06:09:28 +00:00
|
|
|
if (completed_reqs) {
|
|
|
|
__ufshcd_transfer_req_compl(hba, completed_reqs);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
} else {
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
2016-03-10 15:37:12 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_disable_ee - disable exception event
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @mask: exception event to disable
|
|
|
|
*
|
|
|
|
* Disables exception event in the device so that the EVENT_ALERT
|
|
|
|
* bit is not set.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero error value on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_disable_ee(struct ufs_hba *hba, u16 mask)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
if (!(hba->ee_ctrl_mask & mask))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
val = hba->ee_ctrl_mask & ~mask;
|
2017-04-20 12:01:44 +00:00
|
|
|
val &= MASK_EE_STATUS;
|
2016-02-01 13:02:50 +00:00
|
|
|
err = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
|
2013-07-29 19:05:59 +00:00
|
|
|
QUERY_ATTR_IDN_EE_CONTROL, 0, 0, &val);
|
|
|
|
if (!err)
|
|
|
|
hba->ee_ctrl_mask &= ~mask;
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_enable_ee - enable exception event
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @mask: exception event to enable
|
|
|
|
*
|
|
|
|
* Enable corresponding exception event in the device to allow
|
|
|
|
* device to alert host in critical scenarios.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero error value on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_enable_ee(struct ufs_hba *hba, u16 mask)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
if (hba->ee_ctrl_mask & mask)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
val = hba->ee_ctrl_mask | mask;
|
2017-04-20 12:01:44 +00:00
|
|
|
val &= MASK_EE_STATUS;
|
2016-02-01 13:02:50 +00:00
|
|
|
err = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
|
2013-07-29 19:05:59 +00:00
|
|
|
QUERY_ATTR_IDN_EE_CONTROL, 0, 0, &val);
|
|
|
|
if (!err)
|
|
|
|
hba->ee_ctrl_mask |= mask;
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_enable_auto_bkops - Allow device managed BKOPS
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Allow device to manage background operations on its own. Enabling
|
|
|
|
* this might lead to inconsistent latencies during normal data transfers
|
|
|
|
* as the device is allowed to manage its own way of handling background
|
|
|
|
* operations.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_enable_auto_bkops(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (hba->auto_bkops_enabled)
|
|
|
|
goto out;
|
|
|
|
|
2016-02-01 13:02:46 +00:00
|
|
|
err = ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_SET_FLAG,
|
2020-05-08 08:01:12 +00:00
|
|
|
QUERY_FLAG_IDN_BKOPS_EN, 0, NULL);
|
2013-07-29 19:05:59 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to enable bkops %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->auto_bkops_enabled = true;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_auto_bkops_state(dev_name(hba->dev), "Enabled");
|
2013-07-29 19:05:59 +00:00
|
|
|
|
|
|
|
/* No need of URGENT_BKOPS exception from the device */
|
|
|
|
err = ufshcd_disable_ee(hba, MASK_EE_URGENT_BKOPS);
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: failed to disable exception event %d\n",
|
|
|
|
__func__, err);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_disable_auto_bkops - block device in doing background operations
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Disabling background operations improves command response latency but
|
|
|
|
* has drawback of device moving into critical state where the device is
|
|
|
|
* not-operable. Make sure to call ufshcd_enable_auto_bkops() whenever the
|
|
|
|
* host is idle so that BKOPS are managed effectively without any negative
|
|
|
|
* impacts.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_disable_auto_bkops(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!hba->auto_bkops_enabled)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If host assisted BKOPs is to be enabled, make sure
|
|
|
|
* urgent bkops exception is allowed.
|
|
|
|
*/
|
|
|
|
err = ufshcd_enable_ee(hba, MASK_EE_URGENT_BKOPS);
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to enable exception event %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-02-01 13:02:46 +00:00
|
|
|
err = ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_CLEAR_FLAG,
|
2020-05-08 08:01:12 +00:00
|
|
|
QUERY_FLAG_IDN_BKOPS_EN, 0, NULL);
|
2013-07-29 19:05:59 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to disable bkops %d\n",
|
|
|
|
__func__, err);
|
|
|
|
ufshcd_disable_ee(hba, MASK_EE_URGENT_BKOPS);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->auto_bkops_enabled = false;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_auto_bkops_state(dev_name(hba->dev), "Disabled");
|
2019-11-26 06:53:30 +00:00
|
|
|
hba->is_urgent_bkops_lvl_checked = false;
|
2013-07-29 19:05:59 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-12-23 02:41:22 +00:00
|
|
|
* ufshcd_force_reset_auto_bkops - force reset auto bkops state
|
2013-07-29 19:05:59 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* After a device reset the device may toggle the BKOPS_EN flag
|
|
|
|
* to default value. The s/w tracking variables should be updated
|
2016-12-23 02:41:22 +00:00
|
|
|
* as well. This function would change the auto-bkops state based on
|
|
|
|
* UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND.
|
2013-07-29 19:05:59 +00:00
|
|
|
*/
|
2016-12-23 02:41:22 +00:00
|
|
|
static void ufshcd_force_reset_auto_bkops(struct ufs_hba *hba)
|
2013-07-29 19:05:59 +00:00
|
|
|
{
|
2016-12-23 02:41:22 +00:00
|
|
|
if (ufshcd_keep_autobkops_enabled_except_suspend(hba)) {
|
|
|
|
hba->auto_bkops_enabled = false;
|
|
|
|
hba->ee_ctrl_mask |= MASK_EE_URGENT_BKOPS;
|
|
|
|
ufshcd_enable_auto_bkops(hba);
|
|
|
|
} else {
|
|
|
|
hba->auto_bkops_enabled = true;
|
|
|
|
hba->ee_ctrl_mask &= ~MASK_EE_URGENT_BKOPS;
|
|
|
|
ufshcd_disable_auto_bkops(hba);
|
|
|
|
}
|
2020-05-30 14:12:00 +00:00
|
|
|
hba->urgent_bkops_lvl = BKOPS_STATUS_PERF_IMPACT;
|
2019-11-26 06:53:30 +00:00
|
|
|
hba->is_urgent_bkops_lvl_checked = false;
|
2013-07-29 19:05:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_get_bkops_status(struct ufs_hba *hba, u32 *status)
|
|
|
|
{
|
2016-02-01 13:02:50 +00:00
|
|
|
return ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
2013-07-29 19:05:59 +00:00
|
|
|
QUERY_ATTR_IDN_BKOPS_STATUS, 0, 0, status);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-09-25 12:32:30 +00:00
|
|
|
* ufshcd_bkops_ctrl - control the auto bkops based on current bkops status
|
2013-07-29 19:05:59 +00:00
|
|
|
* @hba: per-adapter instance
|
2014-09-25 12:32:30 +00:00
|
|
|
* @status: bkops_status value
|
2013-07-29 19:05:59 +00:00
|
|
|
*
|
2014-09-25 12:32:30 +00:00
|
|
|
* Read the bkops_status from the UFS device and Enable fBackgroundOpsEn
|
|
|
|
* flag in the device to permit background operations if the device
|
|
|
|
* bkops_status is greater than or equal to "status" argument passed to
|
|
|
|
* this function, disable otherwise.
|
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero in case of failure.
|
|
|
|
*
|
|
|
|
* NOTE: Caller of this function can check the "hba->auto_bkops_enabled" flag
|
|
|
|
* to know whether auto bkops is enabled or disabled after this function
|
|
|
|
* returns control to it.
|
2013-07-29 19:05:59 +00:00
|
|
|
*/
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_bkops_ctrl(struct ufs_hba *hba,
|
|
|
|
enum bkops_status status)
|
2013-07-29 19:05:59 +00:00
|
|
|
{
|
|
|
|
int err;
|
2014-09-25 12:32:30 +00:00
|
|
|
u32 curr_status = 0;
|
2013-07-29 19:05:59 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
err = ufshcd_get_bkops_status(hba, &curr_status);
|
2013-07-29 19:05:59 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to get BKOPS status %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
2014-09-25 12:32:30 +00:00
|
|
|
} else if (curr_status > BKOPS_STATUS_MAX) {
|
|
|
|
dev_err(hba->dev, "%s: invalid BKOPS status %d\n",
|
|
|
|
__func__, curr_status);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
2013-07-29 19:05:59 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if (curr_status >= status)
|
2013-07-29 19:05:59 +00:00
|
|
|
err = ufshcd_enable_auto_bkops(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
else
|
|
|
|
err = ufshcd_disable_auto_bkops(hba);
|
2013-07-29 19:05:59 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_urgent_bkops - handle urgent bkops exception event
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Enable fBackgroundOpsEn flag in the device to permit background
|
|
|
|
* operations.
|
|
|
|
*
|
|
|
|
* If BKOPs is enabled, this function returns 0, 1 if the bkops in not enabled
|
|
|
|
* and negative error value for any other failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_urgent_bkops(struct ufs_hba *hba)
|
|
|
|
{
|
2016-03-10 15:37:15 +00:00
|
|
|
return ufshcd_bkops_ctrl(hba, hba->urgent_bkops_lvl);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
static inline int ufshcd_get_ee_status(struct ufs_hba *hba, u32 *status)
|
|
|
|
{
|
2016-02-01 13:02:50 +00:00
|
|
|
return ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
2013-07-29 19:05:59 +00:00
|
|
|
QUERY_ATTR_IDN_EE_STATUS, 0, 0, status);
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:15 +00:00
|
|
|
static void ufshcd_bkops_exception_event_handler(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u32 curr_status = 0;
|
|
|
|
|
|
|
|
if (hba->is_urgent_bkops_lvl_checked)
|
|
|
|
goto enable_auto_bkops;
|
|
|
|
|
|
|
|
err = ufshcd_get_bkops_status(hba, &curr_status);
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to get BKOPS status %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are seeing that some devices are raising the urgent bkops
|
|
|
|
* exception events even when BKOPS status doesn't indicate performace
|
|
|
|
* impacted or critical. Handle these device by determining their urgent
|
|
|
|
* bkops status at runtime.
|
|
|
|
*/
|
|
|
|
if (curr_status < BKOPS_STATUS_PERF_IMPACT) {
|
|
|
|
dev_err(hba->dev, "%s: device raised urgent BKOPS exception for bkops status %d\n",
|
|
|
|
__func__, curr_status);
|
|
|
|
/* update the current status as the urgent bkops level */
|
|
|
|
hba->urgent_bkops_lvl = curr_status;
|
|
|
|
hba->is_urgent_bkops_lvl_checked = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
enable_auto_bkops:
|
|
|
|
err = ufshcd_enable_auto_bkops(hba);
|
|
|
|
out:
|
|
|
|
if (err < 0)
|
|
|
|
dev_err(hba->dev, "%s: failed to handle urgent bkops %d\n",
|
|
|
|
__func__, err);
|
|
|
|
}
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
static int ufshcd_wb_ctrl(struct ufs_hba *hba, bool enable)
|
|
|
|
{
|
|
|
|
int ret;
|
2020-05-08 08:01:13 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
enum query_opcode opcode;
|
|
|
|
|
2020-05-08 08:01:15 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba))
|
2020-04-22 21:41:42 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!(enable ^ hba->wb_enabled))
|
|
|
|
return 0;
|
|
|
|
if (enable)
|
|
|
|
opcode = UPIU_QUERY_OPCODE_SET_FLAG;
|
|
|
|
else
|
|
|
|
opcode = UPIU_QUERY_OPCODE_CLEAR_FLAG;
|
|
|
|
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
ret = ufshcd_query_flag_retry(hba, opcode,
|
2020-05-08 08:01:13 +00:00
|
|
|
QUERY_FLAG_IDN_WB_EN, index, NULL);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s write booster %s failed %d\n",
|
|
|
|
__func__, enable ? "enable" : "disable", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->wb_enabled = enable;
|
|
|
|
dev_dbg(hba->dev, "%s write booster %s %d\n",
|
|
|
|
__func__, enable ? "enable" : "disable", ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_wb_toggle_flush_during_h8(struct ufs_hba *hba, bool set)
|
|
|
|
{
|
|
|
|
int val;
|
2020-05-08 08:01:13 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
|
|
|
|
if (set)
|
|
|
|
val = UPIU_QUERY_OPCODE_SET_FLAG;
|
|
|
|
else
|
|
|
|
val = UPIU_QUERY_OPCODE_CLEAR_FLAG;
|
|
|
|
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
return ufshcd_query_flag_retry(hba, val,
|
2020-05-08 08:01:13 +00:00
|
|
|
QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8,
|
|
|
|
index, NULL);
|
2020-04-22 21:41:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ufshcd_wb_toggle_flush(struct ufs_hba *hba, bool enable)
|
|
|
|
{
|
|
|
|
if (enable)
|
|
|
|
ufshcd_wb_buf_flush_enable(hba);
|
|
|
|
else
|
|
|
|
ufshcd_wb_buf_flush_disable(hba);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_wb_buf_flush_enable(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret;
|
2020-05-08 08:01:13 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2020-05-08 08:01:15 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba) || hba->wb_buf_flush_enabled)
|
2020-04-22 21:41:42 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
ret = ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_SET_FLAG,
|
2020-05-08 08:01:12 +00:00
|
|
|
QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN,
|
2020-05-08 08:01:13 +00:00
|
|
|
index, NULL);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev, "%s WB - buf flush enable failed %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
else
|
|
|
|
hba->wb_buf_flush_enabled = true;
|
|
|
|
|
|
|
|
dev_dbg(hba->dev, "WB - Flush enabled: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_wb_buf_flush_disable(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret;
|
2020-05-08 08:01:13 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2020-05-08 08:01:15 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba) || !hba->wb_buf_flush_enabled)
|
2020-04-22 21:41:42 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
ret = ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_CLEAR_FLAG,
|
2020-05-08 08:01:13 +00:00
|
|
|
QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN,
|
|
|
|
index, NULL);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_warn(hba->dev, "%s: WB - buf flush disable failed %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
} else {
|
|
|
|
hba->wb_buf_flush_enabled = false;
|
|
|
|
dev_dbg(hba->dev, "WB - Flush disabled: %d\n", ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ufshcd_wb_presrv_usrspc_keep_vcc_on(struct ufs_hba *hba,
|
|
|
|
u32 avail_buf)
|
|
|
|
{
|
|
|
|
u32 cur_buf;
|
|
|
|
int ret;
|
2020-05-22 08:32:11 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
|
|
|
QUERY_ATTR_IDN_CURR_WB_BUFF_SIZE,
|
2020-05-22 08:32:11 +00:00
|
|
|
index, 0, &cur_buf);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s dCurWriteBoosterBufferSize read failed %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cur_buf) {
|
|
|
|
dev_info(hba->dev, "dCurWBBuf: %d WB disabled until free-space is available\n",
|
|
|
|
cur_buf);
|
|
|
|
return false;
|
|
|
|
}
|
2020-05-09 09:37:15 +00:00
|
|
|
/* Let it continue to flush when available buffer exceeds threshold */
|
|
|
|
if (avail_buf < hba->vps->wb_flush_threshold)
|
2020-04-22 21:41:42 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
static bool ufshcd_wb_need_flush(struct ufs_hba *hba)
|
2020-04-22 21:41:42 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 avail_buf;
|
2020-05-22 08:32:11 +00:00
|
|
|
u8 index;
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2020-05-08 08:01:15 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba))
|
2020-04-22 21:41:42 +00:00
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* The ufs device needs the vcc to be ON to flush.
|
|
|
|
* With user-space reduction enabled, it's enough to enable flush
|
|
|
|
* by checking only the available buffer. The threshold
|
|
|
|
* defined here is > 90% full.
|
|
|
|
* With user-space preserved enabled, the current-buffer
|
|
|
|
* should be checked too because the wb buffer size can reduce
|
|
|
|
* when disk tends to be full. This info is provided by current
|
|
|
|
* buffer (dCurrentWriteBoosterBufferSize). There's no point in
|
|
|
|
* keeping vcc on when current buffer is empty.
|
|
|
|
*/
|
2020-05-22 08:32:11 +00:00
|
|
|
index = ufshcd_wb_get_query_index(hba);
|
2020-04-22 21:41:42 +00:00
|
|
|
ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
|
|
|
QUERY_ATTR_IDN_AVAIL_WB_BUFF_SIZE,
|
2020-05-22 08:32:11 +00:00
|
|
|
index, 0, &avail_buf);
|
2020-04-22 21:41:42 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_warn(hba->dev, "%s dAvailableWriteBoosterBufferSize read failed %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!hba->dev_info.b_presrv_uspc_en) {
|
2020-05-09 09:37:15 +00:00
|
|
|
if (avail_buf <= UFS_WB_BUF_REMAIN_PERCENT(10))
|
2020-04-22 21:41:42 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ufshcd_wb_presrv_usrspc_keep_vcc_on(hba, avail_buf);
|
|
|
|
}
|
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
static void ufshcd_rpm_dev_flush_recheck_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ufs_hba *hba = container_of(to_delayed_work(work),
|
|
|
|
struct ufs_hba,
|
|
|
|
rpm_dev_flush_recheck_work);
|
|
|
|
/*
|
|
|
|
* To prevent unnecessary VCC power drain after device finishes
|
|
|
|
* WriteBooster buffer flush or Auto BKOPs, force runtime resume
|
|
|
|
* after a certain delay to recheck the threshold by next runtime
|
|
|
|
* suspend.
|
|
|
|
*/
|
|
|
|
pm_runtime_get_sync(hba->dev);
|
|
|
|
pm_runtime_put_sync(hba->dev);
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_exception_event_handler - handle exceptions raised by device
|
|
|
|
* @work: pointer to work data
|
|
|
|
*
|
|
|
|
* Read bExceptionEventStatus attribute from the device and handle the
|
|
|
|
* exception event accordingly.
|
|
|
|
*/
|
|
|
|
static void ufshcd_exception_event_handler(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
int err;
|
|
|
|
u32 status = 0;
|
|
|
|
hba = container_of(work, struct ufs_hba, eeh_work);
|
|
|
|
|
2013-07-29 19:06:00 +00:00
|
|
|
pm_runtime_get_sync(hba->dev);
|
2019-12-24 13:01:05 +00:00
|
|
|
ufshcd_scsi_block_requests(hba);
|
2013-07-29 19:05:59 +00:00
|
|
|
err = ufshcd_get_ee_status(hba, &status);
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: failed to get exception status %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
status &= hba->ee_ctrl_mask;
|
2016-03-10 15:37:15 +00:00
|
|
|
|
|
|
|
if (status & MASK_EE_URGENT_BKOPS)
|
|
|
|
ufshcd_bkops_exception_event_handler(hba);
|
|
|
|
|
2013-07-29 19:05:59 +00:00
|
|
|
out:
|
2019-12-24 13:01:05 +00:00
|
|
|
ufshcd_scsi_unblock_requests(hba);
|
2020-02-11 03:40:44 +00:00
|
|
|
/*
|
|
|
|
* pm_runtime_get_noresume is called while scheduling
|
|
|
|
* eeh_work to avoid suspend racing with exception work.
|
|
|
|
* Hence decrement usage counter using pm_runtime_put_noidle
|
|
|
|
* to allow suspend on completion of exception event handler.
|
|
|
|
*/
|
|
|
|
pm_runtime_put_noidle(hba->dev);
|
|
|
|
pm_runtime_put(hba->dev);
|
2013-07-29 19:05:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:12 +00:00
|
|
|
/* Complete requests that have door-bell cleared */
|
|
|
|
static void ufshcd_complete_requests(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
ufshcd_transfer_req_compl(hba);
|
|
|
|
ufshcd_tmc_handler(hba);
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:13 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_quirk_dl_nac_errors - This function checks if error handling is
|
|
|
|
* to recover from the DL NAC errors or not.
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Returns true if error handling is required, false otherwise
|
|
|
|
*/
|
|
|
|
static bool ufshcd_quirk_dl_nac_errors(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
bool err_handling = true;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
/*
|
|
|
|
* UFS_DEVICE_QUIRK_RECOVERY_FROM_DL_NAC_ERRORS only workaround the
|
|
|
|
* device fatal error and/or DL NAC & REPLAY timeout errors.
|
|
|
|
*/
|
|
|
|
if (hba->saved_err & (CONTROLLER_FATAL_ERROR | SYSTEM_BUS_FATAL_ERROR))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((hba->saved_err & DEVICE_FATAL_ERROR) ||
|
|
|
|
((hba->saved_err & UIC_ERROR) &&
|
|
|
|
(hba->saved_uic_err & UFSHCD_UIC_DL_TCx_REPLAY_ERROR)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((hba->saved_err & UIC_ERROR) &&
|
|
|
|
(hba->saved_uic_err & UFSHCD_UIC_DL_NAC_RECEIVED_ERROR)) {
|
|
|
|
int err;
|
|
|
|
/*
|
|
|
|
* wait for 50ms to see if we can get any other errors or not.
|
|
|
|
*/
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
msleep(50);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* now check if we have got any other severe errors other than
|
|
|
|
* DL NAC error?
|
|
|
|
*/
|
|
|
|
if ((hba->saved_err & INT_FATAL_ERRORS) ||
|
|
|
|
((hba->saved_err & UIC_ERROR) &&
|
|
|
|
(hba->saved_uic_err & ~UFSHCD_UIC_DL_NAC_RECEIVED_ERROR)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* As DL NAC is the only error received so far, send out NOP
|
|
|
|
* command to confirm if link is still active or not.
|
|
|
|
* - If we don't get any response then do error recovery.
|
|
|
|
* - If we get response then clear the DL NAC error bit.
|
|
|
|
*/
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
err = ufshcd_verify_dev_init(hba);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Link seems to be alive hence ignore the DL NAC errors */
|
|
|
|
if (hba->saved_uic_err == UFSHCD_UIC_DL_NAC_RECEIVED_ERROR)
|
|
|
|
hba->saved_err &= ~UIC_ERROR;
|
|
|
|
/* clear NAC error */
|
|
|
|
hba->saved_uic_err &= ~UFSHCD_UIC_DL_NAC_RECEIVED_ERROR;
|
2020-08-14 09:50:34 +00:00
|
|
|
if (!hba->saved_uic_err)
|
2016-03-10 15:37:13 +00:00
|
|
|
err_handling = false;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
return err_handling;
|
|
|
|
}
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
/* host lock must be held before calling this func */
|
|
|
|
static inline bool ufshcd_is_saved_err_fatal(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return (hba->saved_uic_err & UFSHCD_UIC_DL_PA_INIT_ERROR) ||
|
|
|
|
(hba->saved_err & (INT_FATAL_ERRORS | UFSHCD_UIC_HIBERN8_MASK));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* host lock must be held before calling this func */
|
|
|
|
static inline void ufshcd_schedule_eh_work(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
/* handle fatal errors only when link is not in error state */
|
|
|
|
if (hba->ufshcd_state != UFSHCD_STATE_ERROR) {
|
scsi: ufs: Fix a race condition between error handler and runtime PM ops
The current IRQ handler blocks SCSI requests before scheduling eh_work,
when error handler calls pm_runtime_get_sync, if ufshcd_suspend/resume
sends a SCSI cmd, most likely the SSU cmd, since SCSI requests are blocked,
pm_runtime_get_sync() will never return because ufshcd_suspend/resume is
blocked by the SCSI cmd.
- In queuecommand path, hba->ufshcd_state check and ufshcd_send_command
should stay under the same spin lock. This is to make sure that no more
commands leak into doorbell after hba->ufshcd_state is changed.
- Don't block SCSI requests before error handler starts to run, let error
handler block SCSI requests when it is ready to start error recovery.
- Don't let SCSI layer keep requeuing the SCSI cmds sent from HBA runtime
PM ops, let them pass or fail them. Let them pass if eh_work is
scheduled due to non-fatal errors. Fail them if eh_work is scheduled due
to fatal errors, otherwise the cmds may eventually time out since UFS is
in bad state, which gets error handler blocked for too long. If we fail
the SCSI cmds sent from HBA runtime PM ops, HBA runtime PM ops fails
too, but it does not hurt since error handler can recover HBA runtime PM
error.
Link: https://lore.kernel.org/r/1596975355-39813-9-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:54 +00:00
|
|
|
if (hba->force_reset || ufshcd_is_link_broken(hba) ||
|
|
|
|
ufshcd_is_saved_err_fatal(hba))
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_EH_SCHEDULED_FATAL;
|
|
|
|
else
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_EH_SCHEDULED_NON_FATAL;
|
|
|
|
queue_work(hba->eh_wq, &hba->eh_work);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
static void ufshcd_err_handling_prepare(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
pm_runtime_get_sync(hba->dev);
|
|
|
|
if (pm_runtime_suspended(hba->dev)) {
|
|
|
|
/*
|
|
|
|
* Don't assume anything of pm_runtime_get_sync(), if
|
|
|
|
* resume fails, irq and clocks can be OFF, and powers
|
|
|
|
* can be OFF or in LPM.
|
|
|
|
*/
|
|
|
|
ufshcd_setup_hba_vreg(hba, true);
|
|
|
|
ufshcd_enable_irq(hba);
|
|
|
|
ufshcd_setup_vreg(hba, true);
|
|
|
|
ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq);
|
|
|
|
ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq2);
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
if (!ufshcd_is_clkgating_allowed(hba))
|
|
|
|
ufshcd_setup_clocks(hba, true);
|
|
|
|
ufshcd_release(hba);
|
|
|
|
ufshcd_vops_resume(hba, UFS_RUNTIME_PM);
|
|
|
|
} else {
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
if (hba->clk_scaling.is_allowed) {
|
|
|
|
cancel_work_sync(&hba->clk_scaling.suspend_work);
|
|
|
|
cancel_work_sync(&hba->clk_scaling.resume_work);
|
|
|
|
ufshcd_suspend_clkscaling(hba);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_err_handling_unprepare(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
ufshcd_release(hba);
|
|
|
|
if (hba->clk_scaling.is_allowed)
|
|
|
|
ufshcd_resume_clkscaling(hba);
|
|
|
|
pm_runtime_put(hba->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool ufshcd_err_handling_should_stop(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return (hba->ufshcd_state == UFSHCD_STATE_ERROR ||
|
|
|
|
(!(hba->saved_err || hba->saved_uic_err || hba->force_reset ||
|
|
|
|
ufshcd_is_link_broken(hba))));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static void ufshcd_recover_pm_error(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = hba->host;
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct request_queue *q;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set RPM status of hba device to RPM_ACTIVE,
|
|
|
|
* this also clears its runtime error.
|
|
|
|
*/
|
|
|
|
ret = pm_runtime_set_active(hba->dev);
|
|
|
|
/*
|
|
|
|
* If hba device had runtime error, we also need to resume those
|
|
|
|
* scsi devices under hba in case any of them has failed to be
|
|
|
|
* resumed due to hba runtime resume failure. This is to unblock
|
|
|
|
* blk_queue_enter in case there are bios waiting inside it.
|
|
|
|
*/
|
|
|
|
if (!ret) {
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
q = sdev->request_queue;
|
|
|
|
if (q->dev && (q->rpm_status == RPM_SUSPENDED ||
|
|
|
|
q->rpm_status == RPM_SUSPENDING))
|
|
|
|
pm_request_resume(q->dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void ufshcd_recover_pm_error(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2014-05-26 05:29:15 +00:00
|
|
|
* ufshcd_err_handler - handle UFS errors that require s/w attention
|
|
|
|
* @work: pointer to work structure
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2014-05-26 05:29:15 +00:00
|
|
|
static void ufshcd_err_handler(struct work_struct *work)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
struct ufs_hba *hba;
|
2014-05-26 05:29:15 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u32 err_xfer = 0;
|
|
|
|
u32 err_tm = 0;
|
|
|
|
int err = 0;
|
|
|
|
int tag;
|
2016-03-10 15:37:12 +00:00
|
|
|
bool needs_reset = false;
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
hba = container_of(work, struct ufs_hba, eh_work);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
if (ufshcd_err_handling_should_stop(hba)) {
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (hba->ufshcd_state != UFSHCD_STATE_ERROR)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ufshcd_set_eh_in_progress(hba);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
ufshcd_err_handling_prepare(hba);
|
2014-05-26 05:29:15 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Fix a race condition between error handler and runtime PM ops
The current IRQ handler blocks SCSI requests before scheduling eh_work,
when error handler calls pm_runtime_get_sync, if ufshcd_suspend/resume
sends a SCSI cmd, most likely the SSU cmd, since SCSI requests are blocked,
pm_runtime_get_sync() will never return because ufshcd_suspend/resume is
blocked by the SCSI cmd.
- In queuecommand path, hba->ufshcd_state check and ufshcd_send_command
should stay under the same spin lock. This is to make sure that no more
commands leak into doorbell after hba->ufshcd_state is changed.
- Don't block SCSI requests before error handler starts to run, let error
handler block SCSI requests when it is ready to start error recovery.
- Don't let SCSI layer keep requeuing the SCSI cmds sent from HBA runtime
PM ops, let them pass or fail them. Let them pass if eh_work is
scheduled due to non-fatal errors. Fail them if eh_work is scheduled due
to fatal errors, otherwise the cmds may eventually time out since UFS is
in bad state, which gets error handler blocked for too long. If we fail
the SCSI cmds sent from HBA runtime PM ops, HBA runtime PM ops fails
too, but it does not hurt since error handler can recover HBA runtime PM
error.
Link: https://lore.kernel.org/r/1596975355-39813-9-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:54 +00:00
|
|
|
ufshcd_scsi_block_requests(hba);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
/*
|
|
|
|
* A full reset and restore might have happened after preparation
|
|
|
|
* is finished, double check whether we should stop.
|
|
|
|
*/
|
|
|
|
if (ufshcd_err_handling_should_stop(hba)) {
|
|
|
|
if (hba->ufshcd_state != UFSHCD_STATE_ERROR)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
hba->ufshcd_state = UFSHCD_STATE_RESET;
|
|
|
|
|
|
|
|
/* Complete requests that have door-bell cleared by h/w */
|
2016-03-10 15:37:12 +00:00
|
|
|
ufshcd_complete_requests(hba);
|
2016-03-10 15:37:13 +00:00
|
|
|
|
|
|
|
if (hba->dev_quirks & UFS_DEVICE_QUIRK_RECOVERY_FROM_DL_NAC_ERRORS) {
|
|
|
|
bool ret;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
/* release the lock as ufshcd_quirk_dl_nac_errors() may sleep */
|
|
|
|
ret = ufshcd_quirk_dl_nac_errors(hba);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (!ret && !hba->force_reset && ufshcd_is_link_active(hba))
|
2016-03-10 15:37:13 +00:00
|
|
|
goto skip_err_handling;
|
|
|
|
}
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
|
|
|
|
if (hba->force_reset || ufshcd_is_link_broken(hba) ||
|
|
|
|
ufshcd_is_saved_err_fatal(hba) ||
|
2016-03-10 15:37:12 +00:00
|
|
|
((hba->saved_err & UIC_ERROR) &&
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
(hba->saved_uic_err & (UFSHCD_UIC_DL_NAC_RECEIVED_ERROR |
|
|
|
|
UFSHCD_UIC_DL_TCx_REPLAY_ERROR))))
|
2016-03-10 15:37:12 +00:00
|
|
|
needs_reset = true;
|
2014-05-26 05:29:15 +00:00
|
|
|
|
2020-08-09 12:15:53 +00:00
|
|
|
if (hba->saved_err & (INT_FATAL_ERRORS | UIC_ERROR |
|
|
|
|
UFSHCD_UIC_HIBERN8_MASK)) {
|
|
|
|
bool pr_prdt = !!(hba->saved_err & SYSTEM_BUS_FATAL_ERROR);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
ufshcd_print_host_state(hba);
|
|
|
|
ufshcd_print_pwr_info(hba);
|
|
|
|
ufshcd_print_host_regs(hba);
|
|
|
|
ufshcd_print_tmrs(hba, hba->outstanding_tasks);
|
|
|
|
ufshcd_print_trs(hba, hba->outstanding_reqs, pr_prdt);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:12 +00:00
|
|
|
/*
|
|
|
|
* if host reset is required then skip clearing the pending
|
scsi: ufs: Complete pending requests in host reset and restore path
In UFS host reset and restore path, before probe, we stop and start the
host controller once. After host controller is stopped, the pending
requests, if any, are cleared from the doorbell, but no completion IRQ
would be raised due to the hba is stopped. These pending requests shall be
completed along with the first NOP_OUT command (as it is the first command
which can raise a transfer completion IRQ) sent during probe. Since the
OCSs of these pending requests are not SUCCESS (because they are not yet
literally finished), their UPIUs shall be dumped. When there are multiple
pending requests, the UPIU dump can be overwhelming and may lead to
stability issues because it is in atomic context. Therefore, before probe,
complete these pending requests right after host controller is stopped and
silence the UPIU dump from them.
Link: https://lore.kernel.org/r/1574751214-8321-5-git-send-email-cang@qti.qualcomm.com
Reviewed-by: Alim Akhtar <alim.akhtar@samsung.com>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-11-26 06:53:33 +00:00
|
|
|
* transfers forcefully because they will get cleared during
|
|
|
|
* host reset and restore
|
2016-03-10 15:37:12 +00:00
|
|
|
*/
|
|
|
|
if (needs_reset)
|
|
|
|
goto skip_pending_xfer_clear;
|
|
|
|
|
|
|
|
/* release lock as clear command might sleep */
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2014-05-26 05:29:15 +00:00
|
|
|
/* Clear pending transfer requests */
|
2016-03-10 15:37:12 +00:00
|
|
|
for_each_set_bit(tag, &hba->outstanding_reqs, hba->nutrs) {
|
|
|
|
if (ufshcd_clear_cmd(hba, tag)) {
|
|
|
|
err_xfer = true;
|
|
|
|
goto lock_skip_pending_xfer_clear;
|
|
|
|
}
|
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
/* Clear pending task management requests */
|
2016-03-10 15:37:12 +00:00
|
|
|
for_each_set_bit(tag, &hba->outstanding_tasks, hba->nutmrs) {
|
|
|
|
if (ufshcd_clear_tm_cmd(hba, tag)) {
|
|
|
|
err_tm = true;
|
|
|
|
goto lock_skip_pending_xfer_clear;
|
|
|
|
}
|
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
2016-03-10 15:37:12 +00:00
|
|
|
lock_skip_pending_xfer_clear:
|
2014-05-26 05:29:15 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
|
2016-03-10 15:37:12 +00:00
|
|
|
/* Complete the requests that are cleared by s/w */
|
|
|
|
ufshcd_complete_requests(hba);
|
|
|
|
|
|
|
|
if (err_xfer || err_tm)
|
|
|
|
needs_reset = true;
|
|
|
|
|
|
|
|
skip_pending_xfer_clear:
|
2014-05-26 05:29:15 +00:00
|
|
|
/* Fatal errors need reset */
|
2016-03-10 15:37:12 +00:00
|
|
|
if (needs_reset) {
|
|
|
|
unsigned long max_doorbells = (1UL << hba->nutrs) - 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ufshcd_reset_and_restore() does the link reinitialization
|
|
|
|
* which will need atleast one empty doorbell slot to send the
|
|
|
|
* device management commands (NOP and query commands).
|
|
|
|
* If there is no slot empty at this moment then free up last
|
|
|
|
* slot forcefully.
|
|
|
|
*/
|
|
|
|
if (hba->outstanding_reqs == max_doorbells)
|
|
|
|
__ufshcd_transfer_req_compl(hba,
|
|
|
|
(1UL << (hba->nutrs - 1)));
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
hba->force_reset = false;
|
2016-03-10 15:37:12 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2014-05-26 05:29:15 +00:00
|
|
|
err = ufshcd_reset_and_restore(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: reset and restore failed with err %d\n",
|
|
|
|
__func__, err);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
else
|
|
|
|
ufshcd_recover_pm_error(hba);
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2014-05-26 05:29:15 +00:00
|
|
|
}
|
2016-03-10 15:37:12 +00:00
|
|
|
|
2016-03-10 15:37:13 +00:00
|
|
|
skip_err_handling:
|
2016-03-10 15:37:12 +00:00
|
|
|
if (!needs_reset) {
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (hba->ufshcd_state == UFSHCD_STATE_RESET)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
|
2016-03-10 15:37:12 +00:00
|
|
|
if (hba->saved_err || hba->saved_uic_err)
|
|
|
|
dev_err_ratelimited(hba->dev, "%s: exit: saved_err 0x%x saved_uic_err 0x%x",
|
|
|
|
__func__, hba->saved_err, hba->saved_uic_err);
|
|
|
|
}
|
|
|
|
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
out:
|
2014-05-26 05:29:15 +00:00
|
|
|
ufshcd_clear_eh_in_progress(hba);
|
2016-03-10 15:37:12 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2018-05-03 11:07:18 +00:00
|
|
|
ufshcd_scsi_unblock_requests(hba);
|
scsi: ufs: Recover HBA runtime PM error in error handler
The current error handler can not recover HBA runtime PM error if
ufshcd_suspend/resume has failed due to UFS errors, e.g. hibern8 enter/exit
error or SSU cmd error. When this happens, error handler may fail
performing a full reset and restore because error handler always assumes
that power, IRQs and clocks are ready after pm_runtime_get_sync returns,
but actually they are not if ufshcd_resume fails[1].
If ufschd_suspend/resume fails due to UFS errors, runtime PM framework
saves the error value to dev.power.runtime_error. After that, HBA dev
runtime suspend/resume would not be invoked anymore unless runtime_error is
cleared[2].
In case of ufshcd_suspend/resume fails due to UFS errors, for scenario [1],
error handler cannot assume anything of pm_runtime_get_sync, meaning error
handler should explicitly turn ON powers, IRQs and clocks again. To get the
HBA runtime PM work as regard for scenario [2], error handler can clear the
runtime_error by calling pm_runtime_set_active() if full reset and restore
succeeds. And, more important, if pm_runtime_set_active() returns no error,
which means runtime_error has been cleared, we also need to resume those
scsi devices under HBA in case any of them has failed to be resumed due to
HBA runtime resume failure. This is to unblock blk_queue_enter in case
there are bios waiting inside it.
Link: https://lore.kernel.org/r/1596975355-39813-7-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:52 +00:00
|
|
|
ufshcd_err_handling_unprepare(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-05-26 05:29:15 +00:00
|
|
|
* ufshcd_update_uic_error - check and set fatal UIC error flags.
|
|
|
|
* @hba: per-adapter instance
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_update_uic_error(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
2019-11-15 06:09:28 +00:00
|
|
|
irqreturn_t retval = IRQ_NONE;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-11-24 00:32:32 +00:00
|
|
|
/* PHY layer lane error */
|
|
|
|
reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_PHY_ADAPTER_LAYER);
|
|
|
|
/* Ignore LINERESET indication, as this is not an error */
|
|
|
|
if ((reg & UIC_PHY_ADAPTER_LAYER_ERROR) &&
|
2019-11-15 06:09:28 +00:00
|
|
|
(reg & UIC_PHY_ADAPTER_LAYER_LANE_ERR_MASK)) {
|
2016-11-24 00:32:32 +00:00
|
|
|
/*
|
|
|
|
* To know whether this error is fatal or not, DB timeout
|
|
|
|
* must be checked but this error is handled separately.
|
|
|
|
*/
|
|
|
|
dev_dbg(hba->dev, "%s: UIC Lane error reported\n", __func__);
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.pa_err, reg);
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= IRQ_HANDLED;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2016-11-24 00:32:32 +00:00
|
|
|
|
2014-05-26 05:29:15 +00:00
|
|
|
/* PA_INIT_ERROR is fatal and needs UIC reset */
|
|
|
|
reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_DATA_LINK_LAYER);
|
2019-11-15 06:09:28 +00:00
|
|
|
if ((reg & UIC_DATA_LINK_LAYER_ERROR) &&
|
|
|
|
(reg & UIC_DATA_LINK_LAYER_ERROR_CODE_MASK)) {
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.dl_err, reg);
|
2016-12-23 02:42:18 +00:00
|
|
|
|
2019-11-15 06:09:28 +00:00
|
|
|
if (reg & UIC_DATA_LINK_LAYER_ERROR_PA_INIT)
|
|
|
|
hba->uic_error |= UFSHCD_UIC_DL_PA_INIT_ERROR;
|
|
|
|
else if (hba->dev_quirks &
|
|
|
|
UFS_DEVICE_QUIRK_RECOVERY_FROM_DL_NAC_ERRORS) {
|
|
|
|
if (reg & UIC_DATA_LINK_LAYER_ERROR_NAC_RECEIVED)
|
|
|
|
hba->uic_error |=
|
|
|
|
UFSHCD_UIC_DL_NAC_RECEIVED_ERROR;
|
|
|
|
else if (reg & UIC_DATA_LINK_LAYER_ERROR_TCx_REPLAY_TIMEOUT)
|
|
|
|
hba->uic_error |= UFSHCD_UIC_DL_TCx_REPLAY_ERROR;
|
|
|
|
}
|
|
|
|
retval |= IRQ_HANDLED;
|
2016-03-10 15:37:13 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
/* UIC NL/TL/DME errors needs software retry */
|
|
|
|
reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_NETWORK_LAYER);
|
2019-11-15 06:09:28 +00:00
|
|
|
if ((reg & UIC_NETWORK_LAYER_ERROR) &&
|
|
|
|
(reg & UIC_NETWORK_LAYER_ERROR_CODE_MASK)) {
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.nl_err, reg);
|
2014-05-26 05:29:15 +00:00
|
|
|
hba->uic_error |= UFSHCD_UIC_NL_ERROR;
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= IRQ_HANDLED;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_TRANSPORT_LAYER);
|
2019-11-15 06:09:28 +00:00
|
|
|
if ((reg & UIC_TRANSPORT_LAYER_ERROR) &&
|
|
|
|
(reg & UIC_TRANSPORT_LAYER_ERROR_CODE_MASK)) {
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.tl_err, reg);
|
2014-05-26 05:29:15 +00:00
|
|
|
hba->uic_error |= UFSHCD_UIC_TL_ERROR;
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= IRQ_HANDLED;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
reg = ufshcd_readl(hba, REG_UIC_ERROR_CODE_DME);
|
2019-11-15 06:09:28 +00:00
|
|
|
if ((reg & UIC_DME_ERROR) &&
|
|
|
|
(reg & UIC_DME_ERROR_CODE_MASK)) {
|
2019-07-10 13:38:18 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.dme_err, reg);
|
2014-05-26 05:29:15 +00:00
|
|
|
hba->uic_error |= UFSHCD_UIC_DME_ERROR;
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= IRQ_HANDLED;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
|
|
|
dev_dbg(hba->dev, "%s: UIC error flags = 0x%08x\n",
|
|
|
|
__func__, hba->uic_error);
|
2019-11-15 06:09:28 +00:00
|
|
|
return retval;
|
2014-05-26 05:29:15 +00:00
|
|
|
}
|
|
|
|
|
2019-05-21 06:44:54 +00:00
|
|
|
static bool ufshcd_is_auto_hibern8_error(struct ufs_hba *hba,
|
|
|
|
u32 intr_mask)
|
|
|
|
{
|
2020-01-29 10:52:50 +00:00
|
|
|
if (!ufshcd_is_auto_hibern8_supported(hba) ||
|
|
|
|
!ufshcd_is_auto_hibern8_enabled(hba))
|
2019-05-21 06:44:54 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(intr_mask & UFSHCD_UIC_HIBERN8_MASK))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (hba->active_uic_cmd &&
|
|
|
|
(hba->active_uic_cmd->command == UIC_CMD_DME_HIBER_ENTER ||
|
|
|
|
hba->active_uic_cmd->command == UIC_CMD_DME_HIBER_EXIT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:15 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_check_errors - Check for errors that need s/w attention
|
|
|
|
* @hba: per-adapter instance
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2014-05-26 05:29:15 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_check_errors(struct ufs_hba *hba)
|
2014-05-26 05:29:15 +00:00
|
|
|
{
|
|
|
|
bool queue_eh_work = false;
|
2019-11-15 06:09:28 +00:00
|
|
|
irqreturn_t retval = IRQ_NONE;
|
2014-05-26 05:29:15 +00:00
|
|
|
|
2019-07-10 13:38:19 +00:00
|
|
|
if (hba->errors & INT_FATAL_ERRORS) {
|
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.fatal_err, hba->errors);
|
2014-05-26 05:29:15 +00:00
|
|
|
queue_eh_work = true;
|
2019-07-10 13:38:19 +00:00
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
if (hba->errors & UIC_ERROR) {
|
2014-05-26 05:29:15 +00:00
|
|
|
hba->uic_error = 0;
|
2019-11-15 06:09:28 +00:00
|
|
|
retval = ufshcd_update_uic_error(hba);
|
2014-05-26 05:29:15 +00:00
|
|
|
if (hba->uic_error)
|
|
|
|
queue_eh_work = true;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
|
2019-05-21 06:44:54 +00:00
|
|
|
if (hba->errors & UFSHCD_UIC_HIBERN8_MASK) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Auto Hibern8 %s failed - status: 0x%08x, upmcrs: 0x%08x\n",
|
|
|
|
__func__, (hba->errors & UIC_HIBERNATE_ENTER) ?
|
|
|
|
"Enter" : "Exit",
|
|
|
|
hba->errors, ufshcd_get_upmcrs(hba));
|
2019-07-10 13:38:19 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.auto_hibern8_err,
|
|
|
|
hba->errors);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
ufshcd_set_link_broken(hba);
|
2019-05-21 06:44:54 +00:00
|
|
|
queue_eh_work = true;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:15 +00:00
|
|
|
if (queue_eh_work) {
|
2016-03-10 15:37:12 +00:00
|
|
|
/*
|
|
|
|
* update the transfer error masks to sticky bits, let's do this
|
|
|
|
* irrespective of current ufshcd_state.
|
|
|
|
*/
|
|
|
|
hba->saved_err |= hba->errors;
|
|
|
|
hba->saved_uic_err |= hba->uic_error;
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
/* dump controller state before resetting */
|
|
|
|
if (hba->saved_err & (INT_FATAL_ERRORS | UIC_ERROR)) {
|
|
|
|
dev_err(hba->dev, "%s: saved_err 0x%x saved_uic_err 0x%x\n",
|
2016-12-23 02:39:42 +00:00
|
|
|
__func__, hba->saved_err,
|
|
|
|
hba->saved_uic_err);
|
2020-08-09 12:15:53 +00:00
|
|
|
ufshcd_dump_regs(hba, 0, UFSHCI_REG_SPACE_SIZE,
|
|
|
|
"host_regs: ");
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
ufshcd_print_pwr_info(hba);
|
2014-05-26 05:29:15 +00:00
|
|
|
}
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
ufshcd_schedule_eh_work(hba);
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= IRQ_HANDLED;
|
2014-05-26 05:29:14 +00:00
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
/*
|
|
|
|
* if (!queue_eh_work) -
|
|
|
|
* Other errors are either non-fatal where host recovers
|
|
|
|
* itself without s/w intervention or errors that will be
|
|
|
|
* handled by the SCSI core layer.
|
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
return retval;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
struct ctm_info {
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
unsigned long pending;
|
|
|
|
unsigned int ncpl;
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool ufshcd_compl_tm(struct request *req, void *priv, bool reserved)
|
|
|
|
{
|
|
|
|
struct ctm_info *const ci = priv;
|
|
|
|
struct completion *c;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(reserved);
|
|
|
|
if (test_bit(req->tag, &ci->pending))
|
|
|
|
return true;
|
|
|
|
ci->ncpl++;
|
|
|
|
c = req->end_io_data;
|
|
|
|
if (c)
|
|
|
|
complete(c);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_tmc_handler - handle task management function completion
|
|
|
|
* @hba: per adapter instance
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_tmc_handler(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2019-12-09 18:13:09 +00:00
|
|
|
struct request_queue *q = hba->tmf_queue;
|
|
|
|
struct ctm_info ci = {
|
|
|
|
.hba = hba,
|
|
|
|
.pending = ufshcd_readl(hba, REG_UTP_TASK_REQ_DOOR_BELL),
|
|
|
|
};
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
blk_mq_tagset_busy_iter(q->tag_set, ufshcd_compl_tm, &ci);
|
|
|
|
return ci.ncpl ? IRQ_HANDLED : IRQ_NONE;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_sl_intr - Interrupt service routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @intr_status: contains interrupts generated by the controller
|
2019-11-15 06:09:28 +00:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2019-11-15 06:09:28 +00:00
|
|
|
static irqreturn_t ufshcd_sl_intr(struct ufs_hba *hba, u32 intr_status)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2019-11-15 06:09:28 +00:00
|
|
|
irqreturn_t retval = IRQ_NONE;
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
hba->errors = UFSHCD_ERROR_MASK & intr_status;
|
2019-05-21 06:44:54 +00:00
|
|
|
|
|
|
|
if (ufshcd_is_auto_hibern8_error(hba, intr_status))
|
|
|
|
hba->errors |= (UFSHCD_UIC_HIBERN8_MASK & intr_status);
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
if (hba->errors)
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= ufshcd_check_errors(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2013-08-31 16:10:22 +00:00
|
|
|
if (intr_status & UFSHCD_UIC_MASK)
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= ufshcd_uic_cmd_compl(hba, intr_status);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
if (intr_status & UTP_TASK_REQ_COMPL)
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= ufshcd_tmc_handler(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
if (intr_status & UTP_TRANSFER_REQ_COMPL)
|
2019-11-15 06:09:28 +00:00
|
|
|
retval |= ufshcd_transfer_req_compl(hba);
|
|
|
|
|
|
|
|
return retval;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_intr - Main interrupt service routine
|
|
|
|
* @irq: irq number
|
|
|
|
* @__hba: pointer to adapter instance
|
|
|
|
*
|
2019-11-15 06:09:28 +00:00
|
|
|
* Returns
|
|
|
|
* IRQ_HANDLED - If interrupt is valid
|
|
|
|
* IRQ_NONE - If invalid interrupt
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
|
|
|
static irqreturn_t ufshcd_intr(int irq, void *__hba)
|
|
|
|
{
|
2016-02-01 13:02:47 +00:00
|
|
|
u32 intr_status, enabled_intr_status;
|
2012-02-29 06:41:50 +00:00
|
|
|
irqreturn_t retval = IRQ_NONE;
|
|
|
|
struct ufs_hba *hba = __hba;
|
2018-05-03 11:07:20 +00:00
|
|
|
int retries = hba->nutrs;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
spin_lock(hba->host->host_lock);
|
2013-06-26 17:09:26 +00:00
|
|
|
intr_status = ufshcd_readl(hba, REG_INTERRUPT_STATUS);
|
2020-08-09 12:15:50 +00:00
|
|
|
hba->ufs_stats.last_intr_status = intr_status;
|
|
|
|
hba->ufs_stats.last_intr_ts = ktime_get();
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2018-05-03 11:07:20 +00:00
|
|
|
/*
|
|
|
|
* There could be max of hba->nutrs reqs in flight and in worst case
|
|
|
|
* if the reqs get finished 1 by 1 after the interrupt status is
|
|
|
|
* read, make sure we handle them by checking the interrupt status
|
|
|
|
* again in a loop until we process all of the reqs before returning.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
enabled_intr_status =
|
|
|
|
intr_status & ufshcd_readl(hba, REG_INTERRUPT_ENABLE);
|
|
|
|
if (intr_status)
|
|
|
|
ufshcd_writel(hba, intr_status, REG_INTERRUPT_STATUS);
|
2019-11-15 06:09:28 +00:00
|
|
|
if (enabled_intr_status)
|
|
|
|
retval |= ufshcd_sl_intr(hba, enabled_intr_status);
|
2018-05-03 11:07:20 +00:00
|
|
|
|
|
|
|
intr_status = ufshcd_readl(hba, REG_INTERRUPT_STATUS);
|
|
|
|
} while (intr_status && --retries);
|
2016-02-01 13:02:47 +00:00
|
|
|
|
2019-11-15 06:09:28 +00:00
|
|
|
if (retval == IRQ_NONE) {
|
|
|
|
dev_err(hba->dev, "%s: Unhandled interrupt 0x%08x\n",
|
|
|
|
__func__, intr_status);
|
|
|
|
ufshcd_dump_regs(hba, 0, UFSHCI_REG_SPACE_SIZE, "host_regs: ");
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
spin_unlock(hba->host->host_lock);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
static int ufshcd_clear_tm_cmd(struct ufs_hba *hba, int tag)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
u32 mask = 1 << tag;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!test_bit(tag, &hba->outstanding_tasks))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
2018-05-06 10:14:15 +00:00
|
|
|
ufshcd_utmrl_clear(hba, tag);
|
2014-05-26 05:29:12 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
/* poll for max. 1 sec to clear door bell register by h/w */
|
|
|
|
err = ufshcd_wait_for_register(hba,
|
|
|
|
REG_UTP_TASK_REQ_DOOR_BELL,
|
2020-05-07 22:27:50 +00:00
|
|
|
mask, 0, 1000, 1000);
|
2014-05-26 05:29:12 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-10-07 14:30:33 +00:00
|
|
|
static int __ufshcd_issue_tm_cmd(struct ufs_hba *hba,
|
|
|
|
struct utp_task_req_desc *treq, u8 tm_function)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2019-12-09 18:13:09 +00:00
|
|
|
struct request_queue *q = hba->tmf_queue;
|
2018-10-07 14:30:33 +00:00
|
|
|
struct Scsi_Host *host = hba->host;
|
2019-12-09 18:13:09 +00:00
|
|
|
DECLARE_COMPLETION_ONSTACK(wait);
|
|
|
|
struct request *req;
|
2012-02-29 06:41:50 +00:00
|
|
|
unsigned long flags;
|
2018-10-07 14:30:33 +00:00
|
|
|
int free_slot, task_tag, err;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
/*
|
|
|
|
* Get free slot, sleep if slots are unavailable.
|
|
|
|
* Even though we use wait_event() which sleeps indefinitely,
|
|
|
|
* the maximum wait time is bounded by %TM_CMD_TIMEOUT.
|
|
|
|
*/
|
2019-12-09 18:13:09 +00:00
|
|
|
req = blk_get_request(q, REQ_OP_DRV_OUT, BLK_MQ_REQ_RESERVED);
|
|
|
|
req->end_io_data = &wait;
|
|
|
|
free_slot = req->tag;
|
|
|
|
WARN_ON_ONCE(free_slot < 0 || free_slot >= hba->nutmrs);
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
|
|
|
task_tag = hba->nutrs + free_slot;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2018-10-07 14:30:33 +00:00
|
|
|
treq->req_header.dword_0 |= cpu_to_be32(task_tag);
|
|
|
|
|
|
|
|
memcpy(hba->utmrdl_base_addr + free_slot, treq, sizeof(*treq));
|
2016-11-10 12:16:15 +00:00
|
|
|
ufshcd_vops_setup_task_mgmt(hba, free_slot, tm_function);
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* send command to the controller */
|
|
|
|
__set_bit(free_slot, &hba->outstanding_tasks);
|
2016-02-01 13:02:48 +00:00
|
|
|
|
|
|
|
/* Make sure descriptors are ready before ringing the task doorbell */
|
|
|
|
wmb();
|
|
|
|
|
2013-06-26 17:09:26 +00:00
|
|
|
ufshcd_writel(hba, 1 << free_slot, REG_UTP_TASK_REQ_DOOR_BELL);
|
2016-10-18 00:09:36 +00:00
|
|
|
/* Make sure that doorbell is committed immediately */
|
|
|
|
wmb();
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
|
|
|
|
2018-03-28 09:42:18 +00:00
|
|
|
ufshcd_add_tm_upiu_trace(hba, task_tag, "tm_send");
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* wait until the task management command is completed */
|
2019-12-09 18:13:09 +00:00
|
|
|
err = wait_for_completion_io_timeout(&wait,
|
2014-05-26 05:29:12 +00:00
|
|
|
msecs_to_jiffies(TM_CMD_TIMEOUT));
|
2012-02-29 06:41:50 +00:00
|
|
|
if (!err) {
|
2019-12-09 18:13:09 +00:00
|
|
|
/*
|
|
|
|
* Make sure that ufshcd_compl_tm() does not trigger a
|
|
|
|
* use-after-free.
|
|
|
|
*/
|
|
|
|
req->end_io_data = NULL;
|
2018-03-28 09:42:18 +00:00
|
|
|
ufshcd_add_tm_upiu_trace(hba, task_tag, "tm_complete_err");
|
2014-05-26 05:29:12 +00:00
|
|
|
dev_err(hba->dev, "%s: task management cmd 0x%.2x timed-out\n",
|
|
|
|
__func__, tm_function);
|
|
|
|
if (ufshcd_clear_tm_cmd(hba, free_slot))
|
|
|
|
dev_WARN(hba->dev, "%s: unable clear tm cmd (slot %d) after timeout\n",
|
|
|
|
__func__, free_slot);
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
} else {
|
2018-10-07 14:30:33 +00:00
|
|
|
err = 0;
|
|
|
|
memcpy(treq, hba->utmrdl_base_addr + free_slot, sizeof(*treq));
|
|
|
|
|
2018-03-28 09:42:18 +00:00
|
|
|
ufshcd_add_tm_upiu_trace(hba, task_tag, "tm_complete");
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2014-05-26 05:29:12 +00:00
|
|
|
|
2019-08-19 13:43:28 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
__clear_bit(free_slot, &hba->outstanding_tasks);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
blk_put_request(req);
|
2014-05-26 05:29:12 +00:00
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-10-07 14:30:33 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_issue_tm_cmd - issues task management commands to controller
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @lun_id: LUN ID to which TM command is sent
|
|
|
|
* @task_id: task ID to which the TM command is applicable
|
|
|
|
* @tm_function: task management function opcode
|
|
|
|
* @tm_response: task management service response return value
|
|
|
|
*
|
|
|
|
* Returns non-zero value on error, zero on success.
|
|
|
|
*/
|
|
|
|
static int ufshcd_issue_tm_cmd(struct ufs_hba *hba, int lun_id, int task_id,
|
|
|
|
u8 tm_function, u8 *tm_response)
|
|
|
|
{
|
|
|
|
struct utp_task_req_desc treq = { { 0 }, };
|
|
|
|
int ocs_value, err;
|
|
|
|
|
|
|
|
/* Configure task request descriptor */
|
|
|
|
treq.header.dword_0 = cpu_to_le32(UTP_REQ_DESC_INT_CMD);
|
|
|
|
treq.header.dword_2 = cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
|
|
|
|
|
|
|
|
/* Configure task request UPIU */
|
|
|
|
treq.req_header.dword_0 = cpu_to_be32(lun_id << 8) |
|
|
|
|
cpu_to_be32(UPIU_TRANSACTION_TASK_REQ << 24);
|
|
|
|
treq.req_header.dword_1 = cpu_to_be32(tm_function << 16);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The host shall provide the same value for LUN field in the basic
|
|
|
|
* header and for Input Parameter.
|
|
|
|
*/
|
|
|
|
treq.input_param1 = cpu_to_be32(lun_id);
|
|
|
|
treq.input_param2 = cpu_to_be32(task_id);
|
|
|
|
|
|
|
|
err = __ufshcd_issue_tm_cmd(hba, &treq, tm_function);
|
|
|
|
if (err == -ETIMEDOUT)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
ocs_value = le32_to_cpu(treq.header.dword_2) & MASK_OCS;
|
|
|
|
if (ocs_value != OCS_SUCCESS)
|
|
|
|
dev_err(hba->dev, "%s: failed, ocs = 0x%x\n",
|
|
|
|
__func__, ocs_value);
|
|
|
|
else if (tm_response)
|
|
|
|
*tm_response = be32_to_cpu(treq.output_param1) &
|
|
|
|
MASK_TM_SERVICE_RESP;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-10-07 14:30:37 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_issue_devman_upiu_cmd - API for sending "utrd" type requests
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @req_upiu: upiu request
|
|
|
|
* @rsp_upiu: upiu reply
|
|
|
|
* @desc_buff: pointer to descriptor buffer, NULL if NA
|
|
|
|
* @buff_len: descriptor size, 0 if NA
|
2019-10-29 23:07:08 +00:00
|
|
|
* @cmd_type: specifies the type (NOP, Query...)
|
2018-10-07 14:30:37 +00:00
|
|
|
* @desc_op: descriptor operation
|
|
|
|
*
|
|
|
|
* Those type of requests uses UTP Transfer Request Descriptor - utrd.
|
|
|
|
* Therefore, it "rides" the device management infrastructure: uses its tag and
|
|
|
|
* tasks work queues.
|
|
|
|
*
|
|
|
|
* Since there is only one available tag for device management commands,
|
|
|
|
* the caller is expected to hold the hba->dev_cmd.lock mutex.
|
|
|
|
*/
|
|
|
|
static int ufshcd_issue_devman_upiu_cmd(struct ufs_hba *hba,
|
|
|
|
struct utp_upiu_req *req_upiu,
|
|
|
|
struct utp_upiu_req *rsp_upiu,
|
|
|
|
u8 *desc_buff, int *buff_len,
|
2019-10-29 23:07:09 +00:00
|
|
|
enum dev_cmd_type cmd_type,
|
2018-10-07 14:30:37 +00:00
|
|
|
enum query_opcode desc_op)
|
|
|
|
{
|
2019-12-09 18:13:08 +00:00
|
|
|
struct request_queue *q = hba->cmd_queue;
|
|
|
|
struct request *req;
|
2018-10-07 14:30:37 +00:00
|
|
|
struct ufshcd_lrb *lrbp;
|
|
|
|
int err = 0;
|
|
|
|
int tag;
|
|
|
|
struct completion wait;
|
|
|
|
unsigned long flags;
|
2020-07-06 12:39:36 +00:00
|
|
|
u8 upiu_flags;
|
2018-10-07 14:30:37 +00:00
|
|
|
|
|
|
|
down_read(&hba->clk_scaling_lock);
|
|
|
|
|
2019-12-09 18:13:08 +00:00
|
|
|
req = blk_get_request(q, REQ_OP_DRV_OUT, 0);
|
2019-12-13 10:48:28 +00:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2019-12-09 18:13:08 +00:00
|
|
|
tag = req->tag;
|
|
|
|
WARN_ON_ONCE(!ufshcd_valid_tag(hba, tag));
|
2018-10-07 14:30:37 +00:00
|
|
|
|
|
|
|
init_completion(&wait);
|
|
|
|
lrbp = &hba->lrb[tag];
|
|
|
|
WARN_ON(lrbp->cmd);
|
|
|
|
|
|
|
|
lrbp->cmd = NULL;
|
|
|
|
lrbp->sense_bufflen = 0;
|
|
|
|
lrbp->sense_buffer = NULL;
|
|
|
|
lrbp->task_tag = tag;
|
|
|
|
lrbp->lun = 0;
|
|
|
|
lrbp->intr_cmd = true;
|
2020-07-06 20:04:14 +00:00
|
|
|
ufshcd_prepare_lrbp_crypto(NULL, lrbp);
|
2018-10-07 14:30:37 +00:00
|
|
|
hba->dev_cmd.type = cmd_type;
|
|
|
|
|
|
|
|
switch (hba->ufs_version) {
|
|
|
|
case UFSHCI_VERSION_10:
|
|
|
|
case UFSHCI_VERSION_11:
|
|
|
|
lrbp->command_type = UTP_CMD_TYPE_DEV_MANAGE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
lrbp->command_type = UTP_CMD_TYPE_UFS_STORAGE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update the task tag in the request upiu */
|
|
|
|
req_upiu->header.dword_0 |= cpu_to_be32(tag);
|
|
|
|
|
|
|
|
ufshcd_prepare_req_desc_hdr(lrbp, &upiu_flags, DMA_NONE);
|
|
|
|
|
|
|
|
/* just copy the upiu request as it is */
|
|
|
|
memcpy(lrbp->ucd_req_ptr, req_upiu, sizeof(*lrbp->ucd_req_ptr));
|
|
|
|
if (desc_buff && desc_op == UPIU_QUERY_OPCODE_WRITE_DESC) {
|
|
|
|
/* The Data Segment Area is optional depending upon the query
|
|
|
|
* function value. for WRITE DESCRIPTOR, the data segment
|
|
|
|
* follows right after the tsf.
|
|
|
|
*/
|
|
|
|
memcpy(lrbp->ucd_req_ptr + 1, desc_buff, *buff_len);
|
|
|
|
*buff_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(lrbp->ucd_rsp_ptr, 0, sizeof(struct utp_upiu_rsp));
|
|
|
|
|
|
|
|
hba->dev_cmd.complete = &wait;
|
|
|
|
|
|
|
|
/* Make sure descriptors are ready before ringing the doorbell */
|
|
|
|
wmb();
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
ufshcd_send_command(hba, tag);
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ignore the returning value here - ufshcd_check_query_response is
|
|
|
|
* bound to fail since dev_cmd.query and dev_cmd.type were left empty.
|
|
|
|
* read the response directly ignoring all errors.
|
|
|
|
*/
|
|
|
|
ufshcd_wait_for_dev_cmd(hba, lrbp, QUERY_REQ_TIMEOUT);
|
|
|
|
|
|
|
|
/* just copy the upiu response as it is */
|
|
|
|
memcpy(rsp_upiu, lrbp->ucd_rsp_ptr, sizeof(*rsp_upiu));
|
2019-02-20 07:11:13 +00:00
|
|
|
if (desc_buff && desc_op == UPIU_QUERY_OPCODE_READ_DESC) {
|
|
|
|
u8 *descp = (u8 *)lrbp->ucd_rsp_ptr + sizeof(*rsp_upiu);
|
|
|
|
u16 resp_len = be32_to_cpu(lrbp->ucd_rsp_ptr->header.dword_2) &
|
|
|
|
MASK_QUERY_DATA_SEG_LEN;
|
|
|
|
|
|
|
|
if (*buff_len >= resp_len) {
|
|
|
|
memcpy(desc_buff, descp, resp_len);
|
|
|
|
*buff_len = resp_len;
|
|
|
|
} else {
|
2019-11-12 22:34:35 +00:00
|
|
|
dev_warn(hba->dev,
|
|
|
|
"%s: rsp size %d is bigger than buffer size %d",
|
|
|
|
__func__, resp_len, *buff_len);
|
2019-02-20 07:11:13 +00:00
|
|
|
*buff_len = 0;
|
|
|
|
err = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2018-10-07 14:30:37 +00:00
|
|
|
|
2019-12-09 18:13:08 +00:00
|
|
|
blk_put_request(req);
|
2019-12-13 10:48:28 +00:00
|
|
|
out_unlock:
|
2018-10-07 14:30:37 +00:00
|
|
|
up_read(&hba->clk_scaling_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_exec_raw_upiu_cmd - API function for sending raw upiu commands
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @req_upiu: upiu request
|
|
|
|
* @rsp_upiu: upiu reply - only 8 DW as we do not support scsi commands
|
|
|
|
* @msgcode: message code, one of UPIU Transaction Codes Initiator to Target
|
|
|
|
* @desc_buff: pointer to descriptor buffer, NULL if NA
|
|
|
|
* @buff_len: descriptor size, 0 if NA
|
|
|
|
* @desc_op: descriptor operation
|
|
|
|
*
|
|
|
|
* Supports UTP Transfer requests (nop and query), and UTP Task
|
|
|
|
* Management requests.
|
|
|
|
* It is up to the caller to fill the upiu conent properly, as it will
|
|
|
|
* be copied without any further input validations.
|
|
|
|
*/
|
|
|
|
int ufshcd_exec_raw_upiu_cmd(struct ufs_hba *hba,
|
|
|
|
struct utp_upiu_req *req_upiu,
|
|
|
|
struct utp_upiu_req *rsp_upiu,
|
|
|
|
int msgcode,
|
|
|
|
u8 *desc_buff, int *buff_len,
|
|
|
|
enum query_opcode desc_op)
|
|
|
|
{
|
|
|
|
int err;
|
2019-10-29 23:07:09 +00:00
|
|
|
enum dev_cmd_type cmd_type = DEV_CMD_TYPE_QUERY;
|
2018-10-07 14:30:37 +00:00
|
|
|
struct utp_task_req_desc treq = { { 0 }, };
|
|
|
|
int ocs_value;
|
|
|
|
u8 tm_f = be32_to_cpu(req_upiu->header.dword_1) >> 16 & MASK_TM_FUNC;
|
|
|
|
|
|
|
|
switch (msgcode) {
|
|
|
|
case UPIU_TRANSACTION_NOP_OUT:
|
|
|
|
cmd_type = DEV_CMD_TYPE_NOP;
|
|
|
|
/* fall through */
|
|
|
|
case UPIU_TRANSACTION_QUERY_REQ:
|
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
mutex_lock(&hba->dev_cmd.lock);
|
|
|
|
err = ufshcd_issue_devman_upiu_cmd(hba, req_upiu, rsp_upiu,
|
|
|
|
desc_buff, buff_len,
|
|
|
|
cmd_type, desc_op);
|
|
|
|
mutex_unlock(&hba->dev_cmd.lock);
|
|
|
|
ufshcd_release(hba);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case UPIU_TRANSACTION_TASK_REQ:
|
|
|
|
treq.header.dword_0 = cpu_to_le32(UTP_REQ_DESC_INT_CMD);
|
|
|
|
treq.header.dword_2 = cpu_to_le32(OCS_INVALID_COMMAND_STATUS);
|
|
|
|
|
|
|
|
memcpy(&treq.req_header, req_upiu, sizeof(*req_upiu));
|
|
|
|
|
|
|
|
err = __ufshcd_issue_tm_cmd(hba, &treq, tm_f);
|
|
|
|
if (err == -ETIMEDOUT)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ocs_value = le32_to_cpu(treq.header.dword_2) & MASK_OCS;
|
|
|
|
if (ocs_value != OCS_SUCCESS) {
|
|
|
|
dev_err(hba->dev, "%s: failed, ocs = 0x%x\n", __func__,
|
|
|
|
ocs_value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(rsp_upiu, &treq.rsp_header, sizeof(*rsp_upiu));
|
|
|
|
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = -EINVAL;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2014-05-26 05:29:14 +00:00
|
|
|
* ufshcd_eh_device_reset_handler - device reset handler registered to
|
|
|
|
* scsi layer.
|
2012-02-29 06:41:50 +00:00
|
|
|
* @cmd: SCSI command pointer
|
|
|
|
*
|
|
|
|
* Returns SUCCESS/FAILED
|
|
|
|
*/
|
2014-05-26 05:29:14 +00:00
|
|
|
static int ufshcd_eh_device_reset_handler(struct scsi_cmnd *cmd)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
unsigned int tag;
|
|
|
|
u32 pos;
|
|
|
|
int err;
|
2014-05-26 05:29:12 +00:00
|
|
|
u8 resp = 0xF;
|
|
|
|
struct ufshcd_lrb *lrbp;
|
2014-05-26 05:29:14 +00:00
|
|
|
unsigned long flags;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
host = cmd->device->host;
|
|
|
|
hba = shost_priv(host);
|
|
|
|
tag = cmd->request->tag;
|
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
lrbp = &hba->lrb[tag];
|
|
|
|
err = ufshcd_issue_tm_cmd(hba, lrbp->lun, 0, UFS_LOGICAL_RESET, &resp);
|
|
|
|
if (err || resp != UPIU_TASK_MANAGEMENT_FUNC_COMPL) {
|
2014-05-26 05:29:14 +00:00
|
|
|
if (!err)
|
|
|
|
err = resp;
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out;
|
2014-05-26 05:29:12 +00:00
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
/* clear the commands that were pending for corresponding LUN */
|
|
|
|
for_each_set_bit(pos, &hba->outstanding_reqs, hba->nutrs) {
|
|
|
|
if (hba->lrb[pos].lun == lrbp->lun) {
|
|
|
|
err = ufshcd_clear_cmd(hba, pos);
|
|
|
|
if (err)
|
|
|
|
break;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2014-05-26 05:29:14 +00:00
|
|
|
}
|
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
|
|
|
ufshcd_transfer_req_compl(hba);
|
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
2017-02-04 00:56:50 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
out:
|
2017-02-04 00:56:50 +00:00
|
|
|
hba->req_abort_count = 0;
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.dev_reset, (u32)err);
|
2014-05-26 05:29:14 +00:00
|
|
|
if (!err) {
|
|
|
|
err = SUCCESS;
|
|
|
|
} else {
|
|
|
|
dev_err(hba->dev, "%s: failed with err %d\n", __func__, err);
|
|
|
|
err = FAILED;
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-02-04 00:56:40 +00:00
|
|
|
static void ufshcd_set_req_abort_skip(struct ufs_hba *hba, unsigned long bitmap)
|
|
|
|
{
|
|
|
|
struct ufshcd_lrb *lrbp;
|
|
|
|
int tag;
|
|
|
|
|
|
|
|
for_each_set_bit(tag, &bitmap, hba->nutrs) {
|
|
|
|
lrbp = &hba->lrb[tag];
|
|
|
|
lrbp->req_abort_skip = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_abort - abort a specific command
|
|
|
|
* @cmd: SCSI command pointer
|
|
|
|
*
|
2014-05-26 05:29:13 +00:00
|
|
|
* Abort the pending command in device by sending UFS_ABORT_TASK task management
|
|
|
|
* command, and in host controller by clearing the door-bell register. There can
|
|
|
|
* be race between controller sending the command to the device while abort is
|
|
|
|
* issued. To avoid that, first issue UFS_QUERY_TASK to check if the command is
|
|
|
|
* really issued and then try to abort it.
|
|
|
|
*
|
2012-02-29 06:41:50 +00:00
|
|
|
* Returns SUCCESS/FAILED
|
|
|
|
*/
|
|
|
|
static int ufshcd_abort(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int tag;
|
2014-05-26 05:29:13 +00:00
|
|
|
int err = 0;
|
|
|
|
int poll_cnt;
|
2014-05-26 05:29:12 +00:00
|
|
|
u8 resp = 0xF;
|
|
|
|
struct ufshcd_lrb *lrbp;
|
2014-07-01 09:22:37 +00:00
|
|
|
u32 reg;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
host = cmd->device->host;
|
|
|
|
hba = shost_priv(host);
|
|
|
|
tag = cmd->request->tag;
|
2016-12-23 02:40:07 +00:00
|
|
|
lrbp = &hba->lrb[tag];
|
2016-02-01 13:02:39 +00:00
|
|
|
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();
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2016-12-23 02:40:07 +00:00
|
|
|
/*
|
|
|
|
* Task abort to the device W-LUN is illegal. When this command
|
|
|
|
* will fail, due to spec violation, scsi err handling next step
|
|
|
|
* will be to send LU reset which, again, is a spec violation.
|
|
|
|
* To avoid these unnecessary/illegal step we skip to the last error
|
|
|
|
* handling stage: reset and restore.
|
|
|
|
*/
|
|
|
|
if (lrbp->lun == UFS_UPIU_UFS_DEVICE_WLUN)
|
|
|
|
return ufshcd_eh_host_reset_handler(cmd);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
2016-02-01 13:02:39 +00:00
|
|
|
reg = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
|
2014-05-26 05:29:13 +00:00
|
|
|
/* If command is already aborted/completed, return SUCCESS */
|
2016-02-01 13:02:39 +00:00
|
|
|
if (!(test_bit(tag, &hba->outstanding_reqs))) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: cmd at tag %d already completed, outstanding=0x%lx, doorbell=0x%x\n",
|
|
|
|
__func__, tag, hba->outstanding_reqs, reg);
|
2014-05-26 05:29:13 +00:00
|
|
|
goto out;
|
2016-02-01 13:02:39 +00:00
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-07-01 09:22:37 +00:00
|
|
|
if (!(reg & (1 << tag))) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: cmd was completed, but without a notifying intr, tag = %d",
|
|
|
|
__func__, tag);
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:39:42 +00:00
|
|
|
/* Print Transfer Request of aborted task */
|
|
|
|
dev_err(hba->dev, "%s: Device abort task at tag %d\n", __func__, tag);
|
|
|
|
|
2017-02-04 00:56:50 +00:00
|
|
|
/*
|
|
|
|
* Print detailed info about aborted request.
|
|
|
|
* As more than one request might get aborted at the same time,
|
|
|
|
* print full information only for the first aborted request in order
|
|
|
|
* to reduce repeated printouts. For other aborted requests only print
|
|
|
|
* basic details.
|
|
|
|
*/
|
|
|
|
scsi_print_command(hba->lrb[tag].cmd);
|
|
|
|
if (!hba->req_abort_count) {
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.task_abort, 0);
|
2017-02-04 00:56:50 +00:00
|
|
|
ufshcd_print_host_regs(hba);
|
2017-02-04 00:57:28 +00:00
|
|
|
ufshcd_print_host_state(hba);
|
2017-02-04 00:56:50 +00:00
|
|
|
ufshcd_print_pwr_info(hba);
|
|
|
|
ufshcd_print_trs(hba, 1 << tag, true);
|
|
|
|
} else {
|
|
|
|
ufshcd_print_trs(hba, 1 << tag, false);
|
|
|
|
}
|
|
|
|
hba->req_abort_count++;
|
2017-02-04 00:56:40 +00:00
|
|
|
|
|
|
|
/* Skip task abort in case previous aborts failed and report failure */
|
|
|
|
if (lrbp->req_abort_skip) {
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:13 +00:00
|
|
|
for (poll_cnt = 100; poll_cnt; poll_cnt--) {
|
|
|
|
err = ufshcd_issue_tm_cmd(hba, lrbp->lun, lrbp->task_tag,
|
|
|
|
UFS_QUERY_TASK, &resp);
|
|
|
|
if (!err && resp == UPIU_TASK_MANAGEMENT_FUNC_SUCCEEDED) {
|
|
|
|
/* cmd pending in the device */
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "%s: cmd pending in the device. tag = %d\n",
|
|
|
|
__func__, tag);
|
2014-05-26 05:29:13 +00:00
|
|
|
break;
|
|
|
|
} else if (!err && resp == UPIU_TASK_MANAGEMENT_FUNC_COMPL) {
|
|
|
|
/*
|
|
|
|
* cmd not pending in the device, check if it is
|
|
|
|
* in transition.
|
|
|
|
*/
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "%s: cmd at tag %d not pending in the device.\n",
|
|
|
|
__func__, tag);
|
2014-05-26 05:29:13 +00:00
|
|
|
reg = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL);
|
|
|
|
if (reg & (1 << tag)) {
|
|
|
|
/* sleep for max. 200us to stabilize */
|
|
|
|
usleep_range(100, 200);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* command completed already */
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "%s: cmd at tag %d successfully cleared from DB.\n",
|
|
|
|
__func__, tag);
|
2014-05-26 05:29:13 +00:00
|
|
|
goto out;
|
|
|
|
} else {
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: no response from device. tag = %d, err %d\n",
|
|
|
|
__func__, tag, err);
|
2014-05-26 05:29:13 +00:00
|
|
|
if (!err)
|
|
|
|
err = resp; /* service response error */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!poll_cnt) {
|
|
|
|
err = -EBUSY;
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:12 +00:00
|
|
|
err = ufshcd_issue_tm_cmd(hba, lrbp->lun, lrbp->task_tag,
|
|
|
|
UFS_ABORT_TASK, &resp);
|
|
|
|
if (err || resp != UPIU_TASK_MANAGEMENT_FUNC_COMPL) {
|
2016-12-23 02:42:18 +00:00
|
|
|
if (!err) {
|
2014-05-26 05:29:13 +00:00
|
|
|
err = resp; /* service response error */
|
2016-12-23 02:42:18 +00:00
|
|
|
dev_err(hba->dev, "%s: issued. tag = %d, err %d\n",
|
|
|
|
__func__, tag, err);
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out;
|
2014-05-26 05:29:12 +00:00
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-05-26 05:29:13 +00:00
|
|
|
err = ufshcd_clear_cmd(hba, tag);
|
2016-12-23 02:42:18 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: Failed clearing cmd at tag %d, err %d\n",
|
|
|
|
__func__, tag, err);
|
2014-05-26 05:29:13 +00:00
|
|
|
goto out;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
2014-05-26 05:29:13 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
spin_lock_irqsave(host->host_lock, flags);
|
2020-08-09 12:15:55 +00:00
|
|
|
__ufshcd_transfer_req_compl(hba, (1UL << tag));
|
2012-02-29 06:41:50 +00:00
|
|
|
spin_unlock_irqrestore(host->host_lock, flags);
|
2013-07-29 19:05:57 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
out:
|
2014-05-26 05:29:13 +00:00
|
|
|
if (!err) {
|
|
|
|
err = SUCCESS;
|
|
|
|
} else {
|
|
|
|
dev_err(hba->dev, "%s: failed with err %d\n", __func__, err);
|
2017-02-04 00:56:40 +00:00
|
|
|
ufshcd_set_req_abort_skip(hba, hba->outstanding_reqs);
|
2014-05-26 05:29:13 +00:00
|
|
|
err = FAILED;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
/*
|
|
|
|
* This ufshcd_release() corresponds to the original scsi cmd that got
|
|
|
|
* aborted here (as we won't get any IRQ for it).
|
|
|
|
*/
|
|
|
|
ufshcd_release(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_host_reset_and_restore - reset and restore host controller
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Note that host controller reset may issue DME_RESET to
|
|
|
|
* local and remote (device) Uni-Pro stack and the attributes
|
|
|
|
* are reset to default state.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_host_reset_and_restore(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
unsigned long flags;
|
|
|
|
|
scsi: ufs: Complete pending requests in host reset and restore path
In UFS host reset and restore path, before probe, we stop and start the
host controller once. After host controller is stopped, the pending
requests, if any, are cleared from the doorbell, but no completion IRQ
would be raised due to the hba is stopped. These pending requests shall be
completed along with the first NOP_OUT command (as it is the first command
which can raise a transfer completion IRQ) sent during probe. Since the
OCSs of these pending requests are not SUCCESS (because they are not yet
literally finished), their UPIUs shall be dumped. When there are multiple
pending requests, the UPIU dump can be overwhelming and may lead to
stability issues because it is in atomic context. Therefore, before probe,
complete these pending requests right after host controller is stopped and
silence the UPIU dump from them.
Link: https://lore.kernel.org/r/1574751214-8321-5-git-send-email-cang@qti.qualcomm.com
Reviewed-by: Alim Akhtar <alim.akhtar@samsung.com>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-11-26 06:53:33 +00:00
|
|
|
/*
|
|
|
|
* Stop the host controller and complete the requests
|
|
|
|
* cleared by h/w
|
|
|
|
*/
|
2020-05-07 22:27:50 +00:00
|
|
|
ufshcd_hba_stop(hba);
|
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Complete pending requests in host reset and restore path
In UFS host reset and restore path, before probe, we stop and start the
host controller once. After host controller is stopped, the pending
requests, if any, are cleared from the doorbell, but no completion IRQ
would be raised due to the hba is stopped. These pending requests shall be
completed along with the first NOP_OUT command (as it is the first command
which can raise a transfer completion IRQ) sent during probe. Since the
OCSs of these pending requests are not SUCCESS (because they are not yet
literally finished), their UPIUs shall be dumped. When there are multiple
pending requests, the UPIU dump can be overwhelming and may lead to
stability issues because it is in atomic context. Therefore, before probe,
complete these pending requests right after host controller is stopped and
silence the UPIU dump from them.
Link: https://lore.kernel.org/r/1574751214-8321-5-git-send-email-cang@qti.qualcomm.com
Reviewed-by: Alim Akhtar <alim.akhtar@samsung.com>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-11-26 06:53:33 +00:00
|
|
|
hba->silence_err_logs = true;
|
|
|
|
ufshcd_complete_requests(hba);
|
|
|
|
hba->silence_err_logs = false;
|
2014-05-26 05:29:14 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
/* scale up clocks to max frequency before full reinitialization */
|
2020-03-26 09:25:40 +00:00
|
|
|
ufshcd_set_clk_freq(hba, true);
|
2017-02-04 00:57:02 +00:00
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
err = ufshcd_hba_enable(hba);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Establish the link again and restore the device */
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
err = ufshcd_probe_hba(hba, false);
|
2014-09-25 12:32:26 +00:00
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
out:
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: Host init failed %d\n", __func__, err);
|
2019-07-10 13:38:21 +00:00
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.host_reset, (u32)err);
|
2014-05-26 05:29:14 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_reset_and_restore - reset and re-initialize host/device
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Reset and recover device, host and re-establish link. This
|
|
|
|
* is helpful to recover the communication in fatal error conditions.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero on failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_reset_and_restore(struct ufs_hba *hba)
|
|
|
|
{
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
u32 saved_err;
|
|
|
|
u32 saved_uic_err;
|
2014-05-26 05:29:14 +00:00
|
|
|
int err = 0;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
unsigned long flags;
|
2014-09-25 12:32:26 +00:00
|
|
|
int retries = MAX_HOST_RESET_RETRIES;
|
2014-05-26 05:29:14 +00:00
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
/*
|
|
|
|
* This is a fresh start, cache and clear saved error first,
|
|
|
|
* in case new error generated during reset and restore.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
saved_err = hba->saved_err;
|
|
|
|
saved_uic_err = hba->saved_uic_err;
|
|
|
|
hba->saved_err = 0;
|
|
|
|
hba->saved_uic_err = 0;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
do {
|
2019-08-28 19:17:54 +00:00
|
|
|
/* Reset the attached device */
|
|
|
|
ufshcd_vops_device_reset(hba);
|
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
err = ufshcd_host_reset_and_restore(hba);
|
|
|
|
} while (err && --retries);
|
2014-05-26 05:29:14 +00:00
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
/*
|
|
|
|
* Inform scsi mid-layer that we did reset and allow to handle
|
|
|
|
* Unit Attention properly.
|
|
|
|
*/
|
|
|
|
scsi_report_bus_reset(hba->host, 0);
|
|
|
|
if (err) {
|
|
|
|
hba->saved_err |= saved_err;
|
|
|
|
hba->saved_uic_err |= saved_uic_err;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
2014-05-26 05:29:14 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_eh_host_reset_handler - host reset handler registered to scsi layer
|
2018-03-01 23:07:20 +00:00
|
|
|
* @cmd: SCSI command pointer
|
2014-05-26 05:29:14 +00:00
|
|
|
*
|
|
|
|
* Returns SUCCESS/FAILED
|
|
|
|
*/
|
|
|
|
static int ufshcd_eh_host_reset_handler(struct scsi_cmnd *cmd)
|
|
|
|
{
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
int err = SUCCESS;
|
2014-05-26 05:29:14 +00:00
|
|
|
unsigned long flags;
|
|
|
|
struct ufs_hba *hba;
|
|
|
|
|
|
|
|
hba = shost_priv(cmd->device->host);
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
hba->force_reset = true;
|
|
|
|
ufshcd_schedule_eh_work(hba);
|
|
|
|
dev_err(hba->dev, "%s: reset in progress - 1\n", __func__);
|
2014-05-26 05:29:14 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
flush_work(&hba->eh_work);
|
2014-05-26 05:29:14 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (hba->ufshcd_state == UFSHCD_STATE_ERROR)
|
2014-05-26 05:29:14 +00:00
|
|
|
err = FAILED;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:27 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_get_max_icc_level - calculate the ICC level
|
|
|
|
* @sup_curr_uA: max. current supported by the regulator
|
|
|
|
* @start_scan: row at the desc table to start scan from
|
|
|
|
* @buff: power descriptor buffer
|
|
|
|
*
|
|
|
|
* Returns calculated max ICC level for specific regulator
|
|
|
|
*/
|
|
|
|
static u32 ufshcd_get_max_icc_level(int sup_curr_uA, u32 start_scan, char *buff)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int curr_uA;
|
|
|
|
u16 data;
|
|
|
|
u16 unit;
|
|
|
|
|
|
|
|
for (i = start_scan; i >= 0; i--) {
|
2017-01-05 08:45:11 +00:00
|
|
|
data = be16_to_cpup((__be16 *)&buff[2 * i]);
|
2014-09-25 12:32:27 +00:00
|
|
|
unit = (data & ATTR_ICC_LVL_UNIT_MASK) >>
|
|
|
|
ATTR_ICC_LVL_UNIT_OFFSET;
|
|
|
|
curr_uA = data & ATTR_ICC_LVL_VALUE_MASK;
|
|
|
|
switch (unit) {
|
|
|
|
case UFSHCD_NANO_AMP:
|
|
|
|
curr_uA = curr_uA / 1000;
|
|
|
|
break;
|
|
|
|
case UFSHCD_MILI_AMP:
|
|
|
|
curr_uA = curr_uA * 1000;
|
|
|
|
break;
|
|
|
|
case UFSHCD_AMP:
|
|
|
|
curr_uA = curr_uA * 1000 * 1000;
|
|
|
|
break;
|
|
|
|
case UFSHCD_MICRO_AMP:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (sup_curr_uA >= curr_uA)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < 0) {
|
|
|
|
i = 0;
|
|
|
|
pr_err("%s: Couldn't find valid icc_level = %d", __func__, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (u32)i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_calc_icc_level - calculate the max ICC level
|
|
|
|
* In case regulators are not initialized we'll return 0
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @desc_buf: power descriptor buffer to extract ICC levels from.
|
|
|
|
* @len: length of desc_buff
|
|
|
|
*
|
|
|
|
* Returns calculated ICC level
|
|
|
|
*/
|
|
|
|
static u32 ufshcd_find_max_sup_active_icc_level(struct ufs_hba *hba,
|
|
|
|
u8 *desc_buf, int len)
|
|
|
|
{
|
|
|
|
u32 icc_level = 0;
|
|
|
|
|
|
|
|
if (!hba->vreg_info.vcc || !hba->vreg_info.vccq ||
|
|
|
|
!hba->vreg_info.vccq2) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Regulator capability was not set, actvIccLevel=%d",
|
|
|
|
__func__, icc_level);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2019-03-28 09:16:25 +00:00
|
|
|
if (hba->vreg_info.vcc && hba->vreg_info.vcc->max_uA)
|
2014-09-25 12:32:27 +00:00
|
|
|
icc_level = ufshcd_get_max_icc_level(
|
|
|
|
hba->vreg_info.vcc->max_uA,
|
|
|
|
POWER_DESC_MAX_ACTV_ICC_LVLS - 1,
|
|
|
|
&desc_buf[PWR_DESC_ACTIVE_LVLS_VCC_0]);
|
|
|
|
|
2019-03-28 09:16:25 +00:00
|
|
|
if (hba->vreg_info.vccq && hba->vreg_info.vccq->max_uA)
|
2014-09-25 12:32:27 +00:00
|
|
|
icc_level = ufshcd_get_max_icc_level(
|
|
|
|
hba->vreg_info.vccq->max_uA,
|
|
|
|
icc_level,
|
|
|
|
&desc_buf[PWR_DESC_ACTIVE_LVLS_VCCQ_0]);
|
|
|
|
|
2019-03-28 09:16:25 +00:00
|
|
|
if (hba->vreg_info.vccq2 && hba->vreg_info.vccq2->max_uA)
|
2014-09-25 12:32:27 +00:00
|
|
|
icc_level = ufshcd_get_max_icc_level(
|
|
|
|
hba->vreg_info.vccq2->max_uA,
|
|
|
|
icc_level,
|
|
|
|
&desc_buf[PWR_DESC_ACTIVE_LVLS_VCCQ2_0]);
|
|
|
|
out:
|
|
|
|
return icc_level;
|
|
|
|
}
|
|
|
|
|
2020-03-26 09:25:41 +00:00
|
|
|
static void ufshcd_set_active_icc_lvl(struct ufs_hba *hba)
|
2014-09-25 12:32:27 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2020-06-03 09:19:58 +00:00
|
|
|
int buff_len = hba->desc_size[QUERY_DESC_IDN_POWER];
|
2018-05-02 23:58:09 +00:00
|
|
|
u8 *desc_buf;
|
2020-03-26 09:25:41 +00:00
|
|
|
u32 icc_level;
|
2018-05-02 23:58:09 +00:00
|
|
|
|
|
|
|
desc_buf = kmalloc(buff_len, GFP_KERNEL);
|
|
|
|
if (!desc_buf)
|
|
|
|
return;
|
2014-09-25 12:32:27 +00:00
|
|
|
|
2020-06-03 09:19:56 +00:00
|
|
|
ret = ufshcd_read_desc_param(hba, QUERY_DESC_IDN_POWER, 0, 0,
|
|
|
|
desc_buf, buff_len);
|
2014-09-25 12:32:27 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Failed reading power descriptor.len = %d ret = %d",
|
|
|
|
__func__, buff_len, ret);
|
2018-05-02 23:58:09 +00:00
|
|
|
goto out;
|
2014-09-25 12:32:27 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 09:25:41 +00:00
|
|
|
icc_level = ufshcd_find_max_sup_active_icc_level(hba, desc_buf,
|
|
|
|
buff_len);
|
|
|
|
dev_dbg(hba->dev, "%s: setting icc_level 0x%x", __func__, icc_level);
|
2014-09-25 12:32:27 +00:00
|
|
|
|
2017-03-29 06:19:21 +00:00
|
|
|
ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
|
2020-03-26 09:25:41 +00:00
|
|
|
QUERY_ATTR_IDN_ACTIVE_ICC_LVL, 0, 0, &icc_level);
|
2014-09-25 12:32:27 +00:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Failed configuring bActiveICCLevel = %d ret = %d",
|
2020-03-26 09:25:41 +00:00
|
|
|
__func__, icc_level, ret);
|
2014-09-25 12:32:27 +00:00
|
|
|
|
2018-05-02 23:58:09 +00:00
|
|
|
out:
|
|
|
|
kfree(desc_buf);
|
2014-09-25 12:32:27 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 01:09:59 +00:00
|
|
|
static inline void ufshcd_blk_pm_runtime_init(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
scsi_autopm_get_device(sdev);
|
|
|
|
blk_pm_runtime_init(sdev->request_queue, &sdev->sdev_gendev);
|
|
|
|
if (sdev->rpm_autosuspend)
|
|
|
|
pm_runtime_set_autosuspend_delay(&sdev->sdev_gendev,
|
|
|
|
RPM_AUTOSUSPEND_DELAY_MS);
|
|
|
|
scsi_autopm_put_device(sdev);
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:28 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_scsi_add_wlus - Adds required W-LUs
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* UFS device specification requires the UFS devices to support 4 well known
|
|
|
|
* logical units:
|
|
|
|
* "REPORT_LUNS" (address: 01h)
|
|
|
|
* "UFS Device" (address: 50h)
|
|
|
|
* "RPMB" (address: 44h)
|
|
|
|
* "BOOT" (address: 30h)
|
|
|
|
* UFS device's power management needs to be controlled by "POWER CONDITION"
|
|
|
|
* field of SSU (START STOP UNIT) command. But this "power condition" field
|
|
|
|
* will take effect only when its sent to "UFS device" well known logical unit
|
|
|
|
* hence we require the scsi_device instance to represent this logical unit in
|
|
|
|
* order for the UFS host driver to send the SSU command for power management.
|
2018-03-01 23:07:20 +00:00
|
|
|
*
|
2014-09-25 12:32:28 +00:00
|
|
|
* We also require the scsi_device instance for "RPMB" (Replay Protected Memory
|
|
|
|
* Block) LU so user space process can control this LU. User space may also
|
|
|
|
* want to have access to BOOT LU.
|
2018-03-01 23:07:20 +00:00
|
|
|
*
|
2014-09-25 12:32:28 +00:00
|
|
|
* This function adds scsi device instances for each of all well known LUs
|
|
|
|
* (except "REPORT LUNS" LU).
|
|
|
|
*
|
|
|
|
* Returns zero on success (all required W-LUs are added successfully),
|
|
|
|
* non-zero error value on failure (if failed to add any of the required W-LU).
|
|
|
|
*/
|
|
|
|
static int ufshcd_scsi_add_wlus(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2014-10-23 10:25:12 +00:00
|
|
|
struct scsi_device *sdev_rpmb;
|
|
|
|
struct scsi_device *sdev_boot;
|
2014-09-25 12:32:28 +00:00
|
|
|
|
|
|
|
hba->sdev_ufs_device = __scsi_add_device(hba->host, 0, 0,
|
|
|
|
ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_UFS_DEVICE_WLUN), NULL);
|
|
|
|
if (IS_ERR(hba->sdev_ufs_device)) {
|
|
|
|
ret = PTR_ERR(hba->sdev_ufs_device);
|
|
|
|
hba->sdev_ufs_device = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-03-26 01:09:59 +00:00
|
|
|
ufshcd_blk_pm_runtime_init(hba->sdev_ufs_device);
|
2014-10-23 10:25:12 +00:00
|
|
|
scsi_device_put(hba->sdev_ufs_device);
|
2014-09-25 12:32:28 +00:00
|
|
|
|
2014-10-23 10:25:12 +00:00
|
|
|
sdev_rpmb = __scsi_add_device(hba->host, 0, 0,
|
2014-09-25 12:32:28 +00:00
|
|
|
ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_RPMB_WLUN), NULL);
|
2014-10-23 10:25:12 +00:00
|
|
|
if (IS_ERR(sdev_rpmb)) {
|
|
|
|
ret = PTR_ERR(sdev_rpmb);
|
2017-09-22 10:31:47 +00:00
|
|
|
goto remove_sdev_ufs_device;
|
2014-09-25 12:32:28 +00:00
|
|
|
}
|
2020-03-26 01:09:59 +00:00
|
|
|
ufshcd_blk_pm_runtime_init(sdev_rpmb);
|
2014-10-23 10:25:12 +00:00
|
|
|
scsi_device_put(sdev_rpmb);
|
2017-09-22 10:31:47 +00:00
|
|
|
|
|
|
|
sdev_boot = __scsi_add_device(hba->host, 0, 0,
|
|
|
|
ufshcd_upiu_wlun_to_scsi_wlun(UFS_UPIU_BOOT_WLUN), NULL);
|
2020-03-26 01:09:59 +00:00
|
|
|
if (IS_ERR(sdev_boot)) {
|
2017-09-22 10:31:47 +00:00
|
|
|
dev_err(hba->dev, "%s: BOOT WLUN not found\n", __func__);
|
2020-03-26 01:09:59 +00:00
|
|
|
} else {
|
|
|
|
ufshcd_blk_pm_runtime_init(sdev_boot);
|
2017-09-22 10:31:47 +00:00
|
|
|
scsi_device_put(sdev_boot);
|
2020-03-26 01:09:59 +00:00
|
|
|
}
|
2014-09-25 12:32:28 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
remove_sdev_ufs_device:
|
|
|
|
scsi_remove_device(hba->sdev_ufs_device);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
static void ufshcd_wb_probe(struct ufs_hba *hba, u8 *desc_buf)
|
|
|
|
{
|
2020-06-25 03:04:30 +00:00
|
|
|
struct ufs_dev_info *dev_info = &hba->dev_info;
|
2020-05-08 08:01:13 +00:00
|
|
|
u8 lun;
|
|
|
|
u32 d_lu_wb_buf_alloc;
|
|
|
|
|
2020-05-08 08:01:08 +00:00
|
|
|
if (!ufshcd_is_wb_allowed(hba))
|
|
|
|
return;
|
2020-06-25 03:04:30 +00:00
|
|
|
/*
|
|
|
|
* Probe WB only for UFS-2.2 and UFS-3.1 (and later) devices or
|
|
|
|
* UFS devices with quirk UFS_DEVICE_QUIRK_SUPPORT_EXTENDED_FEATURES
|
|
|
|
* enabled
|
|
|
|
*/
|
|
|
|
if (!(dev_info->wspecversion >= 0x310 ||
|
|
|
|
dev_info->wspecversion == 0x220 ||
|
|
|
|
(hba->dev_quirks & UFS_DEVICE_QUIRK_SUPPORT_EXTENDED_FEATURES)))
|
|
|
|
goto wb_disabled;
|
2020-05-08 08:01:08 +00:00
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
if (hba->desc_size[QUERY_DESC_IDN_DEVICE] <
|
|
|
|
DEVICE_DESC_PARAM_EXT_UFS_FEATURE_SUP + 4)
|
2020-05-08 08:01:08 +00:00
|
|
|
goto wb_disabled;
|
|
|
|
|
2020-06-25 03:04:30 +00:00
|
|
|
dev_info->d_ext_ufs_feature_sup =
|
2020-04-22 21:41:42 +00:00
|
|
|
get_unaligned_be32(desc_buf +
|
|
|
|
DEVICE_DESC_PARAM_EXT_UFS_FEATURE_SUP);
|
2020-05-08 08:01:08 +00:00
|
|
|
|
2020-06-25 03:04:30 +00:00
|
|
|
if (!(dev_info->d_ext_ufs_feature_sup & UFS_DEV_WRITE_BOOSTER_SUP))
|
2020-05-08 08:01:08 +00:00
|
|
|
goto wb_disabled;
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
/*
|
|
|
|
* WB may be supported but not configured while provisioning.
|
|
|
|
* The spec says, in dedicated wb buffer mode,
|
|
|
|
* a max of 1 lun would have wb buffer configured.
|
|
|
|
* Now only shared buffer mode is supported.
|
|
|
|
*/
|
2020-06-25 03:04:30 +00:00
|
|
|
dev_info->b_wb_buffer_type =
|
2020-04-22 21:41:42 +00:00
|
|
|
desc_buf[DEVICE_DESC_PARAM_WB_TYPE];
|
|
|
|
|
2020-06-25 03:04:30 +00:00
|
|
|
dev_info->b_presrv_uspc_en =
|
2020-04-22 21:41:42 +00:00
|
|
|
desc_buf[DEVICE_DESC_PARAM_WB_PRESRV_USRSPC_EN];
|
|
|
|
|
2020-06-25 03:04:30 +00:00
|
|
|
if (dev_info->b_wb_buffer_type == WB_BUF_MODE_SHARED) {
|
|
|
|
dev_info->d_wb_alloc_units =
|
2020-05-08 08:01:13 +00:00
|
|
|
get_unaligned_be32(desc_buf +
|
|
|
|
DEVICE_DESC_PARAM_WB_SHARED_ALLOC_UNITS);
|
2020-06-25 03:04:30 +00:00
|
|
|
if (!dev_info->d_wb_alloc_units)
|
2020-05-08 08:01:13 +00:00
|
|
|
goto wb_disabled;
|
|
|
|
} else {
|
|
|
|
for (lun = 0; lun < UFS_UPIU_MAX_WB_LUN_ID; lun++) {
|
|
|
|
d_lu_wb_buf_alloc = 0;
|
|
|
|
ufshcd_read_unit_desc_param(hba,
|
|
|
|
lun,
|
|
|
|
UNIT_DESC_PARAM_WB_BUF_ALLOC_UNITS,
|
|
|
|
(u8 *)&d_lu_wb_buf_alloc,
|
|
|
|
sizeof(d_lu_wb_buf_alloc));
|
|
|
|
if (d_lu_wb_buf_alloc) {
|
2020-06-25 03:04:30 +00:00
|
|
|
dev_info->wb_dedicated_lu = lun;
|
2020-05-08 08:01:13 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-05-08 08:01:08 +00:00
|
|
|
|
2020-05-08 08:01:13 +00:00
|
|
|
if (!d_lu_wb_buf_alloc)
|
|
|
|
goto wb_disabled;
|
|
|
|
}
|
2020-05-08 08:01:08 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
wb_disabled:
|
|
|
|
hba->caps &= ~UFSHCD_CAP_WB_EN;
|
|
|
|
}
|
|
|
|
|
2020-05-08 08:01:10 +00:00
|
|
|
void ufshcd_fixup_dev_quirks(struct ufs_hba *hba, struct ufs_dev_fix *fixups)
|
2020-05-08 08:01:08 +00:00
|
|
|
{
|
|
|
|
struct ufs_dev_fix *f;
|
|
|
|
struct ufs_dev_info *dev_info = &hba->dev_info;
|
|
|
|
|
2020-05-08 08:01:10 +00:00
|
|
|
if (!fixups)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (f = fixups; f->quirk; f++) {
|
2020-05-08 08:01:08 +00:00
|
|
|
if ((f->wmanufacturerid == dev_info->wmanufacturerid ||
|
|
|
|
f->wmanufacturerid == UFS_ANY_VENDOR) &&
|
|
|
|
((dev_info->model &&
|
|
|
|
STR_PRFX_EQUAL(f->model, dev_info->model)) ||
|
|
|
|
!strcmp(f->model, UFS_ANY_MODEL)))
|
|
|
|
hba->dev_quirks |= f->quirk;
|
|
|
|
}
|
2020-04-22 21:41:42 +00:00
|
|
|
}
|
2020-05-08 08:01:10 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_fixup_dev_quirks);
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2020-05-08 08:01:09 +00:00
|
|
|
static void ufs_fixup_device_setup(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
/* fix by general quirk table */
|
2020-05-08 08:01:10 +00:00
|
|
|
ufshcd_fixup_dev_quirks(hba, ufs_fixups);
|
2020-05-08 08:01:09 +00:00
|
|
|
|
|
|
|
/* allow vendors to fix quirks */
|
|
|
|
ufshcd_vops_fixup_dev_quirks(hba);
|
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:14 +00:00
|
|
|
static int ufs_get_device_desc(struct ufs_hba *hba)
|
2016-03-10 15:37:10 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u8 model_index;
|
2018-05-02 23:58:09 +00:00
|
|
|
u8 *desc_buf;
|
2020-01-20 13:08:14 +00:00
|
|
|
struct ufs_dev_info *dev_info = &hba->dev_info;
|
2019-07-30 05:55:17 +00:00
|
|
|
|
2020-06-03 09:19:55 +00:00
|
|
|
desc_buf = kmalloc(QUERY_DESC_MAX_SIZE, GFP_KERNEL);
|
2018-05-02 23:58:09 +00:00
|
|
|
if (!desc_buf) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-03-10 15:37:10 +00:00
|
|
|
|
2020-06-03 09:19:56 +00:00
|
|
|
err = ufshcd_read_desc_param(hba, QUERY_DESC_IDN_DEVICE, 0, 0, desc_buf,
|
2020-06-03 09:19:58 +00:00
|
|
|
hba->desc_size[QUERY_DESC_IDN_DEVICE]);
|
2016-03-10 15:37:10 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: Failed reading Device Desc. err = %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* getting vendor (manufacturerID) and Bank Index in big endian
|
|
|
|
* format
|
|
|
|
*/
|
2020-01-20 13:08:14 +00:00
|
|
|
dev_info->wmanufacturerid = desc_buf[DEVICE_DESC_PARAM_MANF_ID] << 8 |
|
2016-03-10 15:37:10 +00:00
|
|
|
desc_buf[DEVICE_DESC_PARAM_MANF_ID + 1];
|
|
|
|
|
2020-02-11 03:40:49 +00:00
|
|
|
/* getting Specification Version in big endian format */
|
|
|
|
dev_info->wspecversion = desc_buf[DEVICE_DESC_PARAM_SPEC_VER] << 8 |
|
|
|
|
desc_buf[DEVICE_DESC_PARAM_SPEC_VER + 1];
|
|
|
|
|
2016-03-10 15:37:10 +00:00
|
|
|
model_index = desc_buf[DEVICE_DESC_PARAM_PRDCT_NAME];
|
2020-04-22 21:41:42 +00:00
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
err = ufshcd_read_string_desc(hba, model_index,
|
2020-01-20 13:08:14 +00:00
|
|
|
&dev_info->model, SD_ASCII_STD);
|
2019-07-30 05:55:17 +00:00
|
|
|
if (err < 0) {
|
2016-03-10 15:37:10 +00:00
|
|
|
dev_err(hba->dev, "%s: Failed reading Product Name. err = %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-05-08 08:01:08 +00:00
|
|
|
ufs_fixup_device_setup(hba);
|
|
|
|
|
2020-06-25 03:04:30 +00:00
|
|
|
ufshcd_wb_probe(hba, desc_buf);
|
2020-05-08 08:01:08 +00:00
|
|
|
|
2019-07-30 05:55:17 +00:00
|
|
|
/*
|
|
|
|
* ufshcd_read_string_desc returns size of the string
|
|
|
|
* reset the error value
|
|
|
|
*/
|
|
|
|
err = 0;
|
2016-03-10 15:37:10 +00:00
|
|
|
|
|
|
|
out:
|
2018-05-02 23:58:09 +00:00
|
|
|
kfree(desc_buf);
|
2016-03-10 15:37:10 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:14 +00:00
|
|
|
static void ufs_put_device_desc(struct ufs_hba *hba)
|
2019-07-30 05:55:17 +00:00
|
|
|
{
|
2020-01-20 13:08:14 +00:00
|
|
|
struct ufs_dev_info *dev_info = &hba->dev_info;
|
|
|
|
|
|
|
|
kfree(dev_info->model);
|
|
|
|
dev_info->model = NULL;
|
2019-07-30 05:55:17 +00:00
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:16 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_tune_pa_tactivate - Tunes PA_TActivate of local UniPro
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* PA_TActivate parameter can be tuned manually if UniPro version is less than
|
|
|
|
* 1.61. PA_TActivate needs to be greater than or equal to peerM-PHY's
|
|
|
|
* RX_MIN_ACTIVATETIME_CAPABILITY attribute. This optimal value can help reduce
|
|
|
|
* the hibern8 exit latency.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero error value on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_tune_pa_tactivate(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 peer_rx_min_activatetime = 0, tuned_pa_tactivate;
|
|
|
|
|
|
|
|
ret = ufshcd_dme_peer_get(hba,
|
|
|
|
UIC_ARG_MIB_SEL(
|
|
|
|
RX_MIN_ACTIVATETIME_CAPABILITY,
|
|
|
|
UIC_ARG_MPHY_RX_GEN_SEL_INDEX(0)),
|
|
|
|
&peer_rx_min_activatetime);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* make sure proper unit conversion is applied */
|
|
|
|
tuned_pa_tactivate =
|
|
|
|
((peer_rx_min_activatetime * RX_MIN_ACTIVATETIME_UNIT_US)
|
|
|
|
/ PA_TACTIVATE_TIME_UNIT_US);
|
|
|
|
ret = ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TACTIVATE),
|
|
|
|
tuned_pa_tactivate);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_tune_pa_hibern8time - Tunes PA_Hibern8Time of local UniPro
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* PA_Hibern8Time parameter can be tuned manually if UniPro version is less than
|
|
|
|
* 1.61. PA_Hibern8Time needs to be maximum of local M-PHY's
|
|
|
|
* TX_HIBERN8TIME_CAPABILITY & peer M-PHY's RX_HIBERN8TIME_CAPABILITY.
|
|
|
|
* This optimal value can help reduce the hibern8 exit latency.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero error value on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_tune_pa_hibern8time(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 local_tx_hibern8_time_cap = 0, peer_rx_hibern8_time_cap = 0;
|
|
|
|
u32 max_hibern8_time, tuned_pa_hibern8time;
|
|
|
|
|
|
|
|
ret = ufshcd_dme_get(hba,
|
|
|
|
UIC_ARG_MIB_SEL(TX_HIBERN8TIME_CAPABILITY,
|
|
|
|
UIC_ARG_MPHY_TX_GEN_SEL_INDEX(0)),
|
|
|
|
&local_tx_hibern8_time_cap);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_dme_peer_get(hba,
|
|
|
|
UIC_ARG_MIB_SEL(RX_HIBERN8TIME_CAPABILITY,
|
|
|
|
UIC_ARG_MPHY_RX_GEN_SEL_INDEX(0)),
|
|
|
|
&peer_rx_hibern8_time_cap);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
max_hibern8_time = max(local_tx_hibern8_time_cap,
|
|
|
|
peer_rx_hibern8_time_cap);
|
|
|
|
/* make sure proper unit conversion is applied */
|
|
|
|
tuned_pa_hibern8time = ((max_hibern8_time * HIBERN8TIME_UNIT_US)
|
|
|
|
/ PA_HIBERN8_TIME_UNIT_US);
|
|
|
|
ret = ufshcd_dme_set(hba, UIC_ARG_MIB(PA_HIBERN8TIME),
|
|
|
|
tuned_pa_hibern8time);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-11-24 00:32:08 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_quirk_tune_host_pa_tactivate - Ensures that host PA_TACTIVATE is
|
|
|
|
* less than device PA_TACTIVATE time.
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*
|
|
|
|
* Some UFS devices require host PA_TACTIVATE to be lower than device
|
|
|
|
* PA_TACTIVATE, we need to enable UFS_DEVICE_QUIRK_HOST_PA_TACTIVATE quirk
|
|
|
|
* for such devices.
|
|
|
|
*
|
|
|
|
* Returns zero on success, non-zero error value on failure.
|
|
|
|
*/
|
|
|
|
static int ufshcd_quirk_tune_host_pa_tactivate(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
u32 granularity, peer_granularity;
|
|
|
|
u32 pa_tactivate, peer_pa_tactivate;
|
|
|
|
u32 pa_tactivate_us, peer_pa_tactivate_us;
|
|
|
|
u8 gran_to_us_table[] = {1, 4, 8, 16, 32, 100};
|
|
|
|
|
|
|
|
ret = ufshcd_dme_get(hba, UIC_ARG_MIB(PA_GRANULARITY),
|
|
|
|
&granularity);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_GRANULARITY),
|
|
|
|
&peer_granularity);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((granularity < PA_GRANULARITY_MIN_VAL) ||
|
|
|
|
(granularity > PA_GRANULARITY_MAX_VAL)) {
|
|
|
|
dev_err(hba->dev, "%s: invalid host PA_GRANULARITY %d",
|
|
|
|
__func__, granularity);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((peer_granularity < PA_GRANULARITY_MIN_VAL) ||
|
|
|
|
(peer_granularity > PA_GRANULARITY_MAX_VAL)) {
|
|
|
|
dev_err(hba->dev, "%s: invalid device PA_GRANULARITY %d",
|
|
|
|
__func__, peer_granularity);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ufshcd_dme_get(hba, UIC_ARG_MIB(PA_TACTIVATE), &pa_tactivate);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_TACTIVATE),
|
|
|
|
&peer_pa_tactivate);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pa_tactivate_us = pa_tactivate * gran_to_us_table[granularity - 1];
|
|
|
|
peer_pa_tactivate_us = peer_pa_tactivate *
|
|
|
|
gran_to_us_table[peer_granularity - 1];
|
|
|
|
|
|
|
|
if (pa_tactivate_us > peer_pa_tactivate_us) {
|
|
|
|
u32 new_peer_pa_tactivate;
|
|
|
|
|
|
|
|
new_peer_pa_tactivate = pa_tactivate_us /
|
|
|
|
gran_to_us_table[peer_granularity - 1];
|
|
|
|
new_peer_pa_tactivate++;
|
|
|
|
ret = ufshcd_dme_peer_set(hba, UIC_ARG_MIB(PA_TACTIVATE),
|
|
|
|
new_peer_pa_tactivate);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:14 +00:00
|
|
|
static void ufshcd_tune_unipro_params(struct ufs_hba *hba)
|
2016-03-10 15:37:16 +00:00
|
|
|
{
|
|
|
|
if (ufshcd_is_unipro_pa_params_tuning_req(hba)) {
|
|
|
|
ufshcd_tune_pa_tactivate(hba);
|
|
|
|
ufshcd_tune_pa_hibern8time(hba);
|
|
|
|
}
|
|
|
|
|
2020-02-24 04:09:21 +00:00
|
|
|
ufshcd_vops_apply_dev_quirks(hba);
|
|
|
|
|
2016-03-10 15:37:16 +00:00
|
|
|
if (hba->dev_quirks & UFS_DEVICE_QUIRK_PA_TACTIVATE)
|
|
|
|
/* set 1ms timeout for PA_TACTIVATE */
|
|
|
|
ufshcd_dme_set(hba, UIC_ARG_MIB(PA_TACTIVATE), 10);
|
2016-11-24 00:32:08 +00:00
|
|
|
|
|
|
|
if (hba->dev_quirks & UFS_DEVICE_QUIRK_HOST_PA_TACTIVATE)
|
|
|
|
ufshcd_quirk_tune_host_pa_tactivate(hba);
|
2016-03-10 15:37:16 +00:00
|
|
|
}
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
static void ufshcd_clear_dbg_ufs_stats(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
hba->ufs_stats.hibern8_exit_cnt = 0;
|
|
|
|
hba->ufs_stats.last_hibern8_exit_tstamp = ktime_set(0, 0);
|
2017-02-04 00:56:50 +00:00
|
|
|
hba->req_abort_count = 0;
|
2016-12-23 02:42:18 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:19 +00:00
|
|
|
static int ufshcd_device_geo_params_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
size_t buff_len;
|
|
|
|
u8 *desc_buf;
|
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
buff_len = hba->desc_size[QUERY_DESC_IDN_GEOMETRY];
|
2020-01-20 13:08:19 +00:00
|
|
|
desc_buf = kmalloc(buff_len, GFP_KERNEL);
|
|
|
|
if (!desc_buf) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-06-03 09:19:56 +00:00
|
|
|
err = ufshcd_read_desc_param(hba, QUERY_DESC_IDN_GEOMETRY, 0, 0,
|
|
|
|
desc_buf, buff_len);
|
2020-01-20 13:08:19 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "%s: Failed reading Geometry Desc. err = %d\n",
|
|
|
|
__func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc_buf[GEOMETRY_DESC_PARAM_MAX_NUM_LUN] == 1)
|
|
|
|
hba->dev_info.max_lu_supported = 32;
|
|
|
|
else if (desc_buf[GEOMETRY_DESC_PARAM_MAX_NUM_LUN] == 0)
|
|
|
|
hba->dev_info.max_lu_supported = 8;
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(desc_buf);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-10-16 08:59:41 +00:00
|
|
|
static struct ufs_ref_clk ufs_ref_clk_freqs[] = {
|
|
|
|
{19200000, REF_CLK_FREQ_19_2_MHZ},
|
|
|
|
{26000000, REF_CLK_FREQ_26_MHZ},
|
|
|
|
{38400000, REF_CLK_FREQ_38_4_MHZ},
|
|
|
|
{52000000, REF_CLK_FREQ_52_MHZ},
|
|
|
|
{0, REF_CLK_FREQ_INVAL},
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum ufs_ref_clk_freq
|
|
|
|
ufs_get_bref_clk_from_hz(unsigned long freq)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; ufs_ref_clk_freqs[i].freq_hz; i++)
|
|
|
|
if (ufs_ref_clk_freqs[i].freq_hz == freq)
|
|
|
|
return ufs_ref_clk_freqs[i].val;
|
|
|
|
|
|
|
|
return REF_CLK_FREQ_INVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ufshcd_parse_dev_ref_clk_freq(struct ufs_hba *hba, struct clk *refclk)
|
|
|
|
{
|
|
|
|
unsigned long freq;
|
|
|
|
|
|
|
|
freq = clk_get_rate(refclk);
|
|
|
|
|
|
|
|
hba->dev_ref_clk_freq =
|
|
|
|
ufs_get_bref_clk_from_hz(freq);
|
|
|
|
|
|
|
|
if (hba->dev_ref_clk_freq == REF_CLK_FREQ_INVAL)
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"invalid ref_clk setting = %ld\n", freq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_set_dev_ref_clk(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u32 ref_clk;
|
|
|
|
u32 freq = hba->dev_ref_clk_freq;
|
|
|
|
|
|
|
|
err = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR,
|
|
|
|
QUERY_ATTR_IDN_REF_CLK_FREQ, 0, 0, &ref_clk);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "failed reading bRefClkFreq. err = %d\n",
|
|
|
|
err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ref_clk == freq)
|
|
|
|
goto out; /* nothing to update */
|
|
|
|
|
|
|
|
err = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
|
|
|
|
QUERY_ATTR_IDN_REF_CLK_FREQ, 0, 0, &freq);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "bRefClkFreq setting to %lu Hz failed\n",
|
|
|
|
ufs_ref_clk_freqs[freq].freq_hz);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(hba->dev, "bRefClkFreq setting to %lu Hz succeeded\n",
|
|
|
|
ufs_ref_clk_freqs[freq].freq_hz);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
static int ufshcd_device_params_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
bool flag;
|
2020-06-03 09:19:58 +00:00
|
|
|
int ret, i;
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
|
2020-06-03 09:19:58 +00:00
|
|
|
/* Init device descriptor sizes */
|
|
|
|
for (i = 0; i < QUERY_DESC_IDN_MAX; i++)
|
|
|
|
hba->desc_size[i] = QUERY_DESC_MAX_SIZE;
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
|
2020-01-20 13:08:19 +00:00
|
|
|
/* Init UFS geometry descriptor related parameters */
|
|
|
|
ret = ufshcd_device_geo_params_init(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
/* Check and apply UFS device quirks */
|
|
|
|
ret = ufs_get_device_desc(hba);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s: Failed getting device info. err = %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-02-11 03:40:49 +00:00
|
|
|
ufshcd_get_ref_clk_gating_wait(hba);
|
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
if (!ufshcd_query_flag_retry(hba, UPIU_QUERY_OPCODE_READ_FLAG,
|
2020-05-08 08:01:12 +00:00
|
|
|
QUERY_FLAG_IDN_PWR_ON_WPE, 0, &flag))
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
hba->dev_info.f_power_on_wp_en = flag;
|
|
|
|
|
2020-01-20 13:08:16 +00:00
|
|
|
/* Probe maximum power mode co-supported by both UFS host and device */
|
|
|
|
if (ufshcd_get_max_pwr_mode(hba))
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"%s: Failed getting max supported power mode\n",
|
|
|
|
__func__);
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_add_lus - probe and add UFS logical units
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
*/
|
|
|
|
static int ufshcd_add_lus(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Add required well known logical units to scsi mid layer */
|
|
|
|
ret = ufshcd_scsi_add_wlus(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Initialize devfreq after UFS device is detected */
|
|
|
|
if (ufshcd_is_clkscaling_supported(hba)) {
|
|
|
|
memcpy(&hba->clk_scaling.saved_pwr_info.info,
|
|
|
|
&hba->pwr_info,
|
|
|
|
sizeof(struct ufs_pa_layer_attr));
|
|
|
|
hba->clk_scaling.saved_pwr_info.is_valid = true;
|
|
|
|
if (!hba->devfreq) {
|
|
|
|
ret = ufshcd_devfreq_init(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
hba->clk_scaling.is_allowed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ufs_bsg_probe(hba);
|
|
|
|
scsi_scan_host(hba->host);
|
|
|
|
pm_runtime_put_sync(hba->dev);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/**
|
2014-09-25 12:32:26 +00:00
|
|
|
* ufshcd_probe_hba - probe hba to detect device and initialize
|
|
|
|
* @hba: per-adapter instance
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
* @async: asynchronous execution or not
|
2014-09-25 12:32:26 +00:00
|
|
|
*
|
|
|
|
* Execute link-startup and verify device initialization
|
2013-06-26 17:09:29 +00:00
|
|
|
*/
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
static int ufshcd_probe_hba(struct ufs_hba *hba, bool async)
|
2013-06-26 17:09:29 +00:00
|
|
|
{
|
|
|
|
int ret;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
unsigned long flags;
|
2016-12-23 02:39:51 +00:00
|
|
|
ktime_t start = ktime_get();
|
2013-06-26 17:09:29 +00:00
|
|
|
|
|
|
|
ret = ufshcd_link_startup(hba);
|
2013-07-29 19:05:57 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
/* Debug counters initialization */
|
|
|
|
ufshcd_clear_dbg_ufs_stats(hba);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* UniPro link is active now */
|
|
|
|
ufshcd_set_link_active(hba);
|
2013-08-31 16:10:24 +00:00
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
/* Verify device initialization by sending NOP OUT UPIU */
|
2013-07-29 19:05:57 +00:00
|
|
|
ret = ufshcd_verify_dev_init(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2013-07-29 19:05:58 +00:00
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
/* Initiate UFS initialization, and waiting until completion */
|
2013-07-29 19:05:58 +00:00
|
|
|
ret = ufshcd_complete_dev_init(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2013-07-29 19:05:57 +00:00
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
/*
|
|
|
|
* Initialize UFS device parameters used by driver, these
|
|
|
|
* parameters are associated with UFS descriptors.
|
|
|
|
*/
|
|
|
|
if (async) {
|
|
|
|
ret = ufshcd_device_params_init(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2017-01-05 08:45:12 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 13:08:14 +00:00
|
|
|
ufshcd_tune_unipro_params(hba);
|
2019-07-30 05:55:17 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* UFS device is also active now */
|
|
|
|
ufshcd_set_ufs_dev_active(hba);
|
2013-07-29 19:05:59 +00:00
|
|
|
ufshcd_force_reset_auto_bkops(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->wlun_dev_clr_ua = true;
|
|
|
|
|
2020-01-20 13:08:16 +00:00
|
|
|
/* Gear up to HS gear if supported */
|
|
|
|
if (hba->max_pwr_info.is_valid) {
|
2018-10-16 08:59:41 +00:00
|
|
|
/*
|
|
|
|
* Set the right value to bRefClkFreq before attempting to
|
|
|
|
* switch to HS gears.
|
|
|
|
*/
|
|
|
|
if (hba->dev_ref_clk_freq != REF_CLK_FREQ_INVAL)
|
|
|
|
ufshcd_set_dev_ref_clk(hba);
|
2014-09-25 12:32:31 +00:00
|
|
|
ret = ufshcd_config_pwr_mode(hba, &hba->max_pwr_info.info);
|
2016-10-18 00:10:14 +00:00
|
|
|
if (ret) {
|
2014-09-25 12:32:31 +00:00
|
|
|
dev_err(hba->dev, "%s: Failed setting power mode, err = %d\n",
|
|
|
|
__func__, ret);
|
2016-10-18 00:10:14 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2020-02-12 05:38:28 +00:00
|
|
|
ufshcd_print_pwr_info(hba);
|
2014-09-25 12:32:31 +00:00
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2020-03-26 09:25:41 +00:00
|
|
|
/*
|
|
|
|
* bActiveICCLevel is volatile for UFS device (as per latest v2.1 spec)
|
|
|
|
* and for removable UFS card as well, hence always set the parameter.
|
|
|
|
* Note: Error handler may issue the device reset hence resetting
|
|
|
|
* bActiveICCLevel as well so it is always safe to set this here.
|
|
|
|
*/
|
|
|
|
ufshcd_set_active_icc_lvl(hba);
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
ufshcd_wb_config(hba);
|
2019-11-15 06:09:26 +00:00
|
|
|
/* Enable Auto-Hibernate if configured */
|
|
|
|
ufshcd_auto_hibern8_enable(hba);
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
out:
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
if (ret)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_ERROR;
|
|
|
|
else if (hba->ufshcd_state == UFSHCD_STATE_RESET)
|
|
|
|
hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2014-09-25 12:32:26 +00:00
|
|
|
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_init(dev_name(hba->dev), ret,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)),
|
2017-01-11 00:48:25 +00:00
|
|
|
hba->curr_dev_pwr_mode, hba->uic_link_state);
|
2014-09-25 12:32:26 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_async_scan - asynchronous execution for probing hba
|
|
|
|
* @data: data pointer to pass to this function
|
|
|
|
* @cookie: cookie data
|
|
|
|
*/
|
|
|
|
static void ufshcd_async_scan(void *data, async_cookie_t cookie)
|
|
|
|
{
|
|
|
|
struct ufs_hba *hba = (struct ufs_hba *)data;
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:26 +00:00
|
|
|
|
scsi: ufs: Split ufshcd_probe_hba() based on its called flow
This patch has two major non-functionality changes:
1. Take scanning host if-statement out from ufshcd_probe_hba(), and move
into a new added function ufshcd_add_lus(). In this new function
ufshcd_add_lus(), the main functionalitis include: ICC initialization, add
well-known LUs, devfreq initialization, UFS bsg probe and scsi host
scan. The reason for this change is that these functionalities only being
called during booting stage flow ufshcd_init()->ufshcd_async_scan(). In the
processes of error handling and power management ufshcd_suspend(),
ufshcd_resume(), ufshcd_probe_hba() being called, but these functionalitis
above metioned are not hit.
2. Move context of initialization of parameters associated with the UFS
device to a new added function ufshcd_device_params_init(). The reason of
this change is that all of these parameters are used by driver, but only
need to be initialized once when booting. Combine them into an integral
function, make them easier maintain.
Link: https://lore.kernel.org/r/20200120130820.1737-4-huobean@gmail.com
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Bean Huo <beanhuo@micron.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-01-20 13:08:15 +00:00
|
|
|
/* Initialize hba, detect and initialize UFS device */
|
|
|
|
ret = ufshcd_probe_hba(hba, true);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Probe and add UFS logical units */
|
|
|
|
ret = ufshcd_add_lus(hba);
|
|
|
|
out:
|
|
|
|
/*
|
|
|
|
* If we failed to initialize the device or the device is not
|
|
|
|
* present, turn off the power/clocks etc.
|
|
|
|
*/
|
|
|
|
if (ret) {
|
|
|
|
pm_runtime_put_sync(hba->dev);
|
|
|
|
ufshcd_exit_clk_scaling(hba);
|
|
|
|
ufshcd_hba_exit(hba);
|
|
|
|
}
|
2013-06-26 17:09:29 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 12:14:09 +00:00
|
|
|
static const struct attribute_group *ufshcd_driver_groups[] = {
|
|
|
|
&ufs_sysfs_unit_descriptor_group,
|
2018-02-15 12:14:11 +00:00
|
|
|
&ufs_sysfs_lun_attributes_group,
|
2018-02-15 12:14:09 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2020-05-09 09:37:13 +00:00
|
|
|
static struct ufs_hba_variant_params ufs_hba_vps = {
|
|
|
|
.hba_enable_delay_us = 1000,
|
2020-05-09 09:37:15 +00:00
|
|
|
.wb_flush_threshold = UFS_WB_BUF_REMAIN_PERCENT(40),
|
2020-05-09 09:37:13 +00:00
|
|
|
.devfreq_profile.polling_ms = 100,
|
|
|
|
.devfreq_profile.target = ufshcd_devfreq_target,
|
|
|
|
.devfreq_profile.get_dev_status = ufshcd_devfreq_get_dev_status,
|
|
|
|
.ondemand_data.upthreshold = 70,
|
|
|
|
.ondemand_data.downdifferential = 5,
|
|
|
|
};
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
static struct scsi_host_template ufshcd_driver_template = {
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
.name = UFSHCD,
|
|
|
|
.proc_name = UFSHCD,
|
|
|
|
.queuecommand = ufshcd_queuecommand,
|
|
|
|
.slave_alloc = ufshcd_slave_alloc,
|
2014-07-01 14:00:32 +00:00
|
|
|
.slave_configure = ufshcd_slave_configure,
|
2012-02-29 06:41:50 +00:00
|
|
|
.slave_destroy = ufshcd_slave_destroy,
|
2014-06-29 06:40:20 +00:00
|
|
|
.change_queue_depth = ufshcd_change_queue_depth,
|
2012-02-29 06:41:50 +00:00
|
|
|
.eh_abort_handler = ufshcd_abort,
|
2014-05-26 05:29:14 +00:00
|
|
|
.eh_device_reset_handler = ufshcd_eh_device_reset_handler,
|
|
|
|
.eh_host_reset_handler = ufshcd_eh_host_reset_handler,
|
2012-02-29 06:41:50 +00:00
|
|
|
.this_id = -1,
|
|
|
|
.sg_tablesize = SG_ALL,
|
|
|
|
.cmd_per_lun = UFSHCD_CMD_PER_LUN,
|
|
|
|
.can_queue = UFSHCD_CAN_QUEUE,
|
2019-06-17 12:19:55 +00:00
|
|
|
.max_segment_size = PRDT_DATA_BYTE_COUNT_MAX,
|
2014-09-25 12:32:32 +00:00
|
|
|
.max_host_blocked = 1,
|
2014-11-13 13:25:11 +00:00
|
|
|
.track_queue_depth = 1,
|
2018-02-15 12:14:09 +00:00
|
|
|
.sdev_groups = ufshcd_driver_groups,
|
2018-12-13 15:17:09 +00:00
|
|
|
.dma_boundary = PAGE_SIZE - 1,
|
2019-09-16 15:56:50 +00:00
|
|
|
.rpm_autosuspend_delay = RPM_AUTOSUSPEND_DELAY_MS,
|
2012-02-29 06:41:50 +00:00
|
|
|
};
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
|
|
|
|
int ua)
|
|
|
|
{
|
2015-02-12 03:35:28 +00:00
|
|
|
int ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2015-02-12 03:35:28 +00:00
|
|
|
if (!vreg)
|
|
|
|
return 0;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2019-03-28 09:16:25 +00:00
|
|
|
/*
|
|
|
|
* "set_load" operation shall be required on those regulators
|
|
|
|
* which specifically configured current limitation. Otherwise
|
|
|
|
* zero max_uA may cause unexpected behavior when regulator is
|
|
|
|
* enabled or set as high power mode.
|
|
|
|
*/
|
|
|
|
if (!vreg->max_uA)
|
|
|
|
return 0;
|
|
|
|
|
2015-02-12 03:35:28 +00:00
|
|
|
ret = regulator_set_load(vreg->reg, ua);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "%s: %s set load (ua=%d) failed, err=%d\n",
|
|
|
|
__func__, vreg->name, ua, ret);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_config_vreg_lpm(struct ufs_hba *hba,
|
|
|
|
struct ufs_vreg *vreg)
|
|
|
|
{
|
Revert "scsi: ufs: disable vccq if it's not needed by UFS device"
This reverts commit 60f0187031c05e04cbadffb62f557d0ff3564490.
There was one conflict in drivers/scsi/ufs/ufshcd.c
<<<<<<< HEAD
/* Init check for device descriptor sizes */
ufshcd_init_desc_sizes(hba);
ret = ufs_get_device_desc(hba, &card);
if (ret) {
dev_err(hba->dev, "%s: Failed getting device info. err = %d\n",
__func__, ret);
goto out;
}
ufs_fixup_device_setup(hba, &card);
ufshcd_tune_unipro_params(hba);
ret = ufshcd_set_vccq_rail_unused(hba,
(hba->dev_quirks & UFS_DEVICE_NO_VCCQ) ? true : false);
if (ret)
goto out;
=======
ufs_advertise_fixup_device(hba);
>>>>>>> parent of 60f0187031c0... scsi: ufs: disable vccq if it's not needed by UFS device
Resolution: keep HEAD, and delete the ufshcd_set_vccq_rail_unused() call
and corresponding error-handling code.
Clean up loose ends in a follow-up patch.
60f0187031c0 introduced a small power optimization: ignore the vccq load
specified in the UFSHC DT node when said host controller is connected to
specific Flash chips (currently, Samsung and Hynix).
Unfortunately, this optimization breaks UFS on systems where vccq powers
not only the Flash chip, but the host controller as well, such as APQ8098
MEDIABOX or MTP8998:
[ 3.929877] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 5.433815] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937771] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937866] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr_retry: query attribute, idn 13, failed with error -11 after 3 retires
[ 6.946412] ufshcd-qcom 1da4000.ufshc: ufshcd_disable_auto_bkops: failed to enable exception event -11
[ 6.957972] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1587 failed 3 retries
[ 6.967181] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1586 failed 3 retries
[ 6.975025] ufshcd-qcom 1da4000.ufshc: ufshcd_get_max_pwr_mode: invalid max pwm tx gear read = 0
[ 6.982755] ufshcd-qcom 1da4000.ufshc: ufshcd_probe_hba: Failed getting max supported power mode
[ 8.505770] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 10.009807] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513766] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513861] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag_retry: query attribute, opcode 5, idn 3, failed with error -11 after 3 retires
[ 13.049807] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 14.553768] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057767] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057872] ufshcd-qcom 1da4000.ufshc: ufshcd_read_desc_param: Failed reading descriptor. desc_id 8, desc_index 0, param_offset 0, ret -11
[ 16.067109] ufshcd-qcom 1da4000.ufshc: ufshcd_init_icc_levels: Failed reading power descriptor.len = 98 ret = -11
[ 37.073787] ufshcd-qcom 1da4000.ufshc: link startup failed 1
In my opinion, the rationale for the original patch is questionable. If
neither the UFSHC, nor the Flash chip, require any load from vccq, then
that power rail should simply not be specified at all in the DT.
Working around that fact in the driver is detrimental, as evidenced by the
failure to initialize the host controller on MSM8998.
Acked-by: Avri Altman <avri.altman@wdc.com>
Acked-by: Alim Akhtar <alim.akhtar@samsung.com>
Signed-off-by: Marc Gonzalez <marc.w.gonzalez@free.fr>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-27 10:41:45 +00:00
|
|
|
return ufshcd_config_vreg_load(hba->dev, vreg, UFS_VREG_LPM_LOAD_UA);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
|
|
|
|
struct ufs_vreg *vreg)
|
|
|
|
{
|
2019-08-14 12:59:50 +00:00
|
|
|
if (!vreg)
|
|
|
|
return 0;
|
|
|
|
|
Revert "scsi: ufs: disable vccq if it's not needed by UFS device"
This reverts commit 60f0187031c05e04cbadffb62f557d0ff3564490.
There was one conflict in drivers/scsi/ufs/ufshcd.c
<<<<<<< HEAD
/* Init check for device descriptor sizes */
ufshcd_init_desc_sizes(hba);
ret = ufs_get_device_desc(hba, &card);
if (ret) {
dev_err(hba->dev, "%s: Failed getting device info. err = %d\n",
__func__, ret);
goto out;
}
ufs_fixup_device_setup(hba, &card);
ufshcd_tune_unipro_params(hba);
ret = ufshcd_set_vccq_rail_unused(hba,
(hba->dev_quirks & UFS_DEVICE_NO_VCCQ) ? true : false);
if (ret)
goto out;
=======
ufs_advertise_fixup_device(hba);
>>>>>>> parent of 60f0187031c0... scsi: ufs: disable vccq if it's not needed by UFS device
Resolution: keep HEAD, and delete the ufshcd_set_vccq_rail_unused() call
and corresponding error-handling code.
Clean up loose ends in a follow-up patch.
60f0187031c0 introduced a small power optimization: ignore the vccq load
specified in the UFSHC DT node when said host controller is connected to
specific Flash chips (currently, Samsung and Hynix).
Unfortunately, this optimization breaks UFS on systems where vccq powers
not only the Flash chip, but the host controller as well, such as APQ8098
MEDIABOX or MTP8998:
[ 3.929877] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 5.433815] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937771] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937866] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr_retry: query attribute, idn 13, failed with error -11 after 3 retires
[ 6.946412] ufshcd-qcom 1da4000.ufshc: ufshcd_disable_auto_bkops: failed to enable exception event -11
[ 6.957972] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1587 failed 3 retries
[ 6.967181] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1586 failed 3 retries
[ 6.975025] ufshcd-qcom 1da4000.ufshc: ufshcd_get_max_pwr_mode: invalid max pwm tx gear read = 0
[ 6.982755] ufshcd-qcom 1da4000.ufshc: ufshcd_probe_hba: Failed getting max supported power mode
[ 8.505770] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 10.009807] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513766] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513861] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag_retry: query attribute, opcode 5, idn 3, failed with error -11 after 3 retires
[ 13.049807] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 14.553768] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057767] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057872] ufshcd-qcom 1da4000.ufshc: ufshcd_read_desc_param: Failed reading descriptor. desc_id 8, desc_index 0, param_offset 0, ret -11
[ 16.067109] ufshcd-qcom 1da4000.ufshc: ufshcd_init_icc_levels: Failed reading power descriptor.len = 98 ret = -11
[ 37.073787] ufshcd-qcom 1da4000.ufshc: link startup failed 1
In my opinion, the rationale for the original patch is questionable. If
neither the UFSHC, nor the Flash chip, require any load from vccq, then
that power rail should simply not be specified at all in the DT.
Working around that fact in the driver is detrimental, as evidenced by the
failure to initialize the host controller on MSM8998.
Acked-by: Avri Altman <avri.altman@wdc.com>
Acked-by: Alim Akhtar <alim.akhtar@samsung.com>
Signed-off-by: Marc Gonzalez <marc.w.gonzalez@free.fr>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-27 10:41:45 +00:00
|
|
|
return ufshcd_config_vreg_load(hba->dev, vreg, vreg->max_uA);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
static int ufshcd_config_vreg(struct device *dev,
|
|
|
|
struct ufs_vreg *vreg, bool on)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2017-11-20 14:12:29 +00:00
|
|
|
struct regulator *reg;
|
|
|
|
const char *name;
|
2014-09-25 12:32:22 +00:00
|
|
|
int min_uV, uA_load;
|
|
|
|
|
|
|
|
BUG_ON(!vreg);
|
|
|
|
|
2017-11-20 14:12:29 +00:00
|
|
|
reg = vreg->reg;
|
|
|
|
name = vreg->name;
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
if (regulator_count_voltages(reg) > 0) {
|
2020-02-11 03:40:45 +00:00
|
|
|
uA_load = on ? vreg->max_uA : 0;
|
|
|
|
ret = ufshcd_config_vreg_load(dev, vreg, uA_load);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2019-03-28 09:16:24 +00:00
|
|
|
if (vreg->min_uV && vreg->max_uV) {
|
|
|
|
min_uV = on ? vreg->min_uV : 0;
|
|
|
|
ret = regulator_set_voltage(reg, min_uV, vreg->max_uV);
|
2020-08-14 09:50:34 +00:00
|
|
|
if (ret)
|
2019-03-28 09:16:24 +00:00
|
|
|
dev_err(dev,
|
|
|
|
"%s: %s set voltage failed, err=%d\n",
|
2014-09-25 12:32:22 +00:00
|
|
|
__func__, name, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_enable_vreg(struct device *dev, struct ufs_vreg *vreg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
Revert "scsi: ufs: disable vccq if it's not needed by UFS device"
This reverts commit 60f0187031c05e04cbadffb62f557d0ff3564490.
There was one conflict in drivers/scsi/ufs/ufshcd.c
<<<<<<< HEAD
/* Init check for device descriptor sizes */
ufshcd_init_desc_sizes(hba);
ret = ufs_get_device_desc(hba, &card);
if (ret) {
dev_err(hba->dev, "%s: Failed getting device info. err = %d\n",
__func__, ret);
goto out;
}
ufs_fixup_device_setup(hba, &card);
ufshcd_tune_unipro_params(hba);
ret = ufshcd_set_vccq_rail_unused(hba,
(hba->dev_quirks & UFS_DEVICE_NO_VCCQ) ? true : false);
if (ret)
goto out;
=======
ufs_advertise_fixup_device(hba);
>>>>>>> parent of 60f0187031c0... scsi: ufs: disable vccq if it's not needed by UFS device
Resolution: keep HEAD, and delete the ufshcd_set_vccq_rail_unused() call
and corresponding error-handling code.
Clean up loose ends in a follow-up patch.
60f0187031c0 introduced a small power optimization: ignore the vccq load
specified in the UFSHC DT node when said host controller is connected to
specific Flash chips (currently, Samsung and Hynix).
Unfortunately, this optimization breaks UFS on systems where vccq powers
not only the Flash chip, but the host controller as well, such as APQ8098
MEDIABOX or MTP8998:
[ 3.929877] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 5.433815] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937771] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937866] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr_retry: query attribute, idn 13, failed with error -11 after 3 retires
[ 6.946412] ufshcd-qcom 1da4000.ufshc: ufshcd_disable_auto_bkops: failed to enable exception event -11
[ 6.957972] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1587 failed 3 retries
[ 6.967181] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1586 failed 3 retries
[ 6.975025] ufshcd-qcom 1da4000.ufshc: ufshcd_get_max_pwr_mode: invalid max pwm tx gear read = 0
[ 6.982755] ufshcd-qcom 1da4000.ufshc: ufshcd_probe_hba: Failed getting max supported power mode
[ 8.505770] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 10.009807] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513766] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513861] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag_retry: query attribute, opcode 5, idn 3, failed with error -11 after 3 retires
[ 13.049807] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 14.553768] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057767] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057872] ufshcd-qcom 1da4000.ufshc: ufshcd_read_desc_param: Failed reading descriptor. desc_id 8, desc_index 0, param_offset 0, ret -11
[ 16.067109] ufshcd-qcom 1da4000.ufshc: ufshcd_init_icc_levels: Failed reading power descriptor.len = 98 ret = -11
[ 37.073787] ufshcd-qcom 1da4000.ufshc: link startup failed 1
In my opinion, the rationale for the original patch is questionable. If
neither the UFSHC, nor the Flash chip, require any load from vccq, then
that power rail should simply not be specified at all in the DT.
Working around that fact in the driver is detrimental, as evidenced by the
failure to initialize the host controller on MSM8998.
Acked-by: Avri Altman <avri.altman@wdc.com>
Acked-by: Alim Akhtar <alim.akhtar@samsung.com>
Signed-off-by: Marc Gonzalez <marc.w.gonzalez@free.fr>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-27 10:41:45 +00:00
|
|
|
if (!vreg || vreg->enabled)
|
2014-09-25 12:32:22 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_config_vreg(dev, vreg, true);
|
|
|
|
if (!ret)
|
|
|
|
ret = regulator_enable(vreg->reg);
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
vreg->enabled = true;
|
|
|
|
else
|
|
|
|
dev_err(dev, "%s: %s enable failed, err=%d\n",
|
|
|
|
__func__, vreg->name, ret);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_disable_vreg(struct device *dev, struct ufs_vreg *vreg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
Revert "scsi: ufs: disable vccq if it's not needed by UFS device"
This reverts commit 60f0187031c05e04cbadffb62f557d0ff3564490.
There was one conflict in drivers/scsi/ufs/ufshcd.c
<<<<<<< HEAD
/* Init check for device descriptor sizes */
ufshcd_init_desc_sizes(hba);
ret = ufs_get_device_desc(hba, &card);
if (ret) {
dev_err(hba->dev, "%s: Failed getting device info. err = %d\n",
__func__, ret);
goto out;
}
ufs_fixup_device_setup(hba, &card);
ufshcd_tune_unipro_params(hba);
ret = ufshcd_set_vccq_rail_unused(hba,
(hba->dev_quirks & UFS_DEVICE_NO_VCCQ) ? true : false);
if (ret)
goto out;
=======
ufs_advertise_fixup_device(hba);
>>>>>>> parent of 60f0187031c0... scsi: ufs: disable vccq if it's not needed by UFS device
Resolution: keep HEAD, and delete the ufshcd_set_vccq_rail_unused() call
and corresponding error-handling code.
Clean up loose ends in a follow-up patch.
60f0187031c0 introduced a small power optimization: ignore the vccq load
specified in the UFSHC DT node when said host controller is connected to
specific Flash chips (currently, Samsung and Hynix).
Unfortunately, this optimization breaks UFS on systems where vccq powers
not only the Flash chip, but the host controller as well, such as APQ8098
MEDIABOX or MTP8998:
[ 3.929877] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 5.433815] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937771] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr: opcode 0x04 for idn 13 failed, index 0, err = -11
[ 6.937866] ufshcd-qcom 1da4000.ufshc: ufshcd_query_attr_retry: query attribute, idn 13, failed with error -11 after 3 retires
[ 6.946412] ufshcd-qcom 1da4000.ufshc: ufshcd_disable_auto_bkops: failed to enable exception event -11
[ 6.957972] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1587 failed 3 retries
[ 6.967181] ufshcd-qcom 1da4000.ufshc: dme-peer-get: attr-id 0x1586 failed 3 retries
[ 6.975025] ufshcd-qcom 1da4000.ufshc: ufshcd_get_max_pwr_mode: invalid max pwm tx gear read = 0
[ 6.982755] ufshcd-qcom 1da4000.ufshc: ufshcd_probe_hba: Failed getting max supported power mode
[ 8.505770] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 10.009807] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513766] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag: Sending flag query for idn 3 failed, err = -11
[ 11.513861] ufshcd-qcom 1da4000.ufshc: ufshcd_query_flag_retry: query attribute, opcode 5, idn 3, failed with error -11 after 3 retires
[ 13.049807] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 14.553768] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057767] ufshcd-qcom 1da4000.ufshc: __ufshcd_query_descriptor: opcode 0x01 for idn 8 failed, index 0, err = -11
[ 16.057872] ufshcd-qcom 1da4000.ufshc: ufshcd_read_desc_param: Failed reading descriptor. desc_id 8, desc_index 0, param_offset 0, ret -11
[ 16.067109] ufshcd-qcom 1da4000.ufshc: ufshcd_init_icc_levels: Failed reading power descriptor.len = 98 ret = -11
[ 37.073787] ufshcd-qcom 1da4000.ufshc: link startup failed 1
In my opinion, the rationale for the original patch is questionable. If
neither the UFSHC, nor the Flash chip, require any load from vccq, then
that power rail should simply not be specified at all in the DT.
Working around that fact in the driver is detrimental, as evidenced by the
failure to initialize the host controller on MSM8998.
Acked-by: Avri Altman <avri.altman@wdc.com>
Acked-by: Alim Akhtar <alim.akhtar@samsung.com>
Signed-off-by: Marc Gonzalez <marc.w.gonzalez@free.fr>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-27 10:41:45 +00:00
|
|
|
if (!vreg || !vreg->enabled)
|
2014-09-25 12:32:22 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = regulator_disable(vreg->reg);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
/* ignore errors on applying disable config */
|
|
|
|
ufshcd_config_vreg(dev, vreg, false);
|
|
|
|
vreg->enabled = false;
|
|
|
|
} else {
|
|
|
|
dev_err(dev, "%s: %s disable failed, err=%d\n",
|
|
|
|
__func__, vreg->name, ret);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_setup_vreg(struct ufs_hba *hba, bool on)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
struct ufs_vreg_info *info = &hba->vreg_info;
|
|
|
|
|
|
|
|
ret = ufshcd_toggle_vreg(dev, info->vcc, on);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_toggle_vreg(dev, info->vccq, on);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_toggle_vreg(dev, info->vccq2, on);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (ret) {
|
|
|
|
ufshcd_toggle_vreg(dev, info->vccq2, false);
|
|
|
|
ufshcd_toggle_vreg(dev, info->vccq, false);
|
|
|
|
ufshcd_toggle_vreg(dev, info->vcc, false);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
static int ufshcd_setup_hba_vreg(struct ufs_hba *hba, bool on)
|
|
|
|
{
|
|
|
|
struct ufs_vreg_info *info = &hba->vreg_info;
|
|
|
|
|
2019-03-30 09:03:13 +00:00
|
|
|
return ufshcd_toggle_vreg(hba->dev, info->vdd_hba, on);
|
2014-09-25 12:32:24 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
static int ufshcd_get_vreg(struct device *dev, struct ufs_vreg *vreg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!vreg)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
vreg->reg = devm_regulator_get(dev, vreg->name);
|
|
|
|
if (IS_ERR(vreg->reg)) {
|
|
|
|
ret = PTR_ERR(vreg->reg);
|
|
|
|
dev_err(dev, "%s: %s get failed, err=%d\n",
|
|
|
|
__func__, vreg->name, ret);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_init_vreg(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
struct ufs_vreg_info *info = &hba->vreg_info;
|
|
|
|
|
|
|
|
ret = ufshcd_get_vreg(dev, info->vcc);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = ufshcd_get_vreg(dev, info->vccq);
|
2020-08-14 09:50:34 +00:00
|
|
|
if (!ret)
|
|
|
|
ret = ufshcd_get_vreg(dev, info->vccq2);
|
2014-09-25 12:32:22 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
static int ufshcd_init_hba_vreg(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
struct ufs_vreg_info *info = &hba->vreg_info;
|
|
|
|
|
|
|
|
if (info)
|
|
|
|
return ufshcd_get_vreg(hba->dev, info->vdd_hba);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
static int __ufshcd_setup_clocks(struct ufs_hba *hba, bool on,
|
|
|
|
bool skip_ref_clk)
|
2014-09-25 12:32:23 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ufs_clk_info *clki;
|
|
|
|
struct list_head *head = &hba->clk_list_head;
|
2014-09-25 12:32:32 +00:00
|
|
|
unsigned long flags;
|
2016-12-23 02:41:48 +00:00
|
|
|
ktime_t start = ktime_get();
|
|
|
|
bool clk_state_changed = false;
|
2014-09-25 12:32:23 +00:00
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
if (list_empty(head))
|
2014-09-25 12:32:23 +00:00
|
|
|
goto out;
|
|
|
|
|
2020-02-11 03:40:47 +00:00
|
|
|
ret = ufshcd_vops_setup_clocks(hba, on, PRE_CHANGE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-10-07 04:48:22 +00:00
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
list_for_each_entry(clki, head, list) {
|
|
|
|
if (!IS_ERR_OR_NULL(clki->clk)) {
|
2014-09-25 12:32:30 +00:00
|
|
|
if (skip_ref_clk && !strcmp(clki->name, "ref_clk"))
|
|
|
|
continue;
|
|
|
|
|
2016-12-23 02:41:48 +00:00
|
|
|
clk_state_changed = on ^ clki->enabled;
|
2014-09-25 12:32:23 +00:00
|
|
|
if (on && !clki->enabled) {
|
|
|
|
ret = clk_prepare_enable(clki->clk);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s: %s prepare enable failed, %d\n",
|
|
|
|
__func__, clki->name, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else if (!on && clki->enabled) {
|
|
|
|
clk_disable_unprepare(clki->clk);
|
|
|
|
}
|
|
|
|
clki->enabled = on;
|
|
|
|
dev_dbg(hba->dev, "%s: clk: %s %sabled\n", __func__,
|
|
|
|
clki->name, on ? "en" : "dis");
|
|
|
|
}
|
|
|
|
}
|
2014-09-25 12:32:32 +00:00
|
|
|
|
2020-02-11 03:40:47 +00:00
|
|
|
ret = ufshcd_vops_setup_clocks(hba, on, POST_CHANGE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-10-07 04:48:22 +00:00
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
out:
|
|
|
|
if (ret) {
|
|
|
|
list_for_each_entry(clki, head, list) {
|
|
|
|
if (!IS_ERR_OR_NULL(clki->clk) && clki->enabled)
|
|
|
|
clk_disable_unprepare(clki->clk);
|
|
|
|
}
|
2016-12-23 02:39:51 +00:00
|
|
|
} else if (!ret && on) {
|
2014-09-25 12:32:32 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
hba->clk_gating.state = CLKS_ON;
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
2014-09-25 12:32:32 +00:00
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
2014-09-25 12:32:23 +00:00
|
|
|
}
|
2016-12-23 02:39:51 +00:00
|
|
|
|
2016-12-23 02:41:48 +00:00
|
|
|
if (clk_state_changed)
|
|
|
|
trace_ufshcd_profile_clk_gating(dev_name(hba->dev),
|
|
|
|
(on ? "on" : "off"),
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)), ret);
|
2014-09-25 12:32:23 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_setup_clocks(struct ufs_hba *hba, bool on)
|
|
|
|
{
|
|
|
|
return __ufshcd_setup_clocks(hba, on, false);
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
static int ufshcd_init_clocks(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct ufs_clk_info *clki;
|
|
|
|
struct device *dev = hba->dev;
|
|
|
|
struct list_head *head = &hba->clk_list_head;
|
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
if (list_empty(head))
|
2014-09-25 12:32:23 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
list_for_each_entry(clki, head, list) {
|
|
|
|
if (!clki->name)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
clki->clk = devm_clk_get(dev, clki->name);
|
|
|
|
if (IS_ERR(clki->clk)) {
|
|
|
|
ret = PTR_ERR(clki->clk);
|
|
|
|
dev_err(dev, "%s: %s clk get failed, %d\n",
|
|
|
|
__func__, clki->name, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-10-16 08:59:41 +00:00
|
|
|
/*
|
|
|
|
* Parse device ref clk freq as per device tree "ref_clk".
|
|
|
|
* Default dev_ref_clk_freq is set to REF_CLK_FREQ_INVAL
|
|
|
|
* in ufshcd_alloc_host().
|
|
|
|
*/
|
|
|
|
if (!strcmp(clki->name, "ref_clk"))
|
|
|
|
ufshcd_parse_dev_ref_clk_freq(hba, clki->clk);
|
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
if (clki->max_freq) {
|
|
|
|
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);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-09-25 12:32:34 +00:00
|
|
|
clki->curr_freq = clki->max_freq;
|
2014-09-25 12:32:23 +00:00
|
|
|
}
|
|
|
|
dev_dbg(dev, "%s: clk: %s, rate: %lu\n", __func__,
|
|
|
|
clki->name, clk_get_rate(clki->clk));
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
static int ufshcd_variant_hba_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!hba->vops)
|
|
|
|
goto out;
|
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
err = ufshcd_vops_init(hba);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
err = ufshcd_vops_setup_regulators(hba, true);
|
|
|
|
if (err)
|
2020-08-14 09:50:34 +00:00
|
|
|
ufshcd_vops_exit(hba);
|
2014-09-25 12:32:21 +00:00
|
|
|
out:
|
|
|
|
if (err)
|
|
|
|
dev_err(hba->dev, "%s: variant %s init failed err %d\n",
|
2015-10-28 11:15:48 +00:00
|
|
|
__func__, ufshcd_get_var_name(hba), err);
|
2014-09-25 12:32:21 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_variant_hba_exit(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (!hba->vops)
|
|
|
|
return;
|
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_setup_regulators(hba, false);
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_exit(hba);
|
2014-09-25 12:32:21 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
static int ufshcd_hba_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
/*
|
|
|
|
* Handle host controller power separately from the UFS device power
|
|
|
|
* rails as it will help controlling the UFS host controller power
|
|
|
|
* collapse easily which is different than UFS device power collapse.
|
|
|
|
* Also, enable the host controller power before we go ahead with rest
|
|
|
|
* of the initialization here.
|
|
|
|
*/
|
|
|
|
err = ufshcd_init_hba_vreg(hba);
|
2014-09-25 12:32:22 +00:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
err = ufshcd_setup_hba_vreg(hba, true);
|
2014-09-25 12:32:22 +00:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2014-09-25 12:32:24 +00:00
|
|
|
err = ufshcd_init_clocks(hba);
|
|
|
|
if (err)
|
|
|
|
goto out_disable_hba_vreg;
|
|
|
|
|
|
|
|
err = ufshcd_setup_clocks(hba, true);
|
|
|
|
if (err)
|
|
|
|
goto out_disable_hba_vreg;
|
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
err = ufshcd_init_vreg(hba);
|
|
|
|
if (err)
|
|
|
|
goto out_disable_clks;
|
|
|
|
|
|
|
|
err = ufshcd_setup_vreg(hba, true);
|
|
|
|
if (err)
|
|
|
|
goto out_disable_clks;
|
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
err = ufshcd_variant_hba_init(hba);
|
|
|
|
if (err)
|
|
|
|
goto out_disable_vreg;
|
|
|
|
|
2014-09-25 12:32:26 +00:00
|
|
|
hba->is_powered = true;
|
2014-09-25 12:32:22 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
out_disable_vreg:
|
|
|
|
ufshcd_setup_vreg(hba, false);
|
2014-09-25 12:32:23 +00:00
|
|
|
out_disable_clks:
|
|
|
|
ufshcd_setup_clocks(hba, false);
|
2014-09-25 12:32:24 +00:00
|
|
|
out_disable_hba_vreg:
|
|
|
|
ufshcd_setup_hba_vreg(hba, false);
|
2014-09-25 12:32:22 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_hba_exit(struct ufs_hba *hba)
|
|
|
|
{
|
2014-09-25 12:32:26 +00:00
|
|
|
if (hba->is_powered) {
|
|
|
|
ufshcd_variant_hba_exit(hba);
|
|
|
|
ufshcd_setup_vreg(hba, false);
|
2016-10-18 00:10:00 +00:00
|
|
|
ufshcd_suspend_clkscaling(hba);
|
2018-08-07 17:47:39 +00:00
|
|
|
if (ufshcd_is_clkscaling_supported(hba))
|
2017-02-04 00:58:01 +00:00
|
|
|
if (hba->devfreq)
|
|
|
|
ufshcd_suspend_clkscaling(hba);
|
2014-09-25 12:32:26 +00:00
|
|
|
ufshcd_setup_clocks(hba, false);
|
|
|
|
ufshcd_setup_hba_vreg(hba, false);
|
|
|
|
hba->is_powered = false;
|
2020-01-20 13:08:14 +00:00
|
|
|
ufs_put_device_desc(hba);
|
2014-09-25 12:32:26 +00:00
|
|
|
}
|
2014-09-25 12:32:22 +00:00
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
static int
|
|
|
|
ufshcd_send_request_sense(struct ufs_hba *hba, struct scsi_device *sdp)
|
|
|
|
{
|
|
|
|
unsigned char cmd[6] = {REQUEST_SENSE,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
0,
|
2018-11-22 18:04:56 +00:00
|
|
|
UFS_SENSE_SIZE,
|
2014-09-25 12:32:30 +00:00
|
|
|
0};
|
|
|
|
char *buffer;
|
|
|
|
int ret;
|
|
|
|
|
2018-11-22 18:04:56 +00:00
|
|
|
buffer = kzalloc(UFS_SENSE_SIZE, GFP_KERNEL);
|
2014-09-25 12:32:30 +00:00
|
|
|
if (!buffer) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-02-23 15:02:37 +00:00
|
|
|
ret = scsi_execute(sdp, cmd, DMA_FROM_DEVICE, buffer,
|
2018-11-22 18:04:56 +00:00
|
|
|
UFS_SENSE_SIZE, NULL, NULL,
|
2017-02-23 15:02:37 +00:00
|
|
|
msecs_to_jiffies(1000), 3, 0, RQF_PM, NULL);
|
2014-09-25 12:32:30 +00:00
|
|
|
if (ret)
|
|
|
|
pr_err("%s: failed with err %d\n", __func__, ret);
|
|
|
|
|
|
|
|
kfree(buffer);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_set_dev_pwr_mode - sends START STOP UNIT command to set device
|
|
|
|
* power mode
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @pwr_mode: device power mode to set
|
|
|
|
*
|
|
|
|
* Returns 0 if requested power mode is set successfully
|
|
|
|
* Returns non-zero if failed to set the requested power mode
|
|
|
|
*/
|
|
|
|
static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
|
|
|
|
enum ufs_dev_pwr_mode pwr_mode)
|
|
|
|
{
|
|
|
|
unsigned char cmd[6] = { START_STOP };
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2014-10-23 10:25:12 +00:00
|
|
|
struct scsi_device *sdp;
|
|
|
|
unsigned long flags;
|
2014-09-25 12:32:30 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-10-23 10:25:12 +00:00
|
|
|
spin_lock_irqsave(hba->host->host_lock, flags);
|
|
|
|
sdp = hba->sdev_ufs_device;
|
|
|
|
if (sdp) {
|
|
|
|
ret = scsi_device_get(sdp);
|
|
|
|
if (!ret && !scsi_device_online(sdp)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
scsi_device_put(sdp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = -ENODEV;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(hba->host->host_lock, flags);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If scsi commands fail, the scsi mid-layer schedules scsi error-
|
|
|
|
* handling, which would wait for host to be resumed. Since we know
|
|
|
|
* we are functional while we are here, skip host resume in error
|
|
|
|
* handling context.
|
|
|
|
*/
|
|
|
|
hba->host->eh_noresume = 1;
|
|
|
|
if (hba->wlun_dev_clr_ua) {
|
|
|
|
ret = ufshcd_send_request_sense(hba, sdp);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
/* Unit attention condition is cleared now */
|
|
|
|
hba->wlun_dev_clr_ua = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd[4] = pwr_mode << 4;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Current function would be generally called from the power management
|
2016-10-20 13:12:13 +00:00
|
|
|
* callbacks hence set the RQF_PM flag so that it doesn't resume the
|
2014-09-25 12:32:30 +00:00
|
|
|
* already suspended childs.
|
|
|
|
*/
|
2017-02-23 15:02:37 +00:00
|
|
|
ret = scsi_execute(sdp, cmd, DMA_NONE, NULL, 0, NULL, &sshdr,
|
|
|
|
START_STOP_TIMEOUT, 0, 0, RQF_PM, NULL);
|
2014-09-25 12:32:30 +00:00
|
|
|
if (ret) {
|
|
|
|
sdev_printk(KERN_WARNING, sdp,
|
2014-10-24 12:27:00 +00:00
|
|
|
"START_STOP failed for power mode: %d, result %x\n",
|
|
|
|
pwr_mode, ret);
|
2018-06-25 11:20:58 +00:00
|
|
|
if (driver_byte(ret) == DRIVER_SENSE)
|
2015-01-08 06:43:46 +00:00
|
|
|
scsi_print_sense_hdr(sdp, NULL, &sshdr);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
hba->curr_dev_pwr_mode = pwr_mode;
|
|
|
|
out:
|
2014-10-23 10:25:12 +00:00
|
|
|
scsi_device_put(sdp);
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->host->eh_noresume = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_link_state_transition(struct ufs_hba *hba,
|
|
|
|
enum uic_link_state req_link_state,
|
|
|
|
int check_for_bkops)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (req_link_state == hba->uic_link_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (req_link_state == UIC_LINK_HIBERN8_STATE) {
|
|
|
|
ret = ufshcd_uic_hibern8_enter(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (!ret) {
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_set_link_hibern8(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
} else {
|
|
|
|
dev_err(hba->dev, "%s: hibern8 enter failed %d\n",
|
|
|
|
__func__, ret);
|
2014-09-25 12:32:30 +00:00
|
|
|
goto out;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If autobkops is enabled, link can't be turned off because
|
|
|
|
* turning off the link would also turn off the device.
|
|
|
|
*/
|
|
|
|
else if ((req_link_state == UIC_LINK_OFF_STATE) &&
|
2019-12-13 10:49:35 +00:00
|
|
|
(!check_for_bkops || !hba->auto_bkops_enabled)) {
|
2016-03-10 15:37:17 +00:00
|
|
|
/*
|
|
|
|
* Let's make sure that link is in low power mode, we are doing
|
|
|
|
* this currently by putting the link in Hibern8. Otherway to
|
|
|
|
* put the link in low power mode is to send the DME end point
|
|
|
|
* to device and then send the DME reset command to local
|
|
|
|
* unipro. But putting the link in hibern8 is much faster.
|
|
|
|
*/
|
|
|
|
ret = ufshcd_uic_hibern8_enter(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hba->dev, "%s: hibern8 enter failed %d\n",
|
|
|
|
__func__, ret);
|
2016-03-10 15:37:17 +00:00
|
|
|
goto out;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* Change controller state to "reset state" which
|
|
|
|
* should also put the link in off/reset state
|
|
|
|
*/
|
2020-05-07 22:27:50 +00:00
|
|
|
ufshcd_hba_stop(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* TODO: Check if we need any delay to make sure that
|
|
|
|
* controller is reset
|
|
|
|
*/
|
|
|
|
ufshcd_set_link_off(hba);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_vreg_set_lpm(struct ufs_hba *hba)
|
|
|
|
{
|
2020-07-29 05:18:39 +00:00
|
|
|
bool vcc_off = false;
|
|
|
|
|
2016-03-10 15:37:18 +00:00
|
|
|
/*
|
|
|
|
* It seems some UFS devices may keep drawing more than sleep current
|
|
|
|
* (atleast for 500us) from UFS rails (especially from VCCQ rail).
|
|
|
|
* To avoid this situation, add 2ms delay before putting these UFS
|
|
|
|
* rails in LPM mode.
|
|
|
|
*/
|
|
|
|
if (!ufshcd_is_link_active(hba) &&
|
|
|
|
hba->dev_quirks & UFS_DEVICE_QUIRK_DELAY_BEFORE_LPM)
|
|
|
|
usleep_range(2000, 2100);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* If UFS device is either in UFS_Sleep turn off VCC rail to save some
|
|
|
|
* power.
|
|
|
|
*
|
|
|
|
* If UFS device and link is in OFF state, all power supplies (VCC,
|
|
|
|
* VCCQ, VCCQ2) can be turned off if power on write protect is not
|
|
|
|
* required. If UFS link is inactive (Hibern8 or OFF state) and device
|
|
|
|
* is in sleep state, put VCCQ & VCCQ2 rails in LPM mode.
|
|
|
|
*
|
|
|
|
* Ignore the error returned by ufshcd_toggle_vreg() as device is anyway
|
|
|
|
* in low power state which would save some power.
|
2020-04-22 21:41:42 +00:00
|
|
|
*
|
|
|
|
* If Write Booster is enabled and the device needs to flush the WB
|
|
|
|
* buffer OR if bkops status is urgent for WB, keep Vcc on.
|
2014-09-25 12:32:30 +00:00
|
|
|
*/
|
|
|
|
if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba) &&
|
|
|
|
!hba->dev_info.is_lu_power_on_wp) {
|
|
|
|
ufshcd_setup_vreg(hba, false);
|
2020-07-29 05:18:39 +00:00
|
|
|
vcc_off = true;
|
2014-09-25 12:32:30 +00:00
|
|
|
} else if (!ufshcd_is_ufs_dev_active(hba)) {
|
2020-05-22 08:32:12 +00:00
|
|
|
ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, false);
|
2020-07-29 05:18:39 +00:00
|
|
|
vcc_off = true;
|
2014-09-25 12:32:30 +00:00
|
|
|
if (!ufshcd_is_link_active(hba)) {
|
|
|
|
ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq);
|
|
|
|
ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq2);
|
|
|
|
}
|
|
|
|
}
|
2020-07-29 05:18:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some UFS devices require delay after VCC power rail is turned-off.
|
|
|
|
*/
|
|
|
|
if (vcc_off && hba->vreg_info.vcc &&
|
|
|
|
hba->dev_quirks & UFS_DEVICE_QUIRK_DELAY_AFTER_LPM)
|
|
|
|
usleep_range(5000, 5100);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ufshcd_vreg_set_hpm(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba) &&
|
|
|
|
!hba->dev_info.is_lu_power_on_wp) {
|
|
|
|
ret = ufshcd_setup_vreg(hba, true);
|
|
|
|
} else if (!ufshcd_is_ufs_dev_active(hba)) {
|
|
|
|
if (!ret && !ufshcd_is_link_active(hba)) {
|
|
|
|
ret = ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq);
|
|
|
|
if (ret)
|
|
|
|
goto vcc_disable;
|
|
|
|
ret = ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq2);
|
|
|
|
if (ret)
|
|
|
|
goto vccq_lpm;
|
|
|
|
}
|
2016-10-28 00:26:24 +00:00
|
|
|
ret = ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, true);
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
vccq_lpm:
|
|
|
|
ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq);
|
|
|
|
vcc_disable:
|
|
|
|
ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, false);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_hba_vreg_set_lpm(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (ufshcd_is_link_off(hba))
|
|
|
|
ufshcd_setup_hba_vreg(hba, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ufshcd_hba_vreg_set_hpm(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (ufshcd_is_link_off(hba))
|
|
|
|
ufshcd_setup_hba_vreg(hba, true);
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2014-09-25 12:32:30 +00:00
|
|
|
* ufshcd_suspend - helper function for suspend operations
|
2013-02-25 16:14:32 +00:00
|
|
|
* @hba: per adapter instance
|
2014-09-25 12:32:30 +00:00
|
|
|
* @pm_op: desired low power operation type
|
|
|
|
*
|
|
|
|
* This function will try to put the UFS device and link into low power
|
|
|
|
* mode based on the "rpm_lvl" (Runtime PM level) or "spm_lvl"
|
|
|
|
* (System PM level).
|
|
|
|
*
|
|
|
|
* If this function is called during shutdown, it will make sure that
|
|
|
|
* both UFS device and UFS link is powered off.
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
2014-09-25 12:32:30 +00:00
|
|
|
* NOTE: UFS device & link must be active before we enter in this function.
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
int ret = 0;
|
|
|
|
enum ufs_pm_level pm_lvl;
|
|
|
|
enum ufs_dev_pwr_mode req_dev_pwr_mode;
|
|
|
|
enum uic_link_state req_link_state;
|
|
|
|
|
|
|
|
hba->pm_op_in_progress = 1;
|
|
|
|
if (!ufshcd_is_shutdown_pm(pm_op)) {
|
|
|
|
pm_lvl = ufshcd_is_runtime_pm(pm_op) ?
|
|
|
|
hba->rpm_lvl : hba->spm_lvl;
|
|
|
|
req_dev_pwr_mode = ufs_get_pm_lvl_to_dev_pwr_mode(pm_lvl);
|
|
|
|
req_link_state = ufs_get_pm_lvl_to_link_pwr_state(pm_lvl);
|
|
|
|
} else {
|
|
|
|
req_dev_pwr_mode = UFS_POWERDOWN_PWR_MODE;
|
|
|
|
req_link_state = UIC_LINK_OFF_STATE;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/*
|
2014-09-25 12:32:30 +00:00
|
|
|
* If we can't transition into any of the low power modes
|
|
|
|
* just gate the clocks.
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_hold(hba, false);
|
|
|
|
hba->clk_gating.is_suspended = true;
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
if (hba->clk_scaling.is_allowed) {
|
|
|
|
cancel_work_sync(&hba->clk_scaling.suspend_work);
|
|
|
|
cancel_work_sync(&hba->clk_scaling.resume_work);
|
|
|
|
ufshcd_suspend_clkscaling(hba);
|
|
|
|
}
|
2016-10-28 00:26:09 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if (req_dev_pwr_mode == UFS_ACTIVE_PWR_MODE &&
|
|
|
|
req_link_state == UIC_LINK_ACTIVE_STATE) {
|
|
|
|
goto disable_clks;
|
|
|
|
}
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if ((req_dev_pwr_mode == hba->curr_dev_pwr_mode) &&
|
|
|
|
(req_link_state == hba->uic_link_state))
|
2016-10-28 00:26:09 +00:00
|
|
|
goto enable_gating;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
/* UFS device & link must be active before we enter in this function */
|
|
|
|
if (!ufshcd_is_ufs_dev_active(hba) || !ufshcd_is_link_active(hba)) {
|
|
|
|
ret = -EINVAL;
|
2016-10-28 00:26:09 +00:00
|
|
|
goto enable_gating;
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ufshcd_is_runtime_pm(pm_op)) {
|
2014-09-25 12:32:35 +00:00
|
|
|
if (ufshcd_can_autobkops_during_suspend(hba)) {
|
|
|
|
/*
|
|
|
|
* The device is idle with no requests in the queue,
|
|
|
|
* allow background operations if bkops status shows
|
|
|
|
* that performance might be impacted.
|
|
|
|
*/
|
|
|
|
ret = ufshcd_urgent_bkops(hba);
|
|
|
|
if (ret)
|
|
|
|
goto enable_gating;
|
|
|
|
} else {
|
|
|
|
/* make sure that auto bkops is disabled */
|
|
|
|
ufshcd_disable_auto_bkops(hba);
|
|
|
|
}
|
2020-04-22 21:41:42 +00:00
|
|
|
/*
|
2020-05-22 08:32:12 +00:00
|
|
|
* If device needs to do BKOP or WB buffer flush during
|
|
|
|
* Hibern8, keep device power mode as "active power mode"
|
|
|
|
* and VCC supply.
|
2020-04-22 21:41:42 +00:00
|
|
|
*/
|
2020-05-22 08:32:12 +00:00
|
|
|
hba->dev_info.b_rpm_dev_flush_capable =
|
|
|
|
hba->auto_bkops_enabled ||
|
|
|
|
(((req_link_state == UIC_LINK_HIBERN8_STATE) ||
|
|
|
|
((req_link_state == UIC_LINK_ACTIVE_STATE) &&
|
|
|
|
ufshcd_is_auto_hibern8_enabled(hba))) &&
|
|
|
|
ufshcd_wb_need_flush(hba));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req_dev_pwr_mode != hba->curr_dev_pwr_mode) {
|
|
|
|
if ((ufshcd_is_runtime_pm(pm_op) && !hba->auto_bkops_enabled) ||
|
|
|
|
!ufshcd_is_runtime_pm(pm_op)) {
|
|
|
|
/* ensure that bkops is disabled */
|
|
|
|
ufshcd_disable_auto_bkops(hba);
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
if (!hba->dev_info.b_rpm_dev_flush_capable) {
|
|
|
|
ret = ufshcd_set_dev_pwr_mode(hba, req_dev_pwr_mode);
|
|
|
|
if (ret)
|
|
|
|
goto enable_gating;
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
}
|
|
|
|
|
2020-02-11 03:40:44 +00:00
|
|
|
flush_work(&hba->eeh_work);
|
2014-09-25 12:32:30 +00:00
|
|
|
ret = ufshcd_link_state_transition(hba, req_link_state, 1);
|
|
|
|
if (ret)
|
|
|
|
goto set_dev_active;
|
|
|
|
|
|
|
|
ufshcd_vreg_set_lpm(hba);
|
|
|
|
|
|
|
|
disable_clks:
|
|
|
|
/*
|
|
|
|
* Call vendor specific suspend callback. As these callbacks may access
|
|
|
|
* vendor specific host controller register space call them before the
|
|
|
|
* host clocks are ON.
|
|
|
|
*/
|
2015-10-28 11:15:48 +00:00
|
|
|
ret = ufshcd_vops_suspend(hba, pm_op);
|
|
|
|
if (ret)
|
|
|
|
goto set_link_active;
|
2019-12-07 12:22:00 +00:00
|
|
|
/*
|
|
|
|
* Disable the host irq as host controller as there won't be any
|
|
|
|
* host controller transaction expected till resume.
|
|
|
|
*/
|
|
|
|
ufshcd_disable_irq(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
if (!ufshcd_is_link_active(hba))
|
|
|
|
ufshcd_setup_clocks(hba, false);
|
|
|
|
else
|
|
|
|
/* If link is active, device ref_clk can't be switched off */
|
|
|
|
__ufshcd_setup_clocks(hba, false, true);
|
|
|
|
|
2020-08-09 12:15:47 +00:00
|
|
|
if (ufshcd_is_clkgating_allowed(hba)) {
|
|
|
|
hba->clk_gating.state = CLKS_OFF;
|
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
|
|
|
}
|
2019-12-07 12:22:00 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* Put the host controller in low power mode if possible */
|
|
|
|
ufshcd_hba_vreg_set_lpm(hba);
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
set_link_active:
|
2017-02-04 00:57:39 +00:00
|
|
|
if (hba->clk_scaling.is_allowed)
|
|
|
|
ufshcd_resume_clkscaling(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_vreg_set_hpm(hba);
|
|
|
|
if (ufshcd_is_link_hibern8(hba) && !ufshcd_uic_hibern8_exit(hba))
|
|
|
|
ufshcd_set_link_active(hba);
|
|
|
|
else if (ufshcd_is_link_off(hba))
|
|
|
|
ufshcd_host_reset_and_restore(hba);
|
|
|
|
set_dev_active:
|
|
|
|
if (!ufshcd_set_dev_pwr_mode(hba, UFS_ACTIVE_PWR_MODE))
|
|
|
|
ufshcd_disable_auto_bkops(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
enable_gating:
|
2017-02-04 00:57:39 +00:00
|
|
|
if (hba->clk_scaling.is_allowed)
|
|
|
|
ufshcd_resume_clkscaling(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.is_suspended = false;
|
2020-05-22 08:32:12 +00:00
|
|
|
hba->dev_info.b_rpm_dev_flush_capable = false;
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_release(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
out:
|
2020-05-22 08:32:12 +00:00
|
|
|
if (hba->dev_info.b_rpm_dev_flush_capable) {
|
|
|
|
schedule_delayed_work(&hba->rpm_dev_flush_recheck_work,
|
|
|
|
msecs_to_jiffies(RPM_DEV_FLUSH_RECHECK_WORK_DELAY_MS));
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->pm_op_in_progress = 0;
|
2020-05-22 08:32:12 +00:00
|
|
|
|
2019-07-10 13:38:21 +00:00
|
|
|
if (ret)
|
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.suspend_err, (u32)ret);
|
2014-09-25 12:32:30 +00:00
|
|
|
return ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-09-25 12:32:30 +00:00
|
|
|
* ufshcd_resume - helper function for resume operations
|
2013-02-25 16:14:32 +00:00
|
|
|
* @hba: per adapter instance
|
2014-09-25 12:32:30 +00:00
|
|
|
* @pm_op: runtime PM or system PM
|
2012-02-29 06:41:50 +00:00
|
|
|
*
|
2014-09-25 12:32:30 +00:00
|
|
|
* This function basically brings the UFS device, UniPro link and controller
|
|
|
|
* to active state.
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2014-09-25 12:32:30 +00:00
|
|
|
static int ufshcd_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
2014-09-25 12:32:30 +00:00
|
|
|
int ret;
|
|
|
|
enum uic_link_state old_link_state;
|
|
|
|
|
|
|
|
hba->pm_op_in_progress = 1;
|
|
|
|
old_link_state = hba->uic_link_state;
|
|
|
|
|
|
|
|
ufshcd_hba_vreg_set_hpm(hba);
|
|
|
|
/* Make sure clocks are enabled before accessing controller */
|
|
|
|
ret = ufshcd_setup_clocks(hba, true);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* enable the host irq as host controller would be active soon */
|
2019-12-05 02:14:46 +00:00
|
|
|
ufshcd_enable_irq(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
ret = ufshcd_vreg_set_hpm(hba);
|
|
|
|
if (ret)
|
|
|
|
goto disable_irq_and_vops_clks;
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/*
|
2014-09-25 12:32:30 +00:00
|
|
|
* Call vendor specific resume callback. As these callbacks may access
|
|
|
|
* vendor specific host controller register space call them when the
|
|
|
|
* host clocks are ON.
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2015-10-28 11:15:48 +00:00
|
|
|
ret = ufshcd_vops_resume(hba, pm_op);
|
|
|
|
if (ret)
|
|
|
|
goto disable_vreg;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
if (ufshcd_is_link_hibern8(hba)) {
|
|
|
|
ret = ufshcd_uic_hibern8_exit(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
if (!ret) {
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_set_link_active(hba);
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
} else {
|
|
|
|
dev_err(hba->dev, "%s: hibern8 exit failed %d\n",
|
|
|
|
__func__, ret);
|
2014-09-25 12:32:30 +00:00
|
|
|
goto vendor_suspend;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
} else if (ufshcd_is_link_off(hba)) {
|
|
|
|
/*
|
2020-04-14 06:14:48 +00:00
|
|
|
* A full initialization of the host and the device is
|
|
|
|
* required since the link was put to off during suspend.
|
|
|
|
*/
|
|
|
|
ret = ufshcd_reset_and_restore(hba);
|
|
|
|
/*
|
|
|
|
* ufshcd_reset_and_restore() should have already
|
2014-09-25 12:32:30 +00:00
|
|
|
* set the link state as active
|
|
|
|
*/
|
|
|
|
if (ret || !ufshcd_is_link_active(hba))
|
|
|
|
goto vendor_suspend;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ufshcd_is_ufs_dev_active(hba)) {
|
|
|
|
ret = ufshcd_set_dev_pwr_mode(hba, UFS_ACTIVE_PWR_MODE);
|
|
|
|
if (ret)
|
|
|
|
goto set_old_link_state;
|
|
|
|
}
|
|
|
|
|
2016-12-23 02:41:22 +00:00
|
|
|
if (ufshcd_keep_autobkops_enabled_except_suspend(hba))
|
|
|
|
ufshcd_enable_auto_bkops(hba);
|
|
|
|
else
|
|
|
|
/*
|
|
|
|
* If BKOPs operations are urgently needed at this moment then
|
|
|
|
* keep auto-bkops enabled or else disable it.
|
|
|
|
*/
|
|
|
|
ufshcd_urgent_bkops(hba);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
hba->clk_gating.is_suspended = false;
|
|
|
|
|
2016-12-23 02:40:50 +00:00
|
|
|
if (hba->clk_scaling.is_allowed)
|
|
|
|
ufshcd_resume_clkscaling(hba);
|
2014-09-25 12:32:34 +00:00
|
|
|
|
2018-03-20 13:07:38 +00:00
|
|
|
/* Enable Auto-Hibernate if configured */
|
|
|
|
ufshcd_auto_hibern8_enable(hba);
|
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
if (hba->dev_info.b_rpm_dev_flush_capable) {
|
|
|
|
hba->dev_info.b_rpm_dev_flush_capable = false;
|
|
|
|
cancel_delayed_work(&hba->rpm_dev_flush_recheck_work);
|
|
|
|
}
|
|
|
|
|
2019-11-15 06:09:26 +00:00
|
|
|
/* Schedule clock gating in case of no access to UFS device yet */
|
|
|
|
ufshcd_release(hba);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
set_old_link_state:
|
|
|
|
ufshcd_link_state_transition(hba, old_link_state, 0);
|
|
|
|
vendor_suspend:
|
2015-10-28 11:15:48 +00:00
|
|
|
ufshcd_vops_suspend(hba, pm_op);
|
2014-09-25 12:32:30 +00:00
|
|
|
disable_vreg:
|
|
|
|
ufshcd_vreg_set_lpm(hba);
|
|
|
|
disable_irq_and_vops_clks:
|
|
|
|
ufshcd_disable_irq(hba);
|
2017-02-04 00:57:39 +00:00
|
|
|
if (hba->clk_scaling.is_allowed)
|
|
|
|
ufshcd_suspend_clkscaling(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
ufshcd_setup_clocks(hba, false);
|
2020-08-09 12:15:47 +00:00
|
|
|
if (ufshcd_is_clkgating_allowed(hba)) {
|
|
|
|
hba->clk_gating.state = CLKS_OFF;
|
|
|
|
trace_ufshcd_clk_gating(dev_name(hba->dev),
|
|
|
|
hba->clk_gating.state);
|
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
out:
|
|
|
|
hba->pm_op_in_progress = 0;
|
2019-07-10 13:38:21 +00:00
|
|
|
if (ret)
|
|
|
|
ufshcd_update_reg_hist(&hba->ufs_stats.resume_err, (u32)ret);
|
2014-09-25 12:32:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_system_suspend - system suspend routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Check the description of ufshcd_suspend() function for more details.
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
|
|
|
*/
|
|
|
|
int ufshcd_system_suspend(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2016-12-23 02:39:51 +00:00
|
|
|
ktime_t start = ktime_get();
|
2014-09-25 12:32:30 +00:00
|
|
|
|
|
|
|
if (!hba || !hba->is_powered)
|
2014-10-23 10:25:14 +00:00
|
|
|
return 0;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2016-11-24 00:33:08 +00:00
|
|
|
if ((ufs_get_pm_lvl_to_dev_pwr_mode(hba->spm_lvl) ==
|
|
|
|
hba->curr_dev_pwr_mode) &&
|
|
|
|
(ufs_get_pm_lvl_to_link_pwr_state(hba->spm_lvl) ==
|
|
|
|
hba->uic_link_state))
|
|
|
|
goto out;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2016-11-24 00:33:08 +00:00
|
|
|
if (pm_runtime_suspended(hba->dev)) {
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* UFS device and/or UFS link low power states during runtime
|
|
|
|
* suspend seems to be different than what is expected during
|
|
|
|
* system suspend. Hence runtime resume the devic & link and
|
|
|
|
* let the system suspend low power states to take effect.
|
|
|
|
* TODO: If resume takes longer time, we might have optimize
|
|
|
|
* it in future by not resuming everything if possible.
|
|
|
|
*/
|
|
|
|
ret = ufshcd_runtime_resume(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ufshcd_suspend(hba, UFS_SYSTEM_PM);
|
|
|
|
out:
|
2016-12-23 02:39:51 +00:00
|
|
|
trace_ufshcd_system_suspend(dev_name(hba->dev), ret,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)),
|
2017-01-11 00:48:25 +00:00
|
|
|
hba->curr_dev_pwr_mode, hba->uic_link_state);
|
2014-09-25 12:32:36 +00:00
|
|
|
if (!ret)
|
|
|
|
hba->is_sys_suspended = true;
|
2014-09-25 12:32:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_system_suspend);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_system_resume - system resume routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
|
|
|
*/
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
int ufshcd_system_resume(struct ufs_hba *hba)
|
|
|
|
{
|
2016-12-23 02:39:51 +00:00
|
|
|
int ret = 0;
|
|
|
|
ktime_t start = ktime_get();
|
|
|
|
|
2016-10-18 00:09:24 +00:00
|
|
|
if (!hba)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!hba->is_powered || pm_runtime_suspended(hba->dev))
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* Let the runtime resume take care of resuming
|
|
|
|
* if runtime suspended.
|
|
|
|
*/
|
2016-12-23 02:39:51 +00:00
|
|
|
goto out;
|
|
|
|
else
|
|
|
|
ret = ufshcd_resume(hba, UFS_SYSTEM_PM);
|
|
|
|
out:
|
|
|
|
trace_ufshcd_system_resume(dev_name(hba->dev), ret,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)),
|
2017-01-11 00:48:25 +00:00
|
|
|
hba->curr_dev_pwr_mode, hba->uic_link_state);
|
2019-01-07 14:19:34 +00:00
|
|
|
if (!ret)
|
|
|
|
hba->is_sys_suspended = false;
|
2016-12-23 02:39:51 +00:00
|
|
|
return ret;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2014-09-25 12:32:30 +00:00
|
|
|
EXPORT_SYMBOL(ufshcd_system_resume);
|
2013-02-25 16:14:32 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_runtime_suspend - runtime suspend routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Check the description of ufshcd_suspend() function for more details.
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
|
|
|
*/
|
2013-07-29 19:05:59 +00:00
|
|
|
int ufshcd_runtime_suspend(struct ufs_hba *hba)
|
|
|
|
{
|
2016-12-23 02:39:51 +00:00
|
|
|
int ret = 0;
|
|
|
|
ktime_t start = ktime_get();
|
|
|
|
|
2016-10-18 00:09:24 +00:00
|
|
|
if (!hba)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!hba->is_powered)
|
2016-12-23 02:39:51 +00:00
|
|
|
goto out;
|
|
|
|
else
|
|
|
|
ret = ufshcd_suspend(hba, UFS_RUNTIME_PM);
|
|
|
|
out:
|
|
|
|
trace_ufshcd_runtime_suspend(dev_name(hba->dev), ret,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)),
|
2017-01-11 00:48:25 +00:00
|
|
|
hba->curr_dev_pwr_mode, hba->uic_link_state);
|
2016-12-23 02:39:51 +00:00
|
|
|
return ret;
|
2013-07-29 19:05:59 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_runtime_suspend);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_runtime_resume - runtime resume routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* This function basically brings the UFS device, UniPro link and controller
|
|
|
|
* to active state. Following operations are done in this function:
|
|
|
|
*
|
|
|
|
* 1. Turn on all the controller related clocks
|
|
|
|
* 2. Bring the UniPro link out of Hibernate state
|
|
|
|
* 3. If UFS device is in sleep state, turn ON VCC rail and bring the UFS device
|
|
|
|
* to active state.
|
|
|
|
* 4. If auto-bkops is enabled on the device, disable it.
|
|
|
|
*
|
|
|
|
* So following would be the possible power state after this function return
|
|
|
|
* successfully:
|
|
|
|
* S1: UFS device in Active state with VCC rail ON
|
|
|
|
* UniPro link in Active state
|
|
|
|
* All the UFS/UniPro controller clocks are ON
|
|
|
|
*
|
|
|
|
* Returns 0 for success and non-zero for failure
|
|
|
|
*/
|
2013-07-29 19:05:59 +00:00
|
|
|
int ufshcd_runtime_resume(struct ufs_hba *hba)
|
|
|
|
{
|
2016-12-23 02:39:51 +00:00
|
|
|
int ret = 0;
|
|
|
|
ktime_t start = ktime_get();
|
|
|
|
|
2016-10-18 00:09:24 +00:00
|
|
|
if (!hba)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!hba->is_powered)
|
2016-12-23 02:39:51 +00:00
|
|
|
goto out;
|
|
|
|
else
|
|
|
|
ret = ufshcd_resume(hba, UFS_RUNTIME_PM);
|
|
|
|
out:
|
|
|
|
trace_ufshcd_runtime_resume(dev_name(hba->dev), ret,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)),
|
2017-01-11 00:48:25 +00:00
|
|
|
hba->curr_dev_pwr_mode, hba->uic_link_state);
|
2016-12-23 02:39:51 +00:00
|
|
|
return ret;
|
2013-07-29 19:05:59 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_runtime_resume);
|
|
|
|
|
|
|
|
int ufshcd_runtime_idle(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_runtime_idle);
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_shutdown - shutdown routine
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* This function would power off both UFS device and UFS link.
|
|
|
|
*
|
|
|
|
* Returns 0 always to allow force shutdown even in case of errors.
|
|
|
|
*/
|
|
|
|
int ufshcd_shutdown(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2019-09-18 04:20:38 +00:00
|
|
|
if (!hba->is_powered)
|
|
|
|
goto out;
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (pm_runtime_suspended(hba->dev)) {
|
|
|
|
ret = ufshcd_runtime_resume(hba);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ufshcd_suspend(hba, UFS_SHUTDOWN_PM);
|
|
|
|
out:
|
|
|
|
if (ret)
|
|
|
|
dev_err(hba->dev, "%s failed, err %d\n", __func__, ret);
|
|
|
|
/* allow force shutdown even in case of errors */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_shutdown);
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2013-02-25 16:14:32 +00:00
|
|
|
* ufshcd_remove - de-allocate SCSI host and host memory space
|
2012-02-29 06:41:50 +00:00
|
|
|
* data structure memory
|
2018-03-01 23:07:20 +00:00
|
|
|
* @hba: per adapter instance
|
2012-02-29 06:41:50 +00:00
|
|
|
*/
|
2013-02-25 16:14:32 +00:00
|
|
|
void ufshcd_remove(struct ufs_hba *hba)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
scsi: ufs: Add a bsg endpoint that supports UPIUs
For now, just provide an API to allocate and remove ufs-bsg node. We
will use this framework to manage ufs devices by sending UPIU
transactions.
For the time being, implements an empty bsg_request() - will add some
more functionality in coming patches.
Nonetheless, we reveal here the protocol we are planning to use: UFS
Transport Protocol Transactions. UFS transactions consist of packets
called UFS Protocol Information Units (UPIU).
There are UPIU’s defined for UFS SCSI commands, responses, data in and
data out, task management, utility functions, vendor functions,
transaction synchronization and control, and more.
By using UPIUs, we get access to the most fine-grained internals of this
protocol, and able to communicate with the device in ways, that are
sometimes beyond the capacity of the ufs driver.
Moreover and as a result, our core structure - ufs_bsg_node has a pretty
lean structure: using upiu transactions that contains the outmost
detailed info, so we don't really need complex constructs to support it.
Signed-off-by: Avri Altman <avri.altman@wdc.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Bart Van Assche <Bart.VanAssche@wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2018-10-07 14:30:35 +00:00
|
|
|
ufs_bsg_remove(hba);
|
2018-02-15 12:14:01 +00:00
|
|
|
ufs_sysfs_remove_nodes(hba->dev);
|
2019-12-09 18:13:09 +00:00
|
|
|
blk_cleanup_queue(hba->tmf_queue);
|
|
|
|
blk_mq_free_tag_set(&hba->tmf_tag_set);
|
2019-12-09 18:13:08 +00:00
|
|
|
blk_cleanup_queue(hba->cmd_queue);
|
2013-07-29 19:06:03 +00:00
|
|
|
scsi_remove_host(hba->host);
|
2012-02-29 06:41:50 +00:00
|
|
|
/* disable interrupts */
|
2013-06-26 17:09:27 +00:00
|
|
|
ufshcd_disable_intr(hba, hba->intr_mask);
|
2020-05-07 22:27:50 +00:00
|
|
|
ufshcd_hba_stop(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2018-08-07 17:47:39 +00:00
|
|
|
ufshcd_exit_clk_scaling(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_exit_clk_gating(hba);
|
2016-12-23 02:40:50 +00:00
|
|
|
if (ufshcd_is_clkscaling_supported(hba))
|
|
|
|
device_remove_file(hba->dev, &hba->clk_scaling.enable_attr);
|
2014-09-25 12:32:22 +00:00
|
|
|
ufshcd_hba_exit(hba);
|
2013-02-25 16:14:32 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_remove);
|
|
|
|
|
2015-10-28 11:15:49 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_dealloc_host - deallocate Host Bus Adapter (HBA)
|
|
|
|
* @hba: pointer to Host Bus Adapter (HBA)
|
|
|
|
*/
|
|
|
|
void ufshcd_dealloc_host(struct ufs_hba *hba)
|
|
|
|
{
|
2020-07-06 20:04:14 +00:00
|
|
|
ufshcd_crypto_destroy_keyslot_manager(hba);
|
2015-10-28 11:15:49 +00:00
|
|
|
scsi_host_put(hba->host);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_dealloc_host);
|
|
|
|
|
2014-07-13 12:24:46 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_set_dma_mask - Set dma mask based on the controller
|
|
|
|
* addressing capability
|
|
|
|
* @hba: per adapter instance
|
|
|
|
*
|
|
|
|
* Returns 0 for success, non-zero for failure
|
|
|
|
*/
|
|
|
|
static int ufshcd_set_dma_mask(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (hba->capabilities & MASK_64_ADDRESSING_SUPPORT) {
|
|
|
|
if (!dma_set_mask_and_coherent(hba->dev, DMA_BIT_MASK(64)))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return dma_set_mask_and_coherent(hba->dev, DMA_BIT_MASK(32));
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/**
|
2014-09-25 12:32:21 +00:00
|
|
|
* ufshcd_alloc_host - allocate Host Bus Adapter (HBA)
|
2013-02-25 16:14:32 +00:00
|
|
|
* @dev: pointer to device handle
|
|
|
|
* @hba_handle: driver private handle
|
2012-02-29 06:41:50 +00:00
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
2014-09-25 12:32:21 +00:00
|
|
|
int ufshcd_alloc_host(struct device *dev, struct ufs_hba **hba_handle)
|
2012-02-29 06:41:50 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct ufs_hba *hba;
|
2014-09-25 12:32:21 +00:00
|
|
|
int err = 0;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2013-02-25 16:14:32 +00:00
|
|
|
if (!dev) {
|
|
|
|
dev_err(dev,
|
|
|
|
"Invalid memory reference for dev is NULL\n");
|
|
|
|
err = -ENODEV;
|
2012-02-29 06:41:50 +00:00
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
host = scsi_host_alloc(&ufshcd_driver_template,
|
|
|
|
sizeof(struct ufs_hba));
|
|
|
|
if (!host) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(dev, "scsi_host_alloc failed\n");
|
2012-02-29 06:41:50 +00:00
|
|
|
err = -ENOMEM;
|
2013-02-25 16:14:32 +00:00
|
|
|
goto out_error;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
hba = shost_priv(host);
|
|
|
|
hba->host = host;
|
2013-02-25 16:14:32 +00:00
|
|
|
hba->dev = dev;
|
2014-09-25 12:32:21 +00:00
|
|
|
*hba_handle = hba;
|
2018-10-16 08:59:41 +00:00
|
|
|
hba->dev_ref_clk_freq = REF_CLK_FREQ_INVAL;
|
2014-09-25 12:32:21 +00:00
|
|
|
|
2017-06-05 08:36:54 +00:00
|
|
|
INIT_LIST_HEAD(&hba->clk_list_head);
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
out_error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ufshcd_alloc_host);
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
/* This function exists because blk_mq_alloc_tag_set() requires this. */
|
|
|
|
static blk_status_t ufshcd_queue_tmf(struct blk_mq_hw_ctx *hctx,
|
|
|
|
const struct blk_mq_queue_data *qd)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(true);
|
|
|
|
return BLK_STS_NOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct blk_mq_ops ufshcd_tmf_ops = {
|
|
|
|
.queue_rq = ufshcd_queue_tmf,
|
|
|
|
};
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_init - Driver initialization routine
|
|
|
|
* @hba: per-adapter instance
|
|
|
|
* @mmio_base: base register address
|
|
|
|
* @irq: Interrupt line of device
|
|
|
|
* Returns 0 on success, non-zero value on failure
|
|
|
|
*/
|
|
|
|
int ufshcd_init(struct ufs_hba *hba, void __iomem *mmio_base, unsigned int irq)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct Scsi_Host *host = hba->host;
|
|
|
|
struct device *dev = hba->dev;
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
char eh_wq_name[sizeof("ufs_eh_wq_00")];
|
2014-09-25 12:32:21 +00:00
|
|
|
|
|
|
|
if (!mmio_base) {
|
|
|
|
dev_err(hba->dev,
|
|
|
|
"Invalid memory reference for mmio_base is NULL\n");
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_error;
|
|
|
|
}
|
|
|
|
|
2013-02-25 16:14:32 +00:00
|
|
|
hba->mmio_base = mmio_base;
|
|
|
|
hba->irq = irq;
|
2020-05-09 09:37:13 +00:00
|
|
|
hba->vps = &ufs_hba_vps;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:22 +00:00
|
|
|
err = ufshcd_hba_init(hba);
|
2014-09-25 12:32:21 +00:00
|
|
|
if (err)
|
|
|
|
goto out_error;
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* Read capabilities registers */
|
2020-07-06 20:04:14 +00:00
|
|
|
err = ufshcd_hba_capabilities(hba);
|
|
|
|
if (err)
|
|
|
|
goto out_disable;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
|
|
|
/* Get UFS version supported by the controller */
|
|
|
|
hba->ufs_version = ufshcd_get_ufs_version(hba);
|
|
|
|
|
2016-12-06 03:25:02 +00:00
|
|
|
if ((hba->ufs_version != UFSHCI_VERSION_10) &&
|
|
|
|
(hba->ufs_version != UFSHCI_VERSION_11) &&
|
|
|
|
(hba->ufs_version != UFSHCI_VERSION_20) &&
|
|
|
|
(hba->ufs_version != UFSHCI_VERSION_21))
|
|
|
|
dev_err(hba->dev, "invalid UFS version 0x%x\n",
|
|
|
|
hba->ufs_version);
|
|
|
|
|
2013-06-26 17:09:27 +00:00
|
|
|
/* Get Interrupt bit mask per version */
|
|
|
|
hba->intr_mask = ufshcd_get_intr_mask(hba);
|
|
|
|
|
2014-07-13 12:24:46 +00:00
|
|
|
err = ufshcd_set_dma_mask(hba);
|
|
|
|
if (err) {
|
|
|
|
dev_err(hba->dev, "set dma mask failed\n");
|
|
|
|
goto out_disable;
|
|
|
|
}
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* Allocate memory for host memory space */
|
|
|
|
err = ufshcd_memory_alloc(hba);
|
|
|
|
if (err) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev, "Memory allocation failed\n");
|
|
|
|
goto out_disable;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Configure LRB */
|
|
|
|
ufshcd_host_memory_configure(hba);
|
|
|
|
|
|
|
|
host->can_queue = hba->nutrs;
|
|
|
|
host->cmd_per_lun = hba->nutrs;
|
|
|
|
host->max_id = UFSHCD_MAX_ID;
|
2014-09-25 12:32:29 +00:00
|
|
|
host->max_lun = UFS_MAX_LUNS;
|
2012-02-29 06:41:50 +00:00
|
|
|
host->max_channel = UFSHCD_MAX_CHANNEL;
|
|
|
|
host->unique_id = host->host_no;
|
2018-10-07 14:30:34 +00:00
|
|
|
host->max_cmd_len = UFS_CDB_SIZE;
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2014-09-25 12:32:31 +00:00
|
|
|
hba->max_pwr_info.is_valid = false;
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* Initialize work queues */
|
scsi: ufs: Fix concurrency of error handler and other error recovery paths
Error recovery can be invoked from multiple code paths, including hibern8
enter/exit (from ufshcd_link_recovery), ufshcd_eh_host_reset_handler() and
eh_work scheduled from IRQ context. Ultimately, these paths are all trying
to invoke ufshcd_reset_and_restore() in either a synchronous or
asynchronous manner. This causes problems:
- If link recovery happens during ungate work, ufshcd_hold() would be
called recursively. Although commit 53c12d0ef6fc ("scsi: ufs: fix error
recovery after the hibern8 exit failure") fixed a deadlock due to
recursive calls of ufshcd_hold() by adding a check of eh_in_progress
into ufshcd_hold, this check allows eh_work to run in parallel while
link recovery is running.
- Similar concurrency can also happen when error recovery is invoked from
ufshcd_eh_host_reset_handler and ufshcd_link_recovery.
- Concurrency can even happen between eh_works. eh_work, currently queued
on system_wq, is allowed to have multiple instances running in parallel,
but we don't have proper protection for that.
If any of above concurrency scenarios happen, error recovery would fail and
lead ufs device and host into bad states. To fix the concurrency problem,
this change queues eh_work on a single threaded workqueue and removes link
recovery calls from the hibern8 enter/exit path. In addition, make use of
eh_work in eh_host_reset_handler instead of calling
ufshcd_reset_and_restore. This unifies the UFS error recovery mechanism.
According to the UFSHCI JEDEC spec, hibern8 enter/exit error occurs when
the link is broken. This essentially applies to any power mode change
operations (since they all use PACP_PWR cmds in UniPro layer). So, if a
power mode change operation (including AH8 enter/exit) fails, mark link
state as UIC_LINK_BROKEN_STATE and schedule the eh_work. In this case,
error handler needs to do a full reset and restore to recover the link back
to active. Before the link state is recovered to active,
ufshcd_uic_pwr_ctrl simply returns -ENOLINK to avoid more errors.
Link: https://lore.kernel.org/r/1596975355-39813-6-git-send-email-cang@codeaurora.org
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Asutosh Das <asutoshd@codeaurora.org>
Signed-off-by: Can Guo <cang@codeaurora.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-08-09 12:15:51 +00:00
|
|
|
snprintf(eh_wq_name, sizeof(eh_wq_name), "ufs_eh_wq_%d",
|
|
|
|
hba->host->host_no);
|
|
|
|
hba->eh_wq = create_singlethread_workqueue(eh_wq_name);
|
|
|
|
if (!hba->eh_wq) {
|
|
|
|
dev_err(hba->dev, "%s: failed to create eh workqueue\n",
|
|
|
|
__func__);
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out_disable;
|
|
|
|
}
|
2014-05-26 05:29:15 +00:00
|
|
|
INIT_WORK(&hba->eh_work, ufshcd_err_handler);
|
2013-07-29 19:05:59 +00:00
|
|
|
INIT_WORK(&hba->eeh_work, ufshcd_exception_event_handler);
|
2012-02-29 06:41:50 +00:00
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/* Initialize UIC command mutex */
|
|
|
|
mutex_init(&hba->uic_cmd_mutex);
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/* Initialize mutex for device management commands */
|
|
|
|
mutex_init(&hba->dev_cmd.lock);
|
|
|
|
|
2017-02-04 00:57:02 +00:00
|
|
|
init_rwsem(&hba->clk_scaling_lock);
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_init_clk_gating(hba);
|
2016-03-10 15:37:06 +00:00
|
|
|
|
2018-08-07 17:47:39 +00:00
|
|
|
ufshcd_init_clk_scaling(hba);
|
|
|
|
|
2016-03-10 15:37:06 +00:00
|
|
|
/*
|
|
|
|
* In order to avoid any spurious interrupt immediately after
|
|
|
|
* registering UFS controller interrupt handler, clear any pending UFS
|
|
|
|
* interrupt status and disable all the UFS interrupts.
|
|
|
|
*/
|
|
|
|
ufshcd_writel(hba, ufshcd_readl(hba, REG_INTERRUPT_STATUS),
|
|
|
|
REG_INTERRUPT_STATUS);
|
|
|
|
ufshcd_writel(hba, 0, REG_INTERRUPT_ENABLE);
|
|
|
|
/*
|
|
|
|
* Make sure that UFS interrupts are disabled and any pending interrupt
|
|
|
|
* status is cleared before registering UFS interrupt handler.
|
|
|
|
*/
|
|
|
|
mb();
|
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
/* IRQ registration */
|
2013-06-27 04:31:54 +00:00
|
|
|
err = devm_request_irq(dev, irq, ufshcd_intr, IRQF_SHARED, UFSHCD, hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (err) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev, "request irq failed\n");
|
2014-09-25 12:32:32 +00:00
|
|
|
goto exit_gating;
|
2014-09-25 12:32:30 +00:00
|
|
|
} else {
|
|
|
|
hba->is_irq_enabled = true;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2013-02-25 16:14:32 +00:00
|
|
|
err = scsi_add_host(host, hba->dev);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (err) {
|
2013-02-25 16:14:32 +00:00
|
|
|
dev_err(hba->dev, "scsi_add_host failed\n");
|
2014-09-25 12:32:32 +00:00
|
|
|
goto exit_gating;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
|
|
|
|
2019-12-09 18:13:08 +00:00
|
|
|
hba->cmd_queue = blk_mq_init_queue(&hba->host->tag_set);
|
|
|
|
if (IS_ERR(hba->cmd_queue)) {
|
|
|
|
err = PTR_ERR(hba->cmd_queue);
|
|
|
|
goto out_remove_scsi_host;
|
|
|
|
}
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
hba->tmf_tag_set = (struct blk_mq_tag_set) {
|
|
|
|
.nr_hw_queues = 1,
|
|
|
|
.queue_depth = hba->nutmrs,
|
|
|
|
.ops = &ufshcd_tmf_ops,
|
|
|
|
.flags = BLK_MQ_F_NO_SCHED,
|
|
|
|
};
|
|
|
|
err = blk_mq_alloc_tag_set(&hba->tmf_tag_set);
|
|
|
|
if (err < 0)
|
|
|
|
goto free_cmd_queue;
|
|
|
|
hba->tmf_queue = blk_mq_init_queue(&hba->tmf_tag_set);
|
|
|
|
if (IS_ERR(hba->tmf_queue)) {
|
|
|
|
err = PTR_ERR(hba->tmf_queue);
|
|
|
|
goto free_tmf_tag_set;
|
|
|
|
}
|
|
|
|
|
2019-08-28 19:17:54 +00:00
|
|
|
/* Reset the attached device */
|
|
|
|
ufshcd_vops_device_reset(hba);
|
|
|
|
|
2020-07-06 20:04:14 +00:00
|
|
|
ufshcd_init_crypto(hba);
|
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
/* Host controller enable */
|
|
|
|
err = ufshcd_hba_enable(hba);
|
2012-02-29 06:41:50 +00:00
|
|
|
if (err) {
|
2013-06-26 17:09:29 +00:00
|
|
|
dev_err(hba->dev, "Host controller enable failed\n");
|
2016-12-23 02:39:42 +00:00
|
|
|
ufshcd_print_host_regs(hba);
|
2017-02-04 00:57:28 +00:00
|
|
|
ufshcd_print_host_state(hba);
|
2019-12-09 18:13:09 +00:00
|
|
|
goto free_tmf_queue;
|
2012-02-29 06:41:50 +00:00
|
|
|
}
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2016-12-23 02:41:11 +00:00
|
|
|
/*
|
|
|
|
* Set the default power management level for runtime and system PM.
|
|
|
|
* Default power saving mode is to keep UFS link in Hibern8 state
|
|
|
|
* and UFS device in sleep state.
|
|
|
|
*/
|
|
|
|
hba->rpm_lvl = ufs_get_desired_pm_lvl_for_dev_link_state(
|
|
|
|
UFS_SLEEP_PWR_MODE,
|
|
|
|
UIC_LINK_HIBERN8_STATE);
|
|
|
|
hba->spm_lvl = ufs_get_desired_pm_lvl_for_dev_link_state(
|
|
|
|
UFS_SLEEP_PWR_MODE,
|
|
|
|
UIC_LINK_HIBERN8_STATE);
|
|
|
|
|
2020-05-22 08:32:12 +00:00
|
|
|
INIT_DELAYED_WORK(&hba->rpm_dev_flush_recheck_work,
|
|
|
|
ufshcd_rpm_dev_flush_recheck_work);
|
|
|
|
|
2018-03-20 13:07:38 +00:00
|
|
|
/* Set the default auto-hiberate idle timer value to 150 ms */
|
2019-05-21 06:44:53 +00:00
|
|
|
if (ufshcd_is_auto_hibern8_supported(hba) && !hba->ahit) {
|
2018-03-20 13:07:38 +00:00
|
|
|
hba->ahit = FIELD_PREP(UFSHCI_AHIBERN8_TIMER_MASK, 150) |
|
|
|
|
FIELD_PREP(UFSHCI_AHIBERN8_SCALE_MASK, 3);
|
|
|
|
}
|
|
|
|
|
2013-07-29 19:06:00 +00:00
|
|
|
/* Hold auto suspend until async scan completes */
|
|
|
|
pm_runtime_get_sync(dev);
|
2018-05-03 11:07:18 +00:00
|
|
|
atomic_set(&hba->scsi_block_reqs_cnt, 0);
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
2016-11-24 00:32:20 +00:00
|
|
|
* We are assuming that device wasn't put in sleep/power-down
|
|
|
|
* state exclusively during the boot stage before kernel.
|
|
|
|
* This assumption helps avoid doing link startup twice during
|
|
|
|
* ufshcd_probe_hba().
|
2014-09-25 12:32:30 +00:00
|
|
|
*/
|
2016-11-24 00:32:20 +00:00
|
|
|
ufshcd_set_ufs_dev_active(hba);
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2013-06-26 17:09:29 +00:00
|
|
|
async_schedule(ufshcd_async_scan, hba);
|
2018-02-15 12:14:01 +00:00
|
|
|
ufs_sysfs_add_nodes(hba->dev);
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2012-02-29 06:41:50 +00:00
|
|
|
return 0;
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
free_tmf_queue:
|
|
|
|
blk_cleanup_queue(hba->tmf_queue);
|
|
|
|
free_tmf_tag_set:
|
|
|
|
blk_mq_free_tag_set(&hba->tmf_tag_set);
|
2019-12-09 18:13:08 +00:00
|
|
|
free_cmd_queue:
|
|
|
|
blk_cleanup_queue(hba->cmd_queue);
|
2013-02-25 16:14:32 +00:00
|
|
|
out_remove_scsi_host:
|
|
|
|
scsi_remove_host(hba->host);
|
2014-09-25 12:32:32 +00:00
|
|
|
exit_gating:
|
2018-08-07 17:47:39 +00:00
|
|
|
ufshcd_exit_clk_scaling(hba);
|
2014-09-25 12:32:32 +00:00
|
|
|
ufshcd_exit_clk_gating(hba);
|
2013-02-25 16:14:32 +00:00
|
|
|
out_disable:
|
2014-09-25 12:32:30 +00:00
|
|
|
hba->is_irq_enabled = false;
|
2014-09-25 12:32:22 +00:00
|
|
|
ufshcd_hba_exit(hba);
|
2013-02-25 16:14:32 +00:00
|
|
|
out_error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ufshcd_init);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Santosh Yaragnavi <santosh.sy@samsung.com>");
|
|
|
|
MODULE_AUTHOR("Vinayak Holikatti <h.vinayak@samsung.com>");
|
2013-02-25 16:14:33 +00:00
|
|
|
MODULE_DESCRIPTION("Generic UFS host controller driver Core");
|
2012-02-29 06:41:50 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(UFSHCD_DRIVER_VERSION);
|