RE: [PATCH/RFC V2 10/16] scsi: ufs: add UFS power management support

["Dong, Chuanxiao" <chuanxiao.dong@intel.com>]

> -----Original Message-----
> From: linux-scsi-owner@vger.kernel.org
> [mailto:linux-scsi-owner@vger.kernel.org] On Behalf Of Dong, Chuanxiao
> Sent: Wednesday, August 20, 2014 3:21 PM
> To: Dolev Raviv; James.Bottomley@HansenPartnership.com;
> hch@infradead.org
> Cc: linux-scsi@vger.kernel.org; linux-scsi-owner@vger.kernel.org;
> linux-arm-msm@vger.kernel.org; santoshsy@gmail.com; Subhash Jadavani;
> Sujit Reddy Thumma
> Subject: RE: [PATCH/RFC V2 10/16] scsi: ufs: add UFS power management
> support
> 
> 
> 
> > -----Original Message-----
> > From: linux-scsi-owner@vger.kernel.org
> > [mailto:linux-scsi-owner@vger.kernel.org] On Behalf Of Dolev Raviv
> > Sent: Thursday, August 14, 2014 9:31 PM
> > To: James.Bottomley@HansenPartnership.com; hch@infradead.org
> > Cc: linux-scsi@vger.kernel.org; linux-scsi-owner@vger.kernel.org;
> > linux-arm-msm@vger.kernel.org; santoshsy@gmail.com; Subhash Jadavani;
> > Dolev Raviv; Sujit Reddy Thumma
> > Subject: [PATCH/RFC V2 10/16] scsi: ufs: add UFS power management support
> >
> > From: Subhash Jadavani <subhashj@codeaurora.org>
> >
> > This patch adds support for UFS device and UniPro link power management
> > during runtime/system PM.
> >
> > Main idea is to define multiple UFS low power levels based on UFS device and
> > UFS link power states. This would allow any specific platform or pci driver to
> > choose the best suited low power level during runtime and system suspend
> > based on their power goals.
> >
> > bkops handlig:
> > To put the UFS device in sleep state when bkops is disabled, first query the
> > bkops status from the device and enable bkops on device only if device needs
> > time to perform the bkops.
> >
> > START_STOP handling:
> > Before sending START_STOP_UNIT to the device well-known logical unit
> > (w-lun) to make sure that the device w-lun unit attention condition is cleared.
> >
> > Write protection:
> > UFS device specification allows LUs to be write protected, either permanently
> > or power on write protected. If any LU is power on write protected and if the
> > card is power cycled (by powering off VCCQ and/or VCC rails), LU's write
> > protect status would be lost. So this means those LUs can be written now. To
> > ensures that UFS device is power cycled only if the power on protect is not set
> > for any of the LUs, check if power on write protect is set and if device is in
> > sleep/power-off state & link in inactive state (Hibern8 or OFF state).
> > If none of the Logical Units on UFS device is power on write protected then all
> > UFS device power rails (VCC, VCCQ & VCCQ2) can be turned off if UFS device
> is
> > in power-off state and UFS link is in OFF state. But current implementation
> > would disable all device power rails even if UFS link is not in OFF state.
> >
> > Signed-off-by: Subhash Jadavani <subhashj@codeaurora.org>
> > Signed-off-by: Dolev Raviv <draviv@codeaurora.org>
> > Signed-off-by: Sujit Reddy Thumma <sthumma@codeaurora.org>
> >
> > diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h index
> > bcc3a7f..2a82959 100644
> > --- a/drivers/scsi/ufs/ufs.h
> > +++ b/drivers/scsi/ufs/ufs.h
> > @@ -129,6 +129,7 @@ enum {
> >  /* Flag idn for Query Requests*/
> >  enum flag_idn {
> >  	QUERY_FLAG_IDN_FDEVICEINIT      = 0x01,
> > +	QUERY_FLAG_IDN_PWR_ON_WPE	= 0x03,
> >  	QUERY_FLAG_IDN_BKOPS_EN         = 0x04,
> >  };
> >
> > @@ -194,6 +195,18 @@ enum unit_desc_param {
> >  	UNIT_DESC_PARAM_LARGE_UNIT_SIZE_M1	= 0x22,
> >  };
> >
> > +/*
> > + * Logical Unit Write Protect
> > + * 00h: LU not write protected
> > + * 01h: LU write protected when fPowerOnWPEn =1
> > + * 02h: LU permanently write protected when fPermanentWPEn =1  */
> enum
> > +ufs_lu_wp_type {
> > +	UFS_LU_NO_WP		= 0x00,
> > +	UFS_LU_POWER_ON_WP	= 0x01,
> > +	UFS_LU_PERM_WP		= 0x02,
> > +};
> > +
> >  /* bActiveICCLevel parameter current units */  enum {
> >  	UFSHCD_NANO_AMP		= 0,
> > @@ -226,11 +239,12 @@ enum {
> >  };
> >
> >  /* Background operation status */
> > -enum {
> > +enum bkops_status {
> >  	BKOPS_STATUS_NO_OP               = 0x0,
> >  	BKOPS_STATUS_NON_CRITICAL        = 0x1,
> >  	BKOPS_STATUS_PERF_IMPACT         = 0x2,
> >  	BKOPS_STATUS_CRITICAL            = 0x3,
> > +	BKOPS_STATUS_MAX		 = BKOPS_STATUS_CRITICAL,
> >  };
> >
> >  /* UTP QUERY Transaction Specific Fields OpCode */ @@ -291,6 +305,14
> @@
> > enum {
> >  	UPIU_TASK_MANAGEMENT_FUNC_FAILED	= 0x05,
> >  	UPIU_INCORRECT_LOGICAL_UNIT_NO		= 0x09,
> >  };
> > +
> > +/* UFS device power modes */
> > +enum ufs_dev_pwr_mode {
> > +	UFS_ACTIVE_PWR_MODE	= 1,
> > +	UFS_SLEEP_PWR_MODE	= 2,
> > +	UFS_POWERDOWN_PWR_MODE	= 3,
> > +};
> > +
> >  /**
> >   * struct utp_upiu_header - UPIU header structure
> >   * @dword_0: UPIU header DW-0
> > @@ -437,6 +459,12 @@ struct ufs_query_res {
> >  #define UFS_VREG_VCCQ2_MIN_UV	   1650000 /* uV */
> >  #define UFS_VREG_VCCQ2_MAX_UV	   1950000 /* uV */
> >
> > +/*
> > + * VCCQ & VCCQ2 current requirement when UFS device is in sleep state
> > + * and link is in Hibern8 state.
> > + */
> > +#define UFS_VREG_LPM_LOAD_UA	1000 /* uA */
> > +
> >  struct ufs_vreg {
> >  	struct regulator *reg;
> >  	const char *name;
> > @@ -453,4 +481,10 @@ struct ufs_vreg_info {
> >  	struct ufs_vreg *vccq2;
> >  };
> >
> > +struct ufs_dev_info {
> > +	bool f_power_on_wp_en;
> > +	/* Keeps information if any of the LU is power on write protected */
> > +	bool is_lu_power_on_wp;
> > +};
> > +
> >  #endif /* End of Header */
> > diff --git a/drivers/scsi/ufs/ufshcd-pci.c b/drivers/scsi/ufs/ufshcd-pci.c index
> > 1aac2ef..b8f7774 100644
> > --- a/drivers/scsi/ufs/ufshcd-pci.c
> > +++ b/drivers/scsi/ufs/ufshcd-pci.c
> > @@ -43,34 +43,24 @@
> >   * @pdev: pointer to PCI device handle
> >   * @state: power state
> >   *
> > - * Returns -ENOSYS
> > + * Returns 0 if successful
> > + * Returns non-zero otherwise
> >   */
> >  static int ufshcd_pci_suspend(struct device *dev)  {
> > -	/*
> > -	 * TODO:
> > -	 * 1. Call ufshcd_suspend
> > -	 * 2. Do bus specific power management
> > -	 */
> > -
> > -	return -ENOSYS;
> > +	return ufshcd_system_suspend(dev_get_drvdata(dev));
> >  }
> >
> >  /**
> >   * ufshcd_pci_resume - resume power management function
> >   * @pdev: pointer to PCI device handle
> >   *
> > - * Returns -ENOSYS
> > + * Returns 0 if successful
> > + * Returns non-zero otherwise
> >   */
> >  static int ufshcd_pci_resume(struct device *dev)  {
> > -	/*
> > -	 * TODO:
> > -	 * 1. Call ufshcd_resume.
> > -	 * 2. Do bus specific wake up
> > -	 */
> > -
> > -	return -ENOSYS;
> > +	return ufshcd_system_resume(dev_get_drvdata(dev));
> >  }
> >  #else
> >  #define ufshcd_pci_suspend	NULL
> > @@ -80,30 +70,15 @@ static int ufshcd_pci_resume(struct device *dev)
> > #ifdef CONFIG_PM_RUNTIME  static int
> ufshcd_pci_runtime_suspend(struct
> > device *dev)  {
> > -	struct ufs_hba *hba = dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_suspend(hba);
> > +	return ufshcd_runtime_suspend(dev_get_drvdata(dev));
> >  }
> >  static int ufshcd_pci_runtime_resume(struct device *dev)  {
> > -	struct ufs_hba *hba = dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_resume(hba);
> > +	return ufshcd_runtime_resume(dev_get_drvdata(dev));
> >  }
> >  static int ufshcd_pci_runtime_idle(struct device *dev)  {
> > -	struct ufs_hba *hba = dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_idle(hba);
> > +	return ufshcd_runtime_idle(dev_get_drvdata(dev));
> >  }
> >  #else /* !CONFIG_PM_RUNTIME */
> >  #define ufshcd_pci_runtime_suspend	NULL
> > @@ -117,7 +92,7 @@ static int ufshcd_pci_runtime_idle(struct device *dev)
> >   */
> >  static void ufshcd_pci_shutdown(struct pci_dev *pdev)  {
> > -	ufshcd_hba_stop((struct ufs_hba *)pci_get_drvdata(pdev));
> > +	ufshcd_shutdown((struct ufs_hba *)pci_get_drvdata(pdev));
> >  }
> >
> >  /**
> > diff --git a/drivers/scsi/ufs/ufshcd-pltfrm.c b/drivers/scsi/ufs/ufshcd-pltfrm.c
> > index 642d80f..edaccd0 100644
> > --- a/drivers/scsi/ufs/ufshcd-pltfrm.c
> > +++ b/drivers/scsi/ufs/ufshcd-pltfrm.c
> > @@ -216,45 +216,24 @@ out:
> >   * ufshcd_pltfrm_suspend - suspend power management function
> >   * @dev: pointer to device handle
> >   *
> > - *
> > - * Returns 0
> > + * Returns 0 if successful
> > + * Returns non-zero otherwise
> >   */
> >  static int ufshcd_pltfrm_suspend(struct device *dev)  {
> > -	struct platform_device *pdev = to_platform_device(dev);
> > -	struct ufs_hba *hba =  platform_get_drvdata(pdev);
> > -
> > -	/*
> > -	 * TODO:
> > -	 * 1. Call ufshcd_suspend
> > -	 * 2. Do bus specific power management
> > -	 */
> > -
> > -	disable_irq(hba->irq);
> > -
> > -	return 0;
> > +	return ufshcd_system_suspend(dev_get_drvdata(dev));
> >  }
> >
> >  /**
> >   * ufshcd_pltfrm_resume - resume power management function
> >   * @dev: pointer to device handle
> >   *
> > - * Returns 0
> > + * Returns 0 if successful
> > + * Returns non-zero otherwise
> >   */
> >  static int ufshcd_pltfrm_resume(struct device *dev)  {
> > -	struct platform_device *pdev = to_platform_device(dev);
> > -	struct ufs_hba *hba =  platform_get_drvdata(pdev);
> > -
> > -	/*
> > -	 * TODO:
> > -	 * 1. Call ufshcd_resume.
> > -	 * 2. Do bus specific wake up
> > -	 */
> > -
> > -	enable_irq(hba->irq);
> > -
> > -	return 0;
> > +	return ufshcd_system_resume(dev_get_drvdata(dev));
> >  }
> >  #else
> >  #define ufshcd_pltfrm_suspend	NULL
> > @@ -264,30 +243,15 @@ static int ufshcd_pltfrm_resume(struct device
> *dev)
> > #ifdef CONFIG_PM_RUNTIME  static int
> > ufshcd_pltfrm_runtime_suspend(struct device *dev)  {
> > -	struct ufs_hba *hba =  dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_suspend(hba);
> > +	return ufshcd_runtime_suspend(dev_get_drvdata(dev));
> >  }
> >  static int ufshcd_pltfrm_runtime_resume(struct device *dev)  {
> > -	struct ufs_hba *hba =  dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_resume(hba);
> > +	return ufshcd_runtime_resume(dev_get_drvdata(dev));
> >  }
> >  static int ufshcd_pltfrm_runtime_idle(struct device *dev)  {
> > -	struct ufs_hba *hba =  dev_get_drvdata(dev);
> > -
> > -	if (!hba)
> > -		return 0;
> > -
> > -	return ufshcd_runtime_idle(hba);
> > +	return ufshcd_runtime_idle(dev_get_drvdata(dev));
> >  }
> >  #else /* !CONFIG_PM_RUNTIME */
> >  #define ufshcd_pltfrm_runtime_suspend	NULL
> > @@ -295,6 +259,11 @@ static int ufshcd_pltfrm_runtime_idle(struct device
> > *dev)
> >  #define ufshcd_pltfrm_runtime_idle	NULL
> >  #endif /* CONFIG_PM_RUNTIME */
> >
> > +static void ufshcd_pltfrm_shutdown(struct platform_device *pdev) {
> > +	ufshcd_shutdown((struct ufs_hba *)platform_get_drvdata(pdev)); }
> > +
> >  /**
> >   * ufshcd_pltfrm_probe - probe routine of the driver
> >   * @pdev: pointer to Platform device handle @@ -395,6 +364,7 @@ static
> > const struct dev_pm_ops ufshcd_dev_pm_ops = {  static struct
> > platform_driver ufshcd_pltfrm_driver = {
> >  	.probe	= ufshcd_pltfrm_probe,
> >  	.remove	= ufshcd_pltfrm_remove,
> > +	.shutdown = ufshcd_pltfrm_shutdown,
> >  	.driver	= {
> >  		.name	= "ufshcd",
> >  		.owner	= THIS_MODULE,
> > diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index
> > 876d210..fac71c9 100644
> > --- a/drivers/scsi/ufs/ufshcd.c
> > +++ b/drivers/scsi/ufs/ufshcd.c
> > @@ -44,7 +44,6 @@
> >
> >  #define UFSHCD_ENABLE_INTRS	(UTP_TRANSFER_REQ_COMPL |\
> >  				 UTP_TASK_REQ_COMPL |\
> > -				 UIC_POWER_MODE |\
> >  				 UFSHCD_ERROR_MASK)
> >  /* UIC command timeout, unit: ms */
> >  #define UIC_CMD_TIMEOUT	500
> > @@ -138,12 +137,63 @@ enum {
> >  #define ufshcd_clear_eh_in_progress(h) \
> >  	(h->eh_flags &= ~UFSHCD_EH_IN_PROGRESS)
> >
> > +#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) #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)
> > +
> > +static struct ufs_pm_lvl_states ufs_pm_lvl_states[] = {
> > +	{UFS_ACTIVE_PWR_MODE, UIC_LINK_ACTIVE_STATE},
> > +	{UFS_ACTIVE_PWR_MODE, UIC_LINK_HIBERN8_STATE},
> > +	{UFS_SLEEP_PWR_MODE, UIC_LINK_ACTIVE_STATE},
> > +	{UFS_SLEEP_PWR_MODE, UIC_LINK_HIBERN8_STATE},
> > +	{UFS_POWERDOWN_PWR_MODE, UIC_LINK_HIBERN8_STATE},
> > +	{UFS_POWERDOWN_PWR_MODE, UIC_LINK_OFF_STATE}, };
> > +
> > +static inline enum ufs_dev_pwr_mode
> > +ufs_get_pm_lvl_to_dev_pwr_mode(enum ufs_pm_level lvl) {
> > +	return ufs_pm_lvl_states[lvl].dev_state; }
> > +
> > +static inline enum uic_link_state
> > +ufs_get_pm_lvl_to_link_pwr_state(enum ufs_pm_level lvl) {
> > +	return ufs_pm_lvl_states[lvl].link_state;
> > +}
> > +
> >  static void ufshcd_tmc_handler(struct ufs_hba *hba);  static void
> > ufshcd_async_scan(void *data, async_cookie_t cookie);  static int
> > ufshcd_reset_and_restore(struct ufs_hba *hba);  static int
> > ufshcd_clear_tm_cmd(struct ufs_hba *hba, int tag);  static void
> > ufshcd_hba_exit(struct ufs_hba *hba);  static int ufshcd_probe_hba(struct
> > ufs_hba *hba);
> > +static int ufshcd_host_reset_and_restore(struct ufs_hba *hba);
> > +
> > +static inline void ufshcd_enable_irq(struct ufs_hba *hba) {
> > +	if (!hba->is_irq_enabled) {
> > +		enable_irq(hba->irq);
> > +		hba->is_irq_enabled = true;
> > +	}
> > +}
> > +
> > +static inline void ufshcd_disable_irq(struct ufs_hba *hba) {
> > +	if (hba->is_irq_enabled) {
> > +		disable_irq(hba->irq);
> > +		hba->is_irq_enabled = false;
> > +	}
> > +}
> >
> >  /*
> >   * ufshcd_wait_for_register - wait for register value to change @@
> -1778,44
> > +1828,48 @@ out:
> >  EXPORT_SYMBOL_GPL(ufshcd_dme_get_attr);
> >
> >  /**
> > - * ufshcd_uic_change_pwr_mode - Perform the UIC power mode chage
> > - *				using DME_SET primitives.
> > + * ufshcd_uic_pwr_ctrl - executes UIC commands (which affects the link
> > + power
> > + * state) and waits for it to take effect.
> > + *
> >   * @hba: per adapter instance
> > - * @mode: powr mode value
> > + * @cmd: UIC command to execute
> > + *
> > + * DME operations like DME_SET(PA_PWRMODE), DME_HIBERNATE_ENTER
> > &
> > + * DME_HIBERNATE_EXIT commands take some time to take its effect on
> > + both host
> > + * and device UniPro link and hence it's final completion would be
> > + indicated by
> > + * dedicated status bits in Interrupt Status register (UPMS, UHES,
> > + UHXS) in
> > + * addition to normal UIC command completion Status (UCCS). This
> > + function only
> > + * returns after the relevant status bits indicate the completion.
> >   *
> >   * Returns 0 on success, non-zero value on failure
> >   */
> > -static int ufshcd_uic_change_pwr_mode(struct ufs_hba *hba, u8 mode)
> > +int ufshcd_uic_pwr_ctrl(struct ufs_hba *hba, struct uic_command *cmd)
> >  {
> > -	struct uic_command uic_cmd = {0};
> > -	struct completion pwr_done;
> > +	struct completion uic_async_done;
> >  	unsigned long flags;
> >  	u8 status;
> >  	int ret;
> >
> > -	uic_cmd.command = UIC_CMD_DME_SET;
> > -	uic_cmd.argument1 = UIC_ARG_MIB(PA_PWRMODE);
> > -	uic_cmd.argument3 = mode;
> > -	init_completion(&pwr_done);
> > -
> >  	mutex_lock(&hba->uic_cmd_mutex);
> > +	init_completion(&uic_async_done);
> >
> >  	spin_lock_irqsave(hba->host->host_lock, flags);
> > -	hba->pwr_done = &pwr_done;
> > +	hba->uic_async_done = &uic_async_done;
> >  	spin_unlock_irqrestore(hba->host->host_lock, flags);
> > -	ret = __ufshcd_send_uic_cmd(hba, &uic_cmd);
> > +
> > +	ret = __ufshcd_send_uic_cmd(hba, cmd);
> >  	if (ret) {
> >  		dev_err(hba->dev,
> > -			"pwr mode change with mode 0x%x uic error %d\n",
> > -			mode, ret);
> > +			"pwr ctrl cmd 0x%x with mode 0x%x uic error %d\n",
> > +			cmd->command, cmd->argument3, ret);
> >  		goto out;
> >  	}
> >
> > -	if (!wait_for_completion_timeout(hba->pwr_done,
> > +	if (!wait_for_completion_timeout(hba->uic_async_done,
> >  					 msecs_to_jiffies(UIC_CMD_TIMEOUT))) {
> >  		dev_err(hba->dev,
> > -			"pwr mode change with mode 0x%x completion timeout\n",
> > -			mode);
> > +			"pwr ctrl cmd 0x%x with mode 0x%x completion timeout\n",
> > +			cmd->command, cmd->argument3);
> >  		ret = -ETIMEDOUT;
> >  		goto out;
> >  	}
> > @@ -1823,19 +1877,62 @@ static int ufshcd_uic_change_pwr_mode(struct
> > ufs_hba *hba, u8 mode)
> >  	status = ufshcd_get_upmcrs(hba);
> >  	if (status != PWR_LOCAL) {
> >  		dev_err(hba->dev,
> > -			"pwr mode change failed, host umpcrs:0x%x\n",
> > -			status);
> > +			"pwr ctrl cmd 0x%0x failed, host umpcrs:0x%x\n",
> > +			cmd->command, status);
> >  		ret = (status != PWR_OK) ? status : -1;
> >  	}
> >  out:
> >  	spin_lock_irqsave(hba->host->host_lock, flags);
> > -	hba->pwr_done = NULL;
> > +	hba->uic_async_done = NULL;
> >  	spin_unlock_irqrestore(hba->host->host_lock, flags);
> >  	mutex_unlock(&hba->uic_cmd_mutex);
> >  	return ret;
> >  }
> >
> >  /**
> > + * ufshcd_uic_change_pwr_mode - Perform the UIC power mode chage
> > + *				using DME_SET primitives.
> > + * @hba: per adapter instance
> > + * @mode: powr mode value
> > + *
> > + * Returns 0 on success, non-zero value on failure  */ static int
> > +ufshcd_uic_change_pwr_mode(struct ufs_hba *hba, u8 mode) {
> > +	struct uic_command uic_cmd = {0};
> > +
> > +	uic_cmd.command = UIC_CMD_DME_SET;
> > +	uic_cmd.argument1 = UIC_ARG_MIB(PA_PWRMODE);
> > +	uic_cmd.argument3 = mode;
> > +
> > +	return ufshcd_uic_pwr_ctrl(hba, &uic_cmd); }
> > +
> > +static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba) {
> > +	struct uic_command uic_cmd = {0};
> > +
> > +	uic_cmd.command = UIC_CMD_DME_HIBER_ENTER;
> > +
> > +	return ufshcd_uic_pwr_ctrl(hba, &uic_cmd); }
> > +
> > +static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba) {
> > +	struct uic_command uic_cmd = {0};
> > +	int ret;
> > +
> > +	uic_cmd.command = UIC_CMD_DME_HIBER_EXIT;
> > +	ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
> > +	if (ret) {
> > +		ufshcd_set_link_off(hba);
> > +		ret = ufshcd_host_reset_and_restore(hba);
> > +	}
> > +
> > +	return ret;
> > +}
> > +
> > +/**
> >   * ufshcd_config_max_pwr_mode - Set & Change power mode with
> >   *	maximum capability attribute information.
> >   * @hba: per adapter instance
> > @@ -2034,6 +2131,9 @@ static int ufshcd_hba_enable(struct ufs_hba *hba)
> >  		msleep(5);
> >  	}
> >
> > +	/* UniPro link is disabled at this point */
> > +	ufshcd_set_link_off(hba);
> > +
> >  	if (hba->vops && hba->vops->hce_enable_notify)
> >  		hba->vops->hce_enable_notify(hba, PRE_CHANGE);
> >
> > @@ -2066,7 +2166,7 @@ static int ufshcd_hba_enable(struct ufs_hba *hba)
> >  	}
> >
> >  	/* enable UIC related interrupts */
> > -	ufshcd_enable_intr(hba, UIC_COMMAND_COMPL);
> > +	ufshcd_enable_intr(hba, UFSHCD_UIC_MASK);
> >
> >  	if (hba->vops && hba->vops->hce_enable_notify)
> >  		hba->vops->hce_enable_notify(hba, POST_CHANGE); @@ -2195,6
> > +2295,62 @@ static void ufshcd_set_queue_depth(struct scsi_device *sdev)
> >  	scsi_activate_tcq(sdev, lun_qdepth);
> >  }
> >
> > +/*
> > + * ufshcd_get_lu_wp - returns the "b_lu_write_protect" from UNIT
> > +DESCRIPTOR
> > + * @hba: per-adapter instance
> > + * @lun: UFS device lun id
> > + * @b_lu_write_protect: pointer to buffer to hold the LU's write
> > +protect info
> > + *
> > + * Returns 0 in case of success and b_lu_write_protect status would be
> > +returned
> > + * @b_lu_write_protect parameter.
> > + * Returns -ENOTSUPP if reading b_lu_write_protect is not supported.
> > + * Returns -EINVAL in case of invalid parameters passed to this function.
> > + */
> > +static int ufshcd_get_lu_wp(struct ufs_hba *hba,
> > +			    u8 lun,
> > +			    u8 *b_lu_write_protect)
> > +{
> > +	int ret;
> > +
> > +	if (!b_lu_write_protect)
> > +		ret = -EINVAL;
> > +	/*
> > +	 * According to UFS device spec, RPMB LU can't be write
> > +	 * protected so skip reading bLUWriteProtect parameter for
> > +	 * it. For other W-LUs, UNIT DESCRIPTOR is not available.
> > +	 */
> > +	else if (lun >= UFS_UPIU_MAX_GENERAL_LUN)
> > +		ret = -ENOTSUPP;
> > +	else
> > +		ret = ufshcd_read_unit_desc_param(hba,
> > +					  lun,
> > +					  UNIT_DESC_PARAM_LU_WR_PROTECT,
> > +					  b_lu_write_protect,
> > +					  sizeof(*b_lu_write_protect));
> > +	return ret;
> > +}
> > +
> > +/**
> > + * ufshcd_get_lu_power_on_wp_status - get LU's power on write protect
> > + * status
> > + * @hba: per-adapter instance
> > + * @sdev: pointer to SCSI device
> > + *
> > + */
> > +static inline void ufshcd_get_lu_power_on_wp_status(struct ufs_hba *hba,
> > +						    struct scsi_device *sdev)
> > +{
> > +	if (hba->dev_info.f_power_on_wp_en &&
> > +	    !hba->dev_info.is_lu_power_on_wp) {
> > +		u8 b_lu_write_protect;
> > +
> > +		if (!ufshcd_get_lu_wp(hba, ufshcd_scsi_to_upiu_lun(sdev->lun),
> > +				      &b_lu_write_protect) &&
> > +		    (b_lu_write_protect == UFS_LU_POWER_ON_WP))
> > +			hba->dev_info.is_lu_power_on_wp = true;
> > +	}
> > +}
> > +
> >  /**
> >   * ufshcd_slave_alloc - handle initial SCSI device configurations
> >   * @sdev: pointer to SCSI device
> > @@ -2221,6 +2377,21 @@ static int ufshcd_slave_alloc(struct scsi_device
> > *sdev)
> >
> >  	ufshcd_set_queue_depth(sdev);
> >
> > +	ufshcd_get_lu_power_on_wp_status(hba, sdev);
> > +
> > +	/*
> > +	 * For selecting the UFS device power mode (Active / UFS_Sleep /
> > +	 * UFS_PowerDown), SCSI power management command (START STOP
> > UNIT)
> > +	 * needs to be sent to a "UFS device" Well known Logical Unit (W-LU).
> > +	 * As this command would be sent during the UFS host controller
> > +	 * runtime/system PM callbacks, we need a reference to "scsi_device"
> > +	 * associated to "UFS device" W-LU. This change saves the "scsi_device"
> > +	 * reference for "UFS device" W-LU during slave_configure() callback
> > +	 * from SCSI mid layer.
> > +	 */
> > +	if (ufshcd_scsi_to_upiu_lun(sdev->lun) == UFS_UPIU_UFS_DEVICE_WLUN)
> > +		hba->sdev_ufs_device = sdev;
> > +
> >  	return 0;
> >  }
> >
> > @@ -2451,8 +2622,8 @@ static void ufshcd_uic_cmd_compl(struct ufs_hba
> > *hba, u32 intr_status)
> >  		complete(&hba->active_uic_cmd->done);
> >  	}
> >
> > -	if ((intr_status & UIC_POWER_MODE) && hba->pwr_done)
> > -		complete(hba->pwr_done);
> > +	if ((intr_status & UFSHCD_UIC_PWR_MASK) && hba->uic_async_done)
> > +		complete(hba->uic_async_done);
> >  }
> >
> >  /**
> > @@ -2664,33 +2835,62 @@ static inline int ufshcd_get_bkops_status(struct
> > ufs_hba *hba, u32 *status)  }
> >
> >  /**
> > - * ufshcd_urgent_bkops - handle urgent bkops exception event
> > + * ufshcd_bkops_ctrl - control the auto bkops based on current bkops
> > + status
> >   * @hba: per-adapter instance
> > + * @status: bkops_status value
> >   *
> > - * Enable fBackgroundOpsEn flag in the device to permit background
> > - * operations.
> > + * Read the bkops_status from the UFS device and Enable
> > + fBackgroundOpsEn
> > + * flag in the device to permit background operations if the device
> > + * bkops_status is greater than or equal to "status" argument passed to
> > + * this function, disable otherwise.
> > + *
> > + * Returns 0 for success, non-zero in case of failure.
> > + *
> > + * NOTE: Caller of this function can check the
> > + "hba->auto_bkops_enabled" flag
> > + * to know whether auto bkops is enabled or disabled after this
> > + function
> > + * returns control to it.
> >   */
> > -static int ufshcd_urgent_bkops(struct ufs_hba *hba)
> > +static int ufshcd_bkops_ctrl(struct ufs_hba *hba,
> > +			     enum bkops_status status)
> >  {
> >  	int err;
> > -	u32 status = 0;
> > +	u32 curr_status = 0;
> >
> > -	err = ufshcd_get_bkops_status(hba, &status);
> > +	err = ufshcd_get_bkops_status(hba, &curr_status);
> >  	if (err) {
> >  		dev_err(hba->dev, "%s: failed to get BKOPS status %d\n",
> >  				__func__, err);
> >  		goto out;
> > +	} else if (curr_status > BKOPS_STATUS_MAX) {
> > +		dev_err(hba->dev, "%s: invalid BKOPS status %d\n",
> > +				__func__, curr_status);
> > +		err = -EINVAL;
> > +		goto out;
> >  	}
> >
> > -	status = status & 0xF;
> > -
> > -	/* handle only if status indicates performance impact or critical */
> > -	if (status >= BKOPS_STATUS_PERF_IMPACT)
> > +	if (curr_status >= status)
> >  		err = ufshcd_enable_auto_bkops(hba);
> > +	else
> > +		err = ufshcd_disable_auto_bkops(hba);
> >  out:
> >  	return err;
> >  }
> >
> > +/**
> > + * ufshcd_urgent_bkops - handle urgent bkops exception event
> > + * @hba: per-adapter instance
> > + *
> > + * Enable fBackgroundOpsEn flag in the device to permit background
> > + * operations.
> > + *
> > + * If BKOPs is enabled, this function returns 0, 1 if the bkops in not
> > +enabled
> > + * and negative error value for any other failure.
> > + */
> > +static int ufshcd_urgent_bkops(struct ufs_hba *hba) {
> > +	return ufshcd_bkops_ctrl(hba, BKOPS_STATUS_PERF_IMPACT); }
> > +
> >  static inline int ufshcd_get_ee_status(struct ufs_hba *hba, u32 *status)  {
> >  	return ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR, @@
> > -2722,7 +2922,7 @@ static void ufshcd_exception_event_handler(struct
> > work_struct *work)
> >  	status &= hba->ee_ctrl_mask;
> >  	if (status & MASK_EE_URGENT_BKOPS) {
> >  		err = ufshcd_urgent_bkops(hba);
> > -		if (err)
> > +		if (err < 0)
> >  			dev_err(hba->dev, "%s: failed to handle urgent bkops %d\n",
> >  					__func__, err);
> >  	}
> > @@ -3441,7 +3641,8 @@ static int ufshcd_probe_hba(struct ufs_hba *hba)
> >  	if (ret)
> >  		goto out;
> >
> > -	ufshcd_config_max_pwr_mode(hba);
> > +	/* UniPro link is active now */
> > +	ufshcd_set_link_active(hba);
> >
> >  	ret = ufshcd_verify_dev_init(hba);
> >  	if (ret)
> > @@ -3451,14 +3652,29 @@ static int ufshcd_probe_hba(struct ufs_hba
> *hba)
> >  	if (ret)
> >  		goto out;
> >
> > +	/* UFS device is also active now */
> > +	ufshcd_set_ufs_dev_active(hba);
> >  	ufshcd_force_reset_auto_bkops(hba);
> >  	hba->ufshcd_state = UFSHCD_STATE_OPERATIONAL;
> > +	hba->wlun_dev_clr_ua = true;
> > +
> > +	ufshcd_config_max_pwr_mode(hba);
> > +
> > +	/*
> > +	 * If we are in error handling context or in power management callbacks
> > +	 * context, no need to scan the host
> > +	 */
> > +	if (!ufshcd_eh_in_progress(hba) && !hba->pm_op_in_progress) {
> > +		bool flag;
> > +
> > +		/* clear any previous UFS device information */
> > +		memset(&hba->dev_info, 0, sizeof(hba->dev_info));
> > +		if (!ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,
> > +				       QUERY_FLAG_IDN_PWR_ON_WPE, &flag))
> > +			hba->dev_info.f_power_on_wp_en = flag;
> >
> > -	/* If we are in error handling context no need to scan the host */
> > -	if (!ufshcd_eh_in_progress(hba)) {
> >  		if (!hba->is_init_prefetch)
> >  			ufshcd_init_icc_levels(hba);
> > -
> >  		scsi_scan_host(hba->host);
> >  		pm_runtime_put_sync(hba->dev);
> >  	}
> > @@ -3471,8 +3687,10 @@ out:
> >  	 * If we failed to initialize the device or the device is not
> >  	 * present, turn off the power/clocks etc.
> >  	 */
> > -	if (ret && !ufshcd_eh_in_progress(hba))
> > +	if (ret && !ufshcd_eh_in_progress(hba) && !hba->pm_op_in_progress) {
> > +		pm_runtime_put_sync(hba->dev);
> >  		ufshcd_hba_exit(hba);
> > +	}
> >
> >  	return ret;
> >  }
> > @@ -3507,6 +3725,42 @@ static struct scsi_host_template
> > ufshcd_driver_template = {
> >  	.can_queue		= UFSHCD_CAN_QUEUE,
> >  };
> >
> > +static int ufshcd_config_vreg_load(struct device *dev, struct ufs_vreg *vreg,
> > +				   int ua)
> > +{
> > +	int ret = 0;
> > +	struct regulator *reg = vreg->reg;
> > +	const char *name = vreg->name;
> > +
> > +	BUG_ON(!vreg);
> 
> For the UFS host controller driver, which doesn't have the ufs_vreg structure for
> vcc and vccq, this function can cause kernel panic due to this BUG_ON(). Any
> reason to put a BUG_ON here instead of a NULL pointer checking?
> 
> Thanks
> Chuanxiao
> 
> > +
> > +	ret = regulator_set_optimum_mode(reg, ua);
> > +	if (ret >= 0) {
> > +		/*
> > +		 * regulator_set_optimum_mode() returns new regulator
> > +		 * mode upon success.
> > +		 */
> > +		ret = 0;
> > +	} else {
> > +		dev_err(dev, "%s: %s set optimum mode(ua=%d) failed, err=%d\n",
> > +				__func__, name, ua, ret);
> > +	}
> > +
> > +	return ret;
> > +}
> > +
> > +static inline int ufshcd_config_vreg_lpm(struct ufs_hba *hba,
> > +					 struct ufs_vreg *vreg)
> > +{
> > +	return ufshcd_config_vreg_load(hba->dev, vreg,
> > UFS_VREG_LPM_LOAD_UA);
> > +}
> > +
> > +static inline int ufshcd_config_vreg_hpm(struct ufs_hba *hba,
> > +					 struct ufs_vreg *vreg)
> > +{
> > +	return ufshcd_config_vreg_load(hba->dev, vreg, vreg->max_uA); }
> > +
> >  static int ufshcd_config_vreg(struct device *dev,
> >  		struct ufs_vreg *vreg, bool on)
> >  {
> > @@ -3527,18 +3781,9 @@ static int ufshcd_config_vreg(struct device *dev,
> >  		}
> >
> >  		uA_load = on ? vreg->max_uA : 0;
> > -		ret = regulator_set_optimum_mode(reg, uA_load);
> > -		if (ret >= 0) {
> > -			/*
> > -			 * regulator_set_optimum_mode() returns new regulator
> > -			 * mode upon success.
> > -			 */
> > -			ret = 0;
> > -		} else {
> > -			dev_err(dev, "%s: %s set optimum mode(uA_load=%d) failed,
> > err=%d\n",
> > -					__func__, name, uA_load, ret);
> > +		ret = ufshcd_config_vreg_load(dev, vreg, uA_load);
> > +		if (ret)
> >  			goto out;
> > -		}
> >  	}
> >  out:
> >  	return ret;
> > @@ -3654,7 +3899,8 @@ out:
> >  	return ret;
> >  }
> >
> > -static int ufshcd_setup_clocks(struct ufs_hba *hba, bool on)
> > +static int __ufshcd_setup_clocks(struct ufs_hba *hba, bool on,
> > +				 bool skip_ref_clk)
> >  {
> >  	int ret = 0;
> >  	struct ufs_clk_info *clki;
> > @@ -3665,6 +3911,9 @@ static int ufshcd_setup_clocks(struct ufs_hba
> *hba,
> > bool on)
> >
> >  	list_for_each_entry(clki, head, list) {
> >  		if (!IS_ERR_OR_NULL(clki->clk)) {
> > +			if (skip_ref_clk && !strcmp(clki->name, "ref_clk"))
> > +				continue;
> > +
> >  			if (on && !clki->enabled) {
> >  				ret = clk_prepare_enable(clki->clk);
> >  				if (ret) {
> > @@ -3690,6 +3939,11 @@ out:
> >  	return ret;
> >  }
> >
> > +static int ufshcd_setup_clocks(struct ufs_hba *hba, bool on) {
> > +	return  __ufshcd_setup_clocks(hba, on, false); }
> > +
> >  static int ufshcd_init_clocks(struct ufs_hba *hba)  {
> >  	int ret = 0;
> > @@ -3828,68 +4082,514 @@ static void ufshcd_hba_exit(struct ufs_hba
> *hba)
> >  	}
> >  }
> >
> > +static int
> > +ufshcd_send_request_sense(struct ufs_hba *hba, struct scsi_device *sdp)
> > +{
> > +	unsigned char cmd[6] = {REQUEST_SENSE,
> > +				0,
> > +				0,
> > +				0,
> > +				SCSI_SENSE_BUFFERSIZE,
> > +				0};
> > +	char *buffer;
> > +	int ret;
> > +
> > +	buffer = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
> > +	if (!buffer) {
> > +		ret = -ENOMEM;
> > +		goto out;
> > +	}
> > +
> > +	ret = scsi_execute_req_flags(sdp, cmd, DMA_FROM_DEVICE, buffer,
> > +				SCSI_SENSE_BUFFERSIZE, NULL,
> > +				msecs_to_jiffies(1000), 3, NULL, REQ_PM);
> > +	if (ret)
> > +		pr_err("%s: failed with err %d\n", __func__, ret);
> > +
> > +	kfree(buffer);
> > +out:
> > +	return ret;
> > +}
> > +
> >  /**
> > - * ufshcd_suspend - suspend power management function
> > + * ufshcd_set_dev_pwr_mode - sends START STOP UNIT command to set
> > device
> > + *			     power mode
> >   * @hba: per adapter instance
> > - * @state: power state
> > + * @pwr_mode: device power mode to set
> >   *
> > - * Returns -ENOSYS
> > + * Returns 0 if requested power mode is set successfully
> > + * Returns non-zero if failed to set the requested power mode
> >   */
> > -int ufshcd_suspend(struct ufs_hba *hba, pm_message_t state)
> > +static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
> > +				     enum ufs_dev_pwr_mode pwr_mode)
> >  {
> > +	unsigned char cmd[6] = { START_STOP };
> > +	struct scsi_sense_hdr sshdr;
> > +	struct scsi_device *sdp = hba->sdev_ufs_device;
> > +	int ret;
> > +
> > +	if (!sdp || !scsi_device_online(sdp))
> > +		return -ENODEV;
> > +
> > +	/*
> > +	 * If scsi commands fail, the scsi mid-layer schedules scsi error-
> > +	 * handling, which would wait for host to be resumed. Since we know
> > +	 * we are functional while we are here, skip host resume in error
> > +	 * handling context.
> > +	 */
> > +	hba->host->eh_noresume = 1;
> > +	if (hba->wlun_dev_clr_ua) {
> > +		ret = ufshcd_send_request_sense(hba, sdp);
> > +		if (ret)
> > +			goto out;
> > +		/* Unit attention condition is cleared now */
> > +		hba->wlun_dev_clr_ua = false;
> > +	}
> > +
> > +	cmd[4] = pwr_mode << 4;
> > +
> >  	/*
> > -	 * TODO:
> > -	 * 1. Block SCSI requests from SCSI midlayer
> > -	 * 2. Change the internal driver state to non operational
> > -	 * 3. Set UTRLRSR and UTMRLRSR bits to zero
> > -	 * 4. Wait until outstanding commands are completed
> > -	 * 5. Set HCE to zero to send the UFS host controller to reset state
> > +	 * Current function would be generally called from the power
> > management
> > +	 * callbacks hence set the REQ_PM flag so that it doesn't resume the
> > +	 * already suspended childs.
> >  	 */
> > +	ret = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
> > +				     START_STOP_TIMEOUT, 0, NULL, REQ_PM);
> > +	if (ret) {
> > +		sdev_printk(KERN_WARNING, sdp,
> > +			  "START_STOP failed for power mode: %d\n", pwr_mode);
> > +		scsi_show_result(ret);
> > +		if (driver_byte(ret) & DRIVER_SENSE) {
> > +			scsi_show_sense_hdr(&sshdr);
> > +			scsi_show_extd_sense(sshdr.asc, sshdr.ascq);
> > +		}
> > +	}
> >
> > -	return -ENOSYS;
> > +	if (!ret)
> > +		hba->curr_dev_pwr_mode = pwr_mode;
> > +out:
> > +	hba->host->eh_noresume = 0;
> > +	return ret;
> > +}
> > +
> > +static int ufshcd_link_state_transition(struct ufs_hba *hba,
> > +					enum uic_link_state req_link_state,
> > +					int check_for_bkops)
> > +{
> > +	int ret = 0;
> > +
> > +	if (req_link_state == hba->uic_link_state)
> > +		return 0;
> > +
> > +	if (req_link_state == UIC_LINK_HIBERN8_STATE) {
> > +		ret = ufshcd_uic_hibern8_enter(hba);
> > +		if (!ret)
> > +			ufshcd_set_link_hibern8(hba);
> > +		else
> > +			goto out;
> > +	}
> > +	/*
> > +	 * If autobkops is enabled, link can't be turned off because
> > +	 * turning off the link would also turn off the device.
> > +	 */
> > +	else if ((req_link_state == UIC_LINK_OFF_STATE) &&
> > +		   (!check_for_bkops || (check_for_bkops &&
> > +		    !hba->auto_bkops_enabled))) {
> > +		/*
> > +		 * Change controller state to "reset state" which
> > +		 * should also put the link in off/reset state
> > +		 */
> > +		ufshcd_hba_stop(hba);
> > +		/*
> > +		 * TODO: Check if we need any delay to make sure that
> > +		 * controller is reset
> > +		 */
> > +		ufshcd_set_link_off(hba);
> > +	}
> > +
> > +out:
> > +	return ret;
> > +}
> > +
> > +static void ufshcd_vreg_set_lpm(struct ufs_hba *hba) {
> > +	/*
> > +	 * If UFS device is either in UFS_Sleep turn off VCC rail to save some
> > +	 * power.
> > +	 *
> > +	 * If UFS device and link is in OFF state, all power supplies (VCC,
> > +	 * VCCQ, VCCQ2) can be turned off if power on write protect is not
> > +	 * required. If UFS link is inactive (Hibern8 or OFF state) and device
> > +	 * is in sleep state, put VCCQ & VCCQ2 rails in LPM mode.
> > +	 *
> > +	 * Ignore the error returned by ufshcd_toggle_vreg() as device is anyway
> > +	 * in low power state which would save some power.
> > +	 */
> > +	if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba) &&
> > +	    !hba->dev_info.is_lu_power_on_wp) {
> > +		ufshcd_setup_vreg(hba, false);
> > +	} else if (!ufshcd_is_ufs_dev_active(hba)) {
> > +		ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, false);
> > +		if (!ufshcd_is_link_active(hba)) {
> > +			ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq);
> > +			ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq2);
> > +		}
> > +	}
> > +}
> > +
> > +static int ufshcd_vreg_set_hpm(struct ufs_hba *hba) {
> > +	int ret = 0;
> > +
> > +	if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba) &&
> > +	    !hba->dev_info.is_lu_power_on_wp) {
> > +		ret = ufshcd_setup_vreg(hba, true);
> > +	} else if (!ufshcd_is_ufs_dev_active(hba)) {
> > +		ret = ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, true);
> > +		if (!ret && !ufshcd_is_link_active(hba)) {
> > +			ret = ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq);
> > +			if (ret)
> > +				goto vcc_disable;
> > +			ret = ufshcd_config_vreg_hpm(hba, hba->vreg_info.vccq2);
> > +			if (ret)
> > +				goto vccq_lpm;
> > +		}
> > +	}
> > +	goto out;
> > +
> > +vccq_lpm:
> > +	ufshcd_config_vreg_lpm(hba, hba->vreg_info.vccq);
> > +vcc_disable:
> > +	ufshcd_toggle_vreg(hba->dev, hba->vreg_info.vcc, false);
> > +out:
> > +	return ret;
> >  }
> > -EXPORT_SYMBOL_GPL(ufshcd_suspend);
> >
> >  /**
> > - * ufshcd_resume - resume power management function
> > + * ufshcd_suspend - helper function for suspend operations
> >   * @hba: per adapter instance
> > + * @pm_op: desired low power operation type
> >   *
> > - * Returns -ENOSYS
> > + * This function will try to put the UFS device and link into low power
> > + * mode based on the "rpm_lvl" (Runtime PM level) or "spm_lvl"
> > + * (System PM level).
> > + *
> > + * If this function is called during shutdown, it will make sure that
> > + * both UFS device and UFS link is powered off.
> > + *
> > + * NOTE: UFS device & link must be active before we enter in this function.
> > + *
> > + * Returns 0 for success and non-zero for failure
> >   */
> > -int ufshcd_resume(struct ufs_hba *hba)
> > +static int ufshcd_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
> >  {
> > +	int ret = 0;
> > +	enum ufs_pm_level pm_lvl;
> > +	enum ufs_dev_pwr_mode req_dev_pwr_mode;
> > +	enum uic_link_state req_link_state;
> > +
> > +	hba->pm_op_in_progress = 1;
> > +	if (!ufshcd_is_shutdown_pm(pm_op)) {
> > +		pm_lvl = ufshcd_is_runtime_pm(pm_op) ?
> > +			 hba->rpm_lvl : hba->spm_lvl;
> > +		req_dev_pwr_mode = ufs_get_pm_lvl_to_dev_pwr_mode(pm_lvl);
> > +		req_link_state = ufs_get_pm_lvl_to_link_pwr_state(pm_lvl);
> > +	} else {
> > +		req_dev_pwr_mode = UFS_POWERDOWN_PWR_MODE;
> > +		req_link_state = UIC_LINK_OFF_STATE;
> > +	}
> > +
> > +	/*
> > +	 * If we can't transition into any of the low power modes
> > +	 * just gate the clocks.
> > +	 */
> > +	if (req_dev_pwr_mode == UFS_ACTIVE_PWR_MODE &&
> > +			req_link_state == UIC_LINK_ACTIVE_STATE) {
> > +		goto disable_clks;
> > +	}
> > +
> > +	if ((req_dev_pwr_mode == hba->curr_dev_pwr_mode) &&
> > +	    (req_link_state == hba->uic_link_state))
> > +		goto out;
> > +
> > +	/* UFS device & link must be active before we enter in this function */
> > +	if (!ufshcd_is_ufs_dev_active(hba) || !ufshcd_is_link_active(hba)) {
> > +		ret = -EINVAL;
> > +		goto out;
> > +	}
> > +
> > +	if (ufshcd_is_runtime_pm(pm_op)) {
> > +		/*
> > +		 * The device is idle with no requests in the queue,
> > +		 * allow background operations if needed.
> > +		 */
> > +		ret = ufshcd_bkops_ctrl(hba, BKOPS_STATUS_NON_CRITICAL);
> > +		if (ret)
> > +			goto out;
> > +	}
> > +
> > +	if ((req_dev_pwr_mode != hba->curr_dev_pwr_mode) &&
> > +	     ((ufshcd_is_runtime_pm(pm_op) && !hba->auto_bkops_enabled) ||
> > +	       !ufshcd_is_runtime_pm(pm_op))) {
> > +		/* ensure that bkops is disabled */
> > +		ufshcd_disable_auto_bkops(hba);
> > +		ret = ufshcd_set_dev_pwr_mode(hba, req_dev_pwr_mode);
> > +		if (ret)
> > +			goto out;
> > +	}
> > +
> > +	ret = ufshcd_link_state_transition(hba, req_link_state, 1);
> > +	if (ret)
> > +		goto set_dev_active;
> > +
> > +	ufshcd_vreg_set_lpm(hba);
> > +
> > +disable_clks:
> > +	/*
> > +	 * Call vendor specific suspend callback. As these callbacks may access
> > +	 * vendor specific host controller register space call them before the
> > +	 * host clocks are ON.
> > +	 */
> > +	if (hba->vops && hba->vops->suspend) {
> > +		ret = hba->vops->suspend(hba, pm_op);
> > +		if (ret)
> > +			goto set_link_active;
> > +	}
> > +
> > +	if (hba->vops && hba->vops->setup_clocks) {
> > +		ret = hba->vops->setup_clocks(hba, false);
> > +		if (ret)
> > +			goto vops_resume;
> > +	}
> > +
> > +	if (!ufshcd_is_link_active(hba))
> > +		ufshcd_setup_clocks(hba, false);
> > +	else
> > +		/* If link is active, device ref_clk can't be switched off */
> > +		__ufshcd_setup_clocks(hba, false, true);
> > +
> >  	/*
> > -	 * TODO:
> > -	 * 1. Set HCE to 1, to start the UFS host controller
> > -	 * initialization process
> > -	 * 2. Set UTRLRSR and UTMRLRSR bits to 1
> > -	 * 3. Change the internal driver state to operational
> > -	 * 4. Unblock SCSI requests from SCSI midlayer
> > +	 * Disable the host irq as host controller as there won't be any
> > +	 * host controller trasanction expected till resume.
> >  	 */
> > +	ufshcd_disable_irq(hba);
> > +	goto out;
> >
> > -	return -ENOSYS;
> > +vops_resume:
> > +	if (hba->vops && hba->vops->resume)
> > +		hba->vops->resume(hba, pm_op);
> > +set_link_active:
> > +	ufshcd_vreg_set_hpm(hba);
> > +	if (ufshcd_is_link_hibern8(hba) && !ufshcd_uic_hibern8_exit(hba))
> > +		ufshcd_set_link_active(hba);
> > +	else if (ufshcd_is_link_off(hba))
> > +		ufshcd_host_reset_and_restore(hba);
> > +set_dev_active:
> > +	if (!ufshcd_set_dev_pwr_mode(hba, UFS_ACTIVE_PWR_MODE))
> > +		ufshcd_disable_auto_bkops(hba);
> > +out:
> > +	hba->pm_op_in_progress = 0;
> > +	return ret;
> >  }
> > -EXPORT_SYMBOL_GPL(ufshcd_resume);
> >
> > -int ufshcd_runtime_suspend(struct ufs_hba *hba)
> > +/**
> > + * ufshcd_resume - helper function for resume operations
> > + * @hba: per adapter instance
> > + * @pm_op: runtime PM or system PM
> > + *
> > + * This function basically brings the UFS device, UniPro link and
> > +controller
> > + * to active state.
> > + *
> > + * Returns 0 for success and non-zero for failure  */ static int
> > +ufshcd_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op)
> >  {
> > -	if (!hba)
> > -		return 0;
> > +	int ret;
> > +	enum uic_link_state old_link_state;
> > +
> > +	hba->pm_op_in_progress = 1;
> > +	old_link_state = hba->uic_link_state;
> > +	/* Make sure clocks are enabled before accessing controller */
> > +	ret = ufshcd_setup_clocks(hba, true);
> > +	if (ret)
> > +		goto out;
> > +
> > +	if (hba->vops && hba->vops->setup_clocks) {
> > +		ret = hba->vops->setup_clocks(hba, true);
> > +		if (ret)
> > +			goto disable_clks;
> > +	}
> > +
> > +	/* enable the host irq as host controller would be active soon */
> > +	ufshcd_enable_irq(hba);
> > +
> > +	ret = ufshcd_vreg_set_hpm(hba);
> > +	if (ret)
> > +		goto disable_irq_and_vops_clks;
> >
> >  	/*
> > -	 * The device is idle with no requests in the queue,
> > -	 * allow background operations.
> > +	 * Call vendor specific resume callback. As these callbacks may access
> > +	 * vendor specific host controller register space call them when the
> > +	 * host clocks are ON.
> >  	 */
> > -	return ufshcd_enable_auto_bkops(hba);
> > +	if (hba->vops && hba->vops->resume) {
> > +		ret = hba->vops->resume(hba, pm_op);
> > +		if (ret)
> > +			goto disable_vreg;
> > +	}
> > +
> > +	if (ufshcd_is_link_hibern8(hba)) {
> > +		ret = ufshcd_uic_hibern8_exit(hba);
> > +		if (!ret)
> > +			ufshcd_set_link_active(hba);
> > +		else
> > +			goto vendor_suspend;
> > +	} else if (ufshcd_is_link_off(hba)) {
> > +		ret = ufshcd_host_reset_and_restore(hba);
> > +		/*
> > +		 * ufshcd_host_reset_and_restore() should have already
> > +		 * set the link state as active
> > +		 */
> > +		if (ret || !ufshcd_is_link_active(hba))
> > +			goto vendor_suspend;
> > +	}
> > +
> > +	if (!ufshcd_is_ufs_dev_active(hba)) {
> > +		ret = ufshcd_set_dev_pwr_mode(hba, UFS_ACTIVE_PWR_MODE);
> > +		if (ret)
> > +			goto set_old_link_state;
> > +	}
> > +
> > +	ufshcd_disable_auto_bkops(hba);

Should be auto background operation enabled again in ufshcd_resume()? It is disabled during ufshcd_suspend().

Thanks
Chuanxiao

> > +	goto out;
> > +
> > +set_old_link_state:
> > +	ufshcd_link_state_transition(hba, old_link_state, 0);
> > +vendor_suspend:
> > +	if (hba->vops && hba->vops->suspend)
> > +		hba->vops->suspend(hba, pm_op);
> > +disable_vreg:
> > +	ufshcd_vreg_set_lpm(hba);
> > +disable_irq_and_vops_clks:
> > +	ufshcd_disable_irq(hba);
> > +	if (hba->vops && hba->vops->setup_clocks)
> > +		ret = hba->vops->setup_clocks(hba, false);
> > +disable_clks:
> > +	ufshcd_setup_clocks(hba, false);
> > +out:
> > +	hba->pm_op_in_progress = 0;
> > +	return ret;
> > +}
> > +
> > +/**
> > + * ufshcd_system_suspend - system suspend routine
> > + * @hba: per adapter instance
> > + * @pm_op: runtime PM or system PM
> > + *
> > + * Check the description of ufshcd_suspend() function for more details.
> > + *
> > + * Returns 0 for success and non-zero for failure  */ int
> > +ufshcd_system_suspend(struct ufs_hba *hba) {
> > +	int ret = 0;
> > +
> > +	if (!hba || !hba->is_powered)
> > +		goto out;
> > +
> > +	if (pm_runtime_suspended(hba->dev)) {
> > +		if (hba->rpm_lvl == hba->spm_lvl)
> > +			/*
> > +			 * There is possibility that device may still be in
> > +			 * active state during the runtime suspend.
> > +			 */
> > +			if ((ufs_get_pm_lvl_to_dev_pwr_mode(hba->spm_lvl) ==
> > +			    hba->curr_dev_pwr_mode)
> > && !hba->auto_bkops_enabled)
> > +				goto out;
> > +
> > +		/*
> > +		 * UFS device and/or UFS link low power states during runtime
> > +		 * suspend seems to be different than what is expected during
> > +		 * system suspend. Hence runtime resume the devic & link and
> > +		 * let the system suspend low power states to take effect.
> > +		 * TODO: If resume takes longer time, we might have optimize
> > +		 * it in future by not resuming everything if possible.
> > +		 */
> > +		ret = ufshcd_runtime_resume(hba);
> > +		if (ret)
> > +			goto out;
> > +	}
> > +
> > +	ret = ufshcd_suspend(hba, UFS_SYSTEM_PM);
> > +out:
> > +	return ret;
> > +}
> > +EXPORT_SYMBOL(ufshcd_system_suspend);
> > +
> > +/**
> > + * ufshcd_system_resume - system resume routine
> > + * @hba: per adapter instance
> > + *
> > + * Returns 0 for success and non-zero for failure  */
> > +
> > +int ufshcd_system_resume(struct ufs_hba *hba) {
> > +	if (!hba || !hba->is_powered || pm_runtime_suspended(hba->dev))
> > +		/*
> > +		 * Let the runtime resume take care of resuming
> > +		 * if runtime suspended.
> > +		 */
> > +		return 0;
> > +	else
> > +		return ufshcd_resume(hba, UFS_SYSTEM_PM); }
> > +EXPORT_SYMBOL(ufshcd_system_resume);
> > +
> > +/**
> > + * ufshcd_runtime_suspend - runtime suspend routine
> > + * @hba: per adapter instance
> > + *
> > + * Check the description of ufshcd_suspend() function for more details.
> > + *
> > + * Returns 0 for success and non-zero for failure  */ int
> > +ufshcd_runtime_suspend(struct ufs_hba *hba) {
> > +	if (!hba || !hba->is_powered)
> > +		return 0;
> > +	else
> > +		return ufshcd_suspend(hba, UFS_RUNTIME_PM);
> >  }
> >  EXPORT_SYMBOL(ufshcd_runtime_suspend);
> >
> > +/**
> > + * ufshcd_runtime_resume - runtime resume routine
> > + * @hba: per adapter instance
> > + *
> > + * This function basically brings the UFS device, UniPro link and
> > +controller
> > + * to active state. Following operations are done in this function:
> > + *
> > + * 1. Turn on all the controller related clocks
> > + * 2. Bring the UniPro link out of Hibernate state
> > + * 3. If UFS device is in sleep state, turn ON VCC rail and bring the UFS device
> > + *    to active state.
> > + * 4. If auto-bkops is enabled on the device, disable it.
> > + *
> > + * So following would be the possible power state after this function
> > +return
> > + * successfully:
> > + *	S1: UFS device in Active state with VCC rail ON
> > + *	    UniPro link in Active state
> > + *	    All the UFS/UniPro controller clocks are ON
> > + *
> > + * Returns 0 for success and non-zero for failure  */
> >  int ufshcd_runtime_resume(struct ufs_hba *hba)  {
> > -	if (!hba)
> > +	if (!hba || !hba->is_powered)
> >  		return 0;
> > -
> > -	return ufshcd_disable_auto_bkops(hba);
> > +	else
> > +		return ufshcd_resume(hba, UFS_RUNTIME_PM);
> >  }
> >  EXPORT_SYMBOL(ufshcd_runtime_resume);
> >
> > @@ -3900,6 +4600,36 @@ int ufshcd_runtime_idle(struct ufs_hba *hba)
> > EXPORT_SYMBOL(ufshcd_runtime_idle);
> >
> >  /**
> > + * ufshcd_shutdown - shutdown routine
> > + * @hba: per adapter instance
> > + *
> > + * This function would power off both UFS device and UFS link.
> > + *
> > + * Returns 0 always to allow force shutdown even in case of errors.
> > + */
> > +int ufshcd_shutdown(struct ufs_hba *hba) {
> > +	int ret = 0;
> > +
> > +	if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba))
> > +		goto out;
> > +
> > +	if (pm_runtime_suspended(hba->dev)) {
> > +		ret = ufshcd_runtime_resume(hba);
> > +		if (ret)
> > +			goto out;
> > +	}
> > +
> > +	ret = ufshcd_suspend(hba, UFS_SHUTDOWN_PM);
> > +out:
> > +	if (ret)
> > +		dev_err(hba->dev, "%s failed, err %d\n", __func__, ret);
> > +	/* allow force shutdown even in case of errors */
> > +	return 0;
> > +}
> > +EXPORT_SYMBOL(ufshcd_shutdown);
> > +
> > +/**
> >   * ufshcd_remove - de-allocate SCSI host and host memory space
> >   *		data structure memory
> >   * @hba - per adapter instance
> > @@ -4052,6 +4782,8 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem
> > *mmio_base, unsigned int irq)
> >  	if (err) {
> >  		dev_err(hba->dev, "request irq failed\n");
> >  		goto out_disable;
> > +	} else {
> > +		hba->is_irq_enabled = true;
> >  	}
> >
> >  	/* Enable SCSI tag mapping */
> > @@ -4077,6 +4809,12 @@ int ufshcd_init(struct ufs_hba *hba, void
> __iomem
> > *mmio_base, unsigned int irq)
> >  	/* Hold auto suspend until async scan completes */
> >  	pm_runtime_get_sync(dev);
> >
> > +	/*
> > +	 * The device-initialize-sequence hasn't been invoked yet.
> > +	 * Set the device to power-off state
> > +	 */
> > +	ufshcd_set_ufs_dev_poweroff(hba);
> > +
> >  	async_schedule(ufshcd_async_scan, hba);
> >
> >  	return 0;
> > @@ -4084,6 +4822,7 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem
> > *mmio_base, unsigned int irq)
> >  out_remove_scsi_host:
> >  	scsi_remove_host(hba->host);
> >  out_disable:
> > +	hba->is_irq_enabled = false;
> >  	scsi_host_put(host);
> >  	ufshcd_hba_exit(hba);
> >  out_error:
> > diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h index
> > 9b5f77f..1ee429d 100644
> > --- a/drivers/scsi/ufs/ufshcd.h
> > +++ b/drivers/scsi/ufs/ufshcd.h
> > @@ -96,6 +96,54 @@ struct uic_command {
> >  	struct completion done;
> >  };
> >
> > +/* Used to differentiate the power management options */ enum
> ufs_pm_op
> > +{
> > +	UFS_RUNTIME_PM,
> > +	UFS_SYSTEM_PM,
> > +	UFS_SHUTDOWN_PM,
> > +};
> > +
> > +#define ufshcd_is_runtime_pm(op) ((op) == UFS_RUNTIME_PM) #define
> > +ufshcd_is_system_pm(op) ((op) == UFS_SYSTEM_PM) #define
> > +ufshcd_is_shutdown_pm(op) ((op) == 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 */
> > +};
> > +
> > +#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)
> > +#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)
> > +
> > +/*
> > + * UFS Power management levels.
> > + * Each level is in increasing order of power savings.
> > + */
> > +enum ufs_pm_level {
> > +	UFS_PM_LVL_0, /* UFS_ACTIVE_PWR_MODE, UIC_LINK_ACTIVE_STATE
> > */
> > +	UFS_PM_LVL_1, /* UFS_ACTIVE_PWR_MODE, UIC_LINK_HIBERN8_STATE
> > */
> > +	UFS_PM_LVL_2, /* UFS_SLEEP_PWR_MODE, UIC_LINK_ACTIVE_STATE */
> > +	UFS_PM_LVL_3, /* UFS_SLEEP_PWR_MODE, UIC_LINK_HIBERN8_STATE
> > */
> > +	UFS_PM_LVL_4, /* UFS_POWERDOWN_PWR_MODE,
> > UIC_LINK_HIBERN8_STATE */
> > +	UFS_PM_LVL_5, /* UFS_POWERDOWN_PWR_MODE,
> > UIC_LINK_OFF_STATE */
> > +	UFS_PM_LVL_MAX
> > +};
> > +
> > +struct ufs_pm_lvl_states {
> > +	enum ufs_dev_pwr_mode dev_state;
> > +	enum uic_link_state link_state;
> > +};
> > +
> >  /**
> >   * struct ufshcd_lrb - local reference block
> >   * @utr_descriptor_ptr: UTRD address of the command @@ -184,6
> +232,8
> > @@ struct ufs_clk_info {
> >   *                     variant specific Uni-Pro initialization.
> >   * @link_startup_notify: called before and after Link startup is carried out
> >   *                       to allow variant specific Uni-Pro
> initialization.
> > + * @suspend: called during host controller PM callback
> > + * @resume: called during host controller PM callback
> >   */
> >  struct ufs_hba_variant_ops {
> >  	const char *name;
> > @@ -193,6 +243,8 @@ struct ufs_hba_variant_ops {
> >  	int     (*setup_regulators)(struct ufs_hba *, bool);
> >  	int     (*hce_enable_notify)(struct ufs_hba *, bool);
> >  	int     (*link_startup_notify)(struct ufs_hba *, bool);
> > +	int     (*suspend)(struct ufs_hba *, enum ufs_pm_op);
> > +	int     (*resume)(struct ufs_hba *, enum ufs_pm_op);
> >  };
> >
> >  /**
> > @@ -271,6 +323,13 @@ struct ufs_hba {
> >  	 * "UFS device" W-LU.
> >  	 */
> >  	struct scsi_device *sdev_ufs_device;
> > +	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;
> >
> >  	struct ufshcd_lrb *lrb;
> >  	unsigned long lrb_in_use;
> > @@ -285,16 +344,17 @@ struct ufs_hba {
> >  	struct ufs_hba_variant_ops *vops;
> >  	void *priv;
> >  	unsigned int irq;
> > +	bool is_irq_enabled;
> >
> > -	struct uic_command *active_uic_cmd;
> > -	struct mutex uic_cmd_mutex;
> >
> >  	wait_queue_head_t tm_wq;
> >  	wait_queue_head_t tm_tag_wq;
> >  	unsigned long tm_condition;
> >  	unsigned long tm_slots_in_use;
> >
> > -	struct completion *pwr_done;
> > +	struct uic_command *active_uic_cmd;
> > +	struct mutex uic_cmd_mutex;
> > +	struct completion *uic_async_done;
> >
> >  	u32 ufshcd_state;
> >  	u32 eh_flags;
> > @@ -317,9 +377,13 @@ struct ufs_hba {
> >  	/* Device management request data */
> >  	struct ufs_dev_cmd dev_cmd;
> >
> > +	/* Keeps information of the UFS device connected to this host */
> > +	struct ufs_dev_info dev_info;
> >  	bool auto_bkops_enabled;
> >  	struct ufs_vreg_info vreg_info;
> >  	struct list_head clk_list_head;
> > +
> > +	bool wlun_dev_clr_ua;
> >  };
> >
> >  #define ufshcd_writel(hba, val, reg)	\
> > @@ -346,11 +410,12 @@ static inline void check_upiu_size(void)
> >  		GENERAL_UPIU_REQUEST_SIZE + QUERY_DESC_MAX_SIZE);  }
> >
> > -extern int ufshcd_suspend(struct ufs_hba *hba, pm_message_t state);
> > -extern int ufshcd_resume(struct ufs_hba *hba);  extern int
> > ufshcd_runtime_suspend(struct ufs_hba *hba);  extern int
> > ufshcd_runtime_resume(struct ufs_hba *hba);  extern int
> > ufshcd_runtime_idle(struct ufs_hba *hba);
> > +extern int ufshcd_system_suspend(struct ufs_hba *hba); extern int
> > +ufshcd_system_resume(struct ufs_hba *hba); extern int
> > +ufshcd_shutdown(struct ufs_hba *hba);
> >  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, diff --git
> > a/drivers/scsi/ufs/ufshci.h b/drivers/scsi/ufs/ufshci.h index
> e1b844b..d572119
> > 100644
> > --- a/drivers/scsi/ufs/ufshci.h
> > +++ b/drivers/scsi/ufs/ufshci.h
> > @@ -124,8 +124,11 @@ enum {
> >  #define CONTROLLER_FATAL_ERROR			UFS_BIT(16)
> >  #define SYSTEM_BUS_FATAL_ERROR			UFS_BIT(17)
> >
> > -#define UFSHCD_UIC_MASK		(UIC_COMMAND_COMPL |\
> > -				 UIC_POWER_MODE)
> > +#define UFSHCD_UIC_PWR_MASK	(UIC_HIBERNATE_ENTER |\
> > +				UIC_HIBERNATE_EXIT |\
> > +				UIC_POWER_MODE)
> > +
> > +#define UFSHCD_UIC_MASK		(UIC_COMMAND_COMPL |
> > UFSHCD_UIC_PWR_MASK)
> >
> >  #define UFSHCD_ERROR_MASK	(UIC_ERROR |\
> >  				DEVICE_FATAL_ERROR |\
> > @@ -210,7 +213,7 @@ enum {
> >  #define UIC_GET_ATTR_ID(v)		(((v) >> 16) & 0xFFFF)
> >
> >  /* UIC Commands */
> > -enum {
> > +enum uic_cmd_dme {
> >  	UIC_CMD_DME_GET			= 0x01,
> >  	UIC_CMD_DME_SET			= 0x02,
> >  	UIC_CMD_DME_PEER_GET		= 0x03,
> > --
> > 1.8.5.2
> > --
> > QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc. is a
> > member of Code Aurora Forum, hosted by The Linux Foundation
> >
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-scsi" in the body
> > of a message to majordomo@vger.kernel.org More majordomo info at
> > http://vger.kernel.org/majordomo-info.html
> --
> To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html