Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 833ea2a4 authored by Michal' Potomski's avatar Michal' Potomski Committed by Sayali Lokhande
Browse files

scsi: ufs: Factor out ufshcd_read_desc_param 



Since in UFS 2.1 specification some of the descriptor lengths differs
from 2.0 specification and some devices, which are reporting spec
version 2.0 have different descriptor lengths we can not rely on
hardcoded values taken from 2.0 specification. This patch introduces
reading these lengths per each device from descriptor headers at probe
time to ensure their correctness.

Change-Id: I0e1be5b5914e008b0fb09e547b1f8c4ee966efc4
Signed-off-by: default avatarMichal' Potomski <michalx.potomski@intel.com>
Reviewed-by: default avatarSubhash Jadavani <subhashj@codeaurora.org>
Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Git-commit: a4b0e8a4e92b1baa860e744847fbdb84a50a5071
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git


[sayalil@codeaurora.org: resolve trivial merge conflicts]
Signed-off-by: default avatarSayali Lokhande <sayalil@codeaurora.org>
parent a2005826

drivers/scsi/ufs/ufs-debugfs.c

+2 −2
Original line number Diff line number Diff line
@@ -850,8 +850,8 @@ static const struct file_operations ufsdbg_host_regs_fops = { 
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];

	int buff_len = QUERY_DESC_DEVICE_DEF_SIZE;

	u8 desc_buf[QUERY_DESC_DEVICE_DEF_SIZE];

	struct ufs_hba *hba = (struct ufs_hba *)file->private;



	struct desc_field_offset device_desc_field_name[] = {

drivers/scsi/ufs/ufs.h

+8 −13
Original line number Diff line number Diff line
@@ -65,6 +65,7 @@ 
#define UFS_MAX_LUNS		(SCSI_W_LUN_BASE + UFS_UPIU_MAX_UNIT_NUM_ID)

#define UFS_UPIU_WLUN_ID	(1 << 7)

#define UFS_UPIU_MAX_GENERAL_LUN	8

#define QUERY_DESC_IDN_CONFIGURATION	QUERY_DESC_IDN_CONFIGURAION



/* Well known logical unit id in LUN field of UPIU */

enum {
@@ -144,19 +145,13 @@ enum desc_header_offset { 
	QUERY_DESC_DESC_TYPE_OFFSET	= 0x01,

};



enum ufs_desc_max_size {

	QUERY_DESC_DEVICE_MAX_SIZE		= 0x40,

	QUERY_DESC_CONFIGURAION_MAX_SIZE	= 0x90,

	QUERY_DESC_UNIT_MAX_SIZE		= 0x23,

	QUERY_DESC_INTERCONNECT_MAX_SIZE	= 0x06,

	/*

	 * Max. 126 UNICODE characters (2 bytes per character) plus 2 bytes

	 * of descriptor header.

	 */

	QUERY_DESC_STRING_MAX_SIZE		= 0xFE,

	QUERY_DESC_GEOMETRY_MAZ_SIZE		= 0x44,

	QUERY_DESC_POWER_MAX_SIZE		= 0x62,

	QUERY_DESC_RFU_MAX_SIZE			= 0x00,

enum ufs_desc_def_size {

	QUERY_DESC_DEVICE_DEF_SIZE		= 0x40,

	QUERY_DESC_CONFIGURATION_DEF_SIZE	= 0x90,

	QUERY_DESC_UNIT_DEF_SIZE		= 0x23,

	QUERY_DESC_INTERCONNECT_DEF_SIZE	= 0x06,

	QUERY_DESC_GEOMETRY_DEF_SIZE		= 0x44,

	QUERY_DESC_POWER_DEF_SIZE		= 0x62,

};



/* Unit descriptor parameters offsets in bytes*/

drivers/scsi/ufs/ufs_quirks.c

+4 −4
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static struct ufs_card_fix ufs_fixups[] = { 
void ufs_advertise_fixup_device(struct ufs_hba *hba)

{

	int err;

	u8 str_desc_buf[QUERY_DESC_STRING_MAX_SIZE + 1];

	u8 str_desc_buf[QUERY_DESC_MAX_SIZE + 1];

	char *model;

	struct ufs_card_fix *f;
@@ -59,13 +59,13 @@ void ufs_advertise_fixup_device(struct ufs_hba *hba) 
	if (!model)

		goto out;



	memset(str_desc_buf, 0, QUERY_DESC_STRING_MAX_SIZE);

	memset(str_desc_buf, 0, QUERY_DESC_MAX_SIZE);

	err = ufshcd_read_string_desc(hba, hba->dev_info.i_product_name,

			str_desc_buf, QUERY_DESC_STRING_MAX_SIZE, ASCII_STD);

			str_desc_buf, QUERY_DESC_MAX_SIZE, ASCII_STD);

	if (err)

		goto out;



	str_desc_buf[QUERY_DESC_STRING_MAX_SIZE] = '\0';

	str_desc_buf[QUERY_DESC_MAX_SIZE] = '\0';

	strlcpy(model, (str_desc_buf + QUERY_DESC_HDR_SIZE),

		min_t(u8, str_desc_buf[QUERY_DESC_LENGTH_OFFSET],

		      MAX_MODEL_LEN));

drivers/scsi/ufs/ufs_test.c

+2 −2
Original line number Diff line number Diff line
@@ -603,8 +603,8 @@ static void ufs_test_random_async_query(void *data, async_cookie_t cookie) 
	struct ufs_test_data *utd = test_iosched->blk_dev_test_data;

	struct scsi_device *sdev;

	struct ufs_hba *hba;

	int buff_len = QUERY_DESC_UNIT_MAX_SIZE;

	u8 desc_buf[QUERY_DESC_UNIT_MAX_SIZE];

	int buff_len = QUERY_DESC_UNIT_DEF_SIZE;

	u8 desc_buf[QUERY_DESC_UNIT_DEF_SIZE];

	bool flag;

	u32 att;

	int ret = 0;

drivers/scsi/ufs/ufshcd.c

+186 −53
Original line number Diff line number Diff line
@@ -251,19 +251,6 @@ static void ufshcd_hex_dump(struct ufs_hba *hba, const char * const str, 
		       16, 4, buf, len, false);

}



static u32 ufs_query_desc_max_size[] = {

	QUERY_DESC_DEVICE_MAX_SIZE,

	QUERY_DESC_CONFIGURAION_MAX_SIZE,

	QUERY_DESC_UNIT_MAX_SIZE,

	QUERY_DESC_RFU_MAX_SIZE,

	QUERY_DESC_INTERCONNECT_MAX_SIZE,

	QUERY_DESC_STRING_MAX_SIZE,

	QUERY_DESC_RFU_MAX_SIZE,

	QUERY_DESC_GEOMETRY_MAZ_SIZE,

	QUERY_DESC_POWER_MAX_SIZE,

	QUERY_DESC_RFU_MAX_SIZE,

};



enum {

	UFSHCD_MAX_CHANNEL	= 0,

	UFSHCD_MAX_ID		= 1,
@@ -3628,7 +3615,7 @@ static int __ufshcd_query_descriptor(struct ufs_hba *hba, 
		goto out;

	}



	if (*buf_len <= QUERY_DESC_MIN_SIZE || *buf_len > QUERY_DESC_MAX_SIZE) {

	if (*buf_len < QUERY_DESC_MIN_SIZE || *buf_len > QUERY_DESC_MAX_SIZE) {

		dev_err(hba->dev, "%s: descriptor buffer size (%d) is out of range\n",

				__func__, *buf_len);

		err = -EINVAL;
@@ -3707,6 +3694,92 @@ int ufshcd_query_descriptor(struct ufs_hba *hba, 
}

EXPORT_SYMBOL(ufshcd_query_descriptor);



/**

 * ufshcd_read_desc_length - read the specified descriptor length from header

 * @hba: Pointer to adapter instance

 * @desc_id: descriptor idn value

 * @desc_index: descriptor index

 * @desc_length: pointer to variable to read the length of descriptor

 *

 * Return 0 in case of success, non-zero otherwise

 */

static int ufshcd_read_desc_length(struct ufs_hba *hba,

	enum desc_idn desc_id,

	int desc_index,

	int *desc_length)

{

	int ret;

	u8 header[QUERY_DESC_HDR_SIZE];

	int header_len = QUERY_DESC_HDR_SIZE;



	if (desc_id >= QUERY_DESC_IDN_MAX)

		return -EINVAL;



	ret = ufshcd_query_descriptor(hba, UPIU_QUERY_OPCODE_READ_DESC,

					desc_id, desc_index, 0, header,

					&header_len);



	if (ret) {

		dev_err(hba->dev, "%s: Failed to get descriptor header id %d",

			__func__, desc_id);

		return ret;

	} else if (desc_id != header[QUERY_DESC_DESC_TYPE_OFFSET]) {

		dev_warn(hba->dev, "%s: descriptor header id %d and desc_id %d mismatch",

			__func__, header[QUERY_DESC_DESC_TYPE_OFFSET],

			desc_id);

		ret = -EINVAL;

	}



	*desc_length = header[QUERY_DESC_LENGTH_OFFSET];

	return ret;



}



/**

 * ufshcd_map_desc_id_to_length - map descriptor IDN to its length

 * @hba: Pointer to adapter instance

 * @desc_id: descriptor idn value

 * @desc_len: mapped desc length (out)

 *

 * Return 0 in case of success, non-zero otherwise

 */

int ufshcd_map_desc_id_to_length(struct ufs_hba *hba,

	enum desc_idn desc_id, int *desc_len)

{

	switch (desc_id) {

	case QUERY_DESC_IDN_DEVICE:

		*desc_len = hba->desc_size.dev_desc;

		break;

	case QUERY_DESC_IDN_POWER:

		*desc_len = hba->desc_size.pwr_desc;

		break;

	case QUERY_DESC_IDN_GEOMETRY:

		*desc_len = hba->desc_size.geom_desc;

		break;

	case QUERY_DESC_IDN_CONFIGURATION:

		*desc_len = hba->desc_size.conf_desc;

		break;

	case QUERY_DESC_IDN_UNIT:

		*desc_len = hba->desc_size.unit_desc;

		break;

	case QUERY_DESC_IDN_INTERCONNECT:

		*desc_len = hba->desc_size.interc_desc;

		break;

	case QUERY_DESC_IDN_STRING:

		*desc_len = QUERY_DESC_MAX_SIZE;

		break;

	case QUERY_DESC_IDN_RFU_0:

	case QUERY_DESC_IDN_RFU_1:

		*desc_len = 0;

		break;

	default:

		*desc_len = 0;

		return -EINVAL;

	}

	return 0;

}

EXPORT_SYMBOL(ufshcd_map_desc_id_to_length);



/**

 * ufshcd_read_desc_param - read the specified descriptor parameter

 * @hba: Pointer to adapter instance
@@ -3721,37 +3794,45 @@ EXPORT_SYMBOL(ufshcd_query_descriptor); 
static int ufshcd_read_desc_param(struct ufs_hba *hba,

				  enum desc_idn desc_id,

				  int desc_index,

				  u32 param_offset,

				  u8 param_offset,

				  u8 *param_read_buf,

				  u32 param_size)

				  u8 param_size)

{

	int ret;

	u8 *desc_buf;

	u32 buff_len;

	int buff_len;

	bool is_kmalloc = true;



	/* safety checks */

	if (desc_id >= QUERY_DESC_IDN_MAX)

	/* Safety check */

	if (desc_id >= QUERY_DESC_IDN_MAX || !param_size)

		return -EINVAL;



	buff_len = ufs_query_desc_max_size[desc_id];

	if ((param_offset + param_size) > buff_len)

		return -EINVAL;

	/* Get the max length of descriptor from structure filled up at probe

	 * time.

	 */

	ret = ufshcd_map_desc_id_to_length(hba, desc_id, &buff_len);



	if (!param_offset && (param_size == buff_len)) {

		/* memory space already available to hold full descriptor */

		desc_buf = param_read_buf;

		is_kmalloc = false;

	} else {

		/* allocate memory to hold full descriptor */

	/* Sanity checks */

	if (ret || !buff_len) {

		dev_err(hba->dev, "%s: Failed to get full descriptor length",

			__func__);

		return ret;

	}



	/* Check whether we need temp memory */

	if (param_offset != 0 || param_size < buff_len) {

		desc_buf = kmalloc(buff_len, GFP_KERNEL);

		if (!desc_buf)

			return -ENOMEM;

	} else {

		desc_buf = param_read_buf;

		is_kmalloc = false;

	}



	/* Request for full descriptor */

	ret = ufshcd_query_descriptor(hba, UPIU_QUERY_OPCODE_READ_DESC,

				      desc_id, desc_index, 0, desc_buf,

				      &buff_len);

					desc_id, desc_index, 0,

					desc_buf, &buff_len);



	if (ret) {

		dev_err(hba->dev, "%s: Failed reading descriptor. desc_id %d, desc_index %d, param_offset %d, ret %d",
@@ -3768,25 +3849,9 @@ static int ufshcd_read_desc_param(struct ufs_hba *hba, 
		goto out;

	}



	/*

	 * While reading variable size descriptors (like string descriptor),

	 * some UFS devices may report the "LENGTH" (field in "Transaction

	 * Specific fields" of Query Response UPIU) same as what was requested

	 * in Query Request UPIU instead of reporting the actual size of the

	 * variable size descriptor.

	 * Although it's safe to ignore the "LENGTH" field for variable size

	 * descriptors as we can always derive the length of the descriptor from

	 * the descriptor header fields. Hence this change impose the length

	 * match check only for fixed size descriptors (for which we always

	 * request the correct size as part of Query Request UPIU).

	 */

	if ((desc_id != QUERY_DESC_IDN_STRING) &&

	    (buff_len != desc_buf[QUERY_DESC_LENGTH_OFFSET])) {

		dev_err(hba->dev, "%s: desc_buf length mismatch: buff_len %d, buff_len(desc_header) %d",

			__func__, buff_len, desc_buf[QUERY_DESC_LENGTH_OFFSET]);

		ret = -EINVAL;

		goto out;

	}

	/* Check wherher we will not copy more data, than available */

	if (is_kmalloc && param_size > buff_len)

		param_size = buff_len;



	if (is_kmalloc)

		memcpy(param_read_buf, &desc_buf[param_offset], param_size);
@@ -7170,10 +7235,19 @@ static u32 ufshcd_find_max_sup_active_icc_level(struct ufs_hba *hba, 
static void ufshcd_set_active_icc_lvl(struct ufs_hba *hba)

{

	int ret;

	int buff_len = QUERY_DESC_POWER_MAX_SIZE;

	u8 desc_buf[QUERY_DESC_POWER_MAX_SIZE];

	int buff_len = hba->desc_size.pwr_desc;

	u8 *desc_buf = NULL;

	u32 icc_level;



	if (buff_len) {

		desc_buf = kmalloc(buff_len, GFP_KERNEL);

		if (!desc_buf) {

			dev_err(hba->dev,

				"%s: Failed to allocate desc_buf\n", __func__);

			return;

		}

	}



	ret = ufshcd_read_power_desc(hba, desc_buf, buff_len);

	if (ret) {

		dev_err(hba->dev,
@@ -7554,9 +7628,18 @@ static int ufshcd_set_dev_ref_clk(struct ufs_hba *hba) 
static int ufs_read_device_desc_data(struct ufs_hba *hba)

{

	int err;

	u8 desc_buf[QUERY_DESC_DEVICE_MAX_SIZE];

	u8 *desc_buf = NULL;



	err = ufshcd_read_device_desc(hba, desc_buf, sizeof(desc_buf));

	if (hba->desc_size.dev_desc) {

		desc_buf = kmalloc(hba->desc_size.dev_desc, GFP_KERNEL);

		if (!desc_buf) {

			err = -ENOMEM;

			dev_err(hba->dev,

				"%s: Failed to allocate desc_buf\n", __func__);

			return err;

		}

	}

	err = ufshcd_read_device_desc(hba, desc_buf, hba->desc_size.dev_desc);

	if (err)

		return err;
@@ -7574,6 +7657,51 @@ static int ufs_read_device_desc_data(struct ufs_hba *hba) 
	return 0;

}



static void ufshcd_init_desc_sizes(struct ufs_hba *hba)

{

	int err;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_DEVICE, 0,

		&hba->desc_size.dev_desc);

	if (err)

		hba->desc_size.dev_desc = QUERY_DESC_DEVICE_DEF_SIZE;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_POWER, 0,

		&hba->desc_size.pwr_desc);

	if (err)

		hba->desc_size.pwr_desc = QUERY_DESC_POWER_DEF_SIZE;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_INTERCONNECT, 0,

		&hba->desc_size.interc_desc);

	if (err)

		hba->desc_size.interc_desc = QUERY_DESC_INTERCONNECT_DEF_SIZE;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_CONFIGURATION, 0,

		&hba->desc_size.conf_desc);

	if (err)

		hba->desc_size.conf_desc = QUERY_DESC_CONFIGURATION_DEF_SIZE;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_UNIT, 0,

		&hba->desc_size.unit_desc);

	if (err)

		hba->desc_size.unit_desc = QUERY_DESC_UNIT_DEF_SIZE;



	err = ufshcd_read_desc_length(hba, QUERY_DESC_IDN_GEOMETRY, 0,

		&hba->desc_size.geom_desc);

	if (err)

		hba->desc_size.geom_desc = QUERY_DESC_GEOMETRY_DEF_SIZE;

}



static void ufshcd_def_desc_sizes(struct ufs_hba *hba)

{

	hba->desc_size.dev_desc = QUERY_DESC_DEVICE_DEF_SIZE;

	hba->desc_size.pwr_desc = QUERY_DESC_POWER_DEF_SIZE;

	hba->desc_size.interc_desc = QUERY_DESC_INTERCONNECT_DEF_SIZE;

	hba->desc_size.conf_desc = QUERY_DESC_CONFIGURATION_DEF_SIZE;

	hba->desc_size.unit_desc = QUERY_DESC_UNIT_DEF_SIZE;

	hba->desc_size.geom_desc = QUERY_DESC_GEOMETRY_DEF_SIZE;

}



/**

 * ufshcd_probe_hba - probe hba to detect device and initialize

 * @hba: per-adapter instance
@@ -7614,6 +7742,8 @@ static int ufshcd_probe_hba(struct ufs_hba *hba) 
	if (ret)

		goto out;



	/* Init check for device descriptor sizes */

	ufshcd_init_desc_sizes(hba);

	ufs_advertise_fixup_device(hba);

	ufshcd_tune_unipro_params(hba);
@@ -10075,6 +10205,9 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem *mmio_base, unsigned int irq) 


	ufshcd_init_lanes_per_dir(hba);



	/* Set descriptor lengths to specification defaults */

	ufshcd_def_desc_sizes(hba);



	err = ufshcd_hba_init(hba);

	if (err)

		goto out_error;