ufs-sysfs.c

   1// SPDX-License-Identifier: GPL-2.0
   2// Copyright (C) 2018 Western Digital Corporation
   3
   4#include <linux/err.h>
   5#include <linux/string.h>
   6#include <linux/bitfield.h>
   7#include <linux/unaligned.h>
   8#include <linux/string_choices.h>
   9
  10#include <ufs/ufs.h>
  11#include <ufs/unipro.h>
  12#include "ufs-sysfs.h"
  13#include "ufshcd-priv.h"
  14
  15static const char *ufs_pa_pwr_mode_to_string(enum ufs_pa_pwr_mode mode)
  16{
  17	switch (mode) {
  18	case FAST_MODE:		return "FAST_MODE";
  19	case SLOW_MODE:		return "SLOW_MODE";
  20	case FASTAUTO_MODE:	return "FASTAUTO_MODE";
  21	case SLOWAUTO_MODE:	return "SLOWAUTO_MODE";
  22	default:		return "UNKNOWN";
  23	}
  24}
  25
  26static const char *ufs_hs_gear_rate_to_string(enum ufs_hs_gear_rate rate)
  27{
  28	switch (rate) {
  29	case PA_HS_MODE_A:	return "HS_RATE_A";
  30	case PA_HS_MODE_B:	return "HS_RATE_B";
  31	default:		return "UNKNOWN";
  32	}
  33}
  34
  35static const char *ufs_pwm_gear_to_string(enum ufs_pwm_gear_tag gear)
  36{
  37	switch (gear) {
  38	case UFS_PWM_G1:	return "PWM_GEAR1";
  39	case UFS_PWM_G2:	return "PWM_GEAR2";
  40	case UFS_PWM_G3:	return "PWM_GEAR3";
  41	case UFS_PWM_G4:	return "PWM_GEAR4";
  42	case UFS_PWM_G5:	return "PWM_GEAR5";
  43	case UFS_PWM_G6:	return "PWM_GEAR6";
  44	case UFS_PWM_G7:	return "PWM_GEAR7";
  45	default:		return "UNKNOWN";
  46	}
  47}
  48
  49static const char *ufs_hs_gear_to_string(enum ufs_hs_gear_tag gear)
  50{
  51	switch (gear) {
  52	case UFS_HS_G1:	return "HS_GEAR1";
  53	case UFS_HS_G2:	return "HS_GEAR2";
  54	case UFS_HS_G3:	return "HS_GEAR3";
  55	case UFS_HS_G4:	return "HS_GEAR4";
  56	case UFS_HS_G5:	return "HS_GEAR5";
  57	default:	return "UNKNOWN";
  58	}
  59}
  60
  61static const char *ufs_wb_resize_hint_to_string(enum wb_resize_hint hint)
  62{
  63	switch (hint) {
  64	case WB_RESIZE_HINT_KEEP:
  65		return "keep";
  66	case WB_RESIZE_HINT_DECREASE:
  67		return "decrease";
  68	case WB_RESIZE_HINT_INCREASE:
  69		return "increase";
  70	default:
  71		return "unknown";
  72	}
  73}
  74
  75static const char *ufs_wb_resize_status_to_string(enum wb_resize_status status)
  76{
  77	switch (status) {
  78	case WB_RESIZE_STATUS_IDLE:
  79		return "idle";
  80	case WB_RESIZE_STATUS_IN_PROGRESS:
  81		return "in_progress";
  82	case WB_RESIZE_STATUS_COMPLETE_SUCCESS:
  83		return "complete_success";
  84	case WB_RESIZE_STATUS_GENERAL_FAILURE:
  85		return "general_failure";
  86	default:
  87		return "unknown";
  88	}
  89}
  90
  91static const char * const ufs_hid_states[] = {
  92	[HID_IDLE]		= "idle",
  93	[ANALYSIS_IN_PROGRESS]	= "analysis_in_progress",
  94	[DEFRAG_REQUIRED]	= "defrag_required",
  95	[DEFRAG_IN_PROGRESS]	= "defrag_in_progress",
  96	[DEFRAG_COMPLETED]	= "defrag_completed",
  97	[DEFRAG_NOT_REQUIRED]	= "defrag_not_required",
  98};
  99
 100static const char *ufs_hid_state_to_string(enum ufs_hid_state state)
 101{
 102	if (state < NUM_UFS_HID_STATES)
 103		return ufs_hid_states[state];
 104
 105	return "unknown";
 106}
 107
 108static const char *ufshcd_uic_link_state_to_string(
 109			enum uic_link_state state)
 110{
 111	switch (state) {
 112	case UIC_LINK_OFF_STATE:	return "OFF";
 113	case UIC_LINK_ACTIVE_STATE:	return "ACTIVE";
 114	case UIC_LINK_HIBERN8_STATE:	return "HIBERN8";
 115	case UIC_LINK_BROKEN_STATE:	return "BROKEN";
 116	default:			return "UNKNOWN";
 117	}
 118}
 119
 120static const char *ufshcd_ufs_dev_pwr_mode_to_string(
 121			enum ufs_dev_pwr_mode state)
 122{
 123	switch (state) {
 124	case UFS_ACTIVE_PWR_MODE:	return "ACTIVE";
 125	case UFS_SLEEP_PWR_MODE:	return "SLEEP";
 126	case UFS_POWERDOWN_PWR_MODE:	return "POWERDOWN";
 127	case UFS_DEEPSLEEP_PWR_MODE:	return "DEEPSLEEP";
 128	default:			return "UNKNOWN";
 129	}
 130}
 131
 132static inline ssize_t ufs_sysfs_pm_lvl_store(struct device *dev,
 133					     struct device_attribute *attr,
 134					     const char *buf, size_t count,
 135					     bool rpm)
 136{
 137	struct ufs_hba *hba = dev_get_drvdata(dev);
 138	struct ufs_dev_info *dev_info = &hba->dev_info;
 139	unsigned long flags, value;
 140
 141	if (kstrtoul(buf, 0, &value))
 142		return -EINVAL;
 143
 144	if (value >= UFS_PM_LVL_MAX)
 145		return -EINVAL;
 146
 147	if (ufs_pm_lvl_states[value].dev_state == UFS_DEEPSLEEP_PWR_MODE &&
 148	    (!(hba->caps & UFSHCD_CAP_DEEPSLEEP) ||
 149	     !(dev_info->wspecversion >= 0x310)))
 150		return -EINVAL;
 151
 152	spin_lock_irqsave(hba->host->host_lock, flags);
 153	if (rpm)
 154		hba->rpm_lvl = value;
 155	else
 156		hba->spm_lvl = value;
 157	spin_unlock_irqrestore(hba->host->host_lock, flags);
 158	return count;
 159}
 160
 161static ssize_t rpm_lvl_show(struct device *dev,
 162		struct device_attribute *attr, char *buf)
 163{
 164	struct ufs_hba *hba = dev_get_drvdata(dev);
 165
 166	return sysfs_emit(buf, "%d\n", hba->rpm_lvl);
 167}
 168
 169static ssize_t rpm_lvl_store(struct device *dev,
 170		struct device_attribute *attr, const char *buf, size_t count)
 171{
 172	return ufs_sysfs_pm_lvl_store(dev, attr, buf, count, true);
 173}
 174
 175static ssize_t rpm_target_dev_state_show(struct device *dev,
 176		struct device_attribute *attr, char *buf)
 177{
 178	struct ufs_hba *hba = dev_get_drvdata(dev);
 179
 180	return sysfs_emit(buf, "%s\n", ufshcd_ufs_dev_pwr_mode_to_string(
 181			ufs_pm_lvl_states[hba->rpm_lvl].dev_state));
 182}
 183
 184static ssize_t rpm_target_link_state_show(struct device *dev,
 185		struct device_attribute *attr, char *buf)
 186{
 187	struct ufs_hba *hba = dev_get_drvdata(dev);
 188
 189	return sysfs_emit(buf, "%s\n", ufshcd_uic_link_state_to_string(
 190			ufs_pm_lvl_states[hba->rpm_lvl].link_state));
 191}
 192
 193static ssize_t spm_lvl_show(struct device *dev,
 194		struct device_attribute *attr, char *buf)
 195{
 196	struct ufs_hba *hba = dev_get_drvdata(dev);
 197
 198	return sysfs_emit(buf, "%d\n", hba->spm_lvl);
 199}
 200
 201static ssize_t spm_lvl_store(struct device *dev,
 202		struct device_attribute *attr, const char *buf, size_t count)
 203{
 204	return ufs_sysfs_pm_lvl_store(dev, attr, buf, count, false);
 205}
 206
 207static ssize_t spm_target_dev_state_show(struct device *dev,
 208		struct device_attribute *attr, char *buf)
 209{
 210	struct ufs_hba *hba = dev_get_drvdata(dev);
 211
 212	return sysfs_emit(buf, "%s\n", ufshcd_ufs_dev_pwr_mode_to_string(
 213				ufs_pm_lvl_states[hba->spm_lvl].dev_state));
 214}
 215
 216static ssize_t spm_target_link_state_show(struct device *dev,
 217		struct device_attribute *attr, char *buf)
 218{
 219	struct ufs_hba *hba = dev_get_drvdata(dev);
 220
 221	return sysfs_emit(buf, "%s\n", ufshcd_uic_link_state_to_string(
 222				ufs_pm_lvl_states[hba->spm_lvl].link_state));
 223}
 224
 225/* Convert Auto-Hibernate Idle Timer register value to microseconds */
 226static int ufshcd_ahit_to_us(u32 ahit)
 227{
 228	int timer = FIELD_GET(UFSHCI_AHIBERN8_TIMER_MASK, ahit);
 229	int scale = FIELD_GET(UFSHCI_AHIBERN8_SCALE_MASK, ahit);
 230
 231	for (; scale > 0; --scale)
 232		timer *= UFSHCI_AHIBERN8_SCALE_FACTOR;
 233
 234	return timer;
 235}
 236
 237/* Convert microseconds to Auto-Hibernate Idle Timer register value */
 238u32 ufshcd_us_to_ahit(unsigned int timer)
 239{
 240	unsigned int scale;
 241
 242	for (scale = 0; timer > UFSHCI_AHIBERN8_TIMER_MASK; ++scale)
 243		timer /= UFSHCI_AHIBERN8_SCALE_FACTOR;
 244
 245	return FIELD_PREP(UFSHCI_AHIBERN8_TIMER_MASK, timer) |
 246	       FIELD_PREP(UFSHCI_AHIBERN8_SCALE_MASK, scale);
 247}
 248EXPORT_SYMBOL_GPL(ufshcd_us_to_ahit);
 249
 250static int ufshcd_read_hci_reg(struct ufs_hba *hba, u32 *val, unsigned int reg)
 251{
 252	down(&hba->host_sem);
 253	if (!ufshcd_is_user_access_allowed(hba)) {
 254		up(&hba->host_sem);
 255		return -EBUSY;
 256	}
 257
 258	ufshcd_rpm_get_sync(hba);
 259	ufshcd_hold(hba);
 260	*val = ufshcd_readl(hba, reg);
 261	ufshcd_release(hba);
 262	ufshcd_rpm_put_sync(hba);
 263
 264	up(&hba->host_sem);
 265	return 0;
 266}
 267
 268static ssize_t auto_hibern8_show(struct device *dev,
 269				 struct device_attribute *attr, char *buf)
 270{
 271	u32 ahit;
 272	int ret;
 273	struct ufs_hba *hba = dev_get_drvdata(dev);
 274
 275	if (!ufshcd_is_auto_hibern8_supported(hba))
 276		return -EOPNOTSUPP;
 277
 278	ret = ufshcd_read_hci_reg(hba, &ahit, REG_AUTO_HIBERNATE_IDLE_TIMER);
 279	if (ret)
 280		return ret;
 281
 282	return sysfs_emit(buf, "%d\n", ufshcd_ahit_to_us(ahit));
 283}
 284
 285static ssize_t auto_hibern8_store(struct device *dev,
 286				  struct device_attribute *attr,
 287				  const char *buf, size_t count)
 288{
 289	struct ufs_hba *hba = dev_get_drvdata(dev);
 290	unsigned int timer;
 291	int ret = 0;
 292
 293	if (!ufshcd_is_auto_hibern8_supported(hba))
 294		return -EOPNOTSUPP;
 295
 296	if (kstrtouint(buf, 0, &timer))
 297		return -EINVAL;
 298
 299	if (timer > UFSHCI_AHIBERN8_MAX)
 300		return -EINVAL;
 301
 302	down(&hba->host_sem);
 303	if (!ufshcd_is_user_access_allowed(hba)) {
 304		ret = -EBUSY;
 305		goto out;
 306	}
 307
 308	ufshcd_auto_hibern8_update(hba, ufshcd_us_to_ahit(timer));
 309
 310out:
 311	up(&hba->host_sem);
 312	return ret ? ret : count;
 313}
 314
 315static ssize_t wb_on_show(struct device *dev, struct device_attribute *attr,
 316			  char *buf)
 317{
 318	struct ufs_hba *hba = dev_get_drvdata(dev);
 319
 320	return sysfs_emit(buf, "%d\n", hba->dev_info.wb_enabled);
 321}
 322
 323static ssize_t wb_on_store(struct device *dev, struct device_attribute *attr,
 324			   const char *buf, size_t count)
 325{
 326	struct ufs_hba *hba = dev_get_drvdata(dev);
 327	unsigned int wb_enable;
 328	ssize_t res;
 329
 330	if (!ufshcd_is_wb_allowed(hba) || (ufshcd_is_clkscaling_supported(hba)
 331		&& ufshcd_enable_wb_if_scaling_up(hba))) {
 332		/*
 333		 * If the platform supports UFSHCD_CAP_CLK_SCALING, turn WB
 334		 * on/off will be done while clock scaling up/down.
 335		 */
 336		dev_warn(dev, "It is not allowed to configure WB!\n");
 337		return -EOPNOTSUPP;
 338	}
 339
 340	if (kstrtouint(buf, 0, &wb_enable))
 341		return -EINVAL;
 342
 343	if (wb_enable != 0 && wb_enable != 1)
 344		return -EINVAL;
 345
 346	down(&hba->host_sem);
 347	if (!ufshcd_is_user_access_allowed(hba)) {
 348		res = -EBUSY;
 349		goto out;
 350	}
 351
 352	ufshcd_rpm_get_sync(hba);
 353	res = ufshcd_wb_toggle(hba, wb_enable);
 354	ufshcd_rpm_put_sync(hba);
 355out:
 356	up(&hba->host_sem);
 357	return res < 0 ? res : count;
 358}
 359
 360static ssize_t rtc_update_ms_show(struct device *dev, struct device_attribute *attr,
 361				  char *buf)
 362{
 363	struct ufs_hba *hba = dev_get_drvdata(dev);
 364
 365	return sysfs_emit(buf, "%d\n", hba->dev_info.rtc_update_period);
 366}
 367
 368static ssize_t rtc_update_ms_store(struct device *dev, struct device_attribute *attr,
 369				   const char *buf, size_t count)
 370{
 371	struct ufs_hba *hba = dev_get_drvdata(dev);
 372	unsigned int ms;
 373	bool resume_period_update = false;
 374
 375	if (kstrtouint(buf, 0, &ms))
 376		return -EINVAL;
 377
 378	if (!hba->dev_info.rtc_update_period && ms > 0)
 379		resume_period_update =  true;
 380	/* Minimum and maximum update frequency should be synchronized with all UFS vendors */
 381	hba->dev_info.rtc_update_period = ms;
 382
 383	if (resume_period_update)
 384		schedule_delayed_work(&hba->ufs_rtc_update_work,
 385				      msecs_to_jiffies(hba->dev_info.rtc_update_period));
 386	return count;
 387}
 388
 389static ssize_t enable_wb_buf_flush_show(struct device *dev,
 390				    struct device_attribute *attr,
 391				    char *buf)
 392{
 393	struct ufs_hba *hba = dev_get_drvdata(dev);
 394
 395	return sysfs_emit(buf, "%d\n", hba->dev_info.wb_buf_flush_enabled);
 396}
 397
 398static ssize_t enable_wb_buf_flush_store(struct device *dev,
 399				     struct device_attribute *attr,
 400				     const char *buf, size_t count)
 401{
 402	struct ufs_hba *hba = dev_get_drvdata(dev);
 403	unsigned int enable_wb_buf_flush;
 404	ssize_t res;
 405
 406	if (!ufshcd_is_wb_buf_flush_allowed(hba)) {
 407		dev_warn(dev, "It is not allowed to configure WB buf flushing!\n");
 408		return -EOPNOTSUPP;
 409	}
 410
 411	if (kstrtouint(buf, 0, &enable_wb_buf_flush))
 412		return -EINVAL;
 413
 414	if (enable_wb_buf_flush != 0 && enable_wb_buf_flush != 1)
 415		return -EINVAL;
 416
 417	down(&hba->host_sem);
 418	if (!ufshcd_is_user_access_allowed(hba)) {
 419		res = -EBUSY;
 420		goto out;
 421	}
 422
 423	ufshcd_rpm_get_sync(hba);
 424	res = ufshcd_wb_toggle_buf_flush(hba, enable_wb_buf_flush);
 425	ufshcd_rpm_put_sync(hba);
 426
 427out:
 428	up(&hba->host_sem);
 429	return res < 0 ? res : count;
 430}
 431
 432static ssize_t wb_flush_threshold_show(struct device *dev,
 433					 struct device_attribute *attr,
 434					 char *buf)
 435{
 436	struct ufs_hba *hba = dev_get_drvdata(dev);
 437
 438	return sysfs_emit(buf, "%u\n", hba->vps->wb_flush_threshold);
 439}
 440
 441static ssize_t wb_flush_threshold_store(struct device *dev,
 442					  struct device_attribute *attr,
 443					  const char *buf, size_t count)
 444{
 445	struct ufs_hba *hba = dev_get_drvdata(dev);
 446	unsigned int wb_flush_threshold;
 447
 448	if (kstrtouint(buf, 0, &wb_flush_threshold))
 449		return -EINVAL;
 450
 451	/* The range of values for wb_flush_threshold is (0,10] */
 452	if (wb_flush_threshold > UFS_WB_BUF_REMAIN_PERCENT(100) ||
 453	    wb_flush_threshold == 0) {
 454		dev_err(dev, "The value of wb_flush_threshold is invalid!\n");
 455		return -EINVAL;
 456	}
 457
 458	hba->vps->wb_flush_threshold = wb_flush_threshold;
 459
 460	return count;
 461}
 462
 463static const char * const wb_resize_en_mode[] = {
 464	[WB_RESIZE_EN_IDLE]	= "idle",
 465	[WB_RESIZE_EN_DECREASE]	= "decrease",
 466	[WB_RESIZE_EN_INCREASE]	= "increase",
 467};
 468
 469static ssize_t wb_resize_enable_store(struct device *dev,
 470				struct device_attribute *attr,
 471				const char *buf, size_t count)
 472{
 473	struct ufs_hba *hba = dev_get_drvdata(dev);
 474	int mode;
 475	ssize_t res;
 476
 477	if (!ufshcd_is_wb_allowed(hba) || !hba->dev_info.wb_enabled
 478		|| !hba->dev_info.b_presrv_uspc_en
 479		|| !(hba->dev_info.ext_wb_sup & UFS_DEV_WB_BUF_RESIZE))
 480		return -EOPNOTSUPP;
 481
 482	mode = sysfs_match_string(wb_resize_en_mode, buf);
 483	if (mode < 0)
 484		return -EINVAL;
 485
 486	down(&hba->host_sem);
 487	if (!ufshcd_is_user_access_allowed(hba)) {
 488		res = -EBUSY;
 489		goto out;
 490	}
 491
 492	ufshcd_rpm_get_sync(hba);
 493	res = ufshcd_wb_set_resize_en(hba, mode);
 494	ufshcd_rpm_put_sync(hba);
 495
 496out:
 497	up(&hba->host_sem);
 498	return res < 0 ? res : count;
 499}
 500
 501/**
 502 * pm_qos_enable_show - sysfs handler to show pm qos enable value
 503 * @dev: device associated with the UFS controller
 504 * @attr: sysfs attribute handle
 505 * @buf: buffer for sysfs file
 506 *
 507 * Print 1 if PM QoS feature is enabled, 0 if disabled.
 508 *
 509 * Returns number of characters written to @buf.
 510 */
 511static ssize_t pm_qos_enable_show(struct device *dev,
 512		struct device_attribute *attr, char *buf)
 513{
 514	struct ufs_hba *hba = dev_get_drvdata(dev);
 515
 516	guard(mutex)(&hba->pm_qos_mutex);
 517
 518	return sysfs_emit(buf, "%d\n", hba->pm_qos_enabled);
 519}
 520
 521/**
 522 * pm_qos_enable_store - sysfs handler to store value
 523 * @dev: device associated with the UFS controller
 524 * @attr: sysfs attribute handle
 525 * @buf: buffer for sysfs file
 526 * @count: stores buffer characters count
 527 *
 528 * Input 0 to disable PM QoS and 1 value to enable.
 529 * Default state: 1
 530 *
 531 * Return: number of characters written to @buf on success, < 0 upon failure.
 532 */
 533static ssize_t pm_qos_enable_store(struct device *dev,
 534		struct device_attribute *attr, const char *buf, size_t count)
 535{
 536	struct ufs_hba *hba = dev_get_drvdata(dev);
 537	bool value;
 538
 539	if (kstrtobool(buf, &value))
 540		return -EINVAL;
 541
 542	if (value)
 543		ufshcd_pm_qos_init(hba);
 544	else
 545		ufshcd_pm_qos_exit(hba);
 546
 547	return count;
 548}
 549
 550static ssize_t critical_health_show(struct device *dev,
 551				    struct device_attribute *attr, char *buf)
 552{
 553	struct ufs_hba *hba = dev_get_drvdata(dev);
 554
 555	return sysfs_emit(buf, "%d\n", hba->critical_health_count);
 556}
 557
 558static ssize_t device_lvl_exception_count_show(struct device *dev,
 559					       struct device_attribute *attr,
 560					       char *buf)
 561{
 562	struct ufs_hba *hba = dev_get_drvdata(dev);
 563
 564	if (hba->dev_info.wspecversion < 0x410)
 565		return -EOPNOTSUPP;
 566
 567	return sysfs_emit(buf, "%u\n", atomic_read(&hba->dev_lvl_exception_count));
 568}
 569
 570static ssize_t device_lvl_exception_count_store(struct device *dev,
 571						struct device_attribute *attr,
 572						const char *buf, size_t count)
 573{
 574	struct ufs_hba *hba = dev_get_drvdata(dev);
 575	unsigned int value;
 576
 577	if (kstrtouint(buf, 0, &value))
 578		return -EINVAL;
 579
 580	/* the only supported usecase is to reset the dev_lvl_exception_count */
 581	if (value)
 582		return -EINVAL;
 583
 584	atomic_set(&hba->dev_lvl_exception_count, 0);
 585
 586	return count;
 587}
 588
 589static ssize_t device_lvl_exception_id_show(struct device *dev,
 590					    struct device_attribute *attr,
 591					    char *buf)
 592{
 593	struct ufs_hba *hba = dev_get_drvdata(dev);
 594	u64 exception_id;
 595	int err;
 596
 597	ufshcd_rpm_get_sync(hba);
 598	err = ufshcd_read_device_lvl_exception_id(hba, &exception_id);
 599	ufshcd_rpm_put_sync(hba);
 600
 601	if (err)
 602		return err;
 603
 604	hba->dev_lvl_exception_id = exception_id;
 605	return sysfs_emit(buf, "%llu\n", exception_id);
 606}
 607
 608static DEVICE_ATTR_RW(rpm_lvl);
 609static DEVICE_ATTR_RO(rpm_target_dev_state);
 610static DEVICE_ATTR_RO(rpm_target_link_state);
 611static DEVICE_ATTR_RW(spm_lvl);
 612static DEVICE_ATTR_RO(spm_target_dev_state);
 613static DEVICE_ATTR_RO(spm_target_link_state);
 614static DEVICE_ATTR_RW(auto_hibern8);
 615static DEVICE_ATTR_RW(wb_on);
 616static DEVICE_ATTR_RW(enable_wb_buf_flush);
 617static DEVICE_ATTR_RW(wb_flush_threshold);
 618static DEVICE_ATTR_WO(wb_resize_enable);
 619static DEVICE_ATTR_RW(rtc_update_ms);
 620static DEVICE_ATTR_RW(pm_qos_enable);
 621static DEVICE_ATTR_RO(critical_health);
 622static DEVICE_ATTR_RW(device_lvl_exception_count);
 623static DEVICE_ATTR_RO(device_lvl_exception_id);
 624
 625static struct attribute *ufs_sysfs_ufshcd_attrs[] = {
 626	&dev_attr_rpm_lvl.attr,
 627	&dev_attr_rpm_target_dev_state.attr,
 628	&dev_attr_rpm_target_link_state.attr,
 629	&dev_attr_spm_lvl.attr,
 630	&dev_attr_spm_target_dev_state.attr,
 631	&dev_attr_spm_target_link_state.attr,
 632	&dev_attr_auto_hibern8.attr,
 633	&dev_attr_wb_on.attr,
 634	&dev_attr_enable_wb_buf_flush.attr,
 635	&dev_attr_wb_flush_threshold.attr,
 636	&dev_attr_wb_resize_enable.attr,
 637	&dev_attr_rtc_update_ms.attr,
 638	&dev_attr_pm_qos_enable.attr,
 639	&dev_attr_critical_health.attr,
 640	&dev_attr_device_lvl_exception_count.attr,
 641	&dev_attr_device_lvl_exception_id.attr,
 642	NULL
 643};
 644
 645static const struct attribute_group ufs_sysfs_default_group = {
 646	.attrs = ufs_sysfs_ufshcd_attrs,
 647};
 648
 649static ssize_t clock_scaling_show(struct device *dev, struct device_attribute *attr,
 650				  char *buf)
 651{
 652	struct ufs_hba *hba = dev_get_drvdata(dev);
 653
 654	return sysfs_emit(buf, "%d\n", ufshcd_is_clkscaling_supported(hba));
 655}
 656
 657static ssize_t write_booster_show(struct device *dev, struct device_attribute *attr,
 658				  char *buf)
 659{
 660	struct ufs_hba *hba = dev_get_drvdata(dev);
 661
 662	return sysfs_emit(buf, "%d\n", ufshcd_is_wb_allowed(hba));
 663}
 664
 665static DEVICE_ATTR_RO(clock_scaling);
 666static DEVICE_ATTR_RO(write_booster);
 667
 668/*
 669 * See Documentation/ABI/testing/sysfs-driver-ufs for the semantics of this
 670 * group.
 671 */
 672static struct attribute *ufs_sysfs_capabilities_attrs[] = {
 673	&dev_attr_clock_scaling.attr,
 674	&dev_attr_write_booster.attr,
 675	NULL
 676};
 677
 678static const struct attribute_group ufs_sysfs_capabilities_group = {
 679	.name = "capabilities",
 680	.attrs = ufs_sysfs_capabilities_attrs,
 681};
 682
 683static ssize_t version_show(struct device *dev,
 684		struct device_attribute *attr, char *buf)
 685{
 686	struct ufs_hba *hba = dev_get_drvdata(dev);
 687
 688	return sysfs_emit(buf, "0x%x\n", hba->ufs_version);
 689}
 690
 691static ssize_t product_id_show(struct device *dev,
 692		struct device_attribute *attr, char *buf)
 693{
 694	int ret;
 695	u32 val;
 696	struct ufs_hba *hba = dev_get_drvdata(dev);
 697
 698	ret = ufshcd_read_hci_reg(hba, &val, REG_CONTROLLER_PID);
 699	if (ret)
 700		return ret;
 701
 702	return sysfs_emit(buf, "0x%x\n", val);
 703}
 704
 705static ssize_t man_id_show(struct device *dev,
 706		struct device_attribute *attr, char *buf)
 707{
 708	int ret;
 709	u32 val;
 710	struct ufs_hba *hba = dev_get_drvdata(dev);
 711
 712	ret = ufshcd_read_hci_reg(hba, &val, REG_CONTROLLER_MID);
 713	if (ret)
 714		return ret;
 715
 716	return sysfs_emit(buf, "0x%x\n", val);
 717}
 718
 719static DEVICE_ATTR_RO(version);
 720static DEVICE_ATTR_RO(product_id);
 721static DEVICE_ATTR_RO(man_id);
 722
 723static struct attribute *ufs_sysfs_ufshci_cap_attrs[] = {
 724	&dev_attr_version.attr,
 725	&dev_attr_product_id.attr,
 726	&dev_attr_man_id.attr,
 727	NULL
 728};
 729
 730static const struct attribute_group ufs_sysfs_ufshci_group = {
 731	.name = "ufshci_capabilities",
 732	.attrs = ufs_sysfs_ufshci_cap_attrs,
 733};
 734
 735static ssize_t monitor_enable_show(struct device *dev,
 736				   struct device_attribute *attr, char *buf)
 737{
 738	struct ufs_hba *hba = dev_get_drvdata(dev);
 739
 740	return sysfs_emit(buf, "%d\n", hba->monitor.enabled);
 741}
 742
 743static ssize_t monitor_enable_store(struct device *dev,
 744				    struct device_attribute *attr,
 745				    const char *buf, size_t count)
 746{
 747	struct ufs_hba *hba = dev_get_drvdata(dev);
 748	unsigned long value, flags;
 749
 750	if (kstrtoul(buf, 0, &value))
 751		return -EINVAL;
 752
 753	value = !!value;
 754	spin_lock_irqsave(hba->host->host_lock, flags);
 755	if (value == hba->monitor.enabled)
 756		goto out_unlock;
 757
 758	if (!value) {
 759		memset(&hba->monitor, 0, sizeof(hba->monitor));
 760	} else {
 761		hba->monitor.enabled = true;
 762		hba->monitor.enabled_ts = ktime_get();
 763	}
 764
 765out_unlock:
 766	spin_unlock_irqrestore(hba->host->host_lock, flags);
 767	return count;
 768}
 769
 770static ssize_t monitor_chunk_size_show(struct device *dev,
 771				   struct device_attribute *attr, char *buf)
 772{
 773	struct ufs_hba *hba = dev_get_drvdata(dev);
 774
 775	return sysfs_emit(buf, "%lu\n", hba->monitor.chunk_size);
 776}
 777
 778static ssize_t monitor_chunk_size_store(struct device *dev,
 779				    struct device_attribute *attr,
 780				    const char *buf, size_t count)
 781{
 782	struct ufs_hba *hba = dev_get_drvdata(dev);
 783	unsigned long value, flags;
 784
 785	if (kstrtoul(buf, 0, &value))
 786		return -EINVAL;
 787
 788	spin_lock_irqsave(hba->host->host_lock, flags);
 789	/* Only allow chunk size change when monitor is disabled */
 790	if (!hba->monitor.enabled)
 791		hba->monitor.chunk_size = value;
 792	spin_unlock_irqrestore(hba->host->host_lock, flags);
 793	return count;
 794}
 795
 796static ssize_t read_total_sectors_show(struct device *dev,
 797				       struct device_attribute *attr, char *buf)
 798{
 799	struct ufs_hba *hba = dev_get_drvdata(dev);
 800
 801	return sysfs_emit(buf, "%lu\n", hba->monitor.nr_sec_rw[READ]);
 802}
 803
 804static ssize_t read_total_busy_show(struct device *dev,
 805				    struct device_attribute *attr, char *buf)
 806{
 807	struct ufs_hba *hba = dev_get_drvdata(dev);
 808
 809	return sysfs_emit(buf, "%llu\n",
 810			  ktime_to_us(hba->monitor.total_busy[READ]));
 811}
 812
 813static ssize_t read_nr_requests_show(struct device *dev,
 814				     struct device_attribute *attr, char *buf)
 815{
 816	struct ufs_hba *hba = dev_get_drvdata(dev);
 817
 818	return sysfs_emit(buf, "%lu\n", hba->monitor.nr_req[READ]);
 819}
 820
 821static ssize_t read_req_latency_avg_show(struct device *dev,
 822					 struct device_attribute *attr,
 823					 char *buf)
 824{
 825	struct ufs_hba *hba = dev_get_drvdata(dev);
 826	struct ufs_hba_monitor *m = &hba->monitor;
 827
 828	if (!m->nr_req[READ])
 829		return sysfs_emit(buf, "0\n");
 830
 831	return sysfs_emit(buf, "%llu\n", div_u64(ktime_to_us(m->lat_sum[READ]),
 832						 m->nr_req[READ]));
 833}
 834
 835static ssize_t read_req_latency_max_show(struct device *dev,
 836					 struct device_attribute *attr,
 837					 char *buf)
 838{
 839	struct ufs_hba *hba = dev_get_drvdata(dev);
 840
 841	return sysfs_emit(buf, "%llu\n",
 842			  ktime_to_us(hba->monitor.lat_max[READ]));
 843}
 844
 845static ssize_t read_req_latency_min_show(struct device *dev,
 846					 struct device_attribute *attr,
 847					 char *buf)
 848{
 849	struct ufs_hba *hba = dev_get_drvdata(dev);
 850
 851	return sysfs_emit(buf, "%llu\n",
 852			  ktime_to_us(hba->monitor.lat_min[READ]));
 853}
 854
 855static ssize_t read_req_latency_sum_show(struct device *dev,
 856					 struct device_attribute *attr,
 857					 char *buf)
 858{
 859	struct ufs_hba *hba = dev_get_drvdata(dev);
 860
 861	return sysfs_emit(buf, "%llu\n",
 862			  ktime_to_us(hba->monitor.lat_sum[READ]));
 863}
 864
 865static ssize_t write_total_sectors_show(struct device *dev,
 866					struct device_attribute *attr,
 867					char *buf)
 868{
 869	struct ufs_hba *hba = dev_get_drvdata(dev);
 870
 871	return sysfs_emit(buf, "%lu\n", hba->monitor.nr_sec_rw[WRITE]);
 872}
 873
 874static ssize_t write_total_busy_show(struct device *dev,
 875				     struct device_attribute *attr, char *buf)
 876{
 877	struct ufs_hba *hba = dev_get_drvdata(dev);
 878
 879	return sysfs_emit(buf, "%llu\n",
 880			  ktime_to_us(hba->monitor.total_busy[WRITE]));
 881}
 882
 883static ssize_t write_nr_requests_show(struct device *dev,
 884				      struct device_attribute *attr, char *buf)
 885{
 886	struct ufs_hba *hba = dev_get_drvdata(dev);
 887
 888	return sysfs_emit(buf, "%lu\n", hba->monitor.nr_req[WRITE]);
 889}
 890
 891static ssize_t write_req_latency_avg_show(struct device *dev,
 892					  struct device_attribute *attr,
 893					  char *buf)
 894{
 895	struct ufs_hba *hba = dev_get_drvdata(dev);
 896	struct ufs_hba_monitor *m = &hba->monitor;
 897
 898	if (!m->nr_req[WRITE])
 899		return sysfs_emit(buf, "0\n");
 900
 901	return sysfs_emit(buf, "%llu\n", div_u64(ktime_to_us(m->lat_sum[WRITE]),
 902						 m->nr_req[WRITE]));
 903}
 904
 905static ssize_t write_req_latency_max_show(struct device *dev,
 906					  struct device_attribute *attr,
 907					  char *buf)
 908{
 909	struct ufs_hba *hba = dev_get_drvdata(dev);
 910
 911	return sysfs_emit(buf, "%llu\n",
 912			  ktime_to_us(hba->monitor.lat_max[WRITE]));
 913}
 914
 915static ssize_t write_req_latency_min_show(struct device *dev,
 916					  struct device_attribute *attr,
 917					  char *buf)
 918{
 919	struct ufs_hba *hba = dev_get_drvdata(dev);
 920
 921	return sysfs_emit(buf, "%llu\n",
 922			  ktime_to_us(hba->monitor.lat_min[WRITE]));
 923}
 924
 925static ssize_t write_req_latency_sum_show(struct device *dev,
 926					  struct device_attribute *attr,
 927					  char *buf)
 928{
 929	struct ufs_hba *hba = dev_get_drvdata(dev);
 930
 931	return sysfs_emit(buf, "%llu\n",
 932			  ktime_to_us(hba->monitor.lat_sum[WRITE]));
 933}
 934
 935static DEVICE_ATTR_RW(monitor_enable);
 936static DEVICE_ATTR_RW(monitor_chunk_size);
 937static DEVICE_ATTR_RO(read_total_sectors);
 938static DEVICE_ATTR_RO(read_total_busy);
 939static DEVICE_ATTR_RO(read_nr_requests);
 940static DEVICE_ATTR_RO(read_req_latency_avg);
 941static DEVICE_ATTR_RO(read_req_latency_max);
 942static DEVICE_ATTR_RO(read_req_latency_min);
 943static DEVICE_ATTR_RO(read_req_latency_sum);
 944static DEVICE_ATTR_RO(write_total_sectors);
 945static DEVICE_ATTR_RO(write_total_busy);
 946static DEVICE_ATTR_RO(write_nr_requests);
 947static DEVICE_ATTR_RO(write_req_latency_avg);
 948static DEVICE_ATTR_RO(write_req_latency_max);
 949static DEVICE_ATTR_RO(write_req_latency_min);
 950static DEVICE_ATTR_RO(write_req_latency_sum);
 951
 952static struct attribute *ufs_sysfs_monitor_attrs[] = {
 953	&dev_attr_monitor_enable.attr,
 954	&dev_attr_monitor_chunk_size.attr,
 955	&dev_attr_read_total_sectors.attr,
 956	&dev_attr_read_total_busy.attr,
 957	&dev_attr_read_nr_requests.attr,
 958	&dev_attr_read_req_latency_avg.attr,
 959	&dev_attr_read_req_latency_max.attr,
 960	&dev_attr_read_req_latency_min.attr,
 961	&dev_attr_read_req_latency_sum.attr,
 962	&dev_attr_write_total_sectors.attr,
 963	&dev_attr_write_total_busy.attr,
 964	&dev_attr_write_nr_requests.attr,
 965	&dev_attr_write_req_latency_avg.attr,
 966	&dev_attr_write_req_latency_max.attr,
 967	&dev_attr_write_req_latency_min.attr,
 968	&dev_attr_write_req_latency_sum.attr,
 969	NULL
 970};
 971
 972static const struct attribute_group ufs_sysfs_monitor_group = {
 973	.name = "monitor",
 974	.attrs = ufs_sysfs_monitor_attrs,
 975};
 976
 977static ssize_t lane_show(struct device *dev, struct device_attribute *attr,
 978			 char *buf)
 979{
 980	struct ufs_hba *hba = dev_get_drvdata(dev);
 981
 982	return sysfs_emit(buf, "%u\n", hba->pwr_info.lane_rx);
 983}
 984
 985static ssize_t mode_show(struct device *dev, struct device_attribute *attr,
 986			 char *buf)
 987{
 988	struct ufs_hba *hba = dev_get_drvdata(dev);
 989
 990	return sysfs_emit(buf, "%s\n", ufs_pa_pwr_mode_to_string(hba->pwr_info.pwr_rx));
 991}
 992
 993static ssize_t rate_show(struct device *dev, struct device_attribute *attr,
 994			 char *buf)
 995{
 996	struct ufs_hba *hba = dev_get_drvdata(dev);
 997
 998	return sysfs_emit(buf, "%s\n", ufs_hs_gear_rate_to_string(hba->pwr_info.hs_rate));
 999}
