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