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