2020-06-05 20:05:19 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2013-02-25 16:14:33 +00:00
|
|
|
/*
|
|
|
|
* Universal Flash Storage Host controller driver
|
|
|
|
* Copyright (C) 2011-2013 Samsung India Software Operations
|
2016-02-01 13:02:46 +00:00
|
|
|
* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
|
2013-02-25 16:14:33 +00:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Santosh Yaraganavi <santosh.sy@samsung.com>
|
|
|
|
* Vinayak Holikatti <h.vinayak@samsung.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _UFSHCD_H
|
|
|
|
#define _UFSHCD_H
|
|
|
|
|
2020-01-29 10:52:50 +00:00
|
|
|
#include <linux/bitfield.h>
|
2021-10-18 18:04:51 +00:00
|
|
|
#include <linux/blk-crypto-profile.h>
|
2022-04-19 22:58:08 +00:00
|
|
|
#include <linux/blk-mq.h>
|
|
|
|
#include <linux/devfreq.h>
|
2022-12-15 03:06:21 +00:00
|
|
|
#include <linux/msi.h>
|
2022-04-19 22:58:08 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2023-01-08 22:40:56 +00:00
|
|
|
#include <linux/dma-direction.h>
|
2022-04-19 22:58:08 +00:00
|
|
|
#include <scsi/scsi_device.h>
|
2022-05-11 21:25:52 +00:00
|
|
|
#include <ufs/unipro.h>
|
|
|
|
#include <ufs/ufs.h>
|
|
|
|
#include <ufs/ufs_quirks.h>
|
|
|
|
#include <ufs/ufshci.h>
|
2013-02-25 16:14:33 +00:00
|
|
|
|
|
|
|
#define UFSHCD "ufshcd"
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
struct ufs_hba;
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
enum dev_cmd_type {
|
|
|
|
DEV_CMD_TYPE_NOP = 0x0,
|
2013-07-29 19:05:58 +00:00
|
|
|
DEV_CMD_TYPE_QUERY = 0x1,
|
2022-12-01 14:04:37 +00:00
|
|
|
DEV_CMD_TYPE_RPMB = 0x2,
|
2013-07-29 19:05:57 +00:00
|
|
|
};
|
|
|
|
|
2020-12-05 11:58:59 +00:00
|
|
|
enum ufs_event_type {
|
|
|
|
/* uic specific errors */
|
|
|
|
UFS_EVT_PA_ERR = 0,
|
|
|
|
UFS_EVT_DL_ERR,
|
|
|
|
UFS_EVT_NL_ERR,
|
|
|
|
UFS_EVT_TL_ERR,
|
|
|
|
UFS_EVT_DME_ERR,
|
|
|
|
|
|
|
|
/* fatal errors */
|
|
|
|
UFS_EVT_AUTO_HIBERN8_ERR,
|
|
|
|
UFS_EVT_FATAL_ERR,
|
|
|
|
UFS_EVT_LINK_STARTUP_FAIL,
|
|
|
|
UFS_EVT_RESUME_ERR,
|
|
|
|
UFS_EVT_SUSPEND_ERR,
|
2021-04-24 00:20:16 +00:00
|
|
|
UFS_EVT_WL_SUSP_ERR,
|
|
|
|
UFS_EVT_WL_RES_ERR,
|
2020-12-05 11:58:59 +00:00
|
|
|
|
|
|
|
/* abnormal events */
|
|
|
|
UFS_EVT_DEV_RESET,
|
|
|
|
UFS_EVT_HOST_RESET,
|
|
|
|
UFS_EVT_ABORT,
|
|
|
|
|
|
|
|
UFS_EVT_CNT,
|
|
|
|
};
|
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
/**
|
|
|
|
* struct uic_command - UIC command structure
|
|
|
|
* @command: UIC command
|
|
|
|
* @argument1: UIC command argument 1
|
|
|
|
* @argument2: UIC command argument 2
|
|
|
|
* @argument3: UIC command argument 3
|
2020-11-03 06:24:40 +00:00
|
|
|
* @cmd_active: Indicate if UIC command is outstanding
|
2013-06-26 17:09:29 +00:00
|
|
|
* @done: UIC command completion
|
2013-02-25 16:14:33 +00:00
|
|
|
*/
|
|
|
|
struct uic_command {
|
|
|
|
u32 command;
|
|
|
|
u32 argument1;
|
|
|
|
u32 argument2;
|
|
|
|
u32 argument3;
|
2020-11-03 06:24:40 +00:00
|
|
|
int cmd_active;
|
2013-06-26 17:09:29 +00:00
|
|
|
struct completion done;
|
2013-02-25 16:14:33 +00:00
|
|
|
};
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* Used to differentiate the power management options */
|
|
|
|
enum ufs_pm_op {
|
|
|
|
UFS_RUNTIME_PM,
|
|
|
|
UFS_SYSTEM_PM,
|
|
|
|
UFS_SHUTDOWN_PM,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Host <-> Device UniPro Link state */
|
|
|
|
enum uic_link_state {
|
|
|
|
UIC_LINK_OFF_STATE = 0, /* Link powered down or disabled */
|
|
|
|
UIC_LINK_ACTIVE_STATE = 1, /* Link is in Fast/Slow/Sleep state */
|
|
|
|
UIC_LINK_HIBERN8_STATE = 2, /* Link is in Hibernate state */
|
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
|
|
|
UIC_LINK_BROKEN_STATE = 3, /* Link is in broken state */
|
2014-09-25 12:32:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define ufshcd_is_link_off(hba) ((hba)->uic_link_state == UIC_LINK_OFF_STATE)
|
|
|
|
#define ufshcd_is_link_active(hba) ((hba)->uic_link_state == \
|
|
|
|
UIC_LINK_ACTIVE_STATE)
|
|
|
|
#define ufshcd_is_link_hibern8(hba) ((hba)->uic_link_state == \
|
|
|
|
UIC_LINK_HIBERN8_STATE)
|
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
|
|
|
#define ufshcd_is_link_broken(hba) ((hba)->uic_link_state == \
|
|
|
|
UIC_LINK_BROKEN_STATE)
|
2014-09-25 12:32:30 +00:00
|
|
|
#define ufshcd_set_link_off(hba) ((hba)->uic_link_state = UIC_LINK_OFF_STATE)
|
|
|
|
#define ufshcd_set_link_active(hba) ((hba)->uic_link_state = \
|
|
|
|
UIC_LINK_ACTIVE_STATE)
|
|
|
|
#define ufshcd_set_link_hibern8(hba) ((hba)->uic_link_state = \
|
|
|
|
UIC_LINK_HIBERN8_STATE)
|
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
|
|
|
#define ufshcd_set_link_broken(hba) ((hba)->uic_link_state = \
|
|
|
|
UIC_LINK_BROKEN_STATE)
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2020-03-27 09:58:35 +00:00
|
|
|
#define ufshcd_set_ufs_dev_active(h) \
|
|
|
|
((h)->curr_dev_pwr_mode = UFS_ACTIVE_PWR_MODE)
|
|
|
|
#define ufshcd_set_ufs_dev_sleep(h) \
|
|
|
|
((h)->curr_dev_pwr_mode = UFS_SLEEP_PWR_MODE)
|
|
|
|
#define ufshcd_set_ufs_dev_poweroff(h) \
|
|
|
|
((h)->curr_dev_pwr_mode = UFS_POWERDOWN_PWR_MODE)
|
2020-11-03 14:14:02 +00:00
|
|
|
#define ufshcd_set_ufs_dev_deepsleep(h) \
|
|
|
|
((h)->curr_dev_pwr_mode = UFS_DEEPSLEEP_PWR_MODE)
|
2020-03-27 09:58:35 +00:00
|
|
|
#define ufshcd_is_ufs_dev_active(h) \
|
|
|
|
((h)->curr_dev_pwr_mode == UFS_ACTIVE_PWR_MODE)
|
|
|
|
#define ufshcd_is_ufs_dev_sleep(h) \
|
|
|
|
((h)->curr_dev_pwr_mode == UFS_SLEEP_PWR_MODE)
|
|
|
|
#define ufshcd_is_ufs_dev_poweroff(h) \
|
|
|
|
((h)->curr_dev_pwr_mode == UFS_POWERDOWN_PWR_MODE)
|
2020-11-03 14:14:02 +00:00
|
|
|
#define ufshcd_is_ufs_dev_deepsleep(h) \
|
|
|
|
((h)->curr_dev_pwr_mode == UFS_DEEPSLEEP_PWR_MODE)
|
2020-03-27 09:58:35 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/*
|
|
|
|
* UFS Power management levels.
|
2020-11-03 14:14:02 +00:00
|
|
|
* Each level is in increasing order of power savings, except DeepSleep
|
|
|
|
* which is lower than PowerDown with power on but not PowerDown with
|
|
|
|
* power off.
|
2014-09-25 12:32:30 +00:00
|
|
|
*/
|
|
|
|
enum ufs_pm_level {
|
2021-05-19 20:20:58 +00:00
|
|
|
UFS_PM_LVL_0,
|
|
|
|
UFS_PM_LVL_1,
|
|
|
|
UFS_PM_LVL_2,
|
|
|
|
UFS_PM_LVL_3,
|
|
|
|
UFS_PM_LVL_4,
|
|
|
|
UFS_PM_LVL_5,
|
|
|
|
UFS_PM_LVL_6,
|
2014-09-25 12:32:30 +00:00
|
|
|
UFS_PM_LVL_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ufs_pm_lvl_states {
|
|
|
|
enum ufs_dev_pwr_mode dev_state;
|
|
|
|
enum uic_link_state link_state;
|
|
|
|
};
|
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
/**
|
|
|
|
* struct ufshcd_lrb - local reference block
|
|
|
|
* @utr_descriptor_ptr: UTRD address of the command
|
2013-07-29 19:05:57 +00:00
|
|
|
* @ucd_req_ptr: UCD address of the command
|
2013-02-25 16:14:33 +00:00
|
|
|
* @ucd_rsp_ptr: Response UPIU address for this command
|
|
|
|
* @ucd_prdt_ptr: PRDT address of the command
|
2016-12-23 02:42:18 +00:00
|
|
|
* @utrd_dma_addr: UTRD dma address for debug
|
|
|
|
* @ucd_prdt_dma_addr: PRDT dma address for debug
|
|
|
|
* @ucd_rsp_dma_addr: UPIU response dma address for debug
|
|
|
|
* @ucd_req_dma_addr: UPIU request dma address for debug
|
2013-02-25 16:14:33 +00:00
|
|
|
* @cmd: pointer to SCSI command
|
|
|
|
* @scsi_status: SCSI status of the command
|
|
|
|
* @command_type: SCSI, UFS, Query.
|
|
|
|
* @task_tag: Task tag of the command
|
|
|
|
* @lun: LUN of the command
|
2013-07-29 19:05:57 +00:00
|
|
|
* @intr_cmd: Interrupt command (doesn't participate in interrupt aggregation)
|
2022-08-03 20:50:34 +00:00
|
|
|
* @issue_time_stamp: time stamp for debug purposes (CLOCK_MONOTONIC)
|
|
|
|
* @issue_time_stamp_local_clock: time stamp for debug purposes (local_clock)
|
|
|
|
* @compl_time_stamp: time stamp for statistics (CLOCK_MONOTONIC)
|
|
|
|
* @compl_time_stamp_local_clock: time stamp for debug purposes (local_clock)
|
2020-07-06 20:04:14 +00:00
|
|
|
* @crypto_key_slot: the key slot to use for inline crypto (-1 if none)
|
|
|
|
* @data_unit_num: the data unit number for the first block for inline crypto
|
2017-02-04 00:56:40 +00:00
|
|
|
* @req_abort_skip: skip request abort task flag
|
2013-02-25 16:14:33 +00:00
|
|
|
*/
|
|
|
|
struct ufshcd_lrb {
|
|
|
|
struct utp_transfer_req_desc *utr_descriptor_ptr;
|
2013-07-29 19:05:57 +00:00
|
|
|
struct utp_upiu_req *ucd_req_ptr;
|
2013-02-25 16:14:33 +00:00
|
|
|
struct utp_upiu_rsp *ucd_rsp_ptr;
|
|
|
|
struct ufshcd_sg_entry *ucd_prdt_ptr;
|
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
dma_addr_t utrd_dma_addr;
|
|
|
|
dma_addr_t ucd_req_dma_addr;
|
|
|
|
dma_addr_t ucd_rsp_dma_addr;
|
|
|
|
dma_addr_t ucd_prdt_dma_addr;
|
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
struct scsi_cmnd *cmd;
|
|
|
|
int scsi_status;
|
|
|
|
|
|
|
|
int command_type;
|
|
|
|
int task_tag;
|
2014-09-25 12:32:29 +00:00
|
|
|
u8 lun; /* UPIU LUN id field is only 8-bit wide */
|
2013-07-29 19:05:57 +00:00
|
|
|
bool intr_cmd;
|
2016-12-23 02:42:18 +00:00
|
|
|
ktime_t issue_time_stamp;
|
2022-08-03 20:50:34 +00:00
|
|
|
u64 issue_time_stamp_local_clock;
|
2017-09-27 02:06:06 +00:00
|
|
|
ktime_t compl_time_stamp;
|
2022-08-03 20:50:34 +00:00
|
|
|
u64 compl_time_stamp_local_clock;
|
2020-07-06 20:04:14 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_CRYPTO
|
|
|
|
int crypto_key_slot;
|
|
|
|
u64 data_unit_num;
|
|
|
|
#endif
|
2017-02-04 00:56:40 +00:00
|
|
|
|
|
|
|
bool req_abort_skip;
|
2013-02-25 16:14:33 +00:00
|
|
|
};
|
|
|
|
|
2013-07-29 19:05:58 +00:00
|
|
|
/**
|
2016-02-09 08:25:41 +00:00
|
|
|
* struct ufs_query - holds relevant data structures for query request
|
2013-07-29 19:05:58 +00:00
|
|
|
* @request: request upiu and function
|
|
|
|
* @descriptor: buffer for sending/receiving descriptor
|
|
|
|
* @response: response upiu and response
|
|
|
|
*/
|
|
|
|
struct ufs_query {
|
|
|
|
struct ufs_query_req request;
|
|
|
|
u8 *descriptor;
|
|
|
|
struct ufs_query_res response;
|
|
|
|
};
|
|
|
|
|
2013-07-29 19:05:57 +00:00
|
|
|
/**
|
|
|
|
* struct ufs_dev_cmd - all assosiated fields with device management commands
|
|
|
|
* @type: device management command type - Query, NOP OUT
|
|
|
|
* @lock: lock to allow one command at a time
|
|
|
|
* @complete: internal commands completion
|
2022-04-19 22:58:07 +00:00
|
|
|
* @query: Device management query information
|
2013-07-29 19:05:57 +00:00
|
|
|
*/
|
|
|
|
struct ufs_dev_cmd {
|
|
|
|
enum dev_cmd_type type;
|
|
|
|
struct mutex lock;
|
|
|
|
struct completion *complete;
|
2013-07-29 19:05:58 +00:00
|
|
|
struct ufs_query query;
|
2023-01-13 20:48:47 +00:00
|
|
|
struct cq_entry *cqe;
|
2013-07-29 19:05:57 +00:00
|
|
|
};
|
2013-02-25 16:14:33 +00:00
|
|
|
|
2014-09-25 12:32:23 +00:00
|
|
|
/**
|
|
|
|
* struct ufs_clk_info - UFS clock related info
|
|
|
|
* @list: list headed by hba->clk_list_head
|
|
|
|
* @clk: clock node
|
|
|
|
* @name: clock name
|
|
|
|
* @max_freq: maximum frequency supported by the clock
|
2014-09-25 12:32:33 +00:00
|
|
|
* @min_freq: min frequency that can be used for clock scaling
|
2014-09-25 12:32:34 +00:00
|
|
|
* @curr_freq: indicates the current frequency that it is set to
|
2020-11-26 02:01:00 +00:00
|
|
|
* @keep_link_active: indicates that the clk should not be disabled if
|
2022-04-19 22:58:07 +00:00
|
|
|
* link is active
|
2014-09-25 12:32:23 +00:00
|
|
|
* @enabled: variable to check against multiple enable/disable
|
|
|
|
*/
|
|
|
|
struct ufs_clk_info {
|
|
|
|
struct list_head list;
|
|
|
|
struct clk *clk;
|
|
|
|
const char *name;
|
|
|
|
u32 max_freq;
|
2014-09-25 12:32:33 +00:00
|
|
|
u32 min_freq;
|
2014-09-25 12:32:34 +00:00
|
|
|
u32 curr_freq;
|
2020-11-26 02:01:00 +00:00
|
|
|
bool keep_link_active;
|
2014-09-25 12:32:23 +00:00
|
|
|
bool enabled;
|
|
|
|
};
|
|
|
|
|
2015-10-28 11:15:51 +00:00
|
|
|
enum ufs_notify_change_status {
|
|
|
|
PRE_CHANGE,
|
|
|
|
POST_CHANGE,
|
|
|
|
};
|
2014-09-25 12:32:31 +00:00
|
|
|
|
|
|
|
struct ufs_pa_layer_attr {
|
|
|
|
u32 gear_rx;
|
|
|
|
u32 gear_tx;
|
|
|
|
u32 lane_rx;
|
|
|
|
u32 lane_tx;
|
|
|
|
u32 pwr_rx;
|
|
|
|
u32 pwr_tx;
|
|
|
|
u32 hs_rate;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ufs_pwr_mode_info {
|
|
|
|
bool is_valid;
|
|
|
|
struct ufs_pa_layer_attr info;
|
|
|
|
};
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
/**
|
|
|
|
* struct ufs_hba_variant_ops - variant specific callbacks
|
|
|
|
* @name: variant name
|
|
|
|
* @init: called when the driver is initialized
|
|
|
|
* @exit: called to cleanup everything done in init
|
2015-05-17 15:55:05 +00:00
|
|
|
* @get_ufs_hci_version: called to get UFS HCI version
|
2014-09-25 12:32:34 +00:00
|
|
|
* @clk_scale_notify: notifies that clks are scaled up/down
|
2014-09-25 12:32:21 +00:00
|
|
|
* @setup_clocks: called before touching any of the controller registers
|
|
|
|
* @hce_enable_notify: called before and after HCE enable bit is set to allow
|
|
|
|
* variant specific Uni-Pro initialization.
|
|
|
|
* @link_startup_notify: called before and after Link startup is carried out
|
|
|
|
* to allow variant specific Uni-Pro initialization.
|
2014-09-25 12:32:31 +00:00
|
|
|
* @pwr_change_notify: called before and after a power mode change
|
|
|
|
* is carried out to allow vendor spesific capabilities
|
|
|
|
* to be set.
|
2016-11-10 12:14:36 +00:00
|
|
|
* @setup_xfer_req: called before any transfer request is issued
|
|
|
|
* to set some things
|
2016-11-10 12:16:15 +00:00
|
|
|
* @setup_task_mgmt: called before any task management request is issued
|
|
|
|
* to set some things
|
2016-11-10 12:17:43 +00:00
|
|
|
* @hibern8_notify: called around hibern8 enter/exit
|
2016-12-06 03:25:32 +00:00
|
|
|
* @apply_dev_quirks: called to apply device specific quirks
|
2022-04-19 22:58:07 +00:00
|
|
|
* @fixup_dev_quirks: called to modify device specific quirks
|
2014-09-25 12:32:30 +00:00
|
|
|
* @suspend: called during host controller PM callback
|
|
|
|
* @resume: called during host controller PM callback
|
2015-10-28 11:15:50 +00:00
|
|
|
* @dbg_register_dump: used to dump controller debug information
|
2016-05-11 11:21:30 +00:00
|
|
|
* @phy_initialization: used to initialize phys
|
2019-08-28 19:17:54 +00:00
|
|
|
* @device_reset: called to issue a reset pulse on the UFS device
|
2022-04-19 22:58:07 +00:00
|
|
|
* @config_scaling_param: called to configure clock scaling parameters
|
2020-07-10 07:20:11 +00:00
|
|
|
* @program_key: program or evict an inline encryption key
|
2020-12-05 11:59:00 +00:00
|
|
|
* @event_notify: called to notify important events
|
2022-12-22 14:09:56 +00:00
|
|
|
* @reinit_notify: called to notify reinit of UFSHCD during max gear switch
|
2023-01-13 20:48:42 +00:00
|
|
|
* @mcq_config_resource: called to configure MCQ platform resources
|
2023-01-13 20:48:43 +00:00
|
|
|
* @get_hba_mac: called to get vendor specific mac value, mandatory for mcq mode
|
2023-01-13 20:48:45 +00:00
|
|
|
* @op_runtime_config: called to config Operation and runtime regs Pointers
|
2023-01-13 20:48:50 +00:00
|
|
|
* @get_outstanding_cqs: called to get outstanding completion queues
|
2022-12-15 03:06:20 +00:00
|
|
|
* @config_esi: called to config Event Specific Interrupt
|
2014-09-25 12:32:21 +00:00
|
|
|
*/
|
|
|
|
struct ufs_hba_variant_ops {
|
|
|
|
const char *name;
|
|
|
|
int (*init)(struct ufs_hba *);
|
|
|
|
void (*exit)(struct ufs_hba *);
|
2015-05-17 15:55:05 +00:00
|
|
|
u32 (*get_ufs_hci_version)(struct ufs_hba *);
|
2015-10-28 11:15:51 +00:00
|
|
|
int (*clk_scale_notify)(struct ufs_hba *, bool,
|
|
|
|
enum ufs_notify_change_status);
|
2016-10-07 04:48:22 +00:00
|
|
|
int (*setup_clocks)(struct ufs_hba *, bool,
|
|
|
|
enum ufs_notify_change_status);
|
2015-10-28 11:15:51 +00:00
|
|
|
int (*hce_enable_notify)(struct ufs_hba *,
|
|
|
|
enum ufs_notify_change_status);
|
|
|
|
int (*link_startup_notify)(struct ufs_hba *,
|
|
|
|
enum ufs_notify_change_status);
|
2014-09-25 12:32:31 +00:00
|
|
|
int (*pwr_change_notify)(struct ufs_hba *,
|
2015-10-28 11:15:51 +00:00
|
|
|
enum ufs_notify_change_status status,
|
|
|
|
struct ufs_pa_layer_attr *,
|
2014-09-25 12:32:31 +00:00
|
|
|
struct ufs_pa_layer_attr *);
|
2021-12-03 23:19:35 +00:00
|
|
|
void (*setup_xfer_req)(struct ufs_hba *hba, int tag,
|
|
|
|
bool is_scsi_cmd);
|
2016-11-10 12:16:15 +00:00
|
|
|
void (*setup_task_mgmt)(struct ufs_hba *, int, u8);
|
2016-11-10 12:17:43 +00:00
|
|
|
void (*hibern8_notify)(struct ufs_hba *, enum uic_cmd_dme,
|
2016-12-06 03:25:32 +00:00
|
|
|
enum ufs_notify_change_status);
|
2020-01-20 13:08:14 +00:00
|
|
|
int (*apply_dev_quirks)(struct ufs_hba *hba);
|
2020-05-08 08:01:09 +00:00
|
|
|
void (*fixup_dev_quirks)(struct ufs_hba *hba);
|
2021-10-06 05:47:05 +00:00
|
|
|
int (*suspend)(struct ufs_hba *, enum ufs_pm_op,
|
|
|
|
enum ufs_notify_change_status);
|
2014-09-25 12:32:30 +00:00
|
|
|
int (*resume)(struct ufs_hba *, enum ufs_pm_op);
|
2015-10-28 11:15:50 +00:00
|
|
|
void (*dbg_register_dump)(struct ufs_hba *hba);
|
2016-05-11 11:21:30 +00:00
|
|
|
int (*phy_initialization)(struct ufs_hba *);
|
2020-11-03 14:14:03 +00:00
|
|
|
int (*device_reset)(struct ufs_hba *hba);
|
2020-03-25 18:29:01 +00:00
|
|
|
void (*config_scaling_param)(struct ufs_hba *hba,
|
2022-04-19 22:57:57 +00:00
|
|
|
struct devfreq_dev_profile *profile,
|
|
|
|
struct devfreq_simple_ondemand_data *data);
|
2020-07-10 07:20:11 +00:00
|
|
|
int (*program_key)(struct ufs_hba *hba,
|
|
|
|
const union ufs_crypto_cfg_entry *cfg, int slot);
|
2020-12-05 11:59:00 +00:00
|
|
|
void (*event_notify)(struct ufs_hba *hba,
|
|
|
|
enum ufs_event_type evt, void *data);
|
2022-12-22 14:09:56 +00:00
|
|
|
void (*reinit_notify)(struct ufs_hba *);
|
2023-01-13 20:48:42 +00:00
|
|
|
int (*mcq_config_resource)(struct ufs_hba *hba);
|
2023-01-13 20:48:43 +00:00
|
|
|
int (*get_hba_mac)(struct ufs_hba *hba);
|
2023-01-13 20:48:45 +00:00
|
|
|
int (*op_runtime_config)(struct ufs_hba *hba);
|
2023-01-13 20:48:50 +00:00
|
|
|
int (*get_outstanding_cqs)(struct ufs_hba *hba,
|
|
|
|
unsigned long *ocqs);
|
2022-12-15 03:06:20 +00:00
|
|
|
int (*config_esi)(struct ufs_hba *hba);
|
2014-09-25 12:32:21 +00:00
|
|
|
};
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
/* clock gating state */
|
|
|
|
enum clk_gating_state {
|
|
|
|
CLKS_OFF,
|
|
|
|
CLKS_ON,
|
|
|
|
REQ_CLKS_OFF,
|
|
|
|
REQ_CLKS_ON,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct ufs_clk_gating - UFS clock gating related info
|
|
|
|
* @gate_work: worker to turn off clocks after some delay as specified in
|
|
|
|
* delay_ms
|
|
|
|
* @ungate_work: worker to turn on clocks that will be used in case of
|
|
|
|
* interrupt context
|
|
|
|
* @state: the current clocks state
|
|
|
|
* @delay_ms: gating delay in ms
|
|
|
|
* @is_suspended: clk gating is suspended when set to 1 which can be used
|
|
|
|
* during suspend/resume
|
|
|
|
* @delay_attr: sysfs attribute to control delay_attr
|
2016-12-23 02:40:39 +00:00
|
|
|
* @enable_attr: sysfs attribute to enable/disable clock gating
|
|
|
|
* @is_enabled: Indicates the current status of clock gating
|
2021-01-20 10:04:22 +00:00
|
|
|
* @is_initialized: Indicates whether clock gating is initialized or not
|
2014-09-25 12:32:32 +00:00
|
|
|
* @active_reqs: number of requests that are pending and should be waited for
|
|
|
|
* completion before gating clocks.
|
2022-04-19 22:58:07 +00:00
|
|
|
* @clk_gating_workq: workqueue for clock gating work.
|
2014-09-25 12:32:32 +00:00
|
|
|
*/
|
|
|
|
struct ufs_clk_gating {
|
|
|
|
struct delayed_work gate_work;
|
|
|
|
struct work_struct ungate_work;
|
|
|
|
enum clk_gating_state state;
|
|
|
|
unsigned long delay_ms;
|
|
|
|
bool is_suspended;
|
|
|
|
struct device_attribute delay_attr;
|
2016-12-23 02:40:39 +00:00
|
|
|
struct device_attribute enable_attr;
|
|
|
|
bool is_enabled;
|
2021-01-20 10:04:22 +00:00
|
|
|
bool is_initialized;
|
2014-09-25 12:32:32 +00:00
|
|
|
int active_reqs;
|
2018-05-03 11:07:22 +00:00
|
|
|
struct workqueue_struct *clk_gating_workq;
|
2014-09-25 12:32:32 +00:00
|
|
|
};
|
|
|
|
|
2017-02-04 00:57:39 +00:00
|
|
|
/**
|
|
|
|
* struct ufs_clk_scaling - UFS clock scaling related data
|
|
|
|
* @active_reqs: number of requests that are pending. If this is zero when
|
|
|
|
* devfreq ->target() function is called then schedule "suspend_work" to
|
|
|
|
* suspend devfreq.
|
|
|
|
* @tot_busy_t: Total busy time in current polling window
|
|
|
|
* @window_start_t: Start time (in jiffies) of the current polling window
|
|
|
|
* @busy_start_t: Start time of current busy period
|
|
|
|
* @enable_attr: sysfs attribute to enable/disable clock scaling
|
|
|
|
* @saved_pwr_info: UFS power mode may also be changed during scaling and this
|
|
|
|
* one keeps track of previous power mode.
|
|
|
|
* @workq: workqueue to schedule devfreq suspend/resume work
|
|
|
|
* @suspend_work: worker to suspend devfreq
|
|
|
|
* @resume_work: worker to resume devfreq
|
2020-11-27 01:58:48 +00:00
|
|
|
* @min_gear: lowest HS gear to scale down to
|
2021-01-20 10:04:21 +00:00
|
|
|
* @is_enabled: tracks if scaling is currently enabled or not, controlled by
|
2022-04-19 22:58:07 +00:00
|
|
|
* clkscale_enable sysfs node
|
2021-01-20 10:04:21 +00:00
|
|
|
* @is_allowed: tracks if scaling is currently allowed or not, used to block
|
2022-04-19 22:58:07 +00:00
|
|
|
* clock scaling which is not invoked from devfreq governor
|
2021-01-20 10:04:22 +00:00
|
|
|
* @is_initialized: Indicates whether clock scaling is initialized or not
|
2017-02-04 00:57:39 +00:00
|
|
|
* @is_busy_started: tracks if busy period has started or not
|
|
|
|
* @is_suspended: tracks if devfreq is suspended or not
|
|
|
|
*/
|
2014-09-25 12:32:34 +00:00
|
|
|
struct ufs_clk_scaling {
|
2017-02-04 00:57:39 +00:00
|
|
|
int active_reqs;
|
|
|
|
unsigned long tot_busy_t;
|
2020-06-11 10:10:43 +00:00
|
|
|
ktime_t window_start_t;
|
2017-02-04 00:57:39 +00:00
|
|
|
ktime_t busy_start_t;
|
2016-12-23 02:40:50 +00:00
|
|
|
struct device_attribute enable_attr;
|
2023-03-30 01:29:18 +00:00
|
|
|
struct ufs_pa_layer_attr saved_pwr_info;
|
2017-02-04 00:57:39 +00:00
|
|
|
struct workqueue_struct *workq;
|
|
|
|
struct work_struct suspend_work;
|
|
|
|
struct work_struct resume_work;
|
2020-11-27 01:58:48 +00:00
|
|
|
u32 min_gear;
|
2021-01-20 10:04:21 +00:00
|
|
|
bool is_enabled;
|
2017-02-04 00:57:39 +00:00
|
|
|
bool is_allowed;
|
2021-01-20 10:04:22 +00:00
|
|
|
bool is_initialized;
|
2017-02-04 00:57:39 +00:00
|
|
|
bool is_busy_started;
|
|
|
|
bool is_suspended;
|
2014-09-25 12:32:34 +00:00
|
|
|
};
|
|
|
|
|
2020-12-05 11:58:59 +00:00
|
|
|
#define UFS_EVENT_HIST_LENGTH 8
|
2016-12-23 02:42:18 +00:00
|
|
|
/**
|
2020-12-05 11:58:59 +00:00
|
|
|
* struct ufs_event_hist - keeps history of errors
|
2016-12-23 02:42:18 +00:00
|
|
|
* @pos: index to indicate cyclic buffer position
|
2022-04-19 22:58:07 +00:00
|
|
|
* @val: cyclic buffer for registers value
|
2016-12-23 02:42:18 +00:00
|
|
|
* @tstamp: cyclic buffer for time stamp
|
2021-01-07 07:25:38 +00:00
|
|
|
* @cnt: error counter
|
2016-12-23 02:42:18 +00:00
|
|
|
*/
|
2020-12-05 11:58:59 +00:00
|
|
|
struct ufs_event_hist {
|
2016-12-23 02:42:18 +00:00
|
|
|
int pos;
|
2020-12-05 11:58:59 +00:00
|
|
|
u32 val[UFS_EVENT_HIST_LENGTH];
|
2022-08-03 20:50:34 +00:00
|
|
|
u64 tstamp[UFS_EVENT_HIST_LENGTH];
|
2021-01-07 07:25:38 +00:00
|
|
|
unsigned long long cnt;
|
2016-12-23 02:42:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct ufs_stats - keeps usage/err statistics
|
2020-08-09 12:15:50 +00:00
|
|
|
* @last_intr_status: record the last interrupt status.
|
|
|
|
* @last_intr_ts: record the last interrupt timestamp.
|
2016-12-23 02:42:18 +00:00
|
|
|
* @hibern8_exit_cnt: Counter to keep track of number of exits,
|
|
|
|
* reset this after link-startup.
|
|
|
|
* @last_hibern8_exit_tstamp: Set time after the hibern8 exit.
|
|
|
|
* Clear after the first successful command completion.
|
2022-04-19 22:58:07 +00:00
|
|
|
* @event: array with event history.
|
2016-12-23 02:42:18 +00:00
|
|
|
*/
|
|
|
|
struct ufs_stats {
|
2020-08-09 12:15:50 +00:00
|
|
|
u32 last_intr_status;
|
2022-08-03 20:50:34 +00:00
|
|
|
u64 last_intr_ts;
|
2020-08-09 12:15:50 +00:00
|
|
|
|
2016-12-23 02:42:18 +00:00
|
|
|
u32 hibern8_exit_cnt;
|
2022-08-03 20:50:34 +00:00
|
|
|
u64 last_hibern8_exit_tstamp;
|
2020-12-05 11:58:59 +00:00
|
|
|
struct ufs_event_hist event[UFS_EVT_CNT];
|
2016-12-23 02:42:18 +00:00
|
|
|
};
|
|
|
|
|
2021-07-22 03:34:29 +00:00
|
|
|
/**
|
|
|
|
* enum ufshcd_state - UFS host controller state
|
|
|
|
* @UFSHCD_STATE_RESET: Link is not operational. Postpone SCSI command
|
|
|
|
* processing.
|
|
|
|
* @UFSHCD_STATE_OPERATIONAL: The host controller is operational and can process
|
|
|
|
* SCSI commands.
|
|
|
|
* @UFSHCD_STATE_EH_SCHEDULED_NON_FATAL: The error handler has been scheduled.
|
|
|
|
* SCSI commands may be submitted to the controller.
|
|
|
|
* @UFSHCD_STATE_EH_SCHEDULED_FATAL: The error handler has been scheduled. Fail
|
|
|
|
* newly submitted SCSI commands with error code DID_BAD_TARGET.
|
|
|
|
* @UFSHCD_STATE_ERROR: An unrecoverable error occurred, e.g. link recovery
|
|
|
|
* failed. Fail all SCSI commands with error code DID_ERROR.
|
|
|
|
*/
|
|
|
|
enum ufshcd_state {
|
|
|
|
UFSHCD_STATE_RESET,
|
|
|
|
UFSHCD_STATE_OPERATIONAL,
|
|
|
|
UFSHCD_STATE_EH_SCHEDULED_NON_FATAL,
|
|
|
|
UFSHCD_STATE_EH_SCHEDULED_FATAL,
|
|
|
|
UFSHCD_STATE_ERROR,
|
|
|
|
};
|
|
|
|
|
2020-02-21 14:08:12 +00:00
|
|
|
enum ufshcd_quirks {
|
|
|
|
/* Interrupt aggregation support is broken */
|
|
|
|
UFSHCD_QUIRK_BROKEN_INTR_AGGR = 1 << 0,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* delay before each dme command is required as the unipro
|
|
|
|
* layer has shown instabilities
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_DELAY_BEFORE_DME_CMDS = 1 << 1,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If UFS host controller is having issue in processing LCC (Line
|
|
|
|
* Control Command) coming from device then enable this quirk.
|
|
|
|
* When this quirk is enabled, host controller driver should disable
|
|
|
|
* the LCC transmission on UFS device (by clearing TX_LCC_ENABLE
|
|
|
|
* attribute of device to 0).
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_LCC = 1 << 2,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The attribute PA_RXHSUNTERMCAP specifies whether or not the
|
|
|
|
* inbound Link supports unterminated line in HS mode. Setting this
|
|
|
|
* attribute to 1 fixes moving to HS gear.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_PA_RXHSUNTERMCAP = 1 << 3,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller only allows
|
|
|
|
* accessing the peer dme attributes in AUTO mode (FAST AUTO or
|
|
|
|
* SLOW AUTO).
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_DME_PEER_ACCESS_AUTO_MODE = 1 << 4,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller doesn't
|
|
|
|
* advertise the correct version in UFS_VER register. If this quirk
|
|
|
|
* is enabled, standard UFS host driver will call the vendor specific
|
|
|
|
* ops (get_ufs_hci_version) to get the correct version.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_UFS_HCI_VERSION = 1 << 5,
|
2020-05-28 01:16:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear handling for transfer/task request list is just opposite.
|
|
|
|
*/
|
|
|
|
UFSHCI_QUIRK_BROKEN_REQ_LIST_CLR = 1 << 6,
|
2020-05-28 01:16:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if host controller doesn't allow
|
|
|
|
* that the interrupt aggregation timer and counter are reset by s/w.
|
|
|
|
*/
|
|
|
|
UFSHCI_QUIRK_SKIP_RESET_INTR_AGGR = 1 << 7,
|
2020-05-28 01:16:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirks needs to be enabled if host controller cannot be
|
|
|
|
* enabled via HCE register.
|
|
|
|
*/
|
|
|
|
UFSHCI_QUIRK_BROKEN_HCE = 1 << 8,
|
2020-05-28 01:16:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller regards
|
|
|
|
* resolution of the values of PRDTO and PRDTL in UTRD as byte.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_PRDT_BYTE_GRAN = 1 << 9,
|
2020-05-28 01:16:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller reports
|
|
|
|
* OCS FATAL ERROR with device error through sense data
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_OCS_FATAL_ERROR = 1 << 10,
|
2020-08-25 01:43:15 +00:00
|
|
|
|
2020-08-10 14:10:24 +00:00
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller has
|
|
|
|
* auto-hibernate capability but it doesn't work.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_AUTO_HIBERN8 = 1 << 11,
|
2020-09-15 15:24:32 +00:00
|
|
|
|
2020-08-25 01:43:15 +00:00
|
|
|
/*
|
|
|
|
* This quirk needs to disable manual flush for write booster
|
|
|
|
*/
|
2020-09-15 15:24:32 +00:00
|
|
|
UFSHCI_QUIRK_SKIP_MANUAL_WB_FLUSH_CTRL = 1 << 12,
|
|
|
|
|
2020-12-21 01:24:40 +00:00
|
|
|
/*
|
|
|
|
* This quirk needs to disable unipro timeout values
|
|
|
|
* before power mode change
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_SKIP_DEF_UNIPRO_TIMEOUT_SETTING = 1 << 13,
|
|
|
|
|
2021-01-19 03:33:41 +00:00
|
|
|
/*
|
2023-01-12 23:42:13 +00:00
|
|
|
* Align DMA SG entries on a 4 KiB boundary.
|
2021-01-19 03:33:41 +00:00
|
|
|
*/
|
2023-01-12 23:42:13 +00:00
|
|
|
UFSHCD_QUIRK_4KB_DMA_ALIGNMENT = 1 << 14,
|
2021-10-18 12:42:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller does not
|
|
|
|
* support UIC command
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_UIC_CMD = 1 << 15,
|
2021-10-18 12:42:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller cannot
|
|
|
|
* support physical host configuration.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_SKIP_PH_CONFIGURATION = 1 << 16,
|
2022-06-03 11:05:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller has
|
|
|
|
* 64-bit addressing supported capability but it doesn't work.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_BROKEN_64BIT_ADDRESS = 1 << 17,
|
2022-06-03 11:05:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller has
|
|
|
|
* auto-hibernate capability but it's FASTAUTO only.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_HIBERN_FASTAUTO = 1 << 18,
|
2022-12-22 14:09:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This quirk needs to be enabled if the host controller needs
|
|
|
|
* to reinit the device after switching to maximum gear.
|
|
|
|
*/
|
|
|
|
UFSHCD_QUIRK_REINIT_AFTER_MAX_GEAR_SWITCH = 1 << 19,
|
2020-02-21 14:08:12 +00:00
|
|
|
};
|
|
|
|
|
2020-03-18 10:40:11 +00:00
|
|
|
enum ufshcd_caps {
|
|
|
|
/* Allow dynamic clk gating */
|
|
|
|
UFSHCD_CAP_CLK_GATING = 1 << 0,
|
|
|
|
|
|
|
|
/* Allow hiberb8 with clk gating */
|
|
|
|
UFSHCD_CAP_HIBERN8_WITH_CLK_GATING = 1 << 1,
|
|
|
|
|
|
|
|
/* Allow dynamic clk scaling */
|
|
|
|
UFSHCD_CAP_CLK_SCALING = 1 << 2,
|
|
|
|
|
|
|
|
/* Allow auto bkops to enabled during runtime suspend */
|
|
|
|
UFSHCD_CAP_AUTO_BKOPS_SUSPEND = 1 << 3,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows host controller driver to use the UFS HCI's
|
|
|
|
* interrupt aggregation capability.
|
|
|
|
* CAUTION: Enabling this might reduce overall UFS throughput.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_INTR_AGGR = 1 << 4,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the device auto-bkops to be always enabled
|
|
|
|
* except during suspend (both runtime and suspend).
|
|
|
|
* Enabling this capability means that device will always be allowed
|
|
|
|
* to do background operation when it's active but it might degrade
|
|
|
|
* the performance of ongoing read/write operations.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND = 1 << 5,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows host controller driver to automatically
|
|
|
|
* enable runtime power management by itself instead of waiting
|
|
|
|
* for userspace to control the power management.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_RPM_AUTOSUSPEND = 1 << 6,
|
2020-04-22 21:41:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the host controller driver to turn-on
|
|
|
|
* WriteBooster, if the underlying device supports it and is
|
|
|
|
* provisioned to be used. This would increase the write performance.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_WB_EN = 1 << 7,
|
2020-07-06 20:04:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the host controller driver to use the
|
|
|
|
* inline crypto engine, if it is present
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_CRYPTO = 1 << 8,
|
2020-10-27 19:10:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the controller regulators to be put into
|
|
|
|
* lpm mode aggressively during clock gating.
|
|
|
|
* This would increase power savings.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_AGGR_POWER_COLLAPSE = 1 << 9,
|
2020-11-03 14:14:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the host controller driver to use DeepSleep,
|
|
|
|
* if it is supported by the UFS device. The host controller driver must
|
|
|
|
* support device hardware reset via the hba->device_reset() callback,
|
|
|
|
* in order to exit DeepSleep state.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_DEEPSLEEP = 1 << 10,
|
2021-09-15 06:04:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This capability allows the host controller driver to use temperature
|
|
|
|
* notification if it is supported by the UFS device.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_TEMP_NOTIF = 1 << 11,
|
2022-08-04 02:54:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable WriteBooster when scaling up the clock and disable
|
|
|
|
* WriteBooster when scaling the clock down.
|
|
|
|
*/
|
|
|
|
UFSHCD_CAP_WB_WITH_CLK_SCALING = 1 << 12,
|
2020-03-18 10:40:11 +00:00
|
|
|
};
|
|
|
|
|
2020-05-09 09:37:13 +00:00
|
|
|
struct ufs_hba_variant_params {
|
|
|
|
struct devfreq_dev_profile devfreq_profile;
|
|
|
|
struct devfreq_simple_ondemand_data ondemand_data;
|
|
|
|
u16 hba_enable_delay_us;
|
2020-05-09 09:37:15 +00:00
|
|
|
u32 wb_flush_threshold;
|
2020-05-09 09:37:13 +00:00
|
|
|
};
|
|
|
|
|
scsi: ufs: ufshpb: Introduce Host Performance Buffer feature
Implement Host Performance Buffer (HPB) initialization and add function
calls to UFS core driver.
NAND flash-based storage devices, including UFS, have mechanisms to
translate logical addresses of I/O requests to the corresponding physical
addresses of the flash storage. In UFS, logical-to-physical-address (L2P)
map data, which is required to identify the physical address for the
requested I/Os, can only be partially stored in SRAM from NAND flash. Due
to this partial loading, accessing the flash address area, where the L2P
information for that address is not loaded in the SRAM, can result in
serious performance degradation.
The basic concept of HPB is to cache L2P mapping entries in host system
memory so that both physical block address (PBA) and logical block address
(LBA) can be delivered in HPB read command. The HPB read command allows to
read data faster than a regular read command in UFS since it provides the
physical address (HPB Entry) of the desired logical block in addition to
its logical address. The UFS device can access the physical block in NAND
directly without searching and uploading L2P mapping table. This improves
read performance because the NAND read operation for uploading L2P mapping
table is removed.
In HPB initialization, the host checks if the UFS device supports HPB
feature and retrieves related device capabilities. Then, HPB parameters are
configured in the device.
Total start-up time of popular applications was measured and the difference
observed between HPB being enabled and disabled. Popular applications are
12 game apps and 24 non-game apps. Each test cycle consists of running 36
applications in sequence. We repeated the cycle for observing performance
improvement by L2P mapping cache hit in HPB.
The following is the test environment:
- kernel version: 4.4.0
- RAM: 8GB
- UFS 2.1 (64GB)
Results:
+-------+----------+----------+-------+
| cycle | baseline | with HPB | diff |
+-------+----------+----------+-------+
| 1 | 272.4 | 264.9 | -7.5 |
| 2 | 250.4 | 248.2 | -2.2 |
| 3 | 226.2 | 215.6 | -10.6 |
| 4 | 230.6 | 214.8 | -15.8 |
| 5 | 232.0 | 218.1 | -13.9 |
| 6 | 231.9 | 212.6 | -19.3 |
+-------+----------+----------+-------+
We also measured HPB performance using iozone:
$ iozone -r 4k -+n -i2 -ecI -t 16 -l 16 -u 16 -s $IO_RANGE/16 -F \
mnt/tmp_1 mnt/tmp_2 mnt/tmp_3 mnt/tmp_4 mnt/tmp_5 mnt/tmp_6 mnt/tmp_7 \
mnt/tmp_8 mnt/tmp_9 mnt/tmp_10 mnt/tmp_11 mnt/tmp_12 mnt/tmp_13 \
mnt/tmp_14 mnt/tmp_15 mnt/tmp_16
Results:
+----------+--------+---------+
| IO range | HPB on | HPB off |
+----------+--------+---------+
| 1 GB | 294.8 | 300.87 |
| 4 GB | 293.51 | 179.35 |
| 8 GB | 294.85 | 162.52 |
| 16 GB | 293.45 | 156.26 |
| 32 GB | 277.4 | 153.25 |
+----------+--------+---------+
Link: https://lore.kernel.org/r/20210712085830epcms2p8c1288b7f7a81b044158a18232617b572@epcms2p8
Reported-by: kernel test robot <lkp@intel.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Tested-by: Can Guo <cang@codeaurora.org>
Tested-by: Stanley Chu <stanley.chu@mediatek.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Stanley Chu <stanley.chu@mediatek.com>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-07-12 08:58:30 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_HPB
|
|
|
|
/**
|
|
|
|
* struct ufshpb_dev_info - UFSHPB device related info
|
|
|
|
* @num_lu: the number of user logical unit to check whether all lu finished
|
|
|
|
* initialization
|
|
|
|
* @rgn_size: device reported HPB region size
|
|
|
|
* @srgn_size: device reported HPB sub-region size
|
|
|
|
* @slave_conf_cnt: counter to check all lu finished initialization
|
|
|
|
* @hpb_disabled: flag to check if HPB is disabled
|
2021-07-12 09:00:25 +00:00
|
|
|
* @max_hpb_single_cmd: device reported bMAX_DATA_SIZE_FOR_SINGLE_CMD value
|
|
|
|
* @is_legacy: flag to check HPB 1.0
|
2021-07-12 09:50:28 +00:00
|
|
|
* @control_mode: either host or device
|
scsi: ufs: ufshpb: Introduce Host Performance Buffer feature
Implement Host Performance Buffer (HPB) initialization and add function
calls to UFS core driver.
NAND flash-based storage devices, including UFS, have mechanisms to
translate logical addresses of I/O requests to the corresponding physical
addresses of the flash storage. In UFS, logical-to-physical-address (L2P)
map data, which is required to identify the physical address for the
requested I/Os, can only be partially stored in SRAM from NAND flash. Due
to this partial loading, accessing the flash address area, where the L2P
information for that address is not loaded in the SRAM, can result in
serious performance degradation.
The basic concept of HPB is to cache L2P mapping entries in host system
memory so that both physical block address (PBA) and logical block address
(LBA) can be delivered in HPB read command. The HPB read command allows to
read data faster than a regular read command in UFS since it provides the
physical address (HPB Entry) of the desired logical block in addition to
its logical address. The UFS device can access the physical block in NAND
directly without searching and uploading L2P mapping table. This improves
read performance because the NAND read operation for uploading L2P mapping
table is removed.
In HPB initialization, the host checks if the UFS device supports HPB
feature and retrieves related device capabilities. Then, HPB parameters are
configured in the device.
Total start-up time of popular applications was measured and the difference
observed between HPB being enabled and disabled. Popular applications are
12 game apps and 24 non-game apps. Each test cycle consists of running 36
applications in sequence. We repeated the cycle for observing performance
improvement by L2P mapping cache hit in HPB.
The following is the test environment:
- kernel version: 4.4.0
- RAM: 8GB
- UFS 2.1 (64GB)
Results:
+-------+----------+----------+-------+
| cycle | baseline | with HPB | diff |
+-------+----------+----------+-------+
| 1 | 272.4 | 264.9 | -7.5 |
| 2 | 250.4 | 248.2 | -2.2 |
| 3 | 226.2 | 215.6 | -10.6 |
| 4 | 230.6 | 214.8 | -15.8 |
| 5 | 232.0 | 218.1 | -13.9 |
| 6 | 231.9 | 212.6 | -19.3 |
+-------+----------+----------+-------+
We also measured HPB performance using iozone:
$ iozone -r 4k -+n -i2 -ecI -t 16 -l 16 -u 16 -s $IO_RANGE/16 -F \
mnt/tmp_1 mnt/tmp_2 mnt/tmp_3 mnt/tmp_4 mnt/tmp_5 mnt/tmp_6 mnt/tmp_7 \
mnt/tmp_8 mnt/tmp_9 mnt/tmp_10 mnt/tmp_11 mnt/tmp_12 mnt/tmp_13 \
mnt/tmp_14 mnt/tmp_15 mnt/tmp_16
Results:
+----------+--------+---------+
| IO range | HPB on | HPB off |
+----------+--------+---------+
| 1 GB | 294.8 | 300.87 |
| 4 GB | 293.51 | 179.35 |
| 8 GB | 294.85 | 162.52 |
| 16 GB | 293.45 | 156.26 |
| 32 GB | 277.4 | 153.25 |
+----------+--------+---------+
Link: https://lore.kernel.org/r/20210712085830epcms2p8c1288b7f7a81b044158a18232617b572@epcms2p8
Reported-by: kernel test robot <lkp@intel.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Tested-by: Can Guo <cang@codeaurora.org>
Tested-by: Stanley Chu <stanley.chu@mediatek.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Stanley Chu <stanley.chu@mediatek.com>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-07-12 08:58:30 +00:00
|
|
|
*/
|
|
|
|
struct ufshpb_dev_info {
|
|
|
|
int num_lu;
|
|
|
|
int rgn_size;
|
|
|
|
int srgn_size;
|
|
|
|
atomic_t slave_conf_cnt;
|
|
|
|
bool hpb_disabled;
|
2021-07-12 09:00:25 +00:00
|
|
|
u8 max_hpb_single_cmd;
|
|
|
|
bool is_legacy;
|
2021-07-12 09:50:28 +00:00
|
|
|
u8 control_mode;
|
scsi: ufs: ufshpb: Introduce Host Performance Buffer feature
Implement Host Performance Buffer (HPB) initialization and add function
calls to UFS core driver.
NAND flash-based storage devices, including UFS, have mechanisms to
translate logical addresses of I/O requests to the corresponding physical
addresses of the flash storage. In UFS, logical-to-physical-address (L2P)
map data, which is required to identify the physical address for the
requested I/Os, can only be partially stored in SRAM from NAND flash. Due
to this partial loading, accessing the flash address area, where the L2P
information for that address is not loaded in the SRAM, can result in
serious performance degradation.
The basic concept of HPB is to cache L2P mapping entries in host system
memory so that both physical block address (PBA) and logical block address
(LBA) can be delivered in HPB read command. The HPB read command allows to
read data faster than a regular read command in UFS since it provides the
physical address (HPB Entry) of the desired logical block in addition to
its logical address. The UFS device can access the physical block in NAND
directly without searching and uploading L2P mapping table. This improves
read performance because the NAND read operation for uploading L2P mapping
table is removed.
In HPB initialization, the host checks if the UFS device supports HPB
feature and retrieves related device capabilities. Then, HPB parameters are
configured in the device.
Total start-up time of popular applications was measured and the difference
observed between HPB being enabled and disabled. Popular applications are
12 game apps and 24 non-game apps. Each test cycle consists of running 36
applications in sequence. We repeated the cycle for observing performance
improvement by L2P mapping cache hit in HPB.
The following is the test environment:
- kernel version: 4.4.0
- RAM: 8GB
- UFS 2.1 (64GB)
Results:
+-------+----------+----------+-------+
| cycle | baseline | with HPB | diff |
+-------+----------+----------+-------+
| 1 | 272.4 | 264.9 | -7.5 |
| 2 | 250.4 | 248.2 | -2.2 |
| 3 | 226.2 | 215.6 | -10.6 |
| 4 | 230.6 | 214.8 | -15.8 |
| 5 | 232.0 | 218.1 | -13.9 |
| 6 | 231.9 | 212.6 | -19.3 |
+-------+----------+----------+-------+
We also measured HPB performance using iozone:
$ iozone -r 4k -+n -i2 -ecI -t 16 -l 16 -u 16 -s $IO_RANGE/16 -F \
mnt/tmp_1 mnt/tmp_2 mnt/tmp_3 mnt/tmp_4 mnt/tmp_5 mnt/tmp_6 mnt/tmp_7 \
mnt/tmp_8 mnt/tmp_9 mnt/tmp_10 mnt/tmp_11 mnt/tmp_12 mnt/tmp_13 \
mnt/tmp_14 mnt/tmp_15 mnt/tmp_16
Results:
+----------+--------+---------+
| IO range | HPB on | HPB off |
+----------+--------+---------+
| 1 GB | 294.8 | 300.87 |
| 4 GB | 293.51 | 179.35 |
| 8 GB | 294.85 | 162.52 |
| 16 GB | 293.45 | 156.26 |
| 32 GB | 277.4 | 153.25 |
+----------+--------+---------+
Link: https://lore.kernel.org/r/20210712085830epcms2p8c1288b7f7a81b044158a18232617b572@epcms2p8
Reported-by: kernel test robot <lkp@intel.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Tested-by: Can Guo <cang@codeaurora.org>
Tested-by: Stanley Chu <stanley.chu@mediatek.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Stanley Chu <stanley.chu@mediatek.com>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-07-12 08:58:30 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2021-04-22 02:28:39 +00:00
|
|
|
struct ufs_hba_monitor {
|
|
|
|
unsigned long chunk_size;
|
|
|
|
|
|
|
|
unsigned long nr_sec_rw[2];
|
|
|
|
ktime_t total_busy[2];
|
|
|
|
|
|
|
|
unsigned long nr_req[2];
|
|
|
|
/* latencies*/
|
|
|
|
ktime_t lat_sum[2];
|
|
|
|
ktime_t lat_max[2];
|
|
|
|
ktime_t lat_min[2];
|
|
|
|
|
|
|
|
u32 nr_queued[2];
|
|
|
|
ktime_t busy_start_ts[2];
|
|
|
|
|
|
|
|
ktime_t enabled_ts;
|
|
|
|
bool enabled;
|
|
|
|
};
|
|
|
|
|
2023-01-13 20:48:42 +00:00
|
|
|
/**
|
|
|
|
* struct ufshcd_res_info_t - MCQ related resource regions
|
|
|
|
*
|
|
|
|
* @name: resource name
|
|
|
|
* @resource: pointer to resource region
|
|
|
|
* @base: register base address
|
|
|
|
*/
|
|
|
|
struct ufshcd_res_info {
|
|
|
|
const char *name;
|
|
|
|
struct resource *resource;
|
|
|
|
void __iomem *base;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ufshcd_res {
|
|
|
|
RES_UFS,
|
|
|
|
RES_MCQ,
|
|
|
|
RES_MCQ_SQD,
|
|
|
|
RES_MCQ_SQIS,
|
|
|
|
RES_MCQ_CQD,
|
|
|
|
RES_MCQ_CQIS,
|
|
|
|
RES_MCQ_VS,
|
|
|
|
RES_MAX,
|
|
|
|
};
|
|
|
|
|
2023-01-13 20:48:45 +00:00
|
|
|
/**
|
|
|
|
* struct ufshcd_mcq_opr_info_t - Operation and Runtime registers
|
|
|
|
*
|
|
|
|
* @offset: Doorbell Address Offset
|
|
|
|
* @stride: Steps proportional to queue [0...31]
|
|
|
|
* @base: base address
|
|
|
|
*/
|
|
|
|
struct ufshcd_mcq_opr_info_t {
|
|
|
|
unsigned long offset;
|
|
|
|
unsigned long stride;
|
|
|
|
void __iomem *base;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ufshcd_mcq_opr {
|
|
|
|
OPR_SQD,
|
|
|
|
OPR_SQIS,
|
|
|
|
OPR_CQD,
|
|
|
|
OPR_CQIS,
|
|
|
|
OPR_MAX,
|
|
|
|
};
|
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
/**
|
|
|
|
* struct ufs_hba - per adapter private structure
|
|
|
|
* @mmio_base: UFSHCI base register address
|
|
|
|
* @ucdl_base_addr: UFS Command Descriptor base address
|
|
|
|
* @utrdl_base_addr: UTP Transfer Request Descriptor base address
|
|
|
|
* @utmrdl_base_addr: UTP Task Management Descriptor base address
|
|
|
|
* @ucdl_dma_addr: UFS Command Descriptor DMA address
|
|
|
|
* @utrdl_dma_addr: UTRDL DMA address
|
|
|
|
* @utmrdl_dma_addr: UTMRDL DMA address
|
|
|
|
* @host: Scsi_Host instance of the driver
|
|
|
|
* @dev: device handle
|
2022-04-19 22:57:59 +00:00
|
|
|
* @ufs_device_wlun: WLUN that controls the entire UFS device.
|
2022-04-19 22:58:07 +00:00
|
|
|
* @hwmon_device: device instance registered with the hwmon core.
|
|
|
|
* @curr_dev_pwr_mode: active UFS device power mode.
|
|
|
|
* @uic_link_state: active state of the link to the UFS device.
|
|
|
|
* @rpm_lvl: desired UFS power management level during runtime PM.
|
|
|
|
* @spm_lvl: desired UFS power management level during system PM.
|
|
|
|
* @pm_op_in_progress: whether or not a PM operation is in progress.
|
|
|
|
* @ahit: value of Auto-Hibernate Idle Timer register.
|
2013-02-25 16:14:33 +00:00
|
|
|
* @lrb: local reference block
|
|
|
|
* @outstanding_tasks: Bits representing outstanding task requests
|
2021-07-22 03:34:34 +00:00
|
|
|
* @outstanding_lock: Protects @outstanding_reqs.
|
2013-02-25 16:14:33 +00:00
|
|
|
* @outstanding_reqs: Bits representing outstanding transfer requests
|
|
|
|
* @capabilities: UFS Controller Capabilities
|
2023-01-13 20:48:38 +00:00
|
|
|
* @mcq_capabilities: UFS Multi Circular Queue capabilities
|
2013-02-25 16:14:33 +00:00
|
|
|
* @nutrs: Transfer Request Queue depth supported by controller
|
|
|
|
* @nutmrs: Task Management Queue depth supported by controller
|
2021-12-03 23:19:42 +00:00
|
|
|
* @reserved_slot: Used to submit device commands. Protected by @dev_cmd.lock.
|
2013-02-25 16:14:33 +00:00
|
|
|
* @ufs_version: UFS Version to which controller complies
|
2014-09-25 12:32:21 +00:00
|
|
|
* @vops: pointer to variant specific operations
|
2022-04-19 22:58:07 +00:00
|
|
|
* @vps: pointer to variant specific parameters
|
2014-09-25 12:32:21 +00:00
|
|
|
* @priv: pointer to variant specific private data
|
2022-12-08 23:43:58 +00:00
|
|
|
* @sg_entry_size: size of struct ufshcd_sg_entry (may include variant fields)
|
2013-02-25 16:14:33 +00:00
|
|
|
* @irq: Irq number of the controller
|
2022-04-19 22:58:07 +00:00
|
|
|
* @is_irq_enabled: whether or not the UFS controller interrupt is enabled.
|
|
|
|
* @dev_ref_clk_freq: reference clock frequency
|
|
|
|
* @quirks: bitmask with information about deviations from the UFSHCI standard.
|
|
|
|
* @dev_quirks: bitmask with information about deviations from the UFS standard.
|
2019-12-09 18:13:09 +00:00
|
|
|
* @tmf_tag_set: TMF tag set.
|
|
|
|
* @tmf_queue: Used to allocate TMF tags.
|
2022-04-19 22:58:07 +00:00
|
|
|
* @tmf_rqs: array with pointers to TMF requests while these are in progress.
|
|
|
|
* @active_uic_cmd: handle of active UIC command
|
|
|
|
* @uic_cmd_mutex: mutex for UIC command
|
|
|
|
* @uic_async_done: completion used during UIC processing
|
2021-07-22 03:34:29 +00:00
|
|
|
* @ufshcd_state: UFSHCD state
|
2014-05-26 05:29:14 +00:00
|
|
|
* @eh_flags: Error handling flags
|
2013-06-26 17:09:27 +00:00
|
|
|
* @intr_mask: Interrupt Mask Bits
|
2013-07-29 19:05:59 +00:00
|
|
|
* @ee_ctrl_mask: Exception event control mask
|
2022-04-19 22:58:07 +00:00
|
|
|
* @ee_drv_mask: Exception event mask for driver
|
|
|
|
* @ee_usr_mask: Exception event mask for user (set via debugfs)
|
|
|
|
* @ee_ctrl_mutex: Used to serialize exception event information.
|
2014-09-25 12:32:26 +00:00
|
|
|
* @is_powered: flag to check if HBA is powered
|
2021-01-14 03:13:28 +00:00
|
|
|
* @shutting_down: flag to check if shutdown has been invoked
|
|
|
|
* @host_sem: semaphore used to serialize concurrent contexts
|
scsi: ufs: core: Revert "scsi: ufs: Synchronize SCSI and UFS error handling"
This reverts commit a113eaaf86373362b053279049907ff82b5df6c8.
There are a couple of issues with the commit:
1. It causes deadlocks.
2. It causes the shost->eh_cmd_q list of failed requests not to be
processed, ever.
So revert it.
1. Deadlocks
The SCSI error handler runs with requests blocked beginning when
scsi_schedule_eh() sets SHOST_RECOVERY state, continuing through
scsi_error_handler() callback ->eh_strategy_handler() until
scsi_restart_operations() is called. By setting eh_strategy_handler to
ufshcd_err_handler, the patch changed the UFS error handler to run with
requests blocked, including PM requests, for the entire run of the error
handler.
That conflicts with UFS error handler existing synchronization with UFS
device PM operations. The UFS error handler synchronizes with runtime PM
by doing pm_runtime_get_sync() prior to blocking requests itself. It
synchronizes with system PM by use of hba->host_sem, again before blocking
requests itself. However, if requests are already blocked, then PM
operations will block. So:
the UFS error handler blocks waiting on PM
+ PM blocks waiting on SCSI PM requests to process or fail
+ PM requests are blocked waiting on error handling to finish
= deadlock
This happens both for runtime PM and system PM.
Prior to the patch, these deadlocks could not happen even if SCSI error
handling was running, because the presence of requests in shost->eh_cmd_q
would mean the queues could not be suspended, which would mean that, should
the UFS error handler run at the same time, it would not need to wait for
PM or vice versa.
Please note these scenarios are not just theoretical, they were found
during testing on a Samsung Galaxy Book S.
2. ->eh_strategy_handler() must process shost->eh_cmd_q list of failed
requests, as all other eh_strategy_handler's do except UFS error handler.
Refer for example: scsi_unjam_host(), ata_scsi_error() and
sas_scsi_recover_host().
Link: https://lore.kernel.org/r/20210917144349.14058-1-adrian.hunter@intel.com
Fixes: a113eaaf8637 ("scsi: ufs: Synchronize SCSI and UFS error handling")
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-09-17 14:43:49 +00:00
|
|
|
* @eh_wq: Workqueue that eh_work works on
|
|
|
|
* @eh_work: Worker to handle UFS errors that require s/w attention
|
2013-07-29 19:05:59 +00:00
|
|
|
* @eeh_work: Worker to handle exception events
|
2013-02-25 16:14:33 +00:00
|
|
|
* @errors: HBA errors
|
2014-05-26 05:29:15 +00:00
|
|
|
* @uic_error: UFS interconnect layer error status
|
|
|
|
* @saved_err: sticky error mask
|
|
|
|
* @saved_uic_err: sticky UIC error mask
|
2022-04-19 22:58:07 +00:00
|
|
|
* @ufs_stats: various error counters
|
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
|
|
|
* @force_reset: flag to force eh_work perform a full reset
|
2020-08-25 02:07:06 +00:00
|
|
|
* @force_pmc: flag to force a power mode change
|
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
|
|
|
* @silence_err_logs: flag to silence error logs
|
2013-07-29 19:05:57 +00:00
|
|
|
* @dev_cmd: ufs device management command information
|
2015-03-31 14:37:14 +00:00
|
|
|
* @last_dme_cmd_tstamp: time stamp of the last completed DME command
|
2022-04-19 22:58:07 +00:00
|
|
|
* @nop_out_timeout: NOP OUT timeout value
|
|
|
|
* @dev_info: information about the UFS device
|
2013-07-29 19:05:59 +00:00
|
|
|
* @auto_bkops_enabled: to track whether bkops is enabled in device
|
2014-09-25 12:32:22 +00:00
|
|
|
* @vreg_info: UFS device voltage regulator information
|
2014-09-25 12:32:23 +00:00
|
|
|
* @clk_list_head: UFS host controller clocks list node head
|
2022-04-19 22:58:07 +00:00
|
|
|
* @req_abort_count: number of times ufshcd_abort() has been called
|
|
|
|
* @lanes_per_direction: number of lanes per data direction between the UFS
|
|
|
|
* controller and the UFS device.
|
2014-09-25 12:32:31 +00:00
|
|
|
* @pwr_info: holds current power mode
|
|
|
|
* @max_pwr_info: keeps the device max valid pwm
|
2022-04-19 22:58:07 +00:00
|
|
|
* @clk_gating: information related to clock gating
|
|
|
|
* @caps: bitmask with information about UFS controller capabilities
|
|
|
|
* @devfreq: frequency scaling information owned by the devfreq core
|
|
|
|
* @clk_scaling: frequency scaling information owned by the UFS driver
|
2022-10-18 20:29:56 +00:00
|
|
|
* @system_suspending: system suspend has been started and system resume has
|
|
|
|
* not yet finished.
|
|
|
|
* @is_sys_suspended: UFS device has been suspended because of system suspend
|
2016-03-10 15:37:15 +00:00
|
|
|
* @urgent_bkops_lvl: keeps track of urgent bkops level for device
|
|
|
|
* @is_urgent_bkops_lvl_checked: keeps track if the urgent bkops level for
|
|
|
|
* device is known or not.
|
2023-01-16 16:12:01 +00:00
|
|
|
* @wb_mutex: used to serialize devfreq and sysfs write booster toggling
|
2022-04-19 22:58:07 +00:00
|
|
|
* @clk_scaling_lock: used to serialize device commands and clock scaling
|
|
|
|
* @desc_size: descriptor sizes reported by device
|
2018-05-03 11:07:18 +00:00
|
|
|
* @scsi_block_reqs_cnt: reference counting for scsi block requests
|
2022-04-19 22:58:07 +00:00
|
|
|
* @bsg_dev: struct device associated with the BSG queue
|
|
|
|
* @bsg_queue: BSG queue associated with the UFS controller
|
|
|
|
* @rpm_dev_flush_recheck_work: used to suspend from RPM (runtime power
|
|
|
|
* management) after the UFS device has finished a WriteBooster buffer
|
|
|
|
* flush or auto BKOP.
|
|
|
|
* @ufshpb_dev: information related to HPB (Host Performance Booster).
|
|
|
|
* @monitor: statistics about UFS commands
|
2020-07-06 20:04:13 +00:00
|
|
|
* @crypto_capabilities: Content of crypto capabilities register (0x100)
|
|
|
|
* @crypto_cap_array: Array of crypto capabilities
|
|
|
|
* @crypto_cfg_register: Start of the crypto cfg array
|
blk-crypto: rename blk_keyslot_manager to blk_crypto_profile
blk_keyslot_manager is misnamed because it doesn't necessarily manage
keyslots. It actually does several different things:
- Contains the crypto capabilities of the device.
- Provides functions to control the inline encryption hardware.
Originally these were just for programming/evicting keyslots;
however, new functionality (hardware-wrapped keys) will require new
functions here which are unrelated to keyslots. Moreover,
device-mapper devices already (ab)use "keyslot_evict" to pass key
eviction requests to their underlying devices even though
device-mapper devices don't have any keyslots themselves (so it
really should be "evict_key", not "keyslot_evict").
- Sometimes (but not always!) it manages keyslots. Originally it
always did, but device-mapper devices don't have keyslots
themselves, so they use a "passthrough keyslot manager" which
doesn't actually manage keyslots. This hack works, but the
terminology is unnatural. Also, some hardware doesn't have keyslots
and thus also uses a "passthrough keyslot manager" (support for such
hardware is yet to be upstreamed, but it will happen eventually).
Let's stop having keyslot managers which don't actually manage keyslots.
Instead, rename blk_keyslot_manager to blk_crypto_profile.
This is a fairly big change, since for consistency it also has to update
keyslot manager-related function names, variable names, and comments --
not just the actual struct name. However it's still a fairly
straightforward change, as it doesn't change any actual functionality.
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC
Reviewed-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Eric Biggers <ebiggers@google.com>
Link: https://lore.kernel.org/r/20211018180453.40441-4-ebiggers@kernel.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2021-10-18 18:04:52 +00:00
|
|
|
* @crypto_profile: the crypto profile of this hba (if applicable)
|
2022-04-19 22:58:07 +00:00
|
|
|
* @debugfs_root: UFS controller debugfs root directory
|
|
|
|
* @debugfs_ee_work: used to restore ee_ctrl_mask after a delay
|
|
|
|
* @debugfs_ee_rate_limit_ms: user configurable delay after which to restore
|
|
|
|
* ee_ctrl_mask
|
|
|
|
* @luns_avail: number of regular and well known LUNs supported by the UFS
|
|
|
|
* device
|
2023-01-13 20:48:41 +00:00
|
|
|
* @nr_hw_queues: number of hardware queues configured
|
|
|
|
* @nr_queues: number of Queues of different queue types
|
2022-04-19 22:58:07 +00:00
|
|
|
* @complete_put: whether or not to call ufshcd_rpm_put() from inside
|
|
|
|
* ufshcd_resume_complete()
|
2023-01-13 20:48:38 +00:00
|
|
|
* @ext_iid_sup: is EXT_IID is supported by UFSHC
|
2023-01-13 20:48:39 +00:00
|
|
|
* @mcq_sup: is mcq supported by UFSHC
|
2023-01-13 20:48:45 +00:00
|
|
|
* @mcq_enabled: is mcq ready to accept requests
|
2023-01-13 20:48:42 +00:00
|
|
|
* @res: array of resource info of MCQ registers
|
|
|
|
* @mcq_base: Multi circular queue registers base address
|
2023-01-13 20:48:44 +00:00
|
|
|
* @uhq: array of supported hardware queues
|
|
|
|
* @dev_cmd_queue: Queue for issuing device management commands
|
2013-02-25 16:14:33 +00:00
|
|
|
*/
|
|
|
|
struct ufs_hba {
|
|
|
|
void __iomem *mmio_base;
|
|
|
|
|
|
|
|
/* Virtual memory reference */
|
|
|
|
struct utp_transfer_cmd_desc *ucdl_base_addr;
|
|
|
|
struct utp_transfer_req_desc *utrdl_base_addr;
|
|
|
|
struct utp_task_req_desc *utmrdl_base_addr;
|
|
|
|
|
|
|
|
/* DMA memory reference */
|
|
|
|
dma_addr_t ucdl_dma_addr;
|
|
|
|
dma_addr_t utrdl_dma_addr;
|
|
|
|
dma_addr_t utmrdl_dma_addr;
|
|
|
|
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct device *dev;
|
2022-04-19 22:57:59 +00:00
|
|
|
struct scsi_device *ufs_device_wlun;
|
2013-02-25 16:14:33 +00:00
|
|
|
|
2021-09-15 06:04:06 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_HWMON
|
|
|
|
struct device *hwmon_device;
|
|
|
|
#endif
|
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
enum ufs_dev_pwr_mode curr_dev_pwr_mode;
|
|
|
|
enum uic_link_state uic_link_state;
|
|
|
|
/* Desired UFS power management level during runtime PM */
|
|
|
|
enum ufs_pm_level rpm_lvl;
|
|
|
|
/* Desired UFS power management level during system PM */
|
|
|
|
enum ufs_pm_level spm_lvl;
|
|
|
|
int pm_op_in_progress;
|
|
|
|
|
2018-03-20 13:07:38 +00:00
|
|
|
/* Auto-Hibernate Idle Timer register value */
|
|
|
|
u32 ahit;
|
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
struct ufshcd_lrb *lrb;
|
|
|
|
|
|
|
|
unsigned long outstanding_tasks;
|
2021-07-22 03:34:34 +00:00
|
|
|
spinlock_t outstanding_lock;
|
2013-02-25 16:14:33 +00:00
|
|
|
unsigned long outstanding_reqs;
|
|
|
|
|
|
|
|
u32 capabilities;
|
|
|
|
int nutrs;
|
2023-01-13 20:48:38 +00:00
|
|
|
u32 mcq_capabilities;
|
2013-02-25 16:14:33 +00:00
|
|
|
int nutmrs;
|
2021-12-03 23:19:42 +00:00
|
|
|
u32 reserved_slot;
|
2013-02-25 16:14:33 +00:00
|
|
|
u32 ufs_version;
|
2019-03-04 19:39:11 +00:00
|
|
|
const struct ufs_hba_variant_ops *vops;
|
2020-05-09 09:37:13 +00:00
|
|
|
struct ufs_hba_variant_params *vps;
|
2014-09-25 12:32:21 +00:00
|
|
|
void *priv;
|
2022-12-08 23:43:58 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_VARIABLE_SG_ENTRY_SIZE
|
|
|
|
size_t sg_entry_size;
|
|
|
|
#endif
|
2013-02-25 16:14:33 +00:00
|
|
|
unsigned int irq;
|
2014-09-25 12:32:30 +00:00
|
|
|
bool is_irq_enabled;
|
2018-10-16 08:59:41 +00:00
|
|
|
enum ufs_ref_clk_freq dev_ref_clk_freq;
|
2013-02-25 16:14:33 +00:00
|
|
|
|
2015-03-31 14:37:14 +00:00
|
|
|
unsigned int quirks; /* Deviations from standard UFSHCI spec. */
|
2013-06-26 17:09:29 +00:00
|
|
|
|
2016-03-10 15:37:10 +00:00
|
|
|
/* Device deviations from standard UFS device spec. */
|
|
|
|
unsigned int dev_quirks;
|
|
|
|
|
2019-12-09 18:13:09 +00:00
|
|
|
struct blk_mq_tag_set tmf_tag_set;
|
|
|
|
struct request_queue *tmf_queue;
|
2021-09-22 09:10:59 +00:00
|
|
|
struct request **tmf_rqs;
|
2013-02-25 16:14:33 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
struct uic_command *active_uic_cmd;
|
|
|
|
struct mutex uic_cmd_mutex;
|
|
|
|
struct completion *uic_async_done;
|
2013-08-31 16:10:22 +00:00
|
|
|
|
2021-07-22 03:34:29 +00:00
|
|
|
enum ufshcd_state ufshcd_state;
|
2014-05-26 05:29:14 +00:00
|
|
|
u32 eh_flags;
|
2013-06-26 17:09:27 +00:00
|
|
|
u32 intr_mask;
|
2022-04-19 22:58:07 +00:00
|
|
|
u16 ee_ctrl_mask;
|
|
|
|
u16 ee_drv_mask;
|
|
|
|
u16 ee_usr_mask;
|
2021-02-09 06:24:36 +00:00
|
|
|
struct mutex ee_ctrl_mutex;
|
2014-09-25 12:32:26 +00:00
|
|
|
bool is_powered;
|
2021-01-14 03:13:28 +00:00
|
|
|
bool shutting_down;
|
|
|
|
struct semaphore host_sem;
|
2013-02-25 16:14:33 +00:00
|
|
|
|
|
|
|
/* Work Queues */
|
scsi: ufs: core: Revert "scsi: ufs: Synchronize SCSI and UFS error handling"
This reverts commit a113eaaf86373362b053279049907ff82b5df6c8.
There are a couple of issues with the commit:
1. It causes deadlocks.
2. It causes the shost->eh_cmd_q list of failed requests not to be
processed, ever.
So revert it.
1. Deadlocks
The SCSI error handler runs with requests blocked beginning when
scsi_schedule_eh() sets SHOST_RECOVERY state, continuing through
scsi_error_handler() callback ->eh_strategy_handler() until
scsi_restart_operations() is called. By setting eh_strategy_handler to
ufshcd_err_handler, the patch changed the UFS error handler to run with
requests blocked, including PM requests, for the entire run of the error
handler.
That conflicts with UFS error handler existing synchronization with UFS
device PM operations. The UFS error handler synchronizes with runtime PM
by doing pm_runtime_get_sync() prior to blocking requests itself. It
synchronizes with system PM by use of hba->host_sem, again before blocking
requests itself. However, if requests are already blocked, then PM
operations will block. So:
the UFS error handler blocks waiting on PM
+ PM blocks waiting on SCSI PM requests to process or fail
+ PM requests are blocked waiting on error handling to finish
= deadlock
This happens both for runtime PM and system PM.
Prior to the patch, these deadlocks could not happen even if SCSI error
handling was running, because the presence of requests in shost->eh_cmd_q
would mean the queues could not be suspended, which would mean that, should
the UFS error handler run at the same time, it would not need to wait for
PM or vice versa.
Please note these scenarios are not just theoretical, they were found
during testing on a Samsung Galaxy Book S.
2. ->eh_strategy_handler() must process shost->eh_cmd_q list of failed
requests, as all other eh_strategy_handler's do except UFS error handler.
Refer for example: scsi_unjam_host(), ata_scsi_error() and
sas_scsi_recover_host().
Link: https://lore.kernel.org/r/20210917144349.14058-1-adrian.hunter@intel.com
Fixes: a113eaaf8637 ("scsi: ufs: Synchronize SCSI and UFS error handling")
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-09-17 14:43:49 +00:00
|
|
|
struct workqueue_struct *eh_wq;
|
|
|
|
struct work_struct eh_work;
|
2013-07-29 19:05:59 +00:00
|
|
|
struct work_struct eeh_work;
|
2013-02-25 16:14:33 +00:00
|
|
|
|
|
|
|
/* HBA Errors */
|
|
|
|
u32 errors;
|
2014-05-26 05:29:15 +00:00
|
|
|
u32 uic_error;
|
|
|
|
u32 saved_err;
|
|
|
|
u32 saved_uic_err;
|
2016-12-23 02:42:18 +00:00
|
|
|
struct ufs_stats ufs_stats;
|
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
|
|
|
bool force_reset;
|
2020-08-25 02:07:06 +00:00
|
|
|
bool force_pmc;
|
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
|
|
|
bool silence_err_logs;
|
2013-07-29 19:05:57 +00:00
|
|
|
|
|
|
|
/* Device management request data */
|
|
|
|
struct ufs_dev_cmd dev_cmd;
|
2015-03-31 14:37:14 +00:00
|
|
|
ktime_t last_dme_cmd_tstamp;
|
2021-08-31 14:53:17 +00:00
|
|
|
int nop_out_timeout;
|
2013-07-29 19:05:59 +00:00
|
|
|
|
2014-09-25 12:32:30 +00:00
|
|
|
/* Keeps information of the UFS device connected to this host */
|
|
|
|
struct ufs_dev_info dev_info;
|
2013-07-29 19:05:59 +00:00
|
|
|
bool auto_bkops_enabled;
|
2014-09-25 12:32:22 +00:00
|
|
|
struct ufs_vreg_info vreg_info;
|
2014-09-25 12:32:23 +00:00
|
|
|
struct list_head clk_list_head;
|
2014-09-25 12:32:30 +00:00
|
|
|
|
2017-02-04 00:56:50 +00:00
|
|
|
/* Number of requests aborts */
|
|
|
|
int req_abort_count;
|
|
|
|
|
2016-03-10 15:37:05 +00:00
|
|
|
/* Number of lanes available (1 or 2) for Rx/Tx */
|
|
|
|
u32 lanes_per_direction;
|
2014-09-25 12:32:31 +00:00
|
|
|
struct ufs_pa_layer_attr pwr_info;
|
|
|
|
struct ufs_pwr_mode_info max_pwr_info;
|
2014-09-25 12:32:32 +00:00
|
|
|
|
|
|
|
struct ufs_clk_gating clk_gating;
|
|
|
|
/* Control to enable/disable host capabilities */
|
|
|
|
u32 caps;
|
2014-09-25 12:32:34 +00:00
|
|
|
|
|
|
|
struct devfreq *devfreq;
|
|
|
|
struct ufs_clk_scaling clk_scaling;
|
2022-10-18 20:29:56 +00:00
|
|
|
bool system_suspending;
|
2014-09-25 12:32:36 +00:00
|
|
|
bool is_sys_suspended;
|
2016-03-10 15:37:15 +00:00
|
|
|
|
|
|
|
enum bkops_status urgent_bkops_lvl;
|
|
|
|
bool is_urgent_bkops_lvl_checked;
|
2017-02-04 00:57:02 +00:00
|
|
|
|
2023-01-16 16:12:01 +00:00
|
|
|
struct mutex wb_mutex;
|
2017-02-04 00:57:02 +00:00
|
|
|
struct rw_semaphore clk_scaling_lock;
|
2018-05-03 11:07:18 +00:00
|
|
|
atomic_t scsi_block_reqs_cnt;
|
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
|
|
|
|
|
|
|
struct device bsg_dev;
|
|
|
|
struct request_queue *bsg_queue;
|
2020-05-22 08:32:12 +00:00
|
|
|
struct delayed_work rpm_dev_flush_recheck_work;
|
2020-07-06 20:04:13 +00:00
|
|
|
|
scsi: ufs: ufshpb: Introduce Host Performance Buffer feature
Implement Host Performance Buffer (HPB) initialization and add function
calls to UFS core driver.
NAND flash-based storage devices, including UFS, have mechanisms to
translate logical addresses of I/O requests to the corresponding physical
addresses of the flash storage. In UFS, logical-to-physical-address (L2P)
map data, which is required to identify the physical address for the
requested I/Os, can only be partially stored in SRAM from NAND flash. Due
to this partial loading, accessing the flash address area, where the L2P
information for that address is not loaded in the SRAM, can result in
serious performance degradation.
The basic concept of HPB is to cache L2P mapping entries in host system
memory so that both physical block address (PBA) and logical block address
(LBA) can be delivered in HPB read command. The HPB read command allows to
read data faster than a regular read command in UFS since it provides the
physical address (HPB Entry) of the desired logical block in addition to
its logical address. The UFS device can access the physical block in NAND
directly without searching and uploading L2P mapping table. This improves
read performance because the NAND read operation for uploading L2P mapping
table is removed.
In HPB initialization, the host checks if the UFS device supports HPB
feature and retrieves related device capabilities. Then, HPB parameters are
configured in the device.
Total start-up time of popular applications was measured and the difference
observed between HPB being enabled and disabled. Popular applications are
12 game apps and 24 non-game apps. Each test cycle consists of running 36
applications in sequence. We repeated the cycle for observing performance
improvement by L2P mapping cache hit in HPB.
The following is the test environment:
- kernel version: 4.4.0
- RAM: 8GB
- UFS 2.1 (64GB)
Results:
+-------+----------+----------+-------+
| cycle | baseline | with HPB | diff |
+-------+----------+----------+-------+
| 1 | 272.4 | 264.9 | -7.5 |
| 2 | 250.4 | 248.2 | -2.2 |
| 3 | 226.2 | 215.6 | -10.6 |
| 4 | 230.6 | 214.8 | -15.8 |
| 5 | 232.0 | 218.1 | -13.9 |
| 6 | 231.9 | 212.6 | -19.3 |
+-------+----------+----------+-------+
We also measured HPB performance using iozone:
$ iozone -r 4k -+n -i2 -ecI -t 16 -l 16 -u 16 -s $IO_RANGE/16 -F \
mnt/tmp_1 mnt/tmp_2 mnt/tmp_3 mnt/tmp_4 mnt/tmp_5 mnt/tmp_6 mnt/tmp_7 \
mnt/tmp_8 mnt/tmp_9 mnt/tmp_10 mnt/tmp_11 mnt/tmp_12 mnt/tmp_13 \
mnt/tmp_14 mnt/tmp_15 mnt/tmp_16
Results:
+----------+--------+---------+
| IO range | HPB on | HPB off |
+----------+--------+---------+
| 1 GB | 294.8 | 300.87 |
| 4 GB | 293.51 | 179.35 |
| 8 GB | 294.85 | 162.52 |
| 16 GB | 293.45 | 156.26 |
| 32 GB | 277.4 | 153.25 |
+----------+--------+---------+
Link: https://lore.kernel.org/r/20210712085830epcms2p8c1288b7f7a81b044158a18232617b572@epcms2p8
Reported-by: kernel test robot <lkp@intel.com>
Tested-by: Bean Huo <beanhuo@micron.com>
Tested-by: Can Guo <cang@codeaurora.org>
Tested-by: Stanley Chu <stanley.chu@mediatek.com>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Can Guo <cang@codeaurora.org>
Reviewed-by: Bean Huo <beanhuo@micron.com>
Reviewed-by: Stanley Chu <stanley.chu@mediatek.com>
Acked-by: Avri Altman <Avri.Altman@wdc.com>
Signed-off-by: Daejun Park <daejun7.park@samsung.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2021-07-12 08:58:30 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_HPB
|
|
|
|
struct ufshpb_dev_info ufshpb_dev;
|
|
|
|
#endif
|
|
|
|
|
2021-04-22 02:28:39 +00:00
|
|
|
struct ufs_hba_monitor monitor;
|
|
|
|
|
2020-07-06 20:04:13 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_CRYPTO
|
|
|
|
union ufs_crypto_capabilities crypto_capabilities;
|
|
|
|
union ufs_crypto_cap_entry *crypto_cap_array;
|
|
|
|
u32 crypto_cfg_register;
|
blk-crypto: rename blk_keyslot_manager to blk_crypto_profile
blk_keyslot_manager is misnamed because it doesn't necessarily manage
keyslots. It actually does several different things:
- Contains the crypto capabilities of the device.
- Provides functions to control the inline encryption hardware.
Originally these were just for programming/evicting keyslots;
however, new functionality (hardware-wrapped keys) will require new
functions here which are unrelated to keyslots. Moreover,
device-mapper devices already (ab)use "keyslot_evict" to pass key
eviction requests to their underlying devices even though
device-mapper devices don't have any keyslots themselves (so it
really should be "evict_key", not "keyslot_evict").
- Sometimes (but not always!) it manages keyslots. Originally it
always did, but device-mapper devices don't have keyslots
themselves, so they use a "passthrough keyslot manager" which
doesn't actually manage keyslots. This hack works, but the
terminology is unnatural. Also, some hardware doesn't have keyslots
and thus also uses a "passthrough keyslot manager" (support for such
hardware is yet to be upstreamed, but it will happen eventually).
Let's stop having keyslot managers which don't actually manage keyslots.
Instead, rename blk_keyslot_manager to blk_crypto_profile.
This is a fairly big change, since for consistency it also has to update
keyslot manager-related function names, variable names, and comments --
not just the actual struct name. However it's still a fairly
straightforward change, as it doesn't change any actual functionality.
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC
Reviewed-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Eric Biggers <ebiggers@google.com>
Link: https://lore.kernel.org/r/20211018180453.40441-4-ebiggers@kernel.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2021-10-18 18:04:52 +00:00
|
|
|
struct blk_crypto_profile crypto_profile;
|
2020-07-06 20:04:13 +00:00
|
|
|
#endif
|
2021-01-07 07:25:38 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *debugfs_root;
|
2021-02-09 06:24:37 +00:00
|
|
|
struct delayed_work debugfs_ee_work;
|
|
|
|
u32 debugfs_ee_rate_limit_ms;
|
2021-01-07 07:25:38 +00:00
|
|
|
#endif
|
2021-04-24 00:20:16 +00:00
|
|
|
u32 luns_avail;
|
2023-01-13 20:48:41 +00:00
|
|
|
unsigned int nr_hw_queues;
|
|
|
|
unsigned int nr_queues[HCTX_MAX_TYPES];
|
2021-04-24 00:20:16 +00:00
|
|
|
bool complete_put;
|
2023-01-13 20:48:38 +00:00
|
|
|
bool ext_iid_sup;
|
2023-01-13 20:48:40 +00:00
|
|
|
bool scsi_host_added;
|
2023-01-13 20:48:39 +00:00
|
|
|
bool mcq_sup;
|
2023-01-13 20:48:45 +00:00
|
|
|
bool mcq_enabled;
|
2023-01-13 20:48:42 +00:00
|
|
|
struct ufshcd_res_info res[RES_MAX];
|
|
|
|
void __iomem *mcq_base;
|
2023-01-13 20:48:44 +00:00
|
|
|
struct ufs_hw_queue *uhq;
|
|
|
|
struct ufs_hw_queue *dev_cmd_queue;
|
2023-01-13 20:48:45 +00:00
|
|
|
struct ufshcd_mcq_opr_info_t mcq_opr[OPR_MAX];
|
2023-01-13 20:48:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct ufs_hw_queue - per hardware queue structure
|
2023-01-13 20:48:45 +00:00
|
|
|
* @mcq_sq_head: base address of submission queue head pointer
|
|
|
|
* @mcq_sq_tail: base address of submission queue tail pointer
|
|
|
|
* @mcq_cq_head: base address of completion queue head pointer
|
|
|
|
* @mcq_cq_tail: base address of completion queue tail pointer
|
2023-01-13 20:48:44 +00:00
|
|
|
* @sqe_base_addr: submission queue entry base address
|
|
|
|
* @sqe_dma_addr: submission queue dma address
|
|
|
|
* @cqe_base_addr: completion queue base address
|
|
|
|
* @cqe_dma_addr: completion queue dma address
|
|
|
|
* @max_entries: max number of slots in this hardware queue
|
2023-01-13 20:48:45 +00:00
|
|
|
* @id: hardware queue ID
|
2023-01-13 20:48:47 +00:00
|
|
|
* @sq_tp_slot: current slot to which SQ tail pointer is pointing
|
|
|
|
* @sq_lock: serialize submission queue access
|
2023-01-13 20:48:50 +00:00
|
|
|
* @cq_tail_slot: current slot to which CQ tail pointer is pointing
|
|
|
|
* @cq_head_slot: current slot to which CQ head pointer is pointing
|
2023-01-13 20:48:51 +00:00
|
|
|
* @cq_lock: Synchronize between multiple polling instances
|
2023-01-13 20:48:44 +00:00
|
|
|
*/
|
|
|
|
struct ufs_hw_queue {
|
2023-01-13 20:48:45 +00:00
|
|
|
void __iomem *mcq_sq_head;
|
|
|
|
void __iomem *mcq_sq_tail;
|
|
|
|
void __iomem *mcq_cq_head;
|
|
|
|
void __iomem *mcq_cq_tail;
|
|
|
|
|
2023-03-29 10:13:03 +00:00
|
|
|
struct utp_transfer_req_desc *sqe_base_addr;
|
2023-01-13 20:48:44 +00:00
|
|
|
dma_addr_t sqe_dma_addr;
|
|
|
|
struct cq_entry *cqe_base_addr;
|
|
|
|
dma_addr_t cqe_dma_addr;
|
|
|
|
u32 max_entries;
|
2023-01-13 20:48:45 +00:00
|
|
|
u32 id;
|
2023-01-13 20:48:47 +00:00
|
|
|
u32 sq_tail_slot;
|
|
|
|
spinlock_t sq_lock;
|
2023-01-13 20:48:50 +00:00
|
|
|
u32 cq_tail_slot;
|
|
|
|
u32 cq_head_slot;
|
2023-01-13 20:48:51 +00:00
|
|
|
spinlock_t cq_lock;
|
2013-02-25 16:14:33 +00:00
|
|
|
};
|
|
|
|
|
2023-01-13 20:48:45 +00:00
|
|
|
static inline bool is_mcq_enabled(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->mcq_enabled;
|
|
|
|
}
|
|
|
|
|
2022-12-08 23:43:58 +00:00
|
|
|
#ifdef CONFIG_SCSI_UFS_VARIABLE_SG_ENTRY_SIZE
|
|
|
|
static inline size_t ufshcd_sg_entry_size(const struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->sg_entry_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void ufshcd_set_sg_entry_size(struct ufs_hba *hba, size_t sg_entry_size)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(sg_entry_size < sizeof(struct ufshcd_sg_entry));
|
|
|
|
hba->sg_entry_size = sg_entry_size;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline size_t ufshcd_sg_entry_size(const struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return sizeof(struct ufshcd_sg_entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ufshcd_set_sg_entry_size(hba, sg_entry_size) \
|
|
|
|
({ (void)(hba); BUILD_BUG_ON(sg_entry_size != sizeof(struct ufshcd_sg_entry)); })
|
|
|
|
#endif
|
|
|
|
|
2023-05-04 15:44:50 +00:00
|
|
|
static inline size_t ufshcd_get_ucd_size(const struct ufs_hba *hba)
|
2022-12-08 23:43:58 +00:00
|
|
|
{
|
|
|
|
return sizeof(struct utp_transfer_cmd_desc) + SG_ALL * ufshcd_sg_entry_size(hba);
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
/* Returns true if clocks can be gated. Otherwise false */
|
|
|
|
static inline bool ufshcd_is_clkgating_allowed(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_CLK_GATING;
|
|
|
|
}
|
|
|
|
static inline bool ufshcd_can_hibern8_during_gating(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_HIBERN8_WITH_CLK_GATING;
|
|
|
|
}
|
2016-12-23 02:40:50 +00:00
|
|
|
static inline int ufshcd_is_clkscaling_supported(struct ufs_hba *hba)
|
2014-09-25 12:32:34 +00:00
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_CLK_SCALING;
|
|
|
|
}
|
2014-09-25 12:32:35 +00:00
|
|
|
static inline bool ufshcd_can_autobkops_during_suspend(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_AUTO_BKOPS_SUSPEND;
|
|
|
|
}
|
2019-09-16 15:56:50 +00:00
|
|
|
static inline bool ufshcd_is_rpm_autosuspend_allowed(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_RPM_AUTOSUSPEND;
|
|
|
|
}
|
2014-09-25 12:32:35 +00:00
|
|
|
|
2015-05-17 15:54:57 +00:00
|
|
|
static inline bool ufshcd_is_intr_aggr_allowed(struct ufs_hba *hba)
|
|
|
|
{
|
2021-06-28 05:58:01 +00:00
|
|
|
return (hba->caps & UFSHCD_CAP_INTR_AGGR) &&
|
|
|
|
!(hba->quirks & UFSHCD_QUIRK_BROKEN_INTR_AGGR);
|
2015-05-17 15:54:57 +00:00
|
|
|
}
|
|
|
|
|
2020-10-27 19:10:36 +00:00
|
|
|
static inline bool ufshcd_can_aggressive_pc(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return !!(ufshcd_is_link_hibern8(hba) &&
|
|
|
|
(hba->caps & UFSHCD_CAP_AGGR_POWER_COLLAPSE));
|
|
|
|
}
|
|
|
|
|
2019-05-21 06:44:52 +00:00
|
|
|
static inline bool ufshcd_is_auto_hibern8_supported(struct ufs_hba *hba)
|
|
|
|
{
|
2020-08-10 14:10:24 +00:00
|
|
|
return (hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT) &&
|
|
|
|
!(hba->quirks & UFSHCD_QUIRK_BROKEN_AUTO_HIBERN8);
|
2019-05-21 06:44:52 +00:00
|
|
|
}
|
|
|
|
|
2020-01-29 10:52:50 +00:00
|
|
|
static inline bool ufshcd_is_auto_hibern8_enabled(struct ufs_hba *hba)
|
|
|
|
{
|
2022-04-19 22:57:46 +00:00
|
|
|
return FIELD_GET(UFSHCI_AHIBERN8_TIMER_MASK, hba->ahit);
|
2020-01-29 10:52:50 +00:00
|
|
|
}
|
|
|
|
|
2020-04-22 21:41:42 +00:00
|
|
|
static inline bool ufshcd_is_wb_allowed(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_WB_EN;
|
|
|
|
}
|
|
|
|
|
2022-08-04 02:54:22 +00:00
|
|
|
static inline bool ufshcd_enable_wb_if_scaling_up(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return hba->caps & UFSHCD_CAP_WB_WITH_CLK_SCALING;
|
|
|
|
}
|
|
|
|
|
2023-01-13 20:48:45 +00:00
|
|
|
#define ufsmcq_writel(hba, val, reg) \
|
|
|
|
writel((val), (hba)->mcq_base + (reg))
|
|
|
|
#define ufsmcq_readl(hba, reg) \
|
|
|
|
readl((hba)->mcq_base + (reg))
|
|
|
|
|
|
|
|
#define ufsmcq_writelx(hba, val, reg) \
|
|
|
|
writel_relaxed((val), (hba)->mcq_base + (reg))
|
|
|
|
#define ufsmcq_readlx(hba, reg) \
|
|
|
|
readl_relaxed((hba)->mcq_base + (reg))
|
|
|
|
|
2013-06-26 17:09:26 +00:00
|
|
|
#define ufshcd_writel(hba, val, reg) \
|
|
|
|
writel((val), (hba)->mmio_base + (reg))
|
|
|
|
#define ufshcd_readl(hba, reg) \
|
|
|
|
readl((hba)->mmio_base + (reg))
|
|
|
|
|
2014-09-25 12:32:36 +00:00
|
|
|
/**
|
2022-04-19 22:58:07 +00:00
|
|
|
* ufshcd_rmwl - perform read/modify/write for a controller register
|
|
|
|
* @hba: per adapter instance
|
|
|
|
* @mask: mask to apply on read value
|
|
|
|
* @val: actual value to write
|
|
|
|
* @reg: register address
|
2014-09-25 12:32:36 +00:00
|
|
|
*/
|
|
|
|
static inline void ufshcd_rmwl(struct ufs_hba *hba, u32 mask, u32 val, u32 reg)
|
|
|
|
{
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
tmp = ufshcd_readl(hba, reg);
|
|
|
|
tmp &= ~mask;
|
|
|
|
tmp |= (val & mask);
|
|
|
|
ufshcd_writel(hba, tmp, reg);
|
|
|
|
}
|
|
|
|
|
2014-09-25 12:32:21 +00:00
|
|
|
int ufshcd_alloc_host(struct device *, struct ufs_hba **);
|
2015-10-28 11:15:49 +00:00
|
|
|
void ufshcd_dealloc_host(struct ufs_hba *);
|
2020-01-17 03:51:07 +00:00
|
|
|
int ufshcd_hba_enable(struct ufs_hba *hba);
|
2021-05-18 12:12:17 +00:00
|
|
|
int ufshcd_init(struct ufs_hba *, void __iomem *, unsigned int);
|
2020-03-27 09:53:28 +00:00
|
|
|
int ufshcd_link_recovery(struct ufs_hba *hba);
|
2020-01-17 03:51:07 +00:00
|
|
|
int ufshcd_make_hba_operational(struct ufs_hba *hba);
|
2013-02-25 16:14:33 +00:00
|
|
|
void ufshcd_remove(struct ufs_hba *);
|
2021-09-28 09:06:12 +00:00
|
|
|
int ufshcd_uic_hibern8_enter(struct ufs_hba *hba);
|
2020-01-17 03:51:07 +00:00
|
|
|
int ufshcd_uic_hibern8_exit(struct ufs_hba *hba);
|
2020-03-18 10:40:12 +00:00
|
|
|
void ufshcd_delay_us(unsigned long us, unsigned long tolerance);
|
2018-10-16 08:59:41 +00:00
|
|
|
void ufshcd_parse_dev_ref_clk_freq(struct ufs_hba *hba, struct clk *refclk);
|
2020-12-05 11:58:59 +00:00
|
|
|
void ufshcd_update_evt_hist(struct ufs_hba *hba, u32 id, u32 val);
|
2021-05-28 03:36:21 +00:00
|
|
|
void ufshcd_hba_stop(struct ufs_hba *hba);
|
2021-10-20 21:40:19 +00:00
|
|
|
void ufshcd_schedule_eh_work(struct ufs_hba *hba);
|
2022-12-15 03:06:21 +00:00
|
|
|
void ufshcd_mcq_write_cqis(struct ufs_hba *hba, u32 val, int i);
|
|
|
|
unsigned long ufshcd_mcq_poll_cqe_nolock(struct ufs_hba *hba,
|
|
|
|
struct ufs_hw_queue *hwq);
|
|
|
|
void ufshcd_mcq_enable_esi(struct ufs_hba *hba);
|
|
|
|
void ufshcd_mcq_config_esi(struct ufs_hba *hba, struct msi_msg *msg);
|
2013-02-25 16:14:33 +00:00
|
|
|
|
2015-10-28 11:15:47 +00:00
|
|
|
/**
|
|
|
|
* ufshcd_set_variant - set variant specific data to the hba
|
2022-04-19 22:58:07 +00:00
|
|
|
* @hba: per adapter instance
|
|
|
|
* @variant: pointer to variant specific data
|
2015-10-28 11:15:47 +00:00
|
|
|
*/
|
|
|
|
static inline void ufshcd_set_variant(struct ufs_hba *hba, void *variant)
|
|
|
|
{
|
|
|
|
BUG_ON(!hba);
|
|
|
|
hba->priv = variant;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ufshcd_get_variant - get variant specific data from the hba
|
2022-04-19 22:58:07 +00:00
|
|
|
* @hba: per adapter instance
|
2015-10-28 11:15:47 +00:00
|
|
|
*/
|
|
|
|
static inline void *ufshcd_get_variant(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
BUG_ON(!hba);
|
|
|
|
return hba->priv;
|
|
|
|
}
|
2021-09-15 06:04:06 +00:00
|
|
|
|
2021-07-22 03:34:24 +00:00
|
|
|
#ifdef CONFIG_PM
|
2021-07-22 03:34:23 +00:00
|
|
|
extern int ufshcd_runtime_suspend(struct device *dev);
|
|
|
|
extern int ufshcd_runtime_resume(struct device *dev);
|
2021-07-22 03:34:24 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2021-07-22 03:34:23 +00:00
|
|
|
extern int ufshcd_system_suspend(struct device *dev);
|
|
|
|
extern int ufshcd_system_resume(struct device *dev);
|
2023-02-02 16:10:45 +00:00
|
|
|
extern int ufshcd_system_freeze(struct device *dev);
|
|
|
|
extern int ufshcd_system_thaw(struct device *dev);
|
|
|
|
extern int ufshcd_system_restore(struct device *dev);
|
2021-07-22 03:34:24 +00:00
|
|
|
#endif
|
2014-09-25 12:32:30 +00:00
|
|
|
extern int ufshcd_shutdown(struct ufs_hba *hba);
|
2023-02-02 16:10:45 +00:00
|
|
|
|
2020-11-16 06:50:52 +00:00
|
|
|
extern int ufshcd_dme_configure_adapt(struct ufs_hba *hba,
|
|
|
|
int agreed_gear,
|
|
|
|
int adapt_val);
|
2013-08-31 16:10:21 +00:00
|
|
|
extern int ufshcd_dme_set_attr(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u8 attr_set, u32 mib_val, u8 peer);
|
|
|
|
extern int ufshcd_dme_get_attr(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 *mib_val, u8 peer);
|
2018-05-06 10:14:18 +00:00
|
|
|
extern int ufshcd_config_pwr_mode(struct ufs_hba *hba,
|
|
|
|
struct ufs_pa_layer_attr *desired_pwr_mode);
|
2022-06-16 05:37:15 +00:00
|
|
|
extern int ufshcd_uic_change_pwr_mode(struct ufs_hba *hba, u8 mode);
|
2013-08-31 16:10:21 +00:00
|
|
|
|
|
|
|
/* UIC command interfaces for DME primitives */
|
|
|
|
#define DME_LOCAL 0
|
|
|
|
#define DME_PEER 1
|
|
|
|
#define ATTR_SET_NOR 0 /* NORMAL */
|
|
|
|
#define ATTR_SET_ST 1 /* STATIC */
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_set(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_NOR,
|
|
|
|
mib_val, DME_LOCAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_st_set(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_ST,
|
|
|
|
mib_val, DME_LOCAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_peer_set(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_NOR,
|
|
|
|
mib_val, DME_PEER);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_peer_st_set(struct ufs_hba *hba, u32 attr_sel,
|
|
|
|
u32 mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_ST,
|
|
|
|
mib_val, DME_PEER);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_get(struct ufs_hba *hba,
|
|
|
|
u32 attr_sel, u32 *mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_get_attr(hba, attr_sel, mib_val, DME_LOCAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ufshcd_dme_peer_get(struct ufs_hba *hba,
|
|
|
|
u32 attr_sel, u32 *mib_val)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_get_attr(hba, attr_sel, mib_val, DME_PEER);
|
|
|
|
}
|
|
|
|
|
2016-03-10 15:37:20 +00:00
|
|
|
static inline bool ufshcd_is_hs_mode(struct ufs_pa_layer_attr *pwr_info)
|
|
|
|
{
|
|
|
|
return (pwr_info->pwr_rx == FAST_MODE ||
|
|
|
|
pwr_info->pwr_rx == FASTAUTO_MODE) &&
|
|
|
|
(pwr_info->pwr_tx == FAST_MODE ||
|
|
|
|
pwr_info->pwr_tx == FASTAUTO_MODE);
|
|
|
|
}
|
|
|
|
|
2020-02-07 07:03:57 +00:00
|
|
|
static inline int ufshcd_disable_host_tx_lcc(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
return ufshcd_dme_set(hba, UIC_ARG_MIB(PA_LOCAL_TX_LCC_ENABLE), 0);
|
|
|
|
}
|
|
|
|
|
2019-11-15 06:09:26 +00:00
|
|
|
void ufshcd_auto_hibern8_enable(struct ufs_hba *hba);
|
2019-12-30 05:32:28 +00:00
|
|
|
void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit);
|
2022-04-19 22:57:53 +00:00
|
|
|
void ufshcd_fixup_dev_quirks(struct ufs_hba *hba,
|
|
|
|
const struct ufs_dev_quirk *fixups);
|
2019-07-30 05:55:17 +00:00
|
|
|
#define SD_ASCII_STD true
|
|
|
|
#define SD_RAW false
|
|
|
|
int ufshcd_read_string_desc(struct ufs_hba *hba, u8 desc_index,
|
|
|
|
u8 **buf, bool ascii);
|
2018-02-15 12:14:07 +00:00
|
|
|
|
2014-09-25 12:32:32 +00:00
|
|
|
int ufshcd_hold(struct ufs_hba *hba, bool async);
|
|
|
|
void ufshcd_release(struct ufs_hba *hba);
|
2017-02-23 09:05:30 +00:00
|
|
|
|
2022-04-19 22:58:04 +00:00
|
|
|
void ufshcd_clkgate_delay_set(struct device *dev, unsigned long value);
|
|
|
|
|
2016-03-10 15:37:16 +00:00
|
|
|
u32 ufshcd_get_local_unipro_ver(struct ufs_hba *hba);
|
2015-10-28 11:15:48 +00:00
|
|
|
|
2022-06-16 05:37:23 +00:00
|
|
|
int ufshcd_get_vreg(struct device *dev, struct ufs_vreg *vreg);
|
|
|
|
|
2018-10-07 14:30:39 +00:00
|
|
|
int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd);
|
|
|
|
|
2018-10-07 14:30:37 +00:00
|
|
|
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);
|
2022-12-01 14:04:37 +00:00
|
|
|
int ufshcd_advanced_rpmb_req_handler(struct ufs_hba *hba, struct utp_upiu_req *req_upiu,
|
|
|
|
struct utp_upiu_req *rsp_upiu, struct ufs_ehs *ehs_req,
|
|
|
|
struct ufs_ehs *ehs_rsp, int sg_cnt,
|
|
|
|
struct scatterlist *sg_list, enum dma_data_direction dir);
|
2021-03-18 09:55:36 +00:00
|
|
|
int ufshcd_wb_toggle(struct ufs_hba *hba, bool enable);
|
2022-08-04 07:53:54 +00:00
|
|
|
int ufshcd_wb_toggle_buf_flush(struct ufs_hba *hba, bool enable);
|
2021-04-24 00:20:16 +00:00
|
|
|
int ufshcd_suspend_prepare(struct device *dev);
|
2021-10-27 13:06:14 +00:00
|
|
|
int __ufshcd_suspend_prepare(struct device *dev, bool rpm_ok_for_spm);
|
2021-04-24 00:20:16 +00:00
|
|
|
void ufshcd_resume_complete(struct device *dev);
|
2021-01-19 16:38:42 +00:00
|
|
|
|
2015-10-28 11:15:48 +00:00
|
|
|
/* Wrapper functions for safely calling variant operations */
|
|
|
|
static inline int ufshcd_vops_init(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (hba->vops && hba->vops->init)
|
|
|
|
return hba->vops->init(hba);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-05 12:00:39 +00:00
|
|
|
static inline int ufshcd_vops_phy_initialization(struct ufs_hba *hba)
|
|
|
|
{
|
|
|
|
if (hba->vops && hba->vops->phy_initialization)
|
|
|
|
return hba->vops->phy_initialization(hba);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-06-23 10:24:32 +00:00
|
|
|
extern const struct ufs_pm_lvl_states ufs_pm_lvl_states[];
|
2018-02-15 12:14:01 +00:00
|
|
|
|
2018-06-14 08:14:09 +00:00
|
|
|
int ufshcd_dump_regs(struct ufs_hba *hba, size_t offset, size_t len,
|
|
|
|
const char *prefix);
|
|
|
|
|
2021-02-09 06:24:37 +00:00
|
|
|
int __ufshcd_write_ee_control(struct ufs_hba *hba, u32 ee_ctrl_mask);
|
|
|
|
int ufshcd_write_ee_control(struct ufs_hba *hba);
|
2022-06-23 10:24:32 +00:00
|
|
|
int ufshcd_update_ee_control(struct ufs_hba *hba, u16 *mask,
|
|
|
|
const u16 *other_mask, u16 set, u16 clr);
|
2021-02-09 06:24:36 +00:00
|
|
|
|
2013-02-25 16:14:33 +00:00
|
|
|
#endif /* End of Header */
|