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 <asm/unaligned.h>
8
9 #include "ufs.h"
10 #include "ufs-sysfs.h"
11
12 #include <trace/hooks/ufshcd.h>
13
ufschd_uic_link_state_to_string(enum uic_link_state state)14 static const char *ufschd_uic_link_state_to_string(
15 enum uic_link_state state)
16 {
17 switch (state) {
18 case UIC_LINK_OFF_STATE: return "OFF";
19 case UIC_LINK_ACTIVE_STATE: return "ACTIVE";
20 case UIC_LINK_HIBERN8_STATE: return "HIBERN8";
21 case UIC_LINK_BROKEN_STATE: return "BROKEN";
22 default: return "UNKNOWN";
23 }
24 }
25
ufschd_ufs_dev_pwr_mode_to_string(enum ufs_dev_pwr_mode state)26 static const char *ufschd_ufs_dev_pwr_mode_to_string(
27 enum ufs_dev_pwr_mode state)
28 {
29 switch (state) {
30 case UFS_ACTIVE_PWR_MODE: return "ACTIVE";
31 case UFS_SLEEP_PWR_MODE: return "SLEEP";
32 case UFS_POWERDOWN_PWR_MODE: return "POWERDOWN";
33 default: return "UNKNOWN";
34 }
35 }
36
ufs_sysfs_pm_lvl_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count,bool rpm)37 static inline ssize_t ufs_sysfs_pm_lvl_store(struct device *dev,
38 struct device_attribute *attr,
39 const char *buf, size_t count,
40 bool rpm)
41 {
42 struct ufs_hba *hba = dev_get_drvdata(dev);
43 unsigned long flags, value;
44
45 if (kstrtoul(buf, 0, &value))
46 return -EINVAL;
47
48 if (value >= UFS_PM_LVL_MAX)
49 return -EINVAL;
50
51 spin_lock_irqsave(hba->host->host_lock, flags);
52 if (rpm)
53 hba->rpm_lvl = value;
54 else
55 hba->spm_lvl = value;
56 spin_unlock_irqrestore(hba->host->host_lock, flags);
57 return count;
58 }
59
rpm_lvl_show(struct device * dev,struct device_attribute * attr,char * buf)60 static ssize_t rpm_lvl_show(struct device *dev,
61 struct device_attribute *attr, char *buf)
62 {
63 struct ufs_hba *hba = dev_get_drvdata(dev);
64
65 return sysfs_emit(buf, "%d\n", hba->rpm_lvl);
66 }
67
rpm_lvl_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)68 static ssize_t rpm_lvl_store(struct device *dev,
69 struct device_attribute *attr, const char *buf, size_t count)
70 {
71 return ufs_sysfs_pm_lvl_store(dev, attr, buf, count, true);
72 }
73
rpm_target_dev_state_show(struct device * dev,struct device_attribute * attr,char * buf)74 static ssize_t rpm_target_dev_state_show(struct device *dev,
75 struct device_attribute *attr, char *buf)
76 {
77 struct ufs_hba *hba = dev_get_drvdata(dev);
78
79 return sysfs_emit(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
80 ufs_pm_lvl_states[hba->rpm_lvl].dev_state));
81 }
82
rpm_target_link_state_show(struct device * dev,struct device_attribute * attr,char * buf)83 static ssize_t rpm_target_link_state_show(struct device *dev,
84 struct device_attribute *attr, char *buf)
85 {
86 struct ufs_hba *hba = dev_get_drvdata(dev);
87
88 return sysfs_emit(buf, "%s\n", ufschd_uic_link_state_to_string(
89 ufs_pm_lvl_states[hba->rpm_lvl].link_state));
90 }
91
spm_lvl_show(struct device * dev,struct device_attribute * attr,char * buf)92 static ssize_t spm_lvl_show(struct device *dev,
93 struct device_attribute *attr, char *buf)
94 {
95 struct ufs_hba *hba = dev_get_drvdata(dev);
96
97 return sysfs_emit(buf, "%d\n", hba->spm_lvl);
98 }
99
spm_lvl_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)100 static ssize_t spm_lvl_store(struct device *dev,
101 struct device_attribute *attr, const char *buf, size_t count)
102 {
103 return ufs_sysfs_pm_lvl_store(dev, attr, buf, count, false);
104 }
105
spm_target_dev_state_show(struct device * dev,struct device_attribute * attr,char * buf)106 static ssize_t spm_target_dev_state_show(struct device *dev,
107 struct device_attribute *attr, char *buf)
108 {
109 struct ufs_hba *hba = dev_get_drvdata(dev);
110
111 return sysfs_emit(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
112 ufs_pm_lvl_states[hba->spm_lvl].dev_state));
113 }
114
spm_target_link_state_show(struct device * dev,struct device_attribute * attr,char * buf)115 static ssize_t spm_target_link_state_show(struct device *dev,
116 struct device_attribute *attr, char *buf)
117 {
118 struct ufs_hba *hba = dev_get_drvdata(dev);
119
120 return sysfs_emit(buf, "%s\n", ufschd_uic_link_state_to_string(
121 ufs_pm_lvl_states[hba->spm_lvl].link_state));
122 }
123
124 /* Convert Auto-Hibernate Idle Timer register value to microseconds */
ufshcd_ahit_to_us(u32 ahit)125 static int ufshcd_ahit_to_us(u32 ahit)
126 {
127 int timer = FIELD_GET(UFSHCI_AHIBERN8_TIMER_MASK, ahit);
128 int scale = FIELD_GET(UFSHCI_AHIBERN8_SCALE_MASK, ahit);
129
130 for (; scale > 0; --scale)
131 timer *= UFSHCI_AHIBERN8_SCALE_FACTOR;
132
133 return timer;
134 }
135
136 /* Convert microseconds to Auto-Hibernate Idle Timer register value */
ufshcd_us_to_ahit(unsigned int timer)137 static u32 ufshcd_us_to_ahit(unsigned int timer)
138 {
139 unsigned int scale;
140
141 for (scale = 0; timer > UFSHCI_AHIBERN8_TIMER_MASK; ++scale)
142 timer /= UFSHCI_AHIBERN8_SCALE_FACTOR;
143
144 return FIELD_PREP(UFSHCI_AHIBERN8_TIMER_MASK, timer) |
145 FIELD_PREP(UFSHCI_AHIBERN8_SCALE_MASK, scale);
146 }
147
auto_hibern8_show(struct device * dev,struct device_attribute * attr,char * buf)148 static ssize_t auto_hibern8_show(struct device *dev,
149 struct device_attribute *attr, char *buf)
150 {
151 u32 ahit;
152 struct ufs_hba *hba = dev_get_drvdata(dev);
153
154 if (!ufshcd_is_auto_hibern8_supported(hba))
155 return -EOPNOTSUPP;
156
157 pm_runtime_get_sync(hba->dev);
158 ufshcd_hold(hba, false);
159 ahit = ufshcd_readl(hba, REG_AUTO_HIBERNATE_IDLE_TIMER);
160 ufshcd_release(hba);
161 pm_runtime_put_sync(hba->dev);
162
163 return sysfs_emit(buf, "%d\n", ufshcd_ahit_to_us(ahit));
164 }
165
auto_hibern8_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)166 static ssize_t auto_hibern8_store(struct device *dev,
167 struct device_attribute *attr,
168 const char *buf, size_t count)
169 {
170 struct ufs_hba *hba = dev_get_drvdata(dev);
171 unsigned int timer;
172
173 if (!ufshcd_is_auto_hibern8_supported(hba))
174 return -EOPNOTSUPP;
175
176 if (kstrtouint(buf, 0, &timer))
177 return -EINVAL;
178
179 if (timer > UFSHCI_AHIBERN8_MAX)
180 return -EINVAL;
181
182 ufshcd_auto_hibern8_update(hba, ufshcd_us_to_ahit(timer));
183
184 return count;
185 }
186
187 static DEVICE_ATTR_RW(rpm_lvl);
188 static DEVICE_ATTR_RO(rpm_target_dev_state);
189 static DEVICE_ATTR_RO(rpm_target_link_state);
190 static DEVICE_ATTR_RW(spm_lvl);
191 static DEVICE_ATTR_RO(spm_target_dev_state);
192 static DEVICE_ATTR_RO(spm_target_link_state);
193 static DEVICE_ATTR_RW(auto_hibern8);
194
195 static struct attribute *ufs_sysfs_ufshcd_attrs[] = {
196 &dev_attr_rpm_lvl.attr,
197 &dev_attr_rpm_target_dev_state.attr,
198 &dev_attr_rpm_target_link_state.attr,
199 &dev_attr_spm_lvl.attr,
200 &dev_attr_spm_target_dev_state.attr,
201 &dev_attr_spm_target_link_state.attr,
202 &dev_attr_auto_hibern8.attr,
203 NULL
204 };
205
206 static const struct attribute_group ufs_sysfs_default_group = {
207 .attrs = ufs_sysfs_ufshcd_attrs,
208 };
209
monitor_enable_show(struct device * dev,struct device_attribute * attr,char * buf)210 static ssize_t monitor_enable_show(struct device *dev,
211 struct device_attribute *attr, char *buf)
212 {
213 struct ufs_hba *hba = dev_get_drvdata(dev);
214
215 return sysfs_emit(buf, "%d\n", hba->monitor.enabled);
216 }
217
monitor_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)218 static ssize_t monitor_enable_store(struct device *dev,
219 struct device_attribute *attr,
220 const char *buf, size_t count)
221 {
222 struct ufs_hba *hba = dev_get_drvdata(dev);
223 unsigned long value, flags;
224
225 if (kstrtoul(buf, 0, &value))
226 return -EINVAL;
227
228 value = !!value;
229 spin_lock_irqsave(hba->host->host_lock, flags);
230 if (value == hba->monitor.enabled)
231 goto out_unlock;
232
233 if (!value) {
234 memset(&hba->monitor, 0, sizeof(hba->monitor));
235 } else {
236 hba->monitor.enabled = true;
237 hba->monitor.enabled_ts = ktime_get();
238 }
239
240 out_unlock:
241 spin_unlock_irqrestore(hba->host->host_lock, flags);
242 return count;
243 }
244
monitor_chunk_size_show(struct device * dev,struct device_attribute * attr,char * buf)245 static ssize_t monitor_chunk_size_show(struct device *dev,
246 struct device_attribute *attr, char *buf)
247 {
248 struct ufs_hba *hba = dev_get_drvdata(dev);
249
250 return sysfs_emit(buf, "%lu\n", hba->monitor.chunk_size);
251 }
252
monitor_chunk_size_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)253 static ssize_t monitor_chunk_size_store(struct device *dev,
254 struct device_attribute *attr,
255 const char *buf, size_t count)
256 {
257 struct ufs_hba *hba = dev_get_drvdata(dev);
258 unsigned long value, flags;
259
260 if (kstrtoul(buf, 0, &value))
261 return -EINVAL;
262
263 spin_lock_irqsave(hba->host->host_lock, flags);
264 /* Only allow chunk size change when monitor is disabled */
265 if (!hba->monitor.enabled)
266 hba->monitor.chunk_size = value;
267 spin_unlock_irqrestore(hba->host->host_lock, flags);
268 return count;
269 }
270
read_total_sectors_show(struct device * dev,struct device_attribute * attr,char * buf)271 static ssize_t read_total_sectors_show(struct device *dev,
272 struct device_attribute *attr, char *buf)
273 {
274 struct ufs_hba *hba = dev_get_drvdata(dev);
275
276 return sysfs_emit(buf, "%lu\n", hba->monitor.nr_sec_rw[READ]);
277 }
278
read_total_busy_show(struct device * dev,struct device_attribute * attr,char * buf)279 static ssize_t read_total_busy_show(struct device *dev,
280 struct device_attribute *attr, char *buf)
281 {
282 struct ufs_hba *hba = dev_get_drvdata(dev);
283
284 return sysfs_emit(buf, "%llu\n",
285 ktime_to_us(hba->monitor.total_busy[READ]));
286 }
287
read_nr_requests_show(struct device * dev,struct device_attribute * attr,char * buf)288 static ssize_t read_nr_requests_show(struct device *dev,
289 struct device_attribute *attr, char *buf)
290 {
291 struct ufs_hba *hba = dev_get_drvdata(dev);
292
293 return sysfs_emit(buf, "%lu\n", hba->monitor.nr_req[READ]);
294 }
295
read_req_latency_avg_show(struct device * dev,struct device_attribute * attr,char * buf)296 static ssize_t read_req_latency_avg_show(struct device *dev,
297 struct device_attribute *attr,
298 char *buf)
299 {
300 struct ufs_hba *hba = dev_get_drvdata(dev);
301 struct ufs_hba_monitor *m = &hba->monitor;
302
303 return sysfs_emit(buf, "%llu\n", div_u64(ktime_to_us(m->lat_sum[READ]),
304 m->nr_req[READ]));
305 }
306
read_req_latency_max_show(struct device * dev,struct device_attribute * attr,char * buf)307 static ssize_t read_req_latency_max_show(struct device *dev,
308 struct device_attribute *attr,
309 char *buf)
310 {
311 struct ufs_hba *hba = dev_get_drvdata(dev);
312
313 return sysfs_emit(buf, "%llu\n",
314 ktime_to_us(hba->monitor.lat_max[READ]));
315 }
316
read_req_latency_min_show(struct device * dev,struct device_attribute * attr,char * buf)317 static ssize_t read_req_latency_min_show(struct device *dev,
318 struct device_attribute *attr,
319 char *buf)
320 {
321 struct ufs_hba *hba = dev_get_drvdata(dev);
322
323 return sysfs_emit(buf, "%llu\n",
324 ktime_to_us(hba->monitor.lat_min[READ]));
325 }
326
read_req_latency_sum_show(struct device * dev,struct device_attribute * attr,char * buf)327 static ssize_t read_req_latency_sum_show(struct device *dev,
328 struct device_attribute *attr,
329 char *buf)
330 {
331 struct ufs_hba *hba = dev_get_drvdata(dev);
332
333 return sysfs_emit(buf, "%llu\n",
334 ktime_to_us(hba->monitor.lat_sum[READ]));
335 }
336
write_total_sectors_show(struct device * dev,struct device_attribute * attr,char * buf)337 static ssize_t write_total_sectors_show(struct device *dev,
338 struct device_attribute *attr,
339 char *buf)
340 {
341 struct ufs_hba *hba = dev_get_drvdata(dev);
342
343 return sysfs_emit(buf, "%lu\n", hba->monitor.nr_sec_rw[WRITE]);
344 }
345
write_total_busy_show(struct device * dev,struct device_attribute * attr,char * buf)346 static ssize_t write_total_busy_show(struct device *dev,
347 struct device_attribute *attr, char *buf)
348 {
349 struct ufs_hba *hba = dev_get_drvdata(dev);
350
351 return sysfs_emit(buf, "%llu\n",
352 ktime_to_us(hba->monitor.total_busy[WRITE]));
353 }
354
write_nr_requests_show(struct device * dev,struct device_attribute * attr,char * buf)355 static ssize_t write_nr_requests_show(struct device *dev,
356 struct device_attribute *attr, char *buf)
357 {
358 struct ufs_hba *hba = dev_get_drvdata(dev);
359
360 return sysfs_emit(buf, "%lu\n", hba->monitor.nr_req[WRITE]);
361 }
362
write_req_latency_avg_show(struct device * dev,struct device_attribute * attr,char * buf)363 static ssize_t write_req_latency_avg_show(struct device *dev,
364 struct device_attribute *attr,
365 char *buf)
366 {
367 struct ufs_hba *hba = dev_get_drvdata(dev);
368 struct ufs_hba_monitor *m = &hba->monitor;
369
370 return sysfs_emit(buf, "%llu\n", div_u64(ktime_to_us(m->lat_sum[WRITE]),
371 m->nr_req[WRITE]));
372 }
373
write_req_latency_max_show(struct device * dev,struct device_attribute * attr,char * buf)374 static ssize_t write_req_latency_max_show(struct device *dev,
375 struct device_attribute *attr,
376 char *buf)
377 {
378 struct ufs_hba *hba = dev_get_drvdata(dev);
379
380 return sysfs_emit(buf, "%llu\n",
381 ktime_to_us(hba->monitor.lat_max[WRITE]));
382 }
383
write_req_latency_min_show(struct device * dev,struct device_attribute * attr,char * buf)384 static ssize_t write_req_latency_min_show(struct device *dev,
385 struct device_attribute *attr,
386 char *buf)
387 {
388 struct ufs_hba *hba = dev_get_drvdata(dev);
389
390 return sysfs_emit(buf, "%llu\n",
391 ktime_to_us(hba->monitor.lat_min[WRITE]));
392 }
393
write_req_latency_sum_show(struct device * dev,struct device_attribute * attr,char * buf)394 static ssize_t write_req_latency_sum_show(struct device *dev,
395 struct device_attribute *attr,
396 char *buf)
397 {
398 struct ufs_hba *hba = dev_get_drvdata(dev);
399
400 return sysfs_emit(buf, "%llu\n",
401 ktime_to_us(hba->monitor.lat_sum[WRITE]));
402 }
403
404 static DEVICE_ATTR_RW(monitor_enable);
405 static DEVICE_ATTR_RW(monitor_chunk_size);
406 static DEVICE_ATTR_RO(read_total_sectors);
407 static DEVICE_ATTR_RO(read_total_busy);
408 static DEVICE_ATTR_RO(read_nr_requests);
409 static DEVICE_ATTR_RO(read_req_latency_avg);
410 static DEVICE_ATTR_RO(read_req_latency_max);
411 static DEVICE_ATTR_RO(read_req_latency_min);
412 static DEVICE_ATTR_RO(read_req_latency_sum);
413 static DEVICE_ATTR_RO(write_total_sectors);
414 static DEVICE_ATTR_RO(write_total_busy);
415 static DEVICE_ATTR_RO(write_nr_requests);
416 static DEVICE_ATTR_RO(write_req_latency_avg);
417 static DEVICE_ATTR_RO(write_req_latency_max);
418 static DEVICE_ATTR_RO(write_req_latency_min);
419 static DEVICE_ATTR_RO(write_req_latency_sum);
420
421 static struct attribute *ufs_sysfs_monitor_attrs[] = {
422 &dev_attr_monitor_enable.attr,
423 &dev_attr_monitor_chunk_size.attr,
424 &dev_attr_read_total_sectors.attr,
425 &dev_attr_read_total_busy.attr,
426 &dev_attr_read_nr_requests.attr,
427 &dev_attr_read_req_latency_avg.attr,
428 &dev_attr_read_req_latency_max.attr,
429 &dev_attr_read_req_latency_min.attr,
430 &dev_attr_read_req_latency_sum.attr,
431 &dev_attr_write_total_sectors.attr,
432 &dev_attr_write_total_busy.attr,
433 &dev_attr_write_nr_requests.attr,
434 &dev_attr_write_req_latency_avg.attr,
435 &dev_attr_write_req_latency_max.attr,
436 &dev_attr_write_req_latency_min.attr,
437 &dev_attr_write_req_latency_sum.attr,
438 NULL
439 };
440
441 static const struct attribute_group ufs_sysfs_monitor_group = {
442 .name = "monitor",
443 .attrs = ufs_sysfs_monitor_attrs,
444 };
445
ufs_sysfs_read_desc_param(struct ufs_hba * hba,enum desc_idn desc_id,u8 desc_index,u8 param_offset,u8 * sysfs_buf,u8 param_size)446 static ssize_t ufs_sysfs_read_desc_param(struct ufs_hba *hba,
447 enum desc_idn desc_id,
448 u8 desc_index,
449 u8 param_offset,
450 u8 *sysfs_buf,
451 u8 param_size)
452 {
453 u8 desc_buf[8] = {0};
454 int ret;
455
456 if (param_size > 8)
457 return -EINVAL;
458
459 pm_runtime_get_sync(hba->dev);
460 ret = ufshcd_read_desc_param(hba, desc_id, desc_index,
461 param_offset, desc_buf, param_size);
462 pm_runtime_put_sync(hba->dev);
463 if (ret)
464 return -EINVAL;
465 switch (param_size) {
466 case 1:
467 ret = sysfs_emit(sysfs_buf, "0x%02X\n", *desc_buf);
468 break;
469 case 2:
470 ret = sysfs_emit(sysfs_buf, "0x%04X\n",
471 get_unaligned_be16(desc_buf));
472 break;
473 case 4:
474 ret = sysfs_emit(sysfs_buf, "0x%08X\n",
475 get_unaligned_be32(desc_buf));
476 break;
477 case 8:
478 ret = sysfs_emit(sysfs_buf, "0x%016llX\n",
479 get_unaligned_be64(desc_buf));
480 break;
481 }
482
483 return ret;
484 }
485
486 #define UFS_DESC_PARAM(_name, _puname, _duname, _size) \
487 static ssize_t _name##_show(struct device *dev, \
488 struct device_attribute *attr, char *buf) \
489 { \
490 struct ufs_hba *hba = dev_get_drvdata(dev); \
491 return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_##_duname, \
492 0, _duname##_DESC_PARAM##_puname, buf, _size); \
493 } \
494 static DEVICE_ATTR_RO(_name)
495
496 #define UFS_DEVICE_DESC_PARAM(_name, _uname, _size) \
497 UFS_DESC_PARAM(_name, _uname, DEVICE, _size)
498
499 UFS_DEVICE_DESC_PARAM(device_type, _DEVICE_TYPE, 1);
500 UFS_DEVICE_DESC_PARAM(device_class, _DEVICE_CLASS, 1);
501 UFS_DEVICE_DESC_PARAM(device_sub_class, _DEVICE_SUB_CLASS, 1);
502 UFS_DEVICE_DESC_PARAM(protocol, _PRTCL, 1);
503 UFS_DEVICE_DESC_PARAM(number_of_luns, _NUM_LU, 1);
504 UFS_DEVICE_DESC_PARAM(number_of_wluns, _NUM_WLU, 1);
505 UFS_DEVICE_DESC_PARAM(boot_enable, _BOOT_ENBL, 1);
506 UFS_DEVICE_DESC_PARAM(descriptor_access_enable, _DESC_ACCSS_ENBL, 1);
507 UFS_DEVICE_DESC_PARAM(initial_power_mode, _INIT_PWR_MODE, 1);
508 UFS_DEVICE_DESC_PARAM(high_priority_lun, _HIGH_PR_LUN, 1);
509 UFS_DEVICE_DESC_PARAM(secure_removal_type, _SEC_RMV_TYPE, 1);
510 UFS_DEVICE_DESC_PARAM(support_security_lun, _SEC_LU, 1);
511 UFS_DEVICE_DESC_PARAM(bkops_termination_latency, _BKOP_TERM_LT, 1);
512 UFS_DEVICE_DESC_PARAM(initial_active_icc_level, _ACTVE_ICC_LVL, 1);
513 UFS_DEVICE_DESC_PARAM(specification_version, _SPEC_VER, 2);
514 UFS_DEVICE_DESC_PARAM(manufacturing_date, _MANF_DATE, 2);
515 UFS_DEVICE_DESC_PARAM(manufacturer_id, _MANF_ID, 2);
516 UFS_DEVICE_DESC_PARAM(rtt_capability, _RTT_CAP, 1);
517 UFS_DEVICE_DESC_PARAM(rtc_update, _FRQ_RTC, 2);
518 UFS_DEVICE_DESC_PARAM(ufs_features, _UFS_FEAT, 1);
519 UFS_DEVICE_DESC_PARAM(ffu_timeout, _FFU_TMT, 1);
520 UFS_DEVICE_DESC_PARAM(queue_depth, _Q_DPTH, 1);
521 UFS_DEVICE_DESC_PARAM(device_version, _DEV_VER, 2);
522 UFS_DEVICE_DESC_PARAM(number_of_secure_wpa, _NUM_SEC_WPA, 1);
523 UFS_DEVICE_DESC_PARAM(psa_max_data_size, _PSA_MAX_DATA, 4);
524 UFS_DEVICE_DESC_PARAM(psa_state_timeout, _PSA_TMT, 1);
525 UFS_DEVICE_DESC_PARAM(hpb_version, _HPB_VER, 2);
526 UFS_DEVICE_DESC_PARAM(hpb_control, _HPB_CONTROL, 1);
527 UFS_DEVICE_DESC_PARAM(ext_feature_sup, _EXT_UFS_FEATURE_SUP, 4);
528 UFS_DEVICE_DESC_PARAM(wb_presv_us_en, _WB_PRESRV_USRSPC_EN, 1);
529 UFS_DEVICE_DESC_PARAM(wb_type, _WB_TYPE, 1);
530 UFS_DEVICE_DESC_PARAM(wb_shared_alloc_units, _WB_SHARED_ALLOC_UNITS, 4);
531
532 static struct attribute *ufs_sysfs_device_descriptor[] = {
533 &dev_attr_device_type.attr,
534 &dev_attr_device_class.attr,
535 &dev_attr_device_sub_class.attr,
536 &dev_attr_protocol.attr,
537 &dev_attr_number_of_luns.attr,
538 &dev_attr_number_of_wluns.attr,
539 &dev_attr_boot_enable.attr,
540 &dev_attr_descriptor_access_enable.attr,
541 &dev_attr_initial_power_mode.attr,
542 &dev_attr_high_priority_lun.attr,
543 &dev_attr_secure_removal_type.attr,
544 &dev_attr_support_security_lun.attr,
545 &dev_attr_bkops_termination_latency.attr,
546 &dev_attr_initial_active_icc_level.attr,
547 &dev_attr_specification_version.attr,
548 &dev_attr_manufacturing_date.attr,
549 &dev_attr_manufacturer_id.attr,
550 &dev_attr_rtt_capability.attr,
551 &dev_attr_rtc_update.attr,
552 &dev_attr_ufs_features.attr,
553 &dev_attr_ffu_timeout.attr,
554 &dev_attr_queue_depth.attr,
555 &dev_attr_device_version.attr,
556 &dev_attr_number_of_secure_wpa.attr,
557 &dev_attr_psa_max_data_size.attr,
558 &dev_attr_psa_state_timeout.attr,
559 &dev_attr_hpb_version.attr,
560 &dev_attr_hpb_control.attr,
561 &dev_attr_ext_feature_sup.attr,
562 &dev_attr_wb_presv_us_en.attr,
563 &dev_attr_wb_type.attr,
564 &dev_attr_wb_shared_alloc_units.attr,
565 NULL,
566 };
567
568 static const struct attribute_group ufs_sysfs_device_descriptor_group = {
569 .name = "device_descriptor",
570 .attrs = ufs_sysfs_device_descriptor,
571 };
572
573 #define UFS_INTERCONNECT_DESC_PARAM(_name, _uname, _size) \
574 UFS_DESC_PARAM(_name, _uname, INTERCONNECT, _size)
575
576 UFS_INTERCONNECT_DESC_PARAM(unipro_version, _UNIPRO_VER, 2);
577 UFS_INTERCONNECT_DESC_PARAM(mphy_version, _MPHY_VER, 2);
578
579 static struct attribute *ufs_sysfs_interconnect_descriptor[] = {
580 &dev_attr_unipro_version.attr,
581 &dev_attr_mphy_version.attr,
582 NULL,
583 };
584
585 static const struct attribute_group ufs_sysfs_interconnect_descriptor_group = {
586 .name = "interconnect_descriptor",
587 .attrs = ufs_sysfs_interconnect_descriptor,
588 };
589
590 #define UFS_GEOMETRY_DESC_PARAM(_name, _uname, _size) \
591 UFS_DESC_PARAM(_name, _uname, GEOMETRY, _size)
592
593 UFS_GEOMETRY_DESC_PARAM(raw_device_capacity, _DEV_CAP, 8);
594 UFS_GEOMETRY_DESC_PARAM(max_number_of_luns, _MAX_NUM_LUN, 1);
595 UFS_GEOMETRY_DESC_PARAM(segment_size, _SEG_SIZE, 4);
596 UFS_GEOMETRY_DESC_PARAM(allocation_unit_size, _ALLOC_UNIT_SIZE, 1);
597 UFS_GEOMETRY_DESC_PARAM(min_addressable_block_size, _MIN_BLK_SIZE, 1);
598 UFS_GEOMETRY_DESC_PARAM(optimal_read_block_size, _OPT_RD_BLK_SIZE, 1);
599 UFS_GEOMETRY_DESC_PARAM(optimal_write_block_size, _OPT_WR_BLK_SIZE, 1);
600 UFS_GEOMETRY_DESC_PARAM(max_in_buffer_size, _MAX_IN_BUF_SIZE, 1);
601 UFS_GEOMETRY_DESC_PARAM(max_out_buffer_size, _MAX_OUT_BUF_SIZE, 1);
602 UFS_GEOMETRY_DESC_PARAM(rpmb_rw_size, _RPMB_RW_SIZE, 1);
603 UFS_GEOMETRY_DESC_PARAM(dyn_capacity_resource_policy, _DYN_CAP_RSRC_PLC, 1);
604 UFS_GEOMETRY_DESC_PARAM(data_ordering, _DATA_ORDER, 1);
605 UFS_GEOMETRY_DESC_PARAM(max_number_of_contexts, _MAX_NUM_CTX, 1);
606 UFS_GEOMETRY_DESC_PARAM(sys_data_tag_unit_size, _TAG_UNIT_SIZE, 1);
607 UFS_GEOMETRY_DESC_PARAM(sys_data_tag_resource_size, _TAG_RSRC_SIZE, 1);
608 UFS_GEOMETRY_DESC_PARAM(secure_removal_types, _SEC_RM_TYPES, 1);
609 UFS_GEOMETRY_DESC_PARAM(memory_types, _MEM_TYPES, 2);
610 UFS_GEOMETRY_DESC_PARAM(sys_code_memory_max_alloc_units,
611 _SCM_MAX_NUM_UNITS, 4);
612 UFS_GEOMETRY_DESC_PARAM(sys_code_memory_capacity_adjustment_factor,
613 _SCM_CAP_ADJ_FCTR, 2);
614 UFS_GEOMETRY_DESC_PARAM(non_persist_memory_max_alloc_units,
615 _NPM_MAX_NUM_UNITS, 4);
616 UFS_GEOMETRY_DESC_PARAM(non_persist_memory_capacity_adjustment_factor,
617 _NPM_CAP_ADJ_FCTR, 2);
618 UFS_GEOMETRY_DESC_PARAM(enh1_memory_max_alloc_units,
619 _ENM1_MAX_NUM_UNITS, 4);
620 UFS_GEOMETRY_DESC_PARAM(enh1_memory_capacity_adjustment_factor,
621 _ENM1_CAP_ADJ_FCTR, 2);
622 UFS_GEOMETRY_DESC_PARAM(enh2_memory_max_alloc_units,
623 _ENM2_MAX_NUM_UNITS, 4);
624 UFS_GEOMETRY_DESC_PARAM(enh2_memory_capacity_adjustment_factor,
625 _ENM2_CAP_ADJ_FCTR, 2);
626 UFS_GEOMETRY_DESC_PARAM(enh3_memory_max_alloc_units,
627 _ENM3_MAX_NUM_UNITS, 4);
628 UFS_GEOMETRY_DESC_PARAM(enh3_memory_capacity_adjustment_factor,
629 _ENM3_CAP_ADJ_FCTR, 2);
630 UFS_GEOMETRY_DESC_PARAM(enh4_memory_max_alloc_units,
631 _ENM4_MAX_NUM_UNITS, 4);
632 UFS_GEOMETRY_DESC_PARAM(enh4_memory_capacity_adjustment_factor,
633 _ENM4_CAP_ADJ_FCTR, 2);
634 UFS_GEOMETRY_DESC_PARAM(hpb_region_size, _HPB_REGION_SIZE, 1);
635 UFS_GEOMETRY_DESC_PARAM(hpb_number_lu, _HPB_NUMBER_LU, 1);
636 UFS_GEOMETRY_DESC_PARAM(hpb_subregion_size, _HPB_SUBREGION_SIZE, 1);
637 UFS_GEOMETRY_DESC_PARAM(hpb_max_active_regions, _HPB_MAX_ACTIVE_REGS, 2);
638 UFS_GEOMETRY_DESC_PARAM(wb_max_alloc_units, _WB_MAX_ALLOC_UNITS, 4);
639 UFS_GEOMETRY_DESC_PARAM(wb_max_wb_luns, _WB_MAX_WB_LUNS, 1);
640 UFS_GEOMETRY_DESC_PARAM(wb_buff_cap_adj, _WB_BUFF_CAP_ADJ, 1);
641 UFS_GEOMETRY_DESC_PARAM(wb_sup_red_type, _WB_SUP_RED_TYPE, 1);
642 UFS_GEOMETRY_DESC_PARAM(wb_sup_wb_type, _WB_SUP_WB_TYPE, 1);
643
644
645 static struct attribute *ufs_sysfs_geometry_descriptor[] = {
646 &dev_attr_raw_device_capacity.attr,
647 &dev_attr_max_number_of_luns.attr,
648 &dev_attr_segment_size.attr,
649 &dev_attr_allocation_unit_size.attr,
650 &dev_attr_min_addressable_block_size.attr,
651 &dev_attr_optimal_read_block_size.attr,
652 &dev_attr_optimal_write_block_size.attr,
653 &dev_attr_max_in_buffer_size.attr,
654 &dev_attr_max_out_buffer_size.attr,
655 &dev_attr_rpmb_rw_size.attr,
656 &dev_attr_dyn_capacity_resource_policy.attr,
657 &dev_attr_data_ordering.attr,
658 &dev_attr_max_number_of_contexts.attr,
659 &dev_attr_sys_data_tag_unit_size.attr,
660 &dev_attr_sys_data_tag_resource_size.attr,
661 &dev_attr_secure_removal_types.attr,
662 &dev_attr_memory_types.attr,
663 &dev_attr_sys_code_memory_max_alloc_units.attr,
664 &dev_attr_sys_code_memory_capacity_adjustment_factor.attr,
665 &dev_attr_non_persist_memory_max_alloc_units.attr,
666 &dev_attr_non_persist_memory_capacity_adjustment_factor.attr,
667 &dev_attr_enh1_memory_max_alloc_units.attr,
668 &dev_attr_enh1_memory_capacity_adjustment_factor.attr,
669 &dev_attr_enh2_memory_max_alloc_units.attr,
670 &dev_attr_enh2_memory_capacity_adjustment_factor.attr,
671 &dev_attr_enh3_memory_max_alloc_units.attr,
672 &dev_attr_enh3_memory_capacity_adjustment_factor.attr,
673 &dev_attr_enh4_memory_max_alloc_units.attr,
674 &dev_attr_enh4_memory_capacity_adjustment_factor.attr,
675 &dev_attr_hpb_region_size.attr,
676 &dev_attr_hpb_number_lu.attr,
677 &dev_attr_hpb_subregion_size.attr,
678 &dev_attr_hpb_max_active_regions.attr,
679 &dev_attr_wb_max_alloc_units.attr,
680 &dev_attr_wb_max_wb_luns.attr,
681 &dev_attr_wb_buff_cap_adj.attr,
682 &dev_attr_wb_sup_red_type.attr,
683 &dev_attr_wb_sup_wb_type.attr,
684 NULL,
685 };
686
687 static const struct attribute_group ufs_sysfs_geometry_descriptor_group = {
688 .name = "geometry_descriptor",
689 .attrs = ufs_sysfs_geometry_descriptor,
690 };
691
692 #define UFS_HEALTH_DESC_PARAM(_name, _uname, _size) \
693 UFS_DESC_PARAM(_name, _uname, HEALTH, _size)
694
695 UFS_HEALTH_DESC_PARAM(eol_info, _EOL_INFO, 1);
696 UFS_HEALTH_DESC_PARAM(life_time_estimation_a, _LIFE_TIME_EST_A, 1);
697 UFS_HEALTH_DESC_PARAM(life_time_estimation_b, _LIFE_TIME_EST_B, 1);
698
699 static struct attribute *ufs_sysfs_health_descriptor[] = {
700 &dev_attr_eol_info.attr,
701 &dev_attr_life_time_estimation_a.attr,
702 &dev_attr_life_time_estimation_b.attr,
703 NULL,
704 };
705
706 static const struct attribute_group ufs_sysfs_health_descriptor_group = {
707 .name = "health_descriptor",
708 .attrs = ufs_sysfs_health_descriptor,
709 };
710
711 #define UFS_POWER_DESC_PARAM(_name, _uname, _index) \
712 static ssize_t _name##_index##_show(struct device *dev, \
713 struct device_attribute *attr, char *buf) \
714 { \
715 struct ufs_hba *hba = dev_get_drvdata(dev); \
716 return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_POWER, 0, \
717 PWR_DESC##_uname##_0 + _index * 2, buf, 2); \
718 } \
719 static DEVICE_ATTR_RO(_name##_index)
720
721 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 0);
722 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 1);
723 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 2);
724 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 3);
725 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 4);
726 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 5);
727 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 6);
728 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 7);
729 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 8);
730 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 9);
731 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 10);
732 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 11);
733 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 12);
734 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 13);
735 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 14);
736 UFS_POWER_DESC_PARAM(active_icc_levels_vcc, _ACTIVE_LVLS_VCC, 15);
737 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 0);
738 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 1);
739 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 2);
740 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 3);
741 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 4);
742 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 5);
743 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 6);
744 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 7);
745 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 8);
746 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 9);
747 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 10);
748 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 11);
749 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 12);
750 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 13);
751 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 14);
752 UFS_POWER_DESC_PARAM(active_icc_levels_vccq, _ACTIVE_LVLS_VCCQ, 15);
753 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 0);
754 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 1);
755 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 2);
756 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 3);
757 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 4);
758 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 5);
759 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 6);
760 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 7);
761 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 8);
762 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 9);
763 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 10);
764 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 11);
765 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 12);
766 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 13);
767 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 14);
768 UFS_POWER_DESC_PARAM(active_icc_levels_vccq2, _ACTIVE_LVLS_VCCQ2, 15);
769
770 static struct attribute *ufs_sysfs_power_descriptor[] = {
771 &dev_attr_active_icc_levels_vcc0.attr,
772 &dev_attr_active_icc_levels_vcc1.attr,
773 &dev_attr_active_icc_levels_vcc2.attr,
774 &dev_attr_active_icc_levels_vcc3.attr,
775 &dev_attr_active_icc_levels_vcc4.attr,
776 &dev_attr_active_icc_levels_vcc5.attr,
777 &dev_attr_active_icc_levels_vcc6.attr,
778 &dev_attr_active_icc_levels_vcc7.attr,
779 &dev_attr_active_icc_levels_vcc8.attr,
780 &dev_attr_active_icc_levels_vcc9.attr,
781 &dev_attr_active_icc_levels_vcc10.attr,
782 &dev_attr_active_icc_levels_vcc11.attr,
783 &dev_attr_active_icc_levels_vcc12.attr,
784 &dev_attr_active_icc_levels_vcc13.attr,
785 &dev_attr_active_icc_levels_vcc14.attr,
786 &dev_attr_active_icc_levels_vcc15.attr,
787 &dev_attr_active_icc_levels_vccq0.attr,
788 &dev_attr_active_icc_levels_vccq1.attr,
789 &dev_attr_active_icc_levels_vccq2.attr,
790 &dev_attr_active_icc_levels_vccq3.attr,
791 &dev_attr_active_icc_levels_vccq4.attr,
792 &dev_attr_active_icc_levels_vccq5.attr,
793 &dev_attr_active_icc_levels_vccq6.attr,
794 &dev_attr_active_icc_levels_vccq7.attr,
795 &dev_attr_active_icc_levels_vccq8.attr,
796 &dev_attr_active_icc_levels_vccq9.attr,
797 &dev_attr_active_icc_levels_vccq10.attr,
798 &dev_attr_active_icc_levels_vccq11.attr,
799 &dev_attr_active_icc_levels_vccq12.attr,
800 &dev_attr_active_icc_levels_vccq13.attr,
801 &dev_attr_active_icc_levels_vccq14.attr,
802 &dev_attr_active_icc_levels_vccq15.attr,
803 &dev_attr_active_icc_levels_vccq20.attr,
804 &dev_attr_active_icc_levels_vccq21.attr,
805 &dev_attr_active_icc_levels_vccq22.attr,
806 &dev_attr_active_icc_levels_vccq23.attr,
807 &dev_attr_active_icc_levels_vccq24.attr,
808 &dev_attr_active_icc_levels_vccq25.attr,
809 &dev_attr_active_icc_levels_vccq26.attr,
810 &dev_attr_active_icc_levels_vccq27.attr,
811 &dev_attr_active_icc_levels_vccq28.attr,
812 &dev_attr_active_icc_levels_vccq29.attr,
813 &dev_attr_active_icc_levels_vccq210.attr,
814 &dev_attr_active_icc_levels_vccq211.attr,
815 &dev_attr_active_icc_levels_vccq212.attr,
816 &dev_attr_active_icc_levels_vccq213.attr,
817 &dev_attr_active_icc_levels_vccq214.attr,
818 &dev_attr_active_icc_levels_vccq215.attr,
819 NULL,
820 };
821
822 static const struct attribute_group ufs_sysfs_power_descriptor_group = {
823 .name = "power_descriptor",
824 .attrs = ufs_sysfs_power_descriptor,
825 };
826
827 #define UFS_STRING_DESCRIPTOR(_name, _pname) \
828 static ssize_t _name##_show(struct device *dev, \
829 struct device_attribute *attr, char *buf) \
830 { \
831 u8 index; \
832 struct ufs_hba *hba = dev_get_drvdata(dev); \
833 int ret; \
834 int desc_len = QUERY_DESC_MAX_SIZE; \
835 u8 *desc_buf; \
836 \
837 desc_buf = kzalloc(QUERY_DESC_MAX_SIZE, GFP_ATOMIC); \
838 if (!desc_buf) \
839 return -ENOMEM; \
840 pm_runtime_get_sync(hba->dev); \
841 ret = ufshcd_query_descriptor_retry(hba, \
842 UPIU_QUERY_OPCODE_READ_DESC, QUERY_DESC_IDN_DEVICE, \
843 0, 0, desc_buf, &desc_len); \
844 if (ret) { \
845 ret = -EINVAL; \
846 goto out; \
847 } \
848 index = desc_buf[DEVICE_DESC_PARAM##_pname]; \
849 kfree(desc_buf); \
850 desc_buf = NULL; \
851 ret = ufshcd_read_string_desc(hba, index, &desc_buf, \
852 SD_ASCII_STD); \
853 if (ret < 0) \
854 goto out; \
855 ret = sysfs_emit(buf, "%s\n", desc_buf); \
856 out: \
857 pm_runtime_put_sync(hba->dev); \
858 kfree(desc_buf); \
859 return ret; \
860 } \
861 static DEVICE_ATTR_RO(_name)
862
863 UFS_STRING_DESCRIPTOR(manufacturer_name, _MANF_NAME);
864 UFS_STRING_DESCRIPTOR(product_name, _PRDCT_NAME);
865 UFS_STRING_DESCRIPTOR(oem_id, _OEM_ID);
866 UFS_STRING_DESCRIPTOR(serial_number, _SN);
867 UFS_STRING_DESCRIPTOR(product_revision, _PRDCT_REV);
868
869 static struct attribute *ufs_sysfs_string_descriptors[] = {
870 &dev_attr_manufacturer_name.attr,
871 &dev_attr_product_name.attr,
872 &dev_attr_oem_id.attr,
873 &dev_attr_serial_number.attr,
874 &dev_attr_product_revision.attr,
875 NULL,
876 };
877
878 static const struct attribute_group ufs_sysfs_string_descriptors_group = {
879 .name = "string_descriptors",
880 .attrs = ufs_sysfs_string_descriptors,
881 };
882
ufshcd_is_wb_flags(enum flag_idn idn)883 static inline bool ufshcd_is_wb_flags(enum flag_idn idn)
884 {
885 return ((idn >= QUERY_FLAG_IDN_WB_EN) &&
886 (idn <= QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8));
887 }
888
889 #define UFS_FLAG(_name, _uname) \
890 static ssize_t _name##_show(struct device *dev, \
891 struct device_attribute *attr, char *buf) \
892 { \
893 bool flag; \
894 u8 index = 0; \
895 int ret; \
896 struct ufs_hba *hba = dev_get_drvdata(dev); \
897 if (ufshcd_is_wb_flags(QUERY_FLAG_IDN##_uname)) \
898 index = ufshcd_wb_get_query_index(hba); \
899 pm_runtime_get_sync(hba->dev); \
900 ret = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG, \
901 QUERY_FLAG_IDN##_uname, index, &flag); \
902 pm_runtime_put_sync(hba->dev); \
903 if (ret) \
904 return -EINVAL; \
905 return sysfs_emit(buf, "%s\n", flag ? "true" : "false"); \
906 } \
907 static DEVICE_ATTR_RO(_name)
908
909 UFS_FLAG(device_init, _FDEVICEINIT);
910 UFS_FLAG(permanent_wpe, _PERMANENT_WPE);
911 UFS_FLAG(power_on_wpe, _PWR_ON_WPE);
912 UFS_FLAG(bkops_enable, _BKOPS_EN);
913 UFS_FLAG(life_span_mode_enable, _LIFE_SPAN_MODE_ENABLE);
914 UFS_FLAG(phy_resource_removal, _FPHYRESOURCEREMOVAL);
915 UFS_FLAG(busy_rtc, _BUSY_RTC);
916 UFS_FLAG(disable_fw_update, _PERMANENTLY_DISABLE_FW_UPDATE);
917 UFS_FLAG(wb_enable, _WB_EN);
918 UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN);
919 UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8);
920 UFS_FLAG(hpb_enable, _HPB_EN);
921
922 static struct attribute *ufs_sysfs_device_flags[] = {
923 &dev_attr_device_init.attr,
924 &dev_attr_permanent_wpe.attr,
925 &dev_attr_power_on_wpe.attr,
926 &dev_attr_bkops_enable.attr,
927 &dev_attr_life_span_mode_enable.attr,
928 &dev_attr_phy_resource_removal.attr,
929 &dev_attr_busy_rtc.attr,
930 &dev_attr_disable_fw_update.attr,
931 &dev_attr_wb_enable.attr,
932 &dev_attr_wb_flush_en.attr,
933 &dev_attr_wb_flush_during_h8.attr,
934 &dev_attr_hpb_enable.attr,
935 NULL,
936 };
937
938 static const struct attribute_group ufs_sysfs_flags_group = {
939 .name = "flags",
940 .attrs = ufs_sysfs_device_flags,
941 };
942
ufshcd_is_wb_attrs(enum attr_idn idn)943 static inline bool ufshcd_is_wb_attrs(enum attr_idn idn)
944 {
945 return ((idn >= QUERY_ATTR_IDN_WB_FLUSH_STATUS) &&
946 (idn <= QUERY_ATTR_IDN_CURR_WB_BUFF_SIZE));
947 }
948
949 #define UFS_ATTRIBUTE(_name, _uname) \
950 static ssize_t _name##_show(struct device *dev, \
951 struct device_attribute *attr, char *buf) \
952 { \
953 struct ufs_hba *hba = dev_get_drvdata(dev); \
954 u32 value; \
955 int ret; \
956 u8 index = 0; \
957 if (ufshcd_is_wb_attrs(QUERY_ATTR_IDN##_uname)) \
958 index = ufshcd_wb_get_query_index(hba); \
959 pm_runtime_get_sync(hba->dev); \
960 ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR, \
961 QUERY_ATTR_IDN##_uname, index, 0, &value); \
962 pm_runtime_put_sync(hba->dev); \
963 if (ret) \
964 return -EINVAL; \
965 return sysfs_emit(buf, "0x%08X\n", value); \
966 } \
967 static DEVICE_ATTR_RO(_name)
968
969 UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
970 UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
971 UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
972 UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
973 UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
974 UFS_ATTRIBUTE(bkops_status, _BKOPS_STATUS);
975 UFS_ATTRIBUTE(purge_status, _PURGE_STATUS);
976 UFS_ATTRIBUTE(max_data_in_size, _MAX_DATA_IN);
977 UFS_ATTRIBUTE(max_data_out_size, _MAX_DATA_OUT);
978 UFS_ATTRIBUTE(reference_clock_frequency, _REF_CLK_FREQ);
979 UFS_ATTRIBUTE(configuration_descriptor_lock, _CONF_DESC_LOCK);
980 UFS_ATTRIBUTE(max_number_of_rtt, _MAX_NUM_OF_RTT);
981 UFS_ATTRIBUTE(exception_event_control, _EE_CONTROL);
982 UFS_ATTRIBUTE(exception_event_status, _EE_STATUS);
983 UFS_ATTRIBUTE(ffu_status, _FFU_STATUS);
984 UFS_ATTRIBUTE(psa_state, _PSA_STATE);
985 UFS_ATTRIBUTE(psa_data_size, _PSA_DATA_SIZE);
986 UFS_ATTRIBUTE(wb_flush_status, _WB_FLUSH_STATUS);
987 UFS_ATTRIBUTE(wb_avail_buf, _AVAIL_WB_BUFF_SIZE);
988 UFS_ATTRIBUTE(wb_life_time_est, _WB_BUFF_LIFE_TIME_EST);
989 UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE);
990
991
992 static struct attribute *ufs_sysfs_attributes[] = {
993 &dev_attr_boot_lun_enabled.attr,
994 &dev_attr_max_data_size_hpb_single_cmd.attr,
995 &dev_attr_current_power_mode.attr,
996 &dev_attr_active_icc_level.attr,
997 &dev_attr_ooo_data_enabled.attr,
998 &dev_attr_bkops_status.attr,
999 &dev_attr_purge_status.attr,
1000 &dev_attr_max_data_in_size.attr,
1001 &dev_attr_max_data_out_size.attr,
1002 &dev_attr_reference_clock_frequency.attr,
1003 &dev_attr_configuration_descriptor_lock.attr,
1004 &dev_attr_max_number_of_rtt.attr,
1005 &dev_attr_exception_event_control.attr,
1006 &dev_attr_exception_event_status.attr,
1007 &dev_attr_ffu_status.attr,
1008 &dev_attr_psa_state.attr,
1009 &dev_attr_psa_data_size.attr,
1010 &dev_attr_wb_flush_status.attr,
1011 &dev_attr_wb_avail_buf.attr,
1012 &dev_attr_wb_life_time_est.attr,
1013 &dev_attr_wb_cur_buf.attr,
1014 NULL,
1015 };
1016
1017 static const struct attribute_group ufs_sysfs_attributes_group = {
1018 .name = "attributes",
1019 .attrs = ufs_sysfs_attributes,
1020 };
1021
1022 static const struct attribute_group *ufs_sysfs_groups[] = {
1023 &ufs_sysfs_default_group,
1024 &ufs_sysfs_monitor_group,
1025 &ufs_sysfs_device_descriptor_group,
1026 &ufs_sysfs_interconnect_descriptor_group,
1027 &ufs_sysfs_geometry_descriptor_group,
1028 &ufs_sysfs_health_descriptor_group,
1029 &ufs_sysfs_power_descriptor_group,
1030 &ufs_sysfs_string_descriptors_group,
1031 &ufs_sysfs_flags_group,
1032 &ufs_sysfs_attributes_group,
1033 NULL,
1034 };
1035
1036 #define UFS_LUN_DESC_PARAM(_pname, _puname, _duname, _size) \
1037 static ssize_t _pname##_show(struct device *dev, \
1038 struct device_attribute *attr, char *buf) \
1039 { \
1040 struct scsi_device *sdev = to_scsi_device(dev); \
1041 struct ufs_hba *hba = shost_priv(sdev->host); \
1042 u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun); \
1043 if (!ufs_is_valid_unit_desc_lun(&hba->dev_info, lun, \
1044 _duname##_DESC_PARAM##_puname)) \
1045 return -EINVAL; \
1046 return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_##_duname, \
1047 lun, _duname##_DESC_PARAM##_puname, buf, _size); \
1048 } \
1049 static DEVICE_ATTR_RO(_pname)
1050
1051 #define UFS_UNIT_DESC_PARAM(_name, _uname, _size) \
1052 UFS_LUN_DESC_PARAM(_name, _uname, UNIT, _size)
1053
1054 UFS_UNIT_DESC_PARAM(boot_lun_id, _BOOT_LUN_ID, 1);
1055 UFS_UNIT_DESC_PARAM(lun_write_protect, _LU_WR_PROTECT, 1);
1056 UFS_UNIT_DESC_PARAM(lun_queue_depth, _LU_Q_DEPTH, 1);
1057 UFS_UNIT_DESC_PARAM(psa_sensitive, _PSA_SENSITIVE, 1);
1058 UFS_UNIT_DESC_PARAM(lun_memory_type, _MEM_TYPE, 1);
1059 UFS_UNIT_DESC_PARAM(data_reliability, _DATA_RELIABILITY, 1);
1060 UFS_UNIT_DESC_PARAM(logical_block_size, _LOGICAL_BLK_SIZE, 1);
1061 UFS_UNIT_DESC_PARAM(logical_block_count, _LOGICAL_BLK_COUNT, 8);
1062 UFS_UNIT_DESC_PARAM(erase_block_size, _ERASE_BLK_SIZE, 4);
1063 UFS_UNIT_DESC_PARAM(provisioning_type, _PROVISIONING_TYPE, 1);
1064 UFS_UNIT_DESC_PARAM(physical_memory_resourse_count, _PHY_MEM_RSRC_CNT, 8);
1065 UFS_UNIT_DESC_PARAM(context_capabilities, _CTX_CAPABILITIES, 2);
1066 UFS_UNIT_DESC_PARAM(large_unit_granularity, _LARGE_UNIT_SIZE_M1, 1);
1067 UFS_UNIT_DESC_PARAM(hpb_lu_max_active_regions, _HPB_LU_MAX_ACTIVE_RGNS, 2);
1068 UFS_UNIT_DESC_PARAM(hpb_pinned_region_start_offset, _HPB_PIN_RGN_START_OFF, 2);
1069 UFS_UNIT_DESC_PARAM(hpb_number_pinned_regions, _HPB_NUM_PIN_RGNS, 2);
1070 UFS_UNIT_DESC_PARAM(wb_buf_alloc_units, _WB_BUF_ALLOC_UNITS, 4);
1071
1072
1073 static struct attribute *ufs_sysfs_unit_descriptor[] = {
1074 &dev_attr_boot_lun_id.attr,
1075 &dev_attr_lun_write_protect.attr,
1076 &dev_attr_lun_queue_depth.attr,
1077 &dev_attr_psa_sensitive.attr,
1078 &dev_attr_lun_memory_type.attr,
1079 &dev_attr_data_reliability.attr,
1080 &dev_attr_logical_block_size.attr,
1081 &dev_attr_logical_block_count.attr,
1082 &dev_attr_erase_block_size.attr,
1083 &dev_attr_provisioning_type.attr,
1084 &dev_attr_physical_memory_resourse_count.attr,
1085 &dev_attr_context_capabilities.attr,
1086 &dev_attr_large_unit_granularity.attr,
1087 &dev_attr_hpb_lu_max_active_regions.attr,
1088 &dev_attr_hpb_pinned_region_start_offset.attr,
1089 &dev_attr_hpb_number_pinned_regions.attr,
1090 &dev_attr_wb_buf_alloc_units.attr,
1091 NULL,
1092 };
1093
1094 const struct attribute_group ufs_sysfs_unit_descriptor_group = {
1095 .name = "unit_descriptor",
1096 .attrs = ufs_sysfs_unit_descriptor,
1097 };
1098
dyn_cap_needed_attribute_show(struct device * dev,struct device_attribute * attr,char * buf)1099 static ssize_t dyn_cap_needed_attribute_show(struct device *dev,
1100 struct device_attribute *attr, char *buf)
1101 {
1102 u32 value;
1103 struct scsi_device *sdev = to_scsi_device(dev);
1104 struct ufs_hba *hba = shost_priv(sdev->host);
1105 u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);
1106 int ret;
1107
1108 pm_runtime_get_sync(hba->dev);
1109 ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
1110 QUERY_ATTR_IDN_DYN_CAP_NEEDED, lun, 0, &value);
1111 pm_runtime_put_sync(hba->dev);
1112 if (ret)
1113 return -EINVAL;
1114 return sysfs_emit(buf, "0x%08X\n", value);
1115 }
1116 static DEVICE_ATTR_RO(dyn_cap_needed_attribute);
1117
1118 static struct attribute *ufs_sysfs_lun_attributes[] = {
1119 &dev_attr_dyn_cap_needed_attribute.attr,
1120 NULL,
1121 };
1122
1123 const struct attribute_group ufs_sysfs_lun_attributes_group = {
1124 .attrs = ufs_sysfs_lun_attributes,
1125 };
1126
ufs_sysfs_add_nodes(struct ufs_hba * hba)1127 void ufs_sysfs_add_nodes(struct ufs_hba *hba)
1128 {
1129 int ret;
1130
1131 ret = sysfs_create_groups(&hba->dev->kobj, ufs_sysfs_groups);
1132 if (ret) {
1133 dev_err(hba->dev,
1134 "%s: sysfs groups creation failed (err = %d)\n",
1135 __func__, ret);
1136 return;
1137 }
1138
1139 trace_android_vh_ufs_update_sysfs(hba);
1140 }
1141
ufs_sysfs_remove_nodes(struct device * dev)1142 void ufs_sysfs_remove_nodes(struct device *dev)
1143 {
1144 sysfs_remove_groups(&dev->kobj, ufs_sysfs_groups);
1145 }
1146