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