Re: [PATCH v3 2/4] scsi: ufs: add debugfs for ufs

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



> From: Lee Susman <lsusman@xxxxxxxxxxxxxx>
>
> Adding debugfs capability for ufshcd.
>
> debugfs attributes introduced in this patch:
>  - View driver/controller runtime data
>  - Command tag statistics for performance analisis
>  - Dump device descriptor info
>  - Track recoverable errors statistics during runtime
>  - Change UFS power mode during runtime
>      entry a string in the format 'GGLLMM' where:
>          G - selected gear
>          L - number of lanes
>          M - power mode
>              (1=fast mode, 2=slow mode, 4=fast-auto mode,
>               5=slow-auto mode)
>      First letter is for RX, second is for TX.
>  - Get/set DME attributes
>
> Signed-off-by: Lee Susman <lsusman@xxxxxxxxxxxxxx>
> Signed-off-by: Dolev Raviv <draviv@xxxxxxxxxxxxxx>
> Signed-off-by: Yaniv Gardi <ygardi@xxxxxxxxxxxxxx>
> Signed-off-by: Raviv Shvili <rshvili@xxxxxxxxxxxxxx>
> Signed-off-by: Gilad Broner <gbroner@xxxxxxxxxxxxxx>
> ---
>  drivers/scsi/ufs/Makefile      |   1 +
>  drivers/scsi/ufs/ufs-debugfs.c | 902
> +++++++++++++++++++++++++++++++++++++++++
>  drivers/scsi/ufs/ufs-debugfs.h |  38 ++
>  drivers/scsi/ufs/ufshcd.c      | 225 +++++++++-
>  drivers/scsi/ufs/ufshcd.h      |  65 +++
>  drivers/scsi/ufs/ufshci.h      |   2 +
>  6 files changed, 1221 insertions(+), 12 deletions(-)
>  create mode 100644 drivers/scsi/ufs/ufs-debugfs.c
>  create mode 100644 drivers/scsi/ufs/ufs-debugfs.h
>
> diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile
> index 8303bcc..0692314 100644
> --- a/drivers/scsi/ufs/Makefile
> +++ b/drivers/scsi/ufs/Makefile
> @@ -3,3 +3,4 @@ obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o
>  obj-$(CONFIG_SCSI_UFSHCD) += ufshcd.o
>  obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o
>  obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o
> +obj-$(CONFIG_DEBUG_FS) += ufs-debugfs.o
> diff --git a/drivers/scsi/ufs/ufs-debugfs.c
> b/drivers/scsi/ufs/ufs-debugfs.c
> new file mode 100644
> index 0000000..d1eb4f8
> --- /dev/null
> +++ b/drivers/scsi/ufs/ufs-debugfs.c
> @@ -0,0 +1,902 @@
> +/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * UFS debugfs - add debugfs interface to the ufshcd.
> + * This is currently used for statistics collection and exporting from
> the
> + * UFS driver.
> + * This infrastructure can be used for debugging or direct tweaking
> + * of the driver from userspace.
> + *
> + */
> +
> +#include "ufs-debugfs.h"
> +#include "unipro.h"
> +
> +enum field_width {
> +	BYTE	= 1,
> +	WORD	= 2,
> +};
> +
> +struct desc_field_offset {
> +	char *name;
> +	int offset;
> +	enum field_width width_byte;
> +};
> +
> +#define UFS_ERR_STATS_PRINT(file, error_index, string, error_seen)	\
> +	do {								\
> +		if (err_stats[error_index]) {				\
> +			seq_printf(file, string,			\
> +					err_stats[error_index]);	\
> +			error_seen = true;				\
> +		}							\
> +	} while (0)
> +#define DOORBELL_CLR_TOUT_US	(1000 * 1000) /* 1 sec */
> +
> +#define BUFF_LINE_CAPACITY 16
> +#define TAB_CHARS 8
> +
> +static int ufsdbg_tag_stats_show(struct seq_file *file, void *data)
> +{
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +	struct ufs_stats *ufs_stats;
> +	int i, j;
> +	int max_depth;
> +	bool is_tag_empty = true;
> +	unsigned long flags;
> +	char *sep = " | * | ";
> +
> +	if (!hba)
> +		goto exit;
> +
> +	ufs_stats = &hba->ufs_stats;
> +
> +	if (!ufs_stats->enabled) {
> +		pr_debug("%s: ufs statistics are disabled\n", __func__);
> +		seq_puts(file, "ufs statistics are disabled");
> +		goto exit;
> +	}
> +
> +	max_depth = hba->nutrs;
> +
> +	spin_lock_irqsave(hba->host->host_lock, flags);
> +	/* Header */
> +	seq_printf(file, " Tag Stat\t\t%s Queue Fullness\n", sep);
> +	for (i = 0; i < TAB_CHARS * (TS_NUM_STATS + 4); i++) {
> +		seq_puts(file, "-");
> +		if (i == (TAB_CHARS * 3 - 1))
> +			seq_puts(file, sep);
> +	}
> +	seq_printf(file,
> +		"\n #\tnum uses\t%s\t #\tAll\t Read\t Write\t Flush\n",
> +		sep);
> +
> +	/* values */
> +	for (i = 0; i < max_depth; i++) {
> +		if (ufs_stats->tag_stats[i][0] <= 0 &&
> +				ufs_stats->tag_stats[i][1] <= 0 &&
> +				ufs_stats->tag_stats[i][2] <= 0 &&
> +				ufs_stats->tag_stats[i][3] <= 0)
> +			continue;
> +
> +		is_tag_empty = false;
> +		seq_printf(file, " %d\t ", i);
> +		for (j = 0; j < TS_NUM_STATS; j++) {
> +			seq_printf(file, "%llu\t ",
> ufs_stats->tag_stats[i][j]);
> +			if (j == 0)
> +				seq_printf(file, "\t%s\t %d\t%llu\t ",
> sep, i,
> +
> ufs_stats->tag_stats[i][j+1] +
> +
> ufs_stats->tag_stats[i][j+2]);
> +		}
> +		seq_puts(file, "\n");
> +	}
> +	spin_unlock_irqrestore(hba->host->host_lock, flags);
> +
> +	if (is_tag_empty)
> +		pr_debug("%s: All tags statistics are empty", __func__);
> +
> +exit:
> +	return 0;
> +}
> +
> +static int ufsdbg_tag_stats_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, ufsdbg_tag_stats_show, inode->i_private);
> +}
> +
> +static ssize_t ufsdbg_tag_stats_write(struct file *filp,
> +				      const char __user *ubuf, size_t cnt,
> +				       loff_t *ppos)
> +{
> +	struct ufs_hba *hba = filp->f_mapping->host->i_private;
> +	struct ufs_stats *ufs_stats;
> +	int val = 0;
> +	int ret, bit = 0;
> +	unsigned long flags;
> +
> +	ret = kstrtoint_from_user(ubuf, cnt, 0, &val);
> +	if (ret) {
> +		dev_err(hba->dev, "%s: Invalid argument\n", __func__);
> +		return ret;
> +	}
> +
> +	ufs_stats = &hba->ufs_stats;
> +	spin_lock_irqsave(hba->host->host_lock, flags);
> +
> +	if (!val) {
> +		ufs_stats->enabled = false;
> +		pr_debug("%s: Disabling UFS tag statistics", __func__);
> +	} else {
> +		ufs_stats->enabled = true;
> +		pr_debug("%s: Enabling & Resetting UFS tag statistics",
> +			 __func__);
> +		memset(hba->ufs_stats.tag_stats[0], 0,
> +			sizeof(**hba->ufs_stats.tag_stats) *
> +			TS_NUM_STATS * hba->nutrs);
> +
> +		/* initialize current queue depth */
> +		ufs_stats->q_depth = 0;
> +		for_each_set_bit_from(bit, &hba->outstanding_reqs,
> hba->nutrs)
> +			ufs_stats->q_depth++;
> +		pr_debug("%s: Enabled UFS tag statistics", __func__);
> +	}
> +
> +	spin_unlock_irqrestore(hba->host->host_lock, flags);
> +	return cnt;
> +}
> +
> +static const struct file_operations ufsdbg_tag_stats_fops = {
> +	.open		= ufsdbg_tag_stats_open,
> +	.read		= seq_read,
> +	.write		= ufsdbg_tag_stats_write,
> +};
> +
> +static int ufsdbg_err_stats_show(struct seq_file *file, void *data)
> +{
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +	int *err_stats;
> +	unsigned long flags;
> +	bool error_seen = false;
> +
> +	if (!hba)
> +		goto exit;
> +
> +	err_stats = hba->ufs_stats.err_stats;
> +
> +	spin_lock_irqsave(hba->host->host_lock, flags);
> +
> +	seq_puts(file, "\n==UFS errors that caused controller reset==\n");
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_HIBERN8_EXIT,
> +			"controller reset due to hibern8 exit error:\t
> %d\n",
> +			error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_VOPS_SUSPEND,
> +			"controller reset due to vops suspend error:\t\t
> %d\n",
> +			error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_EH,
> +			"controller reset due to error handling:\t\t
> %d\n",
> +			error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_CLEAR_PEND_XFER_TM,
> +			"controller reset due to clear xfer/tm regs:\t\t
> %d\n",
> +			error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_INT_FATAL_ERRORS,
> +			"controller reset due to fatal interrupt:\t %d\n",
> +			error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_INT_UIC_ERROR,
> +			"controller reset due to uic interrupt error:\t
> %d\n",
> +			error_seen);
> +
> +	if (error_seen)
> +		error_seen = false;
> +	else
> +		seq_puts(file,
> +			"so far, no errors that caused controller
> reset\n\n");
> +
> +	seq_puts(file, "\n\n==UFS other errors==\n");
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_HIBERN8_ENTER,
> +			"hibern8 enter:\t\t %d\n", error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_RESUME,
> +			"resume error:\t\t %d\n", error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_SUSPEND,
> +			"suspend error:\t\t %d\n", error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_LINKSTARTUP,
> +			"linkstartup error:\t\t %d\n", error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_POWER_MODE_CHANGE,
> +			"power change error:\t %d\n", error_seen);
> +
> +	UFS_ERR_STATS_PRINT(file, UFS_ERR_TASK_ABORT,
> +			"abort callback:\t\t %d\n\n", error_seen);
> +
> +	if (!error_seen)
> +		seq_puts(file,
> +		"so far, no other UFS related errors\n\n");
> +
> +	spin_unlock_irqrestore(hba->host->host_lock, flags);
> +exit:
> +	return 0;
> +}
> +
> +static int ufsdbg_err_stats_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, ufsdbg_err_stats_show, inode->i_private);
> +}
> +
> +static ssize_t ufsdbg_err_stats_write(struct file *filp,
> +				      const char __user *ubuf, size_t cnt,
> +				       loff_t *ppos)
> +{
> +	struct ufs_hba *hba = filp->f_mapping->host->i_private;
> +	struct ufs_stats *ufs_stats;
> +	unsigned long flags;
> +
> +	ufs_stats = &hba->ufs_stats;
> +	spin_lock_irqsave(hba->host->host_lock, flags);
> +
> +	pr_debug("%s: Resetting UFS error statistics", __func__);
> +	memset(ufs_stats->err_stats, 0, sizeof(hba->ufs_stats.err_stats));
> +
> +	spin_unlock_irqrestore(hba->host->host_lock, flags);
> +	return cnt;
> +}
> +
> +static const struct file_operations ufsdbg_err_stats_fops = {
> +	.open		= ufsdbg_err_stats_open,
> +	.read		= seq_read,
> +	.write		= ufsdbg_err_stats_write,
> +};
> +
> +static int ufshcd_init_statistics(struct ufs_hba *hba)
> +{
> +	struct ufs_stats *stats = &hba->ufs_stats;
> +	int ret = 0;
> +	int i;
> +
> +	stats->enabled = false;
> +	stats->tag_stats = kcalloc(hba->nutrs, sizeof(*stats->tag_stats),
> +			GFP_KERNEL);
> +	if (!hba->ufs_stats.tag_stats)
> +		goto no_mem;
> +
> +	stats->tag_stats[0] = kzalloc(sizeof(**stats->tag_stats) *
> +			TS_NUM_STATS * hba->nutrs, GFP_KERNEL);
> +	if (!stats->tag_stats[0])
> +		goto no_mem;
> +
> +	for (i = 1; i < hba->nutrs; i++)
> +		stats->tag_stats[i] = &stats->tag_stats[0][i *
> TS_NUM_STATS];
> +
> +	memset(stats->err_stats, 0, sizeof(hba->ufs_stats.err_stats));
> +
> +	goto exit;
> +
> +no_mem:
> +	dev_err(hba->dev, "%s: Unable to allocate UFS tag_stats",
> __func__);
> +	ret = -ENOMEM;
> +exit:
> +	return ret;
> +}
> +
> +static void
> +ufsdbg_pr_buf_to_std(struct seq_file *file, void *buff, int size, char
> *str)
> +{
> +	int i;
> +	char linebuf[38];
> +	int lines = size/BUFF_LINE_CAPACITY +
> +			(size % BUFF_LINE_CAPACITY ? 1 : 0);
> +
> +	for (i = 0; i < lines; i++) {
> +		hex_dump_to_buffer(buff + i * BUFF_LINE_CAPACITY,
> +				BUFF_LINE_CAPACITY, BUFF_LINE_CAPACITY, 4,
> +				linebuf, sizeof(linebuf), false);
> +		seq_printf(file, "%s [%x]: %s\n", str, i *
> BUFF_LINE_CAPACITY,
> +				linebuf);
> +	}
> +}
> +
> +static int ufsdbg_host_regs_show(struct seq_file *file, void *data)
> +{
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +
> +	ufshcd_hold(hba, false);
> +	pm_runtime_get_sync(hba->dev);
> +	ufsdbg_pr_buf_to_std(file, hba->mmio_base, UFSHCI_REG_SPACE_SIZE,
> +				"host regs");
> +	pm_runtime_put_sync(hba->dev);
> +	ufshcd_release(hba);
> +	return 0;
> +}
> +
> +static int ufsdbg_host_regs_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, ufsdbg_host_regs_show, inode->i_private);
> +}
> +
> +static const struct file_operations ufsdbg_host_regs_fops = {
> +	.open		= ufsdbg_host_regs_open,
> +	.read		= seq_read,
> +};
> +
> +static int ufsdbg_dump_device_desc_show(struct seq_file *file, void
> *data)
> +{
> +	int err = 0;
> +	int buff_len = QUERY_DESC_DEVICE_MAX_SIZE;
> +	u8 desc_buf[QUERY_DESC_DEVICE_MAX_SIZE];
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +
> +	struct desc_field_offset device_desc_field_name[] = {
> +		{"bLength",		0x00, BYTE},
> +		{"bDescriptorType",	0x01, BYTE},
> +		{"bDevice",		0x02, BYTE},
> +		{"bDeviceClass",	0x03, BYTE},
> +		{"bDeviceSubClass",	0x04, BYTE},
> +		{"bProtocol",		0x05, BYTE},
> +		{"bNumberLU",		0x06, BYTE},
> +		{"bNumberWLU",		0x07, BYTE},
> +		{"bBootEnable",		0x08, BYTE},
> +		{"bDescrAccessEn",	0x09, BYTE},
> +		{"bInitPowerMode",	0x0A, BYTE},
> +		{"bHighPriorityLUN",	0x0B, BYTE},
> +		{"bSecureRemovalType",	0x0C, BYTE},
> +		{"bSecurityLU",		0x0D, BYTE},
> +		{"Reserved",		0x0E, BYTE},
> +		{"bInitActiveICCLevel",	0x0F, BYTE},
> +		{"wSpecVersion",	0x10, WORD},
> +		{"wManufactureDate",	0x12, WORD},
> +		{"iManufactureName",	0x14, BYTE},
> +		{"iProductName",	0x15, BYTE},
> +		{"iSerialNumber",	0x16, BYTE},
> +		{"iOemID",		0x17, BYTE},
> +		{"wManufactureID",	0x18, WORD},
> +		{"bUD0BaseOffset",	0x1A, BYTE},
> +		{"bUDConfigPLength",	0x1B, BYTE},
> +		{"bDeviceRTTCap",	0x1C, BYTE},
> +		{"wPeriodicRTCUpdate",	0x1D, WORD}
> +	};
> +
> +	pm_runtime_get_sync(hba->dev);
> +	err = ufshcd_read_device_desc(hba, desc_buf, buff_len);
> +	pm_runtime_put_sync(hba->dev);
> +
> +	if (!err) {
> +		int i;
> +		struct desc_field_offset *tmp;
> +
> +		for (i = 0; i < ARRAY_SIZE(device_desc_field_name); ++i) {
> +			tmp = &device_desc_field_name[i];
> +
> +			if (tmp->width_byte == BYTE) {
> +				seq_printf(file,
> +					   "Device Descriptor[Byte offset
> 0x%x]: %s = 0x%x\n",
> +					   tmp->offset,
> +					   tmp->name,
> +					   (u8)desc_buf[tmp->offset]);
> +			} else if (tmp->width_byte == WORD) {
> +				seq_printf(file,
> +					   "Device Descriptor[Byte offset
> 0x%x]: %s = 0x%x\n",
> +					   tmp->offset,
> +					   tmp->name,
> +					   *(u16
> *)&desc_buf[tmp->offset]);
> +			} else {
> +				seq_printf(file,
> +				"Device Descriptor[offset 0x%x]: %s. Wrong
> Width = %d",
> +				tmp->offset, tmp->name, tmp->width_byte);
> +			}
> +		}
> +	} else {
> +		seq_printf(file, "Reading Device Descriptor failed. err =
> %d\n",
> +			   err);
> +	}
> +
> +	return err;
> +}
> +
> +static int ufsdbg_show_hba_show(struct seq_file *file, void *data)
> +{
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +
> +	seq_printf(file, "hba->outstanding_tasks = 0x%x\n",
> +			(u32)hba->outstanding_tasks);
> +	seq_printf(file, "hba->outstanding_reqs = 0x%x\n",
> +			(u32)hba->outstanding_reqs);
> +
> +	seq_printf(file, "hba->capabilities = 0x%x\n", hba->capabilities);
> +	seq_printf(file, "hba->nutrs = %d\n", hba->nutrs);
> +	seq_printf(file, "hba->nutmrs = %d\n", hba->nutmrs);
> +	seq_printf(file, "hba->ufs_version = 0x%x\n", hba->ufs_version);
> +	seq_printf(file, "hba->irq = 0x%x\n", hba->irq);
> +	seq_printf(file, "hba->auto_bkops_enabled = %d\n",
> +			hba->auto_bkops_enabled);
> +
> +	seq_printf(file, "hba->ufshcd_state = 0x%x\n", hba->ufshcd_state);
> +	seq_printf(file, "hba->clk_gating.state = 0x%x\n",
> +			hba->clk_gating.state);
> +	seq_printf(file, "hba->eh_flags = 0x%x\n", hba->eh_flags);
> +	seq_printf(file, "hba->intr_mask = 0x%x\n", hba->intr_mask);
> +	seq_printf(file, "hba->ee_ctrl_mask = 0x%x\n", hba->ee_ctrl_mask);
> +
> +	/* HBA Errors */
> +	seq_printf(file, "hba->errors = 0x%x\n", hba->errors);
> +	seq_printf(file, "hba->uic_error = 0x%x\n", hba->uic_error);
> +	seq_printf(file, "hba->saved_err = 0x%x\n", hba->saved_err);
> +	seq_printf(file, "hba->saved_uic_err = 0x%x\n",
> hba->saved_uic_err);
> +
> +	return 0;
> +}
> +
> +static int ufsdbg_show_hba_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, ufsdbg_show_hba_show, inode->i_private);
> +}
> +
> +static const struct file_operations ufsdbg_show_hba_fops = {
> +	.open		= ufsdbg_show_hba_open,
> +	.read		= seq_read,
> +};
> +
> +static int ufsdbg_dump_device_desc_open(struct inode *inode, struct file
> *file)
> +{
> +	return single_open(file,
> +			   ufsdbg_dump_device_desc_show,
> inode->i_private);
> +}
> +
> +static const struct file_operations ufsdbg_dump_device_desc = {
> +	.open		= ufsdbg_dump_device_desc_open,
> +	.read		= seq_read,
> +};
> +
> +static int ufsdbg_power_mode_show(struct seq_file *file, void *data)
> +{
> +	struct ufs_hba *hba = (struct ufs_hba *)file->private;
> +	static const char * const names[] = {
> +		"INVALID MODE",
> +		"FAST MODE",
> +		"SLOW MODE",
> +		"INVALID MODE",
> +		"FASTAUTO MODE",
> +		"SLOWAUTO MODE",
> +		"INVALID MODE",
> +	};
> +
> +	/* Print current status */
> +	seq_puts(file, "UFS current power mode [RX, TX]:");
> +	seq_printf(file, "gear=[%d,%d], lane=[%d,%d], pwr=[%s,%s], rate =
> %c",
> +		 hba->pwr_info.gear_rx, hba->pwr_info.gear_tx,
> +		 hba->pwr_info.lane_rx, hba->pwr_info.lane_tx,
> +		 names[hba->pwr_info.pwr_rx],
> +		 names[hba->pwr_info.pwr_tx],
> +		 hba->pwr_info.hs_rate == PA_HS_MODE_B ? 'B' : 'A');
> +	seq_puts(file, "\n\n");
> +
> +	/* Print usage */
> +	seq_puts(file,
> +		"To change power mode write 'GGLLMM' where:\n"
> +		"G - selected gear\n"
> +		"L - number of lanes\n"
> +		"M - power mode:\n"
> +		"\t1 = fast mode\n"
> +		"\t2 = slow mode\n"
> +		"\t4 = fast-auto mode\n"
> +		"\t5 = slow-auto mode\n"
> +		"first letter is for RX, second letter is for TX.\n\n");
> +
> +	return 0;
> +}
> +
> +static bool ufsdbg_power_mode_validate(struct ufs_pa_layer_attr
> *pwr_mode)
> +{
> +	if (pwr_mode->gear_rx < UFS_PWM_G1 || pwr_mode->gear_rx >
> UFS_PWM_G7 ||
> +	    pwr_mode->gear_tx < UFS_PWM_G1 || pwr_mode->gear_tx >
> UFS_PWM_G7 ||
> +	    pwr_mode->lane_rx < 1 || pwr_mode->lane_rx > 2 ||
> +	    pwr_mode->lane_tx < 1 || pwr_mode->lane_tx > 2 ||
> +	    (pwr_mode->pwr_rx != FAST_MODE && pwr_mode->pwr_rx !=
> SLOW_MODE &&
> +	     pwr_mode->pwr_rx != FASTAUTO_MODE &&
> +	     pwr_mode->pwr_rx != SLOWAUTO_MODE) ||
> +	    (pwr_mode->pwr_tx != FAST_MODE && pwr_mode->pwr_tx !=
> SLOW_MODE &&
> +	     pwr_mode->pwr_tx != FASTAUTO_MODE &&
> +	     pwr_mode->pwr_tx != SLOWAUTO_MODE)) {
> +		pr_err("%s: power parameters are not valid\n", __func__);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
> +static int ufsdbg_cfg_pwr_param(struct ufs_hba *hba,
> +				struct ufs_pa_layer_attr *new_pwr,
> +				struct ufs_pa_layer_attr *final_pwr)
> +{
> +	int ret = 0;
> +	bool is_dev_sup_hs = false;
> +	bool is_new_pwr_hs = false;
> +	int dev_pwm_max_rx_gear;
> +	int dev_pwm_max_tx_gear;
> +
> +	if (!hba->max_pwr_info.is_valid) {
> +		dev_err(hba->dev, "%s: device max power is not valid.
> can't configure power\n",
> +			__func__);
> +		return -EINVAL;
> +	}
> +
> +	if (hba->max_pwr_info.info.pwr_rx == FAST_MODE)
> +		is_dev_sup_hs = true;
> +
> +	if (new_pwr->pwr_rx == FAST_MODE || new_pwr->pwr_rx ==
> FASTAUTO_MODE)
> +		is_new_pwr_hs = true;
> +
> +	final_pwr->lane_rx = hba->max_pwr_info.info.lane_rx;
> +	final_pwr->lane_tx = hba->max_pwr_info.info.lane_tx;
> +
> +	/* device doesn't support HS but requested power is HS */
> +	if (!is_dev_sup_hs && is_new_pwr_hs) {
> +		pr_err("%s: device doesn't support HS. requested power is
> HS\n",
> +			__func__);
> +		return -ENOTSUPP;
> +	} else if ((is_dev_sup_hs && is_new_pwr_hs) ||
> +		   (!is_dev_sup_hs && !is_new_pwr_hs)) {
> +		/*
> +		 * If device and requested power mode are both HS or both
> PWM
> +		 * then dev_max->gear_xx are the gears to be assign to
> +		 * final_pwr->gear_xx
> +		 */
> +		final_pwr->gear_rx = hba->max_pwr_info.info.gear_rx;
> +		final_pwr->gear_tx = hba->max_pwr_info.info.gear_tx;
> +	} else if (is_dev_sup_hs && !is_new_pwr_hs) {
> +		/*
> +		 * If device supports HS but requested power is PWM, then
> we
> +		 * need to find out what is the max gear in PWM the device
> +		 * supports
> +		 */
> +
> +		ufshcd_dme_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR),
> +			       &dev_pwm_max_rx_gear);
> +
> +		if (!dev_pwm_max_rx_gear) {
> +			pr_err("%s: couldn't get device max pwm rx
> gear\n",
> +				__func__);
> +			ret = -EINVAL;
> +			goto out;
> +		}
> +
> +		ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR),
> +				    &dev_pwm_max_tx_gear);
> +
> +		if (!dev_pwm_max_tx_gear) {
> +			pr_err("%s: couldn't get device max pwm tx
> gear\n",
> +				__func__);
> +			ret = -EINVAL;
> +			goto out;
> +		}
> +
> +		final_pwr->gear_rx = dev_pwm_max_rx_gear;
> +		final_pwr->gear_tx = dev_pwm_max_tx_gear;
> +	}
> +
> +	if ((new_pwr->gear_rx > final_pwr->gear_rx) ||
> +	    (new_pwr->gear_tx > final_pwr->gear_tx) ||
> +	    (new_pwr->lane_rx > final_pwr->lane_rx) ||
> +	    (new_pwr->lane_tx > final_pwr->lane_tx)) {
> +		pr_err("%s: (RX,TX) GG,LL: in PWM/HS new pwr [%d%d,%d%d]
> exceeds device limitation [%d%d,%d%d]\n",
> +			__func__,
> +			new_pwr->gear_rx, new_pwr->gear_tx,
> +			new_pwr->lane_rx, new_pwr->lane_tx,
> +			final_pwr->gear_rx, final_pwr->gear_tx,
> +			final_pwr->lane_rx, final_pwr->lane_tx);
> +		return -ENOTSUPP;
> +	}
> +
> +	final_pwr->gear_rx = new_pwr->gear_rx;
> +	final_pwr->gear_tx = new_pwr->gear_tx;
> +	final_pwr->lane_rx = new_pwr->lane_rx;
> +	final_pwr->lane_tx = new_pwr->lane_tx;
> +	final_pwr->pwr_rx = new_pwr->pwr_rx;
> +	final_pwr->pwr_tx = new_pwr->pwr_tx;
> +	final_pwr->hs_rate = new_pwr->hs_rate;
> +
> +out:
> +	return ret;
> +}
> +
> +static int ufsdbg_config_pwr_mode(struct ufs_hba *hba,
> +		struct ufs_pa_layer_attr *desired_pwr_mode)
> +{
> +	int ret;
> +
> +	pm_runtime_get_sync(hba->dev);
> +	scsi_block_requests(hba->host);
> +	ret = ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US);
> +	if (!ret)
> +		ret = ufshcd_change_power_mode(hba, desired_pwr_mode);
> +	scsi_unblock_requests(hba->host);
> +	pm_runtime_put_sync(hba->dev);
> +
> +	return ret;
> +}
> +
> +static ssize_t ufsdbg_power_mode_write(struct file *file,
> +				const char __user *ubuf, size_t cnt,
> +				loff_t *ppos)
> +{
> +	struct ufs_hba *hba = file->f_mapping->host->i_private;
> +	struct ufs_pa_layer_attr pwr_mode;
> +	struct ufs_pa_layer_attr final_pwr_mode;
> +	char pwr_mode_str[BUFF_LINE_CAPACITY] = {0};
> +	loff_t buff_pos = 0;
> +	int ret;
> +	int idx = 0;
> +
> +	ret = simple_write_to_buffer(pwr_mode_str, BUFF_LINE_CAPACITY,
> +		&buff_pos, ubuf, cnt);
> +
> +	pwr_mode.gear_rx = pwr_mode_str[idx++] - '0';
> +	pwr_mode.gear_tx = pwr_mode_str[idx++] - '0';
> +	pwr_mode.lane_rx = pwr_mode_str[idx++] - '0';
> +	pwr_mode.lane_tx = pwr_mode_str[idx++] - '0';
> +	pwr_mode.pwr_rx = pwr_mode_str[idx++] - '0';
> +	pwr_mode.pwr_tx = pwr_mode_str[idx++] - '0';
> +
> +	/*
> +	 * Switching between rates is not currently supported so use the
> +	 * current rate.
> +	 * TODO: add rate switching if and when it is supported in the
> future
> +	 */
> +	pwr_mode.hs_rate = hba->pwr_info.hs_rate;
> +
> +	/* Validate user input */
> +	if (!ufsdbg_power_mode_validate(&pwr_mode))
> +		return -EINVAL;
> +
> +	pr_debug("%s: new power mode requested [RX,TX]: Gear=[%d,%d],
> Lane=[%d,%d], Mode=[%d,%d]\n",
> +		__func__,
> +		pwr_mode.gear_rx, pwr_mode.gear_tx, pwr_mode.lane_rx,
> +		pwr_mode.lane_tx, pwr_mode.pwr_rx, pwr_mode.pwr_tx);
> +
> +	ret = ufsdbg_cfg_pwr_param(hba, &pwr_mode, &final_pwr_mode);
> +	if (ret) {
> +		dev_err(hba->dev,
> +			"%s: failed to configure new power parameters, ret
> = %d\n",
> +			__func__, ret);
> +		return cnt;
> +	}
> +
> +	ret = ufsdbg_config_pwr_mode(hba, &final_pwr_mode);
> +	if (ret == -EBUSY)
> +		dev_err(hba->dev,
> +			"%s: ufshcd_config_pwr_mode failed: system is
> busy, try again\n",
> +			__func__);
> +	else if (ret)
> +		dev_err(hba->dev,
> +			"%s: ufshcd_config_pwr_mode failed, ret=%d\n",
> +			__func__, ret);
> +
> +	return cnt;
> +}
> +
> +static int ufsdbg_power_mode_open(struct inode *inode, struct file *file)
> +{
> +	return single_open(file, ufsdbg_power_mode_show,
> inode->i_private);
> +}
> +
> +static const struct file_operations ufsdbg_power_mode_desc = {
> +	.open		= ufsdbg_power_mode_open,
> +	.read		= seq_read,
> +	.write		= ufsdbg_power_mode_write,
> +};
> +
> +static int ufsdbg_dme_read(void *data, u64 *attr_val, bool peer)
> +{
> +	int ret;
> +	struct ufs_hba *hba = data;
> +	u32 attr_id, read_val = 0;
> +	int (*read_func)(struct ufs_hba *, u32, u32 *);
> +
> +	if (!hba)
> +		return -EINVAL;
> +
> +	read_func = peer ? ufshcd_dme_peer_get : ufshcd_dme_get;
> +	attr_id = peer ? hba->debugfs_files.dme_peer_attr_id :
> +			 hba->debugfs_files.dme_local_attr_id;
> +	pm_runtime_get_sync(hba->dev);
> +	scsi_block_requests(hba->host);
> +	ret = ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US);
> +	if (!ret)
> +		ret = read_func(hba, UIC_ARG_MIB(attr_id), &read_val);
> +	scsi_unblock_requests(hba->host);
> +	pm_runtime_put_sync(hba->dev);
> +
> +	if (!ret)
> +		*attr_val = (u64)read_val;
> +
> +	return ret;
> +}
> +
> +static int ufsdbg_dme_local_set_attr_id(void *data, u64 attr_id)
> +{
> +	struct ufs_hba *hba = data;
> +
> +	if (!hba)
> +		return -EINVAL;
> +
> +	hba->debugfs_files.dme_local_attr_id = (u32)attr_id;
> +
> +	return 0;
> +}
> +
> +static int ufsdbg_dme_local_read(void *data, u64 *attr_val)
> +{
> +	return ufsdbg_dme_read(data, attr_val, false);
> +}
> +
> +DEFINE_SIMPLE_ATTRIBUTE(ufsdbg_dme_local_read_ops,
> +			ufsdbg_dme_local_read,
> +			ufsdbg_dme_local_set_attr_id,
> +			"%llu\n");
> +
> +static int ufsdbg_dme_peer_read(void *data, u64 *attr_val)
> +{
> +	struct ufs_hba *hba = data;
> +
> +	if (!hba)
> +		return -EINVAL;
> +	else
> +		return ufsdbg_dme_read(data, attr_val, true);
> +}
> +
> +static int ufsdbg_dme_peer_set_attr_id(void *data, u64 attr_id)
> +{
> +	struct ufs_hba *hba = data;
> +
> +	if (!hba)
> +		return -EINVAL;
> +
> +	hba->debugfs_files.dme_peer_attr_id = (u32)attr_id;
> +
> +	return 0;
> +}
> +
> +DEFINE_SIMPLE_ATTRIBUTE(ufsdbg_dme_peer_read_ops,
> +			ufsdbg_dme_peer_read,
> +			ufsdbg_dme_peer_set_attr_id,
> +			"%llu\n");
> +
> +void ufsdbg_add_debugfs(struct ufs_hba *hba)
> +{
> +	char root_name[32];
> +
> +	if (!hba) {
> +		pr_err("%s: NULL hba, exiting\n", __func__);
> +		return;
> +	}
> +
> +	snprintf(root_name, 32, "%s%d", UFSHCD, hba->host->host_no);
> +
> +	hba->debugfs_files.debugfs_root = debugfs_create_dir(root_name,
> NULL);
> +	if (IS_ERR(hba->debugfs_files.debugfs_root))
> +		/* Don't complain -- debugfs just isn't enabled */
> +		goto err_no_root;
> +	if (!hba->debugfs_files.debugfs_root) {
> +		/*
> +		 * Complain -- debugfs is enabled, but it failed to
> +		 * create the directory
> +		 */
> +		dev_err(hba->dev,
> +			"%s: NULL debugfs root directory, exiting",
> __func__);
> +		goto err_no_root;
> +	}
> +
> +	hba->debugfs_files.tag_stats =
> +		debugfs_create_file("tag_stats", S_IRUSR,
> +
> hba->debugfs_files.debugfs_root, hba,
> +					   &ufsdbg_tag_stats_fops);
> +	if (!hba->debugfs_files.tag_stats) {
> +		dev_err(hba->dev, "%s:  NULL tag stats file, exiting",
> +			__func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.err_stats =
> +		debugfs_create_file("err_stats", S_IRUSR,
> +
> hba->debugfs_files.debugfs_root, hba,
> +					   &ufsdbg_err_stats_fops);
> +	if (!hba->debugfs_files.err_stats) {
> +		dev_err(hba->dev, "%s:  NULL err stats file, exiting",
> +			__func__);
> +		goto err;
> +	}
> +
> +	if (ufshcd_init_statistics(hba)) {
> +		dev_err(hba->dev, "%s: Error initializing statistics",
> +			__func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.host_regs = debugfs_create_file("host_regs",
> S_IRUSR,
> +				hba->debugfs_files.debugfs_root, hba,
> +				&ufsdbg_host_regs_fops);
> +	if (!hba->debugfs_files.host_regs) {
> +		dev_err(hba->dev, "%s:  NULL hcd regs file, exiting",
> __func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.show_hba = debugfs_create_file("show_hba",
> S_IRUSR,
> +				hba->debugfs_files.debugfs_root, hba,
> +				&ufsdbg_show_hba_fops);
> +	if (!hba->debugfs_files.show_hba) {
> +		dev_err(hba->dev, "%s:  NULL hba file, exiting",
> __func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.dump_dev_desc =
> +		debugfs_create_file("dump_device_desc", S_IRUSR,
> +				    hba->debugfs_files.debugfs_root, hba,
> +				    &ufsdbg_dump_device_desc);
> +	if (!hba->debugfs_files.dump_dev_desc) {
> +		dev_err(hba->dev,
> +			"%s:  NULL dump_device_desc file, exiting",
> __func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.power_mode =
> +		debugfs_create_file("power_mode", S_IRUSR | S_IWUSR,
> +				    hba->debugfs_files.debugfs_root, hba,
> +				    &ufsdbg_power_mode_desc);
> +	if (!hba->debugfs_files.power_mode) {
> +		dev_err(hba->dev,
> +			"%s:  NULL power_mode_desc file, exiting",
> __func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.dme_local_read =
> +		debugfs_create_file("dme_local_read", S_IRUSR | S_IWUSR,
> +				    hba->debugfs_files.debugfs_root, hba,
> +				    &ufsdbg_dme_local_read_ops);
> +	if (!hba->debugfs_files.dme_local_read) {
> +		dev_err(hba->dev,
> +			"%s:  failed create dme_local_read debugfs
> entry\n",
> +			__func__);
> +		goto err;
> +	}
> +
> +	hba->debugfs_files.dme_peer_read =
> +		debugfs_create_file("dme_peer_read", S_IRUSR | S_IWUSR,
> +				    hba->debugfs_files.debugfs_root, hba,
> +				    &ufsdbg_dme_peer_read_ops);
> +	if (!hba->debugfs_files.dme_peer_read) {
> +		dev_err(hba->dev,
> +			"%s:  failed create dme_peer_read debugfs
> entry\n",
> +			__func__);
> +		goto err;
> +	}
> +
> +	return;
> +
> +err:
> +	debugfs_remove_recursive(hba->debugfs_files.debugfs_root);
> +	hba->debugfs_files.debugfs_root = NULL;
> +err_no_root:
> +	dev_err(hba->dev, "%s: failed to initialize debugfs\n", __func__);
> +}
> +
> +void ufsdbg_remove_debugfs(struct ufs_hba *hba)
> +{
> +	debugfs_remove_recursive(hba->debugfs_files.debugfs_root);
> +	kfree(hba->ufs_stats.tag_stats);
> +
> +}
> diff --git a/drivers/scsi/ufs/ufs-debugfs.h
> b/drivers/scsi/ufs/ufs-debugfs.h
> new file mode 100644
> index 0000000..7ed308d
> --- /dev/null
> +++ b/drivers/scsi/ufs/ufs-debugfs.h
> @@ -0,0 +1,38 @@
> +/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * UFS debugfs - add debugfs interface to the ufshcd.
> + * This is currently used for statistics collection and exporting from
> the
> + * UFS driver.
> + * This infrastructure can be used for debugging or direct tweaking
> + * of the driver from userspace.
> + *
> + */
> +
> +#ifndef _UFS_DEBUGFS_H
> +#define _UFS_DEBUGFS_H
> +
> +#include <linux/debugfs.h>
> +#include "ufshcd.h"
> +
> +#ifdef CONFIG_DEBUG_FS
> +void ufsdbg_add_debugfs(struct ufs_hba *hba);
> +void ufsdbg_remove_debugfs(struct ufs_hba *hba);
> +#else
> +static inline void ufsdbg_add_debugfs(struct ufs_hba *hba)
> +{
> +}
> +static inline void ufsdbg_remove_debugfs(struct ufs_hba *hba)
> +{
> +}
> +#endif
> +
> +#endif /* End of Header */
> diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
> index cb357f8..84caf6d 100644
> --- a/drivers/scsi/ufs/ufshcd.c
> +++ b/drivers/scsi/ufs/ufshcd.c
> @@ -43,6 +43,55 @@
>
>  #include "ufshcd.h"
>  #include "unipro.h"
> +#include "ufs-debugfs.h"
> +
> +#ifdef CONFIG_DEBUG_FS
> +
> +#define UFSHCD_UPDATE_ERROR_STATS(hba, type)	\
> +	do {					\
> +		if (type < UFS_ERR_MAX)	\
> +			hba->ufs_stats.err_stats[type]++;	\
> +	} while (0)
> +
> +#define UFSHCD_UPDATE_TAG_STATS(hba, tag)			\
> +	do {							\
> +		struct request *rq = hba->lrb[task_tag].cmd ?	\
> +			hba->lrb[task_tag].cmd->request : NULL;	\
> +		u64 **tag_stats = hba->ufs_stats.tag_stats;	\
> +		int rq_type = -1;				\
> +		if (!hba->ufs_stats.enabled)			\
> +			break;					\
> +		tag_stats[tag][TS_TAG]++;			\
> +		if (!rq)					\
> +			break;					\
> +		WARN_ON(hba->ufs_stats.q_depth > hba->nutrs);	\
> +		if (rq_data_dir(rq) == READ)			\
> +			rq_type = TS_READ;			\
> +		else if (rq_data_dir(rq) == WRITE)		\
> +			rq_type = TS_WRITE;			\
> +		else if (rq->cmd_flags & REQ_FLUSH)		\
> +			rq_type = TS_FLUSH;			\
> +		else						\
> +			break;					\
> +		tag_stats[hba->ufs_stats.q_depth++][rq_type]++;	\
> +	} while (0)
> +
> +#define UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd)		\
> +	do {							\
> +		struct request *rq = cmd ? cmd->request : NULL;	\
> +		if (cmd->request &&				\
> +				((rq_data_dir(rq) == READ) ||	\
> +				(rq_data_dir(rq) == WRITE) ||	\
> +				(rq->cmd_flags & REQ_FLUSH)))	\
> +			hba->ufs_stats.q_depth--;		\
> +	} while (0)
> +
> +#else
> +#define UFSHCD_UPDATE_TAG_STATS(hba, tag)
> +#define UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd)
> +#define UFSHCD_UPDATE_ERROR_STATS(hba, type)
> +
> +#endif
>
>  #define UFSHCD_ENABLE_INTRS	(UTP_TRANSFER_REQ_COMPL |\
>  				 UTP_TASK_REQ_COMPL |\
> @@ -50,6 +99,9 @@
>  /* UIC command timeout, unit: ms */
>  #define UIC_CMD_TIMEOUT	500
>
> +/* Retries waiting for doorbells to clear */
> +#define POWER_MODE_RETRIES	10
> +
>  /* NOP OUT retries waiting for NOP IN response */
>  #define NOP_OUT_RETRIES    10
>  /* Timeout after 30 msecs if NOP OUT hangs without response */
> @@ -189,8 +241,6 @@ static int ufshcd_uic_hibern8_exit(struct ufs_hba
> *hba);
>  static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba);
>  static int ufshcd_host_reset_and_restore(struct ufs_hba *hba);
>  static irqreturn_t ufshcd_intr(int irq, void *__hba);
> -static int ufshcd_config_pwr_mode(struct ufs_hba *hba,
> -		struct ufs_pa_layer_attr *desired_pwr_mode);
>
>  static inline int ufshcd_enable_irq(struct ufs_hba *hba)
>  {
> @@ -789,6 +839,7 @@ void ufshcd_send_command(struct ufs_hba *hba, unsigned
> int task_tag)
>  	ufshcd_clk_scaling_start_busy(hba);
>  	__set_bit(task_tag, &hba->outstanding_reqs);
>  	ufshcd_writel(hba, 1 << task_tag, REG_UTP_TRANSFER_REQ_DOOR_BELL);
> +	UFSHCD_UPDATE_TAG_STATS(hba, task_tag);
>  }
>
>  /**
> @@ -975,6 +1026,7 @@ ufshcd_send_uic_cmd(struct ufs_hba *hba, struct
> uic_command *uic_cmd)
>  	unsigned long flags;
>
>  	ufshcd_hold(hba, false);
> +	pm_runtime_get_sync(hba->dev);
>  	mutex_lock(&hba->uic_cmd_mutex);
>  	spin_lock_irqsave(hba->host->host_lock, flags);
>  	ret = __ufshcd_send_uic_cmd(hba, uic_cmd);
> @@ -983,7 +1035,7 @@ ufshcd_send_uic_cmd(struct ufs_hba *hba, struct
> uic_command *uic_cmd)
>  		ret = ufshcd_wait_for_uic_cmd(hba, uic_cmd);
>
>  	mutex_unlock(&hba->uic_cmd_mutex);
> -
> +	pm_runtime_put_sync(hba->dev);
>  	ufshcd_release(hba);
>  	return ret;
>  }
> @@ -1866,6 +1918,27 @@ static inline int ufshcd_read_power_desc(struct
> ufs_hba *hba,
>  	return ufshcd_read_desc(hba, QUERY_DESC_IDN_POWER, 0, buf, size);
>  }
>
> +int ufshcd_read_device_desc(struct ufs_hba *hba, u8 *buf, u32 size)
> +{
> +	int err = 0;
> +	int retries;
> +
> +	for (retries = QUERY_REQ_RETRIES; retries > 0; retries--) {
> +		/* Read descriptor*/
> +		err = ufshcd_read_desc(hba,
> +				       QUERY_DESC_IDN_DEVICE, 0, buf,
> size);
> +		if (!err)
> +			break;
> +		dev_dbg(hba->dev, "%s: error %d retrying\n", __func__,
> err);
> +	}
> +
> +	if (err)
> +		dev_err(hba->dev, "%s: reading Device Desc failed. err =
> %d\n",
> +			__func__, err);
> +
> +	return err;
> +}
> +
>  /**
>   * ufshcd_read_unit_desc_param - read the specified unit descriptor
> parameter
>   * @hba: Pointer to adapter instance
> @@ -2158,11 +2231,42 @@ static int ufshcd_uic_pwr_ctrl(struct ufs_hba
> *hba, struct uic_command *cmd)
>  	unsigned long flags;
>  	u8 status;
>  	int ret;
> +	u32 tm_doorbell;
> +	u32 tr_doorbell;
> +	bool uic_ready;
> +	int retries = POWER_MODE_RETRIES;
>
> +	ufshcd_hold(hba, false);
> +	pm_runtime_get_sync(hba->dev);
>  	mutex_lock(&hba->uic_cmd_mutex);
>  	init_completion(&uic_async_done);
>
> -	spin_lock_irqsave(hba->host->host_lock, flags);
> +	/*
> +	 * Before changing the power mode there should be no outstanding
> +	 * tasks/transfer requests. Verify by checking the doorbell
> registers
> +	 * are clear.
> +	 */
> +	do {
> +		spin_lock_irqsave(hba->host->host_lock, flags);
> +		uic_ready = ufshcd_ready_for_uic_cmd(hba);
> +		tm_doorbell = ufshcd_readl(hba,
> REG_UTP_TASK_REQ_DOOR_BELL);
> +		tr_doorbell = ufshcd_readl(hba,
> REG_UTP_TRANSFER_REQ_DOOR_BELL);
> +		if (!tm_doorbell && !tr_doorbell && uic_ready)
> +			break;
> +
> +		spin_unlock_irqrestore(hba->host->host_lock, flags);
> +		schedule();
> +		retries--;
> +	} while (retries && (tm_doorbell || tr_doorbell || !uic_ready));
> +
> +	if (!retries) {
> +		dev_err(hba->dev,
> +			"%s: too many retries waiting for doorbell to
> clear (tm=0x%x, tr=0x%x, uicrdy=%d)\n",
> +			__func__, tm_doorbell, tr_doorbell, uic_ready);
> +		ret = -EBUSY;
> +		goto out;
> +	}
> +
>  	hba->uic_async_done = &uic_async_done;
>  	ret = __ufshcd_send_uic_cmd(hba, cmd);
>  	spin_unlock_irqrestore(hba->host->host_lock, flags);
> @@ -2201,7 +2305,56 @@ out:
>  	hba->uic_async_done = NULL;
>  	spin_unlock_irqrestore(hba->host->host_lock, flags);
>  	mutex_unlock(&hba->uic_cmd_mutex);
> +	pm_runtime_put_sync(hba->dev);
> +	ufshcd_release(hba);
> +	return ret;
> +}
> +
> +int ufshcd_wait_for_doorbell_clr(struct ufs_hba *hba, u64
> wait_timeout_us)
> +{
> +	unsigned long flags;
> +	int ret = 0;
> +	u32 tm_doorbell;
> +	u32 tr_doorbell;
> +	bool timeout = false;
> +	ktime_t start = ktime_get();
> +
> +	ufshcd_hold(hba, false);
> +	spin_lock_irqsave(hba->host->host_lock, flags);
> +	if (hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL) {
> +		ret = -EBUSY;
> +		goto out;
> +	}
>
> +	/*
> +	 * Wait for all the outstanding tasks/transfer requests.
> +	 * Verify by checking the doorbell registers are clear.
> +	 */
> +	do {
> +		tm_doorbell = ufshcd_readl(hba,
> REG_UTP_TASK_REQ_DOOR_BELL);
> +		tr_doorbell = ufshcd_readl(hba,
> REG_UTP_TRANSFER_REQ_DOOR_BELL);
> +		if (!tm_doorbell && !tr_doorbell) {
> +			timeout = false;
> +			break;
> +		}
> +
> +		spin_unlock_irqrestore(hba->host->host_lock, flags);
> +		schedule();
> +		if (ktime_to_us(ktime_sub(ktime_get(), start)) >
> +		    wait_timeout_us)
> +			timeout = true;
> +		spin_lock_irqsave(hba->host->host_lock, flags);
> +	} while (tm_doorbell || tr_doorbell);
> +
> +	if (timeout) {
> +		dev_err(hba->dev,
> +			"%s: timedout waiting for doorbell to clear
> (tm=0x%x, tr=0x%x)\n",
> +			__func__, tm_doorbell, tr_doorbell);
> +		ret = -EBUSY;
> +	}
> +out:
> +	spin_unlock_irqrestore(hba->host->host_lock, flags);
> +	ufshcd_release(hba);
>  	return ret;
>  }
>
> @@ -2230,11 +2383,20 @@ static int ufshcd_uic_change_pwr_mode(struct
> ufs_hba *hba, u8 mode)
>
>  static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba)
>  {
> +	int ret;
>  	struct uic_command uic_cmd = {0};
>
>  	uic_cmd.command = UIC_CMD_DME_HIBER_ENTER;
>
> -	return ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
> +	ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
> +
> +	if (ret) {
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_HIBERN8_ENTER);
> +		dev_err(hba->dev, "%s: hibern8 enter failed. ret = %d",
> +			__func__, ret);
> +	}
> +
> +	return ret;
>  }
>
>  static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba)
> @@ -2246,6 +2408,9 @@ static int ufshcd_uic_hibern8_exit(struct ufs_hba
> *hba)
>  	ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd);
>  	if (ret) {
>  		ufshcd_set_link_off(hba);
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_HIBERN8_EXIT);
> +		dev_err(hba->dev, "%s: hibern8 exit failed. ret = %d",
> +			__func__, ret);
>  		ret = ufshcd_host_reset_and_restore(hba);
>  	}
>
> @@ -2279,8 +2444,8 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba
> *hba)
>  	if (hba->max_pwr_info.is_valid)
>  		return 0;
>
> -	pwr_info->pwr_tx = FASTAUTO_MODE;
> -	pwr_info->pwr_rx = FASTAUTO_MODE;
> +	pwr_info->pwr_tx = FAST_MODE;
> +	pwr_info->pwr_rx = FAST_MODE;
>  	pwr_info->hs_rate = PA_HS_MODE_B;
>
>  	/* Get the connected lane count */
> @@ -2311,7 +2476,7 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba
> *hba)
>  				__func__, pwr_info->gear_rx);
>  			return -EINVAL;
>  		}
> -		pwr_info->pwr_rx = SLOWAUTO_MODE;
> +		pwr_info->pwr_rx = SLOW_MODE;
>  	}
>
>  	ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXHSGEAR),
> @@ -2324,14 +2489,14 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba
> *hba)
>  				__func__, pwr_info->gear_tx);
>  			return -EINVAL;
>  		}
> -		pwr_info->pwr_tx = SLOWAUTO_MODE;
> +		pwr_info->pwr_tx = SLOW_MODE;
>  	}
>
>  	hba->max_pwr_info.is_valid = true;
>  	return 0;
>  }
>
> -static int ufshcd_change_power_mode(struct ufs_hba *hba,
> +int ufshcd_change_power_mode(struct ufs_hba *hba,
>  			     struct ufs_pa_layer_attr *pwr_mode)
>  {
>  	int ret;
> @@ -2383,6 +2548,7 @@ static int ufshcd_change_power_mode(struct ufs_hba
> *hba,
>  			| pwr_mode->pwr_tx);
>
>  	if (ret) {
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_POWER_MODE_CHANGE);
>  		dev_err(hba->dev,
>  			"%s: power mode change failed %d\n", __func__,
> ret);
>  	} else {
> @@ -2613,9 +2779,12 @@ static int ufshcd_link_startup(struct ufs_hba *hba)
>  			hba->vops->link_startup_notify(hba, PRE_CHANGE);
>
>  		ret = ufshcd_dme_link_startup(hba);
> +		if (ret)
> +			UFSHCD_UPDATE_ERROR_STATS(hba,
> UFS_ERR_LINKSTARTUP);
>
>  		/* check if device is detected by inter-connect layer */
>  		if (!ret && !ufshcd_is_device_present(hba)) {
> +			UFSHCD_UPDATE_ERROR_STATS(hba,
> UFS_ERR_LINKSTARTUP);
>  			dev_err(hba->dev, "%s: Device not present\n",
> __func__);
>  			ret = -ENXIO;
>  			goto out;
> @@ -3051,6 +3220,7 @@ static void ufshcd_transfer_req_compl(struct ufs_hba
> *hba)
>  		lrbp = &hba->lrb[index];
>  		cmd = lrbp->cmd;
>  		if (cmd) {
> +			UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd);
>  			result = ufshcd_transfer_rsp_status(hba, lrbp);
>  			scsi_dma_unmap(cmd);
>  			cmd->result = result;
> @@ -3382,6 +3552,19 @@ static void ufshcd_err_handler(struct work_struct
> *work)
>  	if (err_xfer || err_tm || (hba->saved_err & INT_FATAL_ERRORS) ||
>  			((hba->saved_err & UIC_ERROR) &&
>  			 (hba->saved_uic_err &
> UFSHCD_UIC_DL_PA_INIT_ERROR))) {
> +
> +		if (hba->saved_err & INT_FATAL_ERRORS)
> +			UFSHCD_UPDATE_ERROR_STATS(hba,
> +
> UFS_ERR_INT_FATAL_ERRORS);
> +
> +		if (hba->saved_err & UIC_ERROR)
> +			UFSHCD_UPDATE_ERROR_STATS(hba,
> +						  UFS_ERR_INT_UIC_ERROR);
> +
> +		if (err_xfer || err_tm)
> +			UFSHCD_UPDATE_ERROR_STATS(hba,
> +
> UFS_ERR_CLEAR_PEND_XFER_TM);
> +
>  		err = ufshcd_reset_and_restore(hba);
>  		if (err) {
>  			dev_err(hba->dev, "%s: reset and restore
> failed\n",
> @@ -3719,6 +3902,9 @@ static int ufshcd_abort(struct scsi_cmnd *cmd)
>  	hba = shost_priv(host);
>  	tag = cmd->request->tag;
>
> +	UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_TASK_ABORT);
> +
> +
>  	ufshcd_hold(hba, false);
>  	/* If command is already aborted/completed, return SUCCESS */
>  	if (!(test_bit(tag, &hba->outstanding_reqs)))
> @@ -3903,6 +4089,7 @@ static int ufshcd_eh_host_reset_handler(struct
> scsi_cmnd *cmd)
>  	ufshcd_set_eh_in_progress(hba);
>  	spin_unlock_irqrestore(hba->host->host_lock, flags);
>
> +	UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_EH);
>  	err = ufshcd_reset_and_restore(hba);
>
>  	spin_lock_irqsave(hba->host->host_lock, flags);
> @@ -5188,10 +5375,12 @@ 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))
> +	if (ufshcd_is_link_hibern8(hba) && !ufshcd_uic_hibern8_exit(hba))
> {
>  		ufshcd_set_link_active(hba);
> -	else if (ufshcd_is_link_off(hba))
> +	} else if (ufshcd_is_link_off(hba)) {
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_VOPS_SUSPEND);
>  		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);
> @@ -5200,6 +5389,10 @@ enable_gating:
>  	ufshcd_release(hba);
>  out:
>  	hba->pm_op_in_progress = 0;
> +
> +	if (ret)
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_SUSPEND);
> +
>  	return ret;
>  }
>
> @@ -5295,6 +5488,10 @@ disable_irq_and_vops_clks:
>  	ufshcd_setup_clocks(hba, false);
>  out:
>  	hba->pm_op_in_progress = 0;
> +
> +	if (ret)
> +		UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_RESUME);
> +
>  	return ret;
>  }
>
> @@ -5466,6 +5663,7 @@ void ufshcd_remove(struct ufs_hba *hba)
>  	if (ufshcd_is_clkscaling_enabled(hba))
>  		devfreq_remove_device(hba->devfreq);
>  	ufshcd_hba_exit(hba);
> +	ufsdbg_remove_debugfs(hba);
>  }
>  EXPORT_SYMBOL_GPL(ufshcd_remove);
>
> @@ -5760,6 +5958,8 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem
> *mmio_base, unsigned int irq)
>
>  	async_schedule(ufshcd_async_scan, hba);
>
> +	ufsdbg_add_debugfs(hba);
> +
>  	return 0;
>
>  out_remove_scsi_host:
> @@ -5769,6 +5969,7 @@ exit_gating:
>  out_disable:
>  	hba->is_irq_enabled = false;
>  	scsi_host_put(host);
> +	ufsdbg_remove_debugfs(hba);
>  	ufshcd_hba_exit(hba);
>  out_error:
>  	return err;
> diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
> index 4a574aa..d9b1251 100644
> --- a/drivers/scsi/ufs/ufshcd.h
> +++ b/drivers/scsi/ufs/ufshcd.h
> @@ -3,6 +3,7 @@
>   *
>   * This code is based on drivers/scsi/ufs/ufshcd.h
>   * Copyright (C) 2011-2013 Samsung India Software Operations
> + * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
>   *
>   * Authors:
>   *	Santosh Yaraganavi <santosh.sy@xxxxxxxxxxx>
> @@ -125,6 +126,25 @@ enum uic_link_state {
>  #define ufshcd_set_link_hibern8(hba) ((hba)->uic_link_state = \
>  				    UIC_LINK_HIBERN8_STATE)
>
> +enum {
> +	/* errors which require the host controller reset for recovery */
> +	UFS_ERR_HIBERN8_EXIT,
> +	UFS_ERR_VOPS_SUSPEND,
> +	UFS_ERR_EH,
> +	UFS_ERR_CLEAR_PEND_XFER_TM,
> +	UFS_ERR_INT_FATAL_ERRORS,
> +	UFS_ERR_INT_UIC_ERROR,
> +
> +	/* other errors */
> +	UFS_ERR_HIBERN8_ENTER,
> +	UFS_ERR_RESUME,
> +	UFS_ERR_SUSPEND,
> +	UFS_ERR_LINKSTARTUP,
> +	UFS_ERR_POWER_MODE_CHANGE,
> +	UFS_ERR_TASK_ABORT,
> +	UFS_ERR_MAX,
> +};
> +
>  /*
>   * UFS Power management levels.
>   * Each level is in increasing order of power savings.
> @@ -203,6 +223,39 @@ struct ufs_dev_cmd {
>  	struct ufs_query query;
>  };
>
> +#ifdef CONFIG_DEBUG_FS
> +struct ufs_stats {
> +	bool enabled;
> +	u64 **tag_stats;
> +	int q_depth;
> +	int err_stats[UFS_ERR_MAX];
> +};
> +
> +struct debugfs_files {
> +	struct dentry *debugfs_root;
> +	struct dentry *tag_stats;
> +	struct dentry *err_stats;
> +	struct dentry *show_hba;
> +	struct dentry *host_regs;
> +	struct dentry *dump_dev_desc;
> +	struct dentry *power_mode;
> +	struct dentry *dme_local_read;
> +	struct dentry *dme_peer_read;
> +	u32 dme_local_attr_id;
> +	u32 dme_peer_attr_id;
> +};
> +
> +/* tag stats statistics types */
> +enum ts_types {
> +	TS_NOT_SUPPORTED	= -1,
> +	TS_TAG			= 0,
> +	TS_READ			= 1,
> +	TS_WRITE		= 2,
> +	TS_FLUSH		= 3,
> +	TS_NUM_STATS		= 4,
> +};
> +#endif
> +
>  /**
>   * struct ufs_clk_info - UFS clock related info
>   * @list: list headed by hba->clk_list_head
> @@ -371,6 +424,8 @@ struct ufs_init_prefetch {
>   * @clk_list_head: UFS host controller clocks list node head
>   * @pwr_info: holds current power mode
>   * @max_pwr_info: keeps the device max valid pwm
> + * @ufs_stats: ufshcd statistics to be used via debugfs
> + * @debugfs_files: debugfs files associated with the ufs stats
>   */
>  struct ufs_hba {
>  	void __iomem *mmio_base;
> @@ -473,6 +528,10 @@ struct ufs_hba {
>  	struct devfreq *devfreq;
>  	struct ufs_clk_scaling clk_scaling;
>  	bool is_sys_suspended;
> +#ifdef CONFIG_DEBUG_FS
> +	struct ufs_stats ufs_stats;
> +	struct debugfs_files debugfs_files;
> +#endif
>  };
>
>  /* Returns true if clocks can be gated. Otherwise false */
> @@ -593,4 +652,10 @@ static inline int ufshcd_dme_peer_get(struct ufs_hba
> *hba,
>
>  int ufshcd_hold(struct ufs_hba *hba, bool async);
>  void ufshcd_release(struct ufs_hba *hba);
> +int ufshcd_read_device_desc(struct ufs_hba *hba, u8 *buf, u32 size);
> +
> +/* Expose Query-Request API */
> +int ufshcd_wait_for_doorbell_clr(struct ufs_hba *hba, u64
> wait_timeout_us);
> +int ufshcd_change_power_mode(struct ufs_hba *hba,
> +			     struct ufs_pa_layer_attr *pwr_mode);
>  #endif /* End of Header */
> diff --git a/drivers/scsi/ufs/ufshci.h b/drivers/scsi/ufs/ufshci.h
> index d572119..c8b178f 100644
> --- a/drivers/scsi/ufs/ufshci.h
> +++ b/drivers/scsi/ufs/ufshci.h
> @@ -72,6 +72,8 @@ enum {
>  	REG_UIC_COMMAND_ARG_1			= 0x94,
>  	REG_UIC_COMMAND_ARG_2			= 0x98,
>  	REG_UIC_COMMAND_ARG_3			= 0x9C,
> +
> +	UFSHCI_REG_SPACE_SIZE			= 0xA0,
>  };
>
>  /* Controller capability masks */
> --
> Qualcomm Israel, on behalf of Qualcomm Innovation Center, Inc.
> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
> a Linux Foundation Collaborative Project
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>

Reviewed-by: Dov Levenglick <dovl@xxxxxxxxxxxxxx>

QUALCOMM ISRAEL, on behalf of Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project

--
To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [Linux for Sparc]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]

  Powered by Linux