1000
1001static ssize_t gear_show(struct device *dev, struct device_attribute *attr,
1002			 char *buf)
1003{
1004	struct ufs_hba *hba = dev_get_drvdata(dev);
1005
1006	return sysfs_emit(buf, "%s\n", hba->pwr_info.hs_rate ?
1007			  ufs_hs_gear_to_string(hba->pwr_info.gear_rx) :
1008			  ufs_pwm_gear_to_string(hba->pwr_info.gear_rx));
1009}
1010
1011static ssize_t dev_pm_show(struct device *dev, struct device_attribute *attr,
1012			   char *buf)
1013{
1014	struct ufs_hba *hba = dev_get_drvdata(dev);
1015
1016	return sysfs_emit(buf, "%s\n", ufshcd_ufs_dev_pwr_mode_to_string(hba->curr_dev_pwr_mode));
1017}
1018
1019static ssize_t link_state_show(struct device *dev,
1020			       struct device_attribute *attr, char *buf)
1021{
1022	struct ufs_hba *hba = dev_get_drvdata(dev);
1023
1024	return sysfs_emit(buf, "%s\n", ufshcd_uic_link_state_to_string(hba->uic_link_state));
1025}
1026
1027static DEVICE_ATTR_RO(lane);
1028static DEVICE_ATTR_RO(mode);
1029static DEVICE_ATTR_RO(rate);
1030static DEVICE_ATTR_RO(gear);
1031static DEVICE_ATTR_RO(dev_pm);
1032static DEVICE_ATTR_RO(link_state);
1033
1034static struct attribute *ufs_power_info_attrs[] = {
1035	&dev_attr_lane.attr,
1036	&dev_attr_mode.attr,
1037	&dev_attr_rate.attr,
1038	&dev_attr_gear.attr,
1039	&dev_attr_dev_pm.attr,
1040	&dev_attr_link_state.attr,
1041	NULL
1042};
1043
1044static const struct attribute_group ufs_sysfs_power_info_group = {
1045	.name = "power_info",
1046	.attrs = ufs_power_info_attrs,
1047};
1048
1049static ssize_t ufs_sysfs_read_desc_param(struct ufs_hba *hba,
1050				  enum desc_idn desc_id,
1051				  u8 desc_index,
1052				  u8 param_offset,
1053				  u8 *sysfs_buf,
1054				  u8 param_size)
1055{
1056	u8 desc_buf[8] = {0};
1057	int ret;
1058
1059	if (param_size > 8)
1060		return -EINVAL;
1061
1062	down(&hba->host_sem);
1063	if (!ufshcd_is_user_access_allowed(hba)) {
1064		ret = -EBUSY;
1065		goto out;
1066	}
1067
1068	ufshcd_rpm_get_sync(hba);
1069	ret = ufshcd_read_desc_param(hba, desc_id, desc_index,
1070				param_offset, desc_buf, param_size);
1071	ufshcd_rpm_put_sync(hba);
1072	if (ret) {
1073		ret = -EINVAL;
1074		goto out;
1075	}
1076
1077	switch (param_size) {
1078	case 1:
1079		ret = sysfs_emit(sysfs_buf, "0x%02X\n", *desc_buf);
1080		break;
1081	case 2:
1082		ret = sysfs_emit(sysfs_buf, "0x%04X\n",
1083			get_unaligned_be16(desc_buf));
1084		break;
1085	case 4:
1086		ret = sysfs_emit(sysfs_buf, "0x%08X\n",
1087			get_unaligned_be32(desc_buf));
1088		break;
1089	case 8:
1090		ret = sysfs_emit(sysfs_buf, "0x%016llX\n",
1091			get_unaligned_be64(desc_buf));
1092		break;
1093	}
1094
1095out:
1096	up(&hba->host_sem);
1097	return ret;
1098}
1099
1100#define UFS_DESC_PARAM(_name, _puname, _duname, _size)			\
1101static ssize_t _name##_show(struct device *dev,				\
1102	struct device_attribute *attr, char *buf)			\
1103{									\
1104	struct ufs_hba *hba = dev_get_drvdata(dev);			\
1105	return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_##_duname,	\
1106		0, _duname##_DESC_PARAM##_puname, buf, _size);		\
1107}									\
1108static DEVICE_ATTR_RO(_name)
1109
1110#define UFS_DEVICE_DESC_PARAM(_name, _uname, _size)			\
1111	UFS_DESC_PARAM(_name, _uname, DEVICE, _size)
1112
1113UFS_DEVICE_DESC_PARAM(device_type, _DEVICE_TYPE, 1);
1114UFS_DEVICE_DESC_PARAM(device_class, _DEVICE_CLASS, 1);
1115UFS_DEVICE_DESC_PARAM(device_sub_class, _DEVICE_SUB_CLASS, 1);
1116UFS_DEVICE_DESC_PARAM(protocol, _PRTCL, 1);
1117UFS_DEVICE_DESC_PARAM(number_of_luns, _NUM_LU, 1);
1118UFS_DEVICE_DESC_PARAM(number_of_wluns, _NUM_WLU, 1);
1119UFS_DEVICE_DESC_PARAM(boot_enable, _BOOT_ENBL, 1);
1120UFS_DEVICE_DESC_PARAM(descriptor_access_enable, _DESC_ACCSS_ENBL, 1);
1121UFS_DEVICE_DESC_PARAM(initial_power_mode, _INIT_PWR_MODE, 1);
1122UFS_DEVICE_DESC_PARAM(high_priority_lun, _HIGH_PR_LUN, 1);
1123UFS_DEVICE_DESC_PARAM(secure_removal_type, _SEC_RMV_TYPE, 1);
1124UFS_DEVICE_DESC_PARAM(support_security_lun, _SEC_LU, 1);
1125UFS_DEVICE_DESC_PARAM(bkops_termination_latency, _BKOP_TERM_LT, 1);
1126UFS_DEVICE_DESC_PARAM(initial_active_icc_level, _ACTVE_ICC_LVL, 1);
1127UFS_DEVICE_DESC_PARAM(specification_version, _SPEC_VER, 2);
1128UFS_DEVICE_DESC_PARAM(manufacturing_date, _MANF_DATE, 2);
1129UFS_DEVICE_DESC_PARAM(manufacturer_id, _MANF_ID, 2);
1130UFS_DEVICE_DESC_PARAM(rtt_capability, _RTT_CAP, 1);
1131UFS_DEVICE_DESC_PARAM(rtc_update, _FRQ_RTC, 2);
1132UFS_DEVICE_DESC_PARAM(ufs_features, _UFS_FEAT, 1);
1133UFS_DEVICE_DESC_PARAM(ffu_timeout, _FFU_TMT, 1);
1134UFS_DEVICE_DESC_PARAM(queue_depth, _Q_DPTH, 1);
1135UFS_DEVICE_DESC_PARAM(device_version, _DEV_VER, 2);
1136UFS_DEVICE_DESC_PARAM(number_of_secure_wpa, _NUM_SEC_WPA, 1);
1137UFS_DEVICE_DESC_PARAM(psa_max_data_size, _PSA_MAX_DATA, 4);
1138UFS_DEVICE_DESC_PARAM(psa_state_timeout, _PSA_TMT, 1);
1139UFS_DEVICE_DESC_PARAM(ext_feature_sup, _EXT_UFS_FEATURE_SUP, 4);
1140UFS_DEVICE_DESC_PARAM(wb_presv_us_en, _WB_PRESRV_USRSPC_EN, 1);
1141UFS_DEVICE_DESC_PARAM(wb_type, _WB_TYPE, 1);
1142UFS_DEVICE_DESC_PARAM(wb_shared_alloc_units, _WB_SHARED_ALLOC_UNITS, 4);
1143
1144static struct attribute *ufs_sysfs_device_descriptor[] = {
1145	&dev_attr_device_type.attr,
1146	&dev_attr_device_class.attr,
1147	&dev_attr_device_sub_class.attr,
1148	&dev_attr_protocol.attr,
1149	&dev_attr_number_of_luns.attr,
1150	&dev_attr_number_of_wluns.attr,
1151	&dev_attr_boot_enable.attr,
1152	&dev_attr_descriptor_access_enable.attr,
1153	&dev_attr_initial_power_mode.attr,
1154	&dev_attr_high_priority_lun.attr,
1155	&dev_attr_secure_removal_type.attr,
1156	&dev_attr_support_security_lun.attr,
1157	&dev_attr_bkops_termination_latency.attr,
1158	&dev_attr_initial_active_icc_level.attr,
1159	&dev_attr_specification_version.attr,
1160	&dev_attr_manufacturing_date.attr,
1161	&dev_attr_manufacturer_id.attr,
1162	&dev_attr_rtt_capability.attr,
1163	&dev_attr_rtc_update.attr,
1164	&dev_attr_ufs_features.attr,
1165	&dev_attr_ffu_timeout.attr,
1166	&dev_attr_queue_depth.attr,
1167	&dev_attr_device_version.attr,
1168	&dev_attr_number_of_secure_wpa.attr,
1169	&dev_attr_psa_max_data_size.attr,
1170	&dev_attr_psa_state_timeout.attr,
1171	&dev_attr_ext_feature_sup.attr,
1172	&dev_attr_wb_presv_us_en.attr,
1173	&dev_attr_wb_type.attr,
1174	&dev_attr_wb_shared_alloc_units.attr,
1175	NULL,
1176};
1177
1178static const struct attribute_group ufs_sysfs_device_descriptor_group = {
1179	.name = "device_descriptor",
1180	.attrs = ufs_sysfs_device_descriptor,
1181};
1182
1183#define UFS_INTERCONNECT_DESC_PARAM(_name, _uname, _size)		\
1184	UFS_DESC_PARAM(_name, _uname, INTERCONNECT, _size)
1185
1186UFS_INTERCONNECT_DESC_PARAM(unipro_version, _UNIPRO_VER, 2);
1187UFS_INTERCONNECT_DESC_PARAM(mphy_version, _MPHY_VER, 2);
1188
1189static struct attribute *ufs_sysfs_interconnect_descriptor[] = {
1190	&dev_attr_unipro_version.attr,
1191	&dev_attr_mphy_version.attr,
1192	NULL,
1193};
1194
1195static const struct attribute_group ufs_sysfs_interconnect_descriptor_group = {
1196	.name = "interconnect_descriptor",
1197	.attrs = ufs_sysfs_interconnect_descriptor,
1198};
1199
1200#define UFS_GEOMETRY_DESC_PARAM(_name, _uname, _size)			\
1201	UFS_DESC_PARAM(_name, _uname, GEOMETRY, _size)
1202
1203UFS_GEOMETRY_DESC_PARAM(raw_device_capacity, _DEV_CAP, 8);
1204UFS_GEOMETRY_DESC_PARAM(max_number_of_luns, _MAX_NUM_LUN, 1);
1205UFS_GEOMETRY_DESC_PARAM(segment_size, _SEG_SIZE, 4);
1206UFS_GEOMETRY_DESC_PARAM(allocation_unit_size, _ALLOC_UNIT_SIZE, 1);
1207UFS_GEOMETRY_DESC_PARAM(min_addressable_block_size, _MIN_BLK_SIZE, 1);
1208UFS_GEOMETRY_DESC_PARAM(optimal_read_block_size, _OPT_RD_BLK_SIZE, 1);
1209UFS_GEOMETRY_DESC_PARAM(optimal_write_block_size, _OPT_WR_BLK_SIZE, 1);
1210UFS_GEOMETRY_DESC_PARAM(max_in_buffer_size, _MAX_IN_BUF_SIZE, 1);
1211UFS_GEOMETRY_DESC_PARAM(max_out_buffer_size, _MAX_OUT_BUF_SIZE, 1);
1212UFS_GEOMETRY_DESC_PARAM(rpmb_rw_size, _RPMB_RW_SIZE, 1);
1213UFS_GEOMETRY_DESC_PARAM(dyn_capacity_resource_policy, _DYN_CAP_RSRC_PLC, 1);
1214UFS_GEOMETRY_DESC_PARAM(data_ordering, _DATA_ORDER, 1);
1215UFS_GEOMETRY_DESC_PARAM(max_number_of_contexts, _MAX_NUM_CTX, 1);
1216UFS_GEOMETRY_DESC_PARAM(sys_data_tag_unit_size, _TAG_UNIT_SIZE, 1);
1217UFS_GEOMETRY_DESC_PARAM(sys_data_tag_resource_size, _TAG_RSRC_SIZE, 1);
1218UFS_GEOMETRY_DESC_PARAM(secure_removal_types, _SEC_RM_TYPES, 1);
1219UFS_GEOMETRY_DESC_PARAM(memory_types, _MEM_TYPES, 2);
1220UFS_GEOMETRY_DESC_PARAM(sys_code_memory_max_alloc_units,
1221	_SCM_MAX_NUM_UNITS, 4);
1222UFS_GEOMETRY_DESC_PARAM(sys_code_memory_capacity_adjustment_factor,
1223	_SCM_CAP_ADJ_FCTR, 2);
1224UFS_GEOMETRY_DESC_PARAM(non_persist_memory_max_alloc_units,
1225	_NPM_MAX_NUM_UNITS, 4);
1226UFS_GEOMETRY_DESC_PARAM(non_persist_memory_capacity_adjustment_factor,
1227	_NPM_CAP_ADJ_FCTR, 2);
1228UFS_GEOMETRY_DESC_PARAM(enh1_memory_max_alloc_units,
1229	_ENM1_MAX_NUM_UNITS, 4);
1230UFS_GEOMETRY_DESC_PARAM(enh1_memory_capacity_adjustment_factor,
1231	_ENM1_CAP_ADJ_FCTR, 2);
1232UFS_GEOMETRY_DESC_PARAM(enh2_memory_max_alloc_units,
1233	_ENM2_MAX_NUM_UNITS, 4);
1234UFS_GEOMETRY_DESC_PARAM(enh2_memory_capacity_adjustment_factor,
1235	_ENM2_CAP_ADJ_FCTR, 2);
1236UFS_GEOMETRY_DESC_PARAM(enh3_memory_max_alloc_units,
1237	_ENM3_MAX_NUM_UNITS, 4);
1238UFS_GEOMETRY_DESC_PARAM(enh3_memory_capacity_adjustment_factor,
1239	_ENM3_CAP_ADJ_FCTR, 2);
1240UFS_GEOMETRY_DESC_PARAM(enh4_memory_max_alloc_units,
1241	_ENM4_MAX_NUM_UNITS, 4);
1242UFS_GEOMETRY_DESC_PARAM(enh4_memory_capacity_adjustment_factor,
1243	_ENM4_CAP_ADJ_FCTR, 2);
1244UFS_GEOMETRY_DESC_PARAM(wb_max_alloc_units, _WB_MAX_ALLOC_UNITS, 4);
1245UFS_GEOMETRY_DESC_PARAM(wb_max_wb_luns, _WB_MAX_WB_LUNS, 1);
1246UFS_GEOMETRY_DESC_PARAM(wb_buff_cap_adj, _WB_BUFF_CAP_ADJ, 1);
1247UFS_GEOMETRY_DESC_PARAM(wb_sup_red_type, _WB_SUP_RED_TYPE, 1);
1248UFS_GEOMETRY_DESC_PARAM(wb_sup_wb_type, _WB_SUP_WB_TYPE, 1);
1249
1250
1251static struct attribute *ufs_sysfs_geometry_descriptor[] = {
1252	&dev_attr_raw_device_capacity.attr,
1253	&dev_attr_max_number_of_luns.attr,
1254	&dev_attr_segment_size.attr,
1255	&dev_attr_allocation_unit_size.attr,
1256	&dev_attr_min_addressable_block_size.attr,
1257	&dev_attr_optimal_read_block_size.attr,
1258	&dev_attr_optimal_write_block_size.attr,
1259	&dev_attr_max_in_buffer_size.attr,
1260	&dev_attr_max_out_buffer_size.attr,
1261	&dev_attr_rpmb_rw_size.attr,
1262	&dev_attr_dyn_capacity_resource_policy.attr,
1263	&dev_attr_data_ordering.attr,
1264	&dev_attr_max_number_of_contexts.attr,
1265	&dev_attr_sys_data_tag_unit_size.attr,
1266	&dev_attr_sys_data_tag_resource_size.attr,
1267	&dev_attr_secure_removal_types.attr,
1268	&dev_attr_memory_types.attr,
1269	&dev_attr_sys_code_memory_max_alloc_units.attr,
1270	&dev_attr_sys_code_memory_capacity_adjustment_factor.attr,
1271	&dev_attr_non_persist_memory_max_alloc_units.attr,
1272	&dev_attr_non_persist_memory_capacity_adjustment_factor.attr,
1273	&dev_attr_enh1_memory_max_alloc_units.attr,
1274	&dev_attr_enh1_memory_capacity_adjustment_factor.attr,
1275	&dev_attr_enh2_memory_max_alloc_units.attr,
1276	&dev_attr_enh2_memory_capacity_adjustment_factor.attr,
1277	&dev_attr_enh3_memory_max_alloc_units.attr,
1278	&dev_attr_enh3_memory_capacity_adjustment_factor.attr,
1279	&dev_attr_enh4_memory_max_alloc_units.attr,
1280	&dev_attr_enh4_memory_capacity_adjustment_factor.attr,
1281	&dev_attr_wb_max_alloc_units.attr,
1282	&dev_attr_wb_max_wb_luns.attr,
1283	&dev_attr_wb_buff_cap_adj.attr,
1284	&dev_attr_wb_sup_red_type.attr,
1285	&dev_attr_wb_sup_wb_type.attr,
1286	NULL,
1287};
1288
1289static const struct attribute_group ufs_sysfs_geometry_descriptor_group = {
1290	.name = "geometry_descriptor",
1291	.attrs = ufs_sysfs_geometry_descriptor,
1292};
1293
1294#define UFS_HEALTH_DESC_PARAM(_name, _uname, _size)			\
1295	UFS_DESC_PARAM(_name, _uname, HEALTH, _size)
1296
1297UFS_HEALTH_DESC_PARAM(eol_info, _EOL_INFO, 1);
1298UFS_HEALTH_DESC_PARAM(life_time_estimation_a, _LIFE_TIME_EST_A, 1);
1299UFS_HEALTH_DESC_PARAM(life_time_estimation_b, _LIFE_TIME_EST_B, 1);
1300
1301static struct attribute *ufs_sysfs_health_descriptor[] = {
1302	&dev_attr_eol_info.attr,
1303	&dev_attr_life_time_estimation_a.attr,
1304	&dev_attr_life_time_estimation_b.attr,
1305	NULL,
1306};
1307
1308static const struct attribute_group ufs_sysfs_health_descriptor_group = {
1309	.name = "health_descriptor",
1310	.attrs = ufs_sysfs_health_descriptor,
1311};
1312
1313#define UFS_POWER_DESC_PARAM(_name, _uname, _index)			\
1314static ssize_t _name##_index##_show(struct device *dev,			\
1315	struct device_attribute *attr, char *buf)			\
1316{									\
1317	struct ufs_hba *hba = dev_get_drvdata(dev);			\
1318	return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_POWER, 0,	\
1319		PWR_DESC##_uname##_0 + _index * 2, buf, 2);		\
1320}									\
1321static DEVICE_ATTR_RO(_name##_index)
1322
1323UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 0);
1324UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 1);
1325UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 2);
1326UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 3);
1327UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 4);
1328UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 5);
1329UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 6);
1330UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 7);
1331UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 8);
1332UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 9);
1333UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 10);
1334UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 11);
1335UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 12);
1336UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 13);
1337UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 14);
1338UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 15);
1339UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 0);
1340UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 1);
1341UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 2);
1342UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 3);
1343UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 4);
1344UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 5);
1345UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 6);
1346UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 7);
1347UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 8);
1348UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 9);
1349UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 10);
1350UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 11);
1351UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 12);
1352UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 13);
1353UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 14);
1354UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 15);
1355UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 0);
1356UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 1);
1357UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 2);
1358UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 3);
1359UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 4);
1360UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 5);
1361UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 6);
1362UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 7);
1363UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 8);
1364UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 9);
1365UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 10);
1366UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 11);
1367UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 12);
1368UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 13);
1369UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 14);
1370UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 15);
1371
1372static struct attribute *ufs_sysfs_power_descriptor[] = {
1373	&dev_attr_active_icc_levels_vcc0.attr,
1374	&dev_attr_active_icc_levels_vcc1.attr,
1375	&dev_attr_active_icc_levels_vcc2.attr,
1376	&dev_attr_active_icc_levels_vcc3.attr,
1377	&dev_attr_active_icc_levels_vcc4.attr,
1378	&dev_attr_active_icc_levels_vcc5.attr,
1379	&dev_attr_active_icc_levels_vcc6.attr,
1380	&dev_attr_active_icc_levels_vcc7.attr,
1381	&dev_attr_active_icc_levels_vcc8.attr,
1382	&dev_attr_active_icc_levels_vcc9.attr,
1383	&dev_attr_active_icc_levels_vcc10.attr,
1384	&dev_attr_active_icc_levels_vcc11.attr,
1385	&dev_attr_active_icc_levels_vcc12.attr,
1386	&dev_attr_active_icc_levels_vcc13.attr,
1387	&dev_attr_active_icc_levels_vcc14.attr,
1388	&dev_attr_active_icc_levels_vcc15.attr,
1389	&dev_attr_active_icc_levels_vccq0.attr,
1390	&dev_attr_active_icc_levels_vccq1.attr,
1391	&dev_attr_active_icc_levels_vccq2.attr,
1392	&dev_attr_active_icc_levels_vccq3.attr,
1393	&dev_attr_active_icc_levels_vccq4.attr,
1394	&dev_attr_active_icc_levels_vccq5.attr,
1395	&dev_attr_active_icc_levels_vccq6.attr,
1396	&dev_attr_active_icc_levels_vccq7.attr,
1397	&dev_attr_active_icc_levels_vccq8.attr,
1398	&dev_attr_active_icc_levels_vccq9.attr,
1399	&dev_attr_active_icc_levels_vccq10.attr,
1400	&dev_attr_active_icc_levels_vccq11.attr,
1401	&dev_attr_active_icc_levels_vccq12.attr,
1402	&dev_attr_active_icc_levels_vccq13.attr,
1403	&dev_attr_active_icc_levels_vccq14.attr,
1404	&dev_attr_active_icc_levels_vccq15.attr,
1405	&dev_attr_active_icc_levels_vccq20.attr,
1406	&dev_attr_active_icc_levels_vccq21.attr,
1407	&dev_attr_active_icc_levels_vccq22.attr,
1408	&dev_attr_active_icc_levels_vccq23.attr,
1409	&dev_attr_active_icc_levels_vccq24.attr,
1410	&dev_attr_active_icc_levels_vccq25.attr,
1411	&dev_attr_active_icc_levels_vccq26.attr,
1412	&dev_attr_active_icc_levels_vccq27.attr,
1413	&dev_attr_active_icc_levels_vccq28.attr,
1414	&dev_attr_active_icc_levels_vccq29.attr,
1415	&dev_attr_active_icc_levels_vccq210.attr,
1416	&dev_attr_active_icc_levels_vccq211.attr,
1417	&dev_attr_active_icc_levels_vccq212.attr,
1418	&dev_attr_active_icc_levels_vccq213.attr,
1419	&dev_attr_active_icc_levels_vccq214.attr,
1420	&dev_attr_active_icc_levels_vccq215.attr,
1421	NULL,
1422};
1423
1424static const struct attribute_group ufs_sysfs_power_descriptor_group = {
1425	.name = "power_descriptor",
1426	.attrs = ufs_sysfs_power_descriptor,
1427};
1428
1429#define UFS_STRING_DESCRIPTOR(_name, _pname)				\
1430static ssize_t _name##_show(struct device *dev,				\
1431	struct device_attribute *attr, char *buf)			\
1432{									\
1433	u8 index;							\
1434	struct ufs_hba *hba = dev_get_drvdata(dev);			\
1435	int ret;							\
1436	int desc_len = QUERY_DESC_MAX_SIZE;				\
1437	u8 *desc_buf;							\
1438									\
1439	down(&hba->host_sem);						\
1440	if (!ufshcd_is_user_access_allowed(hba)) {			\
1441		up(&hba->host_sem);					\
1442		return -EBUSY;						\
1443	}								\
1444	desc_buf = kzalloc(QUERY_DESC_MAX_SIZE, GFP_ATOMIC);		\
1445	if (!desc_buf) {						\
1446		up(&hba->host_sem);					\
1447		return -ENOMEM;						\
1448	}								\
1449	ufshcd_rpm_get_sync(hba);					\
1450	ret = ufshcd_query_descriptor_retry(hba,			\
1451		UPIU_QUERY_OPCODE_READ_DESC, QUERY_DESC_IDN_DEVICE,	\
1452		0, 0, desc_buf, &desc_len);				\
1453	if (ret) {							\
1454		ret = -EINVAL;						\
1455		goto out;						\
1456	}								\
1457	index = desc_buf[DEVICE_DESC_PARAM##_pname];			\
1458	kfree(desc_buf);						\
1459	desc_buf = NULL;						\
1460	ret = ufshcd_read_string_desc(hba, index, &desc_buf,		\
1461				      SD_ASCII_STD);			\
1462	if (ret < 0)							\
1463		goto out;						\
1464	ret = sysfs_emit(buf, "%s\n", desc_buf);			\
1465out:									\
1466	ufshcd_rpm_put_sync(hba);					\
1467	kfree(desc_buf);						\
1468	up(&hba->host_sem);						\
1469	return ret;							\
1470}									\
1471static DEVICE_ATTR_RO(_name)
1472
1473UFS_STRING_DESCRIPTOR(manufacturer_name, _MANF_NAME);
1474UFS_STRING_DESCRIPTOR(product_name, _PRDCT_NAME);
1475UFS_STRING_DESCRIPTOR(oem_id, _OEM_ID);
1476UFS_STRING_DESCRIPTOR(serial_number, _SN);
1477UFS_STRING_DESCRIPTOR(product_revision, _PRDCT_REV);
1478
1479static struct attribute *ufs_sysfs_string_descriptors[] = {
1480	&dev_attr_manufacturer_name.attr,
1481	&dev_attr_product_name.attr,
1482	&dev_attr_oem_id.attr,
1483	&dev_attr_serial_number.attr,
1484	&dev_attr_product_revision.attr,
1485	NULL,
1486};
1487
1488static const struct attribute_group ufs_sysfs_string_descriptors_group = {
1489	.name = "string_descriptors",
1490	.attrs = ufs_sysfs_string_descriptors,
1491};
1492
1493static inline bool ufshcd_is_wb_flags(enum flag_idn idn)
1494{
1495	return idn >= QUERY_FLAG_IDN_WB_EN &&
1496		idn <= QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8;
1497}
1498
1499#define UFS_FLAG(_name, _uname)						\
1500static ssize_t _name##_show(struct device *dev,				\
1501	struct device_attribute *attr, char *buf)			\
1502{									\
1503	bool flag;							\
1504	u8 index = 0;							\
1505	int ret;							\
1506	struct ufs_hba *hba = dev_get_drvdata(dev);			\
1507									\
1508	down(&hba->host_sem);						\
1509	if (!ufshcd_is_user_access_allowed(hba)) {			\
1510		up(&hba->host_sem);					\
1511		return -EBUSY;						\
1512	}								\
1513	if (ufshcd_is_wb_flags(QUERY_FLAG_IDN##_uname))			\
1514		index = ufshcd_wb_get_query_index(hba);			\
1515	ufshcd_rpm_get_sync(hba);					\
1516	ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,	\
1517		QUERY_FLAG_IDN##_uname, index, &flag);			\
1518	ufshcd_rpm_put_sync(hba);					\
1519	if (ret) {							\
1520		ret = -EINVAL;						\
1521		goto out;						\
1522	}								\
1523	ret = sysfs_emit(buf, "%s\n", str_true_false(flag));		\
1524out:									\
1525	up(&hba->host_sem);						\
1526	return ret;							\
1527}									\
1528static DEVICE_ATTR_RO(_name)
1529
1530UFS_FLAG(device_init, _FDEVICEINIT);
1531UFS_FLAG(permanent_wpe, _PERMANENT_WPE);
1532UFS_FLAG(power_on_wpe, _PWR_ON_WPE);
1533UFS_FLAG(bkops_enable, _BKOPS_EN);
1534UFS_FLAG(life_span_mode_enable, _LIFE_SPAN_MODE_ENABLE);
1535UFS_FLAG(phy_resource_removal, _FPHYRESOURCEREMOVAL);
1536UFS_FLAG(busy_rtc, _BUSY_RTC);
1537UFS_FLAG(disable_fw_update, _PERMANENTLY_DISABLE_FW_UPDATE);
1538UFS_FLAG(wb_enable, _WB_EN);
1539UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
1540UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
1541
1542static struct attribute *ufs_sysfs_device_flags[] = {
1543	&dev_attr_device_init.attr,
1544	&dev_attr_permanent_wpe.attr,
1545	&dev_attr_power_on_wpe.attr,
1546	&dev_attr_bkops_enable.attr,
1547	&dev_attr_life_span_mode_enable.attr,
1548	&dev_attr_phy_resource_removal.attr,
1549	&dev_attr_busy_rtc.attr,
1550	&dev_attr_disable_fw_update.attr,
1551	&dev_attr_wb_enable.attr,
1552	&dev_attr_wb_flush_en.attr,
1553	&dev_attr_wb_flush_during_h8.attr,
1554	NULL,
1555};
1556
1557static const struct attribute_group ufs_sysfs_flags_group = {
1558	.name = "flags",
1559	.attrs = ufs_sysfs_device_flags,
1560};
1561
1562static ssize_t max_number_of_rtt_show(struct device *dev,
1563				      struct device_attribute *attr, char *buf)
1564{
1565	struct ufs_hba *hba = dev_get_drvdata(dev);
1566	u32 rtt;
1567	int ret;
1568
1569	down(&hba->host_sem);
1570	if (!ufshcd_is_user_access_allowed(hba)) {
1571		up(&hba->host_sem);
1572		return -EBUSY;
1573	}
1574
1575	ufshcd_rpm_get_sync(hba);
1576	ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1577		QUERY_ATTR_IDN_MAX_NUM_OF_RTT, 0, 0, &rtt);
1578	ufshcd_rpm_put_sync(hba);
1579
1580	if (ret)
1581		goto out;
1582
1583	ret = sysfs_emit(buf, "0x%08X\n", rtt);
1584
1585out:
1586	up(&hba->host_sem);
1587	return ret;
1588}
1589
1590static ssize_t max_number_of_rtt_store(struct device *dev,
1591				       struct device_attribute *attr,
1592				       const char *buf, size_t count)
1593{
1594	struct ufs_hba *hba = dev_get_drvdata(dev);
1595	struct ufs_dev_info *dev_info = &hba->dev_info;
1596	struct scsi_device *sdev;
1597	unsigned int memflags;
1598	unsigned int rtt;
1599	int ret;
1600
1601	if (kstrtouint(buf, 0, &rtt))
1602		return -EINVAL;
1603
1604	if (rtt > dev_info->rtt_cap) {
1605		dev_err(dev, "rtt can be at most bDeviceRTTCap\n");
1606		return -EINVAL;
1607	}
1608
1609	down(&hba->host_sem);
1610	if (!ufshcd_is_user_access_allowed(hba)) {
1611		ret = -EBUSY;
1612		goto out;
1613	}
1614
1615	ufshcd_rpm_get_sync(hba);
1616
1617	memflags = memalloc_noio_save();
1618	shost_for_each_device(sdev, hba->host)
1619		blk_mq_freeze_queue_nomemsave(sdev->request_queue);
1620
1621	ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
1622		QUERY_ATTR_IDN_MAX_NUM_OF_RTT, 0, 0, &rtt);
1623
1624	shost_for_each_device(sdev, hba->host)
1625		blk_mq_unfreeze_queue_nomemrestore(sdev->request_queue);
1626	memalloc_noio_restore(memflags);
1627
1628	ufshcd_rpm_put_sync(hba);
1629
1630out:
1631	up(&hba->host_sem);
1632	return ret < 0 ? ret : count;
1633}
1634
1635static DEVICE_ATTR_RW(max_number_of_rtt);
1636
1637static inline bool ufshcd_is_wb_attrs(enum attr_idn idn)
1638{
1639	return idn >= QUERY_ATTR_IDN_WB_FLUSH_STATUS &&
1640		idn <= QUERY_ATTR_IDN_CURR_WB_BUFF_SIZE;
1641}
1642
1643static int wb_read_resize_attrs(struct ufs_hba *hba,
1644			enum attr_idn idn, u32 *attr_val)
1645{
1646	u8 index = 0;
1647	int ret;
1648
1649	if (!ufshcd_is_wb_allowed(hba) || !hba->dev_info.wb_enabled
1650		|| !hba->dev_info.b_presrv_uspc_en
1651		|| !(hba->dev_info.ext_wb_sup & UFS_DEV_WB_BUF_RESIZE))
1652		return -EOPNOTSUPP;
1653
1654	down(&hba->host_sem);
1655	if (!ufshcd_is_user_access_allowed(hba)) {
1656		up(&hba->host_sem);
1657		return -EBUSY;
1658	}
1659
1660	index = ufshcd_wb_get_query_index(hba);
1661	ufshcd_rpm_get_sync(hba);
1662	ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1663			idn, index, 0, attr_val);
1664	ufshcd_rpm_put_sync(hba);
1665
1666	up(&hba->host_sem);
1667	return ret;
1668}
1669
1670static ssize_t wb_resize_hint_show(struct device *dev,
1671				struct device_attribute *attr, char *buf)
1672{
1673	struct ufs_hba *hba = dev_get_drvdata(dev);
1674	int ret;
1675	u32 value;
1676
1677	ret = wb_read_resize_attrs(hba,
1678			QUERY_ATTR_IDN_WB_BUF_RESIZE_HINT, &value);
1679	if (ret)
1680		return ret;
1681
1682	return sysfs_emit(buf, "%s\n", ufs_wb_resize_hint_to_string(value));
1683}
1684
1685static DEVICE_ATTR_RO(wb_resize_hint);
1686
1687static ssize_t wb_resize_status_show(struct device *dev,
1688				struct device_attribute *attr, char *buf)
1689{
1690	struct ufs_hba *hba = dev_get_drvdata(dev);
1691	int ret;
1692	u32 value;
1693
1694	ret = wb_read_resize_attrs(hba,
1695			QUERY_ATTR_IDN_WB_BUF_RESIZE_STATUS, &value);
1696	if (ret)
1697		return ret;
1698
1699	return sysfs_emit(buf, "%s\n", ufs_wb_resize_status_to_string(value));
1700}
1701
1702static DEVICE_ATTR_RO(wb_resize_status);
1703
1704#define UFS_ATTRIBUTE(_name, _uname)					\
1705static ssize_t _name##_show(struct device *dev,				\
1706	struct device_attribute *attr, char *buf)			\
1707{									\
1708	struct ufs_hba *hba = dev_get_drvdata(dev);			\
1709	u32 value;							\
1710	int ret;							\
1711	u8 index = 0;							\
1712									\
1713	down(&hba->host_sem);						\
1714	if (!ufshcd_is_user_access_allowed(hba)) {			\
1715		up(&hba->host_sem);					\
1716		return -EBUSY;						\
1717	}								\
1718	if (ufshcd_is_wb_attrs(QUERY_ATTR_IDN##_uname))			\
1719		index = ufshcd_wb_get_query_index(hba);			\
1720	ufshcd_rpm_get_sync(hba);					\
1721	ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,	\
1722		QUERY_ATTR_IDN##_uname, index, 0, &value);		\
1723	ufshcd_rpm_put_sync(hba);					\
1724	if (ret) {							\
1725		ret = -EINVAL;						\
1726		goto out;						\
1727	}								\
1728	ret = sysfs_emit(buf, "0x%08X\n", value);			\
1729out:									\
1730	up(&hba->host_sem);						\
1731	return ret;							\
1732}									\
1733static DEVICE_ATTR_RO(_name)
1734
1735UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
1736UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
1737UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
1738UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
1739UFS_ATTRIBUTE(bkops_status, _BKOPS_STATUS);
1740UFS_ATTRIBUTE(purge_status, _PURGE_STATUS);
1741UFS_ATTRIBUTE(max_data_in_size, _MAX_DATA_IN);
1742UFS_ATTRIBUTE(max_data_out_size, _MAX_DATA_OUT);
1743UFS_ATTRIBUTE(reference_clock_frequency, _REF_CLK_FREQ);
1744UFS_ATTRIBUTE(configuration_descriptor_lock, _CONF_DESC_LOCK);
1745UFS_ATTRIBUTE(exception_event_control, _EE_CONTROL);
1746UFS_ATTRIBUTE(exception_event_status, _EE_STATUS);
1747UFS_ATTRIBUTE(ffu_status, _FFU_STATUS);
1748UFS_ATTRIBUTE(psa_state, _PSA_STATE);
1749UFS_ATTRIBUTE(psa_data_size, _PSA_DATA_SIZE);
1750UFS_ATTRIBUTE(wb_flush_status, _WB_FLUSH_STATUS);
1751UFS_ATTRIBUTE(wb_avail_buf, _AVAIL_WB_BUFF_SIZE);
1752UFS_ATTRIBUTE(wb_life_time_est, _WB_BUFF_LIFE_TIME_EST);
1753UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
1754
1755
1756static struct attribute *ufs_sysfs_attributes[] = {
1757	&dev_attr_boot_lun_enabled.attr,
1758	&dev_attr_current_power_mode.attr,
1759	&dev_attr_active_icc_level.attr,
1760	&dev_attr_ooo_data_enabled.attr,
1761	&dev_attr_bkops_status.attr,
1762	&dev_attr_purge_status.attr,
1763	&dev_attr_max_data_in_size.attr,
1764	&dev_attr_max_data_out_size.attr,
1765	&dev_attr_reference_clock_frequency.attr,
1766	&dev_attr_configuration_descriptor_lock.attr,
1767	&dev_attr_max_number_of_rtt.attr,
1768	&dev_attr_exception_event_control.attr,
1769	&dev_attr_exception_event_status.attr,
1770	&dev_attr_ffu_status.attr,
1771	&dev_attr_psa_state.attr,
1772	&dev_attr_psa_data_size.attr,
1773	&dev_attr_wb_flush_status.attr,
1774	&dev_attr_wb_avail_buf.attr,
1775	&dev_attr_wb_life_time_est.attr,
1776	&dev_attr_wb_cur_buf.attr,
1777	&dev_attr_wb_resize_hint.attr,
1778	&dev_attr_wb_resize_status.attr,
1779	NULL,
1780};
1781
1782static const struct attribute_group ufs_sysfs_attributes_group = {
1783	.name = "attributes",
1784	.attrs = ufs_sysfs_attributes,
1785};
1786
1787static int hid_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
1788			enum attr_idn idn, u32 *attr_val)
1789{
1790	int ret;
1791
1792	down(&hba->host_sem);
1793	if (!ufshcd_is_user_access_allowed(hba)) {
1794		up(&hba->host_sem);
1795		return -EBUSY;
1796	}
1797
1798	ufshcd_rpm_get_sync(hba);
1799	ret = ufshcd_query_attr(hba, opcode, idn, 0, 0, attr_val);
1800	ufshcd_rpm_put_sync(hba);
1801
1802	up(&hba->host_sem);
1803	return ret;
1804}
1805
1806static ssize_t analysis_trigger_store(struct device *dev,
1807		struct device_attribute *attr, const char *buf, size_t count)
1808{
1809	struct ufs_hba *hba = dev_get_drvdata(dev);
1810	int mode;
1811	int ret;
1812
1813	if (sysfs_streq(buf, "enable"))
1814		mode = HID_ANALYSIS_ENABLE;
1815	else if (sysfs_streq(buf, "disable"))
1816		mode = HID_ANALYSIS_AND_DEFRAG_DISABLE;
1817	else
1818		return -EINVAL;
1819
1820	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
1821			QUERY_ATTR_IDN_HID_DEFRAG_OPERATION, &mode);
1822
1823	return ret < 0 ? ret : count;
1824}
1825
1826static DEVICE_ATTR_WO(analysis_trigger);
1827
1828static ssize_t defrag_trigger_store(struct device *dev,
1829		struct device_attribute *attr, const char *buf, size_t count)
1830{
1831	struct ufs_hba *hba = dev_get_drvdata(dev);
1832	int mode;
1833	int ret;
1834
1835	if (sysfs_streq(buf, "enable"))
1836		mode = HID_ANALYSIS_AND_DEFRAG_ENABLE;
1837	else if (sysfs_streq(buf, "disable"))
1838		mode = HID_ANALYSIS_AND_DEFRAG_DISABLE;
1839	else
1840		return -EINVAL;
1841
1842	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
1843			QUERY_ATTR_IDN_HID_DEFRAG_OPERATION, &mode);
1844
1845	return ret < 0 ? ret : count;
1846}
1847
1848static DEVICE_ATTR_WO(defrag_trigger);
1849
1850static ssize_t fragmented_size_show(struct device *dev,
1851		struct device_attribute *attr, char *buf)
1852{
1853	struct ufs_hba *hba = dev_get_drvdata(dev);
1854	u32 value;
1855	int ret;
1856
1857	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1858			QUERY_ATTR_IDN_HID_AVAILABLE_SIZE, &value);
1859	if (ret)
1860		return ret;
1861
1862	return sysfs_emit(buf, "%u\n", value);
1863}
1864
1865static DEVICE_ATTR_RO(fragmented_size);
1866
1867static ssize_t defrag_size_show(struct device *dev,
1868		struct device_attribute *attr, char *buf)
1869{
1870	struct ufs_hba *hba = dev_get_drvdata(dev);
1871	u32 value;
1872	int ret;
1873
1874	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1875			QUERY_ATTR_IDN_HID_SIZE, &value);
1876	if (ret)
1877		return ret;
1878
1879	return sysfs_emit(buf, "%u\n", value);
1880}
1881
1882static ssize_t defrag_size_store(struct device *dev,
1883		struct device_attribute *attr, const char *buf, size_t count)
1884{
1885	struct ufs_hba *hba = dev_get_drvdata(dev);
1886	u32 value;
1887	int ret;
1888
1889	if (kstrtou32(buf, 0, &value))
1890		return -EINVAL;
1891
1892	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
1893			QUERY_ATTR_IDN_HID_SIZE, &value);
1894
1895	return ret < 0 ? ret : count;
1896}
1897
1898static DEVICE_ATTR_RW(defrag_size);
1899
1900static ssize_t progress_ratio_show(struct device *dev,
1901		struct device_attribute *attr, char *buf)
1902{
1903	struct ufs_hba *hba = dev_get_drvdata(dev);
1904	u32 value;
1905	int ret;
1906
1907	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1908			QUERY_ATTR_IDN_HID_PROGRESS_RATIO, &value);
1909	if (ret)
1910		return ret;
1911
1912	return sysfs_emit(buf, "%u\n", value);
1913}
1914
1915static DEVICE_ATTR_RO(progress_ratio);
1916
1917static ssize_t state_show(struct device *dev,
1918		struct device_attribute *attr, char *buf)
1919{
1920	struct ufs_hba *hba = dev_get_drvdata(dev);
1921	u32 value;
1922	int ret;
1923
1924	ret = hid_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1925			QUERY_ATTR_IDN_HID_STATE, &value);
1926	if (ret)
1927		return ret;
1928
1929	return sysfs_emit(buf, "%s\n", ufs_hid_state_to_string(value));
1930}
1931
1932static DEVICE_ATTR_RO(state);
1933
1934static struct attribute *ufs_sysfs_hid[] = {
1935	&dev_attr_analysis_trigger.attr,
1936	&dev_attr_defrag_trigger.attr,
1937	&dev_attr_fragmented_size.attr,
1938	&dev_attr_defrag_size.attr,
1939	&dev_attr_progress_ratio.attr,
1940	&dev_attr_state.attr,
1941	NULL,
1942};
1943
1944static umode_t ufs_sysfs_hid_is_visible(struct kobject *kobj,
1945		struct attribute *attr, int n)
1946{
1947	struct device *dev = container_of(kobj, struct device, kobj);
1948	struct ufs_hba *hba = dev_get_drvdata(dev);
1949
1950	return	hba->dev_info.hid_sup ? attr->mode : 0;
1951}
1952
1953static const struct attribute_group ufs_sysfs_hid_group = {
1954	.name = "hid",
1955	.attrs = ufs_sysfs_hid,
1956	.is_visible = ufs_sysfs_hid_is_visible,
1957};
1958
1959static const struct attribute_group *ufs_sysfs_groups[] = {
1960	&ufs_sysfs_default_group,
1961	&ufs_sysfs_capabilities_group,
1962	&ufs_sysfs_ufshci_group,
1963	&ufs_sysfs_monitor_group,
1964	&ufs_sysfs_power_info_group,
1965	&ufs_sysfs_device_descriptor_group,
1966	&ufs_sysfs_interconnect_descriptor_group,
1967	&ufs_sysfs_geometry_descriptor_group,
1968	&ufs_sysfs_health_descriptor_group,
1969	&ufs_sysfs_power_descriptor_group,
1970	&ufs_sysfs_string_descriptors_group,
1971	&ufs_sysfs_flags_group,
1972	&ufs_sysfs_attributes_group,
1973	&ufs_sysfs_hid_group,
1974	NULL,
1975};
1976
1977#define UFS_LUN_DESC_PARAM(_pname, _puname, _duname, _size)		\
1978static ssize_t _pname##_show(struct device *dev,			\
1979	struct device_attribute *attr, char *buf)			\
1980{									\
1981	struct scsi_device *sdev = to_scsi_device(dev);			\
1982	struct ufs_hba *hba = shost_priv(sdev->host);			\
1983	u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);			\
1984	if (!ufs_is_valid_unit_desc_lun(&hba->dev_info, lun))		\
1985		return -EINVAL;						\
1986	return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_##_duname,	\
1987		lun, _duname##_DESC_PARAM##_puname, buf, _size);	\
1988}									\
1989static DEVICE_ATTR_RO(_pname)
1990
1991#define UFS_UNIT_DESC_PARAM(_name, _uname, _size)			\
1992	UFS_LUN_DESC_PARAM(_name, _uname, UNIT, _size)
1993
1994UFS_UNIT_DESC_PARAM(lu_enable, _LU_ENABLE, 1);
1995UFS_UNIT_DESC_PARAM(boot_lun_id, _BOOT_LUN_ID, 1);
1996UFS_UNIT_DESC_PARAM(lun_write_protect, _LU_WR_PROTECT, 1);
1997UFS_UNIT_DESC_PARAM(lun_queue_depth, _LU_Q_DEPTH, 1);
1998UFS_UNIT_DESC_PARAM(psa_sensitive, _PSA_SENSITIVE, 1);
1999UFS_UNIT_DESC_PARAM(lun_memory_type, _MEM_TYPE, 1);
2000UFS_UNIT_DESC_PARAM(data_reliability, _DATA_RELIABILITY, 1);
2001UFS_UNIT_DESC_PARAM(logical_block_size, _LOGICAL_BLK_SIZE, 1);
2002UFS_UNIT_DESC_PARAM(logical_block_count, _LOGICAL_BLK_COUNT, 8);
2003UFS_UNIT_DESC_PARAM(erase_block_size, _ERASE_BLK_SIZE, 4);
2004UFS_UNIT_DESC_PARAM(provisioning_type, _PROVISIONING_TYPE, 1);
2005UFS_UNIT_DESC_PARAM(physical_memory_resource_count, _PHY_MEM_RSRC_CNT, 8);
2006UFS_UNIT_DESC_PARAM(context_capabilities, _CTX_CAPABILITIES, 2);
2007UFS_UNIT_DESC_PARAM(large_unit_granularity, _LARGE_UNIT_SIZE_M1, 1);
2008UFS_UNIT_DESC_PARAM(wb_buf_alloc_units, _WB_BUF_ALLOC_UNITS, 4);
2009
2010static struct attribute *ufs_sysfs_unit_descriptor[] = {
2011	&dev_attr_lu_enable.attr,
2012	&dev_attr_boot_lun_id.attr,
2013	&dev_attr_lun_write_protect.attr,
2014	&dev_attr_lun_queue_depth.attr,
2015	&dev_attr_psa_sensitive.attr,
2016	&dev_attr_lun_memory_type.attr,
2017	&dev_attr_data_reliability.attr,
2018	&dev_attr_logical_block_size.attr,
2019	&dev_attr_logical_block_count.attr,
2020	&dev_attr_erase_block_size.attr,
2021	&dev_attr_provisioning_type.attr,
2022	&dev_attr_physical_memory_resource_count.attr,
2023	&dev_attr_context_capabilities.attr,
2024	&dev_attr_large_unit_granularity.attr,
2025	&dev_attr_wb_buf_alloc_units.attr,
2026	NULL,
2027};
2028
2029static umode_t ufs_unit_descriptor_is_visible(struct kobject *kobj, struct attribute *attr, int n)
2030{
2031	struct device *dev = container_of(kobj, struct device, kobj);
2032	struct scsi_device *sdev = to_scsi_device(dev);
2033	u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);
2034	umode_t mode = attr->mode;
2035
2036	if (lun == UFS_UPIU_BOOT_WLUN || lun == UFS_UPIU_UFS_DEVICE_WLUN)
2037		/* Boot and device WLUN have no unit descriptors */
2038		mode = 0;
2039	if (lun == UFS_UPIU_RPMB_WLUN && attr == &dev_attr_wb_buf_alloc_units.attr)
2040		mode = 0;
2041
2042	return mode;
2043}
2044
2045
2046const struct attribute_group ufs_sysfs_unit_descriptor_group = {
2047	.name = "unit_descriptor",
2048	.attrs = ufs_sysfs_unit_descriptor,
2049	.is_visible = ufs_unit_descriptor_is_visible,
2050};
2051
2052static ssize_t dyn_cap_needed_attribute_show(struct device *dev,
2053	struct device_attribute *attr, char *buf)
2054{
2055	u32 value;
2056	struct scsi_device *sdev = to_scsi_device(dev);
2057	struct ufs_hba *hba = shost_priv(sdev->host);
2058	u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);
2059	int ret;
2060
2061	down(&hba->host_sem);
2062	if (!ufshcd_is_user_access_allowed(hba)) {
2063		ret = -EBUSY;
2064		goto out;
2065	}
2066
2067	ufshcd_rpm_get_sync(hba);
2068	ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
2069		QUERY_ATTR_IDN_DYN_CAP_NEEDED, lun, 0, &value);
2070	ufshcd_rpm_put_sync(hba);
2071	if (ret) {
2072		ret = -EINVAL;
2073		goto out;
2074	}
2075
2076	ret = sysfs_emit(buf, "0x%08X\n", value);
2077
2078out:
2079	up(&hba->host_sem);
2080	return ret;
2081}
2082static DEVICE_ATTR_RO(dyn_cap_needed_attribute);
2083
2084static struct attribute *ufs_sysfs_lun_attributes[] = {
2085	&dev_attr_dyn_cap_needed_attribute.attr,
2086	NULL,
2087};
2088
2089const struct attribute_group ufs_sysfs_lun_attributes_group = {
2090	.attrs = ufs_sysfs_lun_attributes,
2091};
2092
2093void ufs_sysfs_add_nodes(struct device *dev)
2094{
2095	int ret;
2096
2097	ret = sysfs_create_groups(&dev->kobj, ufs_sysfs_groups);
2098	if (ret)
2099		dev_err(dev,
2100			"%s: sysfs groups creation failed (err = %d)\n",
2101			__func__, ret);
2102}
2103
2104void ufs_sysfs_remove_nodes(struct device *dev)
2105{
2106	sysfs_remove_groups(&dev->kobj, ufs_sysfs_groups);
2107}