forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d 
 kernel/drivers/scsi/ufs/ufs-sysfs.c
....@@ -9,6 +9,8 @@
99 #include "ufs.h"
1010 #include "ufs-sysfs.h"
1111 
12
+#include <trace/hooks/ufshcd.h>
13
+
1214 static const char *ufschd_uic_link_state_to_string(
1315 			enum uic_link_state state)
1416 {
....@@ -16,6 +18,7 @@
1618 	case UIC_LINK_OFF_STATE:	return "OFF";
1719 	case UIC_LINK_ACTIVE_STATE:	return "ACTIVE";
1820 	case UIC_LINK_HIBERN8_STATE:	return "HIBERN8";
21
+	case UIC_LINK_BROKEN_STATE:	return "BROKEN";
1922 	default:			return "UNKNOWN";
2023 	}
2124 }
....@@ -59,7 +62,7 @@
5962 {
6063 	struct ufs_hba *hba = dev_get_drvdata(dev);
6164 
62
-	return sprintf(buf, "%d\n", hba->rpm_lvl);
65
+	return sysfs_emit(buf, "%d\n", hba->rpm_lvl);
6366 }
6467 
6568 static ssize_t rpm_lvl_store(struct device *dev,
....@@ -73,7 +76,7 @@
7376 {
7477 	struct ufs_hba *hba = dev_get_drvdata(dev);
7578 
76
-	return sprintf(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
79
+	return sysfs_emit(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
7780 			ufs_pm_lvl_states[hba->rpm_lvl].dev_state));
7881 }
7982 
....@@ -82,7 +85,7 @@
8285 {
8386 	struct ufs_hba *hba = dev_get_drvdata(dev);
8487 
85
-	return sprintf(buf, "%s\n", ufschd_uic_link_state_to_string(
88
+	return sysfs_emit(buf, "%s\n", ufschd_uic_link_state_to_string(
8689 			ufs_pm_lvl_states[hba->rpm_lvl].link_state));
8790 }
8891 
....@@ -91,7 +94,7 @@
9194 {
9295 	struct ufs_hba *hba = dev_get_drvdata(dev);
9396 
94
-	return sprintf(buf, "%d\n", hba->spm_lvl);
97
+	return sysfs_emit(buf, "%d\n", hba->spm_lvl);
9598 }
9699 
97100 static ssize_t spm_lvl_store(struct device *dev,
....@@ -105,7 +108,7 @@
105108 {
106109 	struct ufs_hba *hba = dev_get_drvdata(dev);
107110 
108
-	return sprintf(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
111
+	return sysfs_emit(buf, "%s\n", ufschd_ufs_dev_pwr_mode_to_string(
109112 				ufs_pm_lvl_states[hba->spm_lvl].dev_state));
110113 }
111114 
....@@ -114,25 +117,8 @@
114117 {
115118 	struct ufs_hba *hba = dev_get_drvdata(dev);
116119 
117
-	return sprintf(buf, "%s\n", ufschd_uic_link_state_to_string(
120
+	return sysfs_emit(buf, "%s\n", ufschd_uic_link_state_to_string(
118121 				ufs_pm_lvl_states[hba->spm_lvl].link_state));
119
-}
120
-
121
-static void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit)
122
-{
123
-	unsigned long flags;
124
-
125
-	if (!(hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT))
126
-		return;
127
-
128
-	spin_lock_irqsave(hba->host->host_lock, flags);
129
-	if (hba->ahit == ahit)
130
-		goto out_unlock;
131
-	hba->ahit = ahit;
132
-	if (!pm_runtime_suspended(hba->dev))
133
-		ufshcd_writel(hba, hba->ahit, REG_AUTO_HIBERNATE_IDLE_TIMER);
134
-out_unlock:
135
-	spin_unlock_irqrestore(hba->host->host_lock, flags);
136122 }
137123 
138124 /* Convert Auto-Hibernate Idle Timer register value to microseconds */
....@@ -162,12 +148,19 @@
162148 static ssize_t auto_hibern8_show(struct device *dev,
163149 				 struct device_attribute *attr, char *buf)
164150 {
151
+	u32 ahit;
165152 	struct ufs_hba *hba = dev_get_drvdata(dev);
166153 
167
-	if (!(hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT))
154
+	if (!ufshcd_is_auto_hibern8_supported(hba))
168155 		return -EOPNOTSUPP;
169156 
170
-	return snprintf(buf, PAGE_SIZE, "%d\n", ufshcd_ahit_to_us(hba->ahit));
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));
171164 }
172165 
173166 static ssize_t auto_hibern8_store(struct device *dev,
....@@ -177,7 +170,7 @@
177170 	struct ufs_hba *hba = dev_get_drvdata(dev);
178171 	unsigned int timer;
179172 
180
-	if (!(hba->capabilities & MASK_AUTO_HIBERN8_SUPPORT))
173
+	if (!ufshcd_is_auto_hibern8_supported(hba))
181174 		return -EOPNOTSUPP;
182175 
183176 	if (kstrtouint(buf, 0, &timer))
....@@ -214,6 +207,242 @@
214207 	.attrs = ufs_sysfs_ufshcd_attrs,
215208 };
216209 
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
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
+
217446 static ssize_t ufs_sysfs_read_desc_param(struct ufs_hba *hba,
218447 				  enum desc_idn desc_id,
219448 				  u8 desc_index,
....@@ -227,24 +456,26 @@
227456 	if (param_size > 8)
228457 		return -EINVAL;
229458 
459
+	pm_runtime_get_sync(hba->dev);
230460 	ret = ufshcd_read_desc_param(hba, desc_id, desc_index,
231461 				param_offset, desc_buf, param_size);
462
+	pm_runtime_put_sync(hba->dev);
232463 	if (ret)
233464 		return -EINVAL;
234465 	switch (param_size) {
235466 	case 1:
236
-		ret = sprintf(sysfs_buf, "0x%02X\n", *desc_buf);
467
+		ret = sysfs_emit(sysfs_buf, "0x%02X\n", *desc_buf);
237468 		break;
238469 	case 2:
239
-		ret = sprintf(sysfs_buf, "0x%04X\n",
470
+		ret = sysfs_emit(sysfs_buf, "0x%04X\n",
240471 			get_unaligned_be16(desc_buf));
241472 		break;
242473 	case 4:
243
-		ret = sprintf(sysfs_buf, "0x%08X\n",
474
+		ret = sysfs_emit(sysfs_buf, "0x%08X\n",
244475 			get_unaligned_be32(desc_buf));
245476 		break;
246477 	case 8:
247
-		ret = sprintf(sysfs_buf, "0x%016llX\n",
478
+		ret = sysfs_emit(sysfs_buf, "0x%016llX\n",
248479 			get_unaligned_be64(desc_buf));
249480 		break;
250481 	}
....@@ -291,6 +522,12 @@
291522 UFS_DEVICE_DESC_PARAM(number_of_secure_wpa, _NUM_SEC_WPA, 1);
292523 UFS_DEVICE_DESC_PARAM(psa_max_data_size, _PSA_MAX_DATA, 4);
293524 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);
294531 
295532 static struct attribute *ufs_sysfs_device_descriptor[] = {
296533 	&dev_attr_device_type.attr,
....@@ -319,6 +556,12 @@
319556 	&dev_attr_number_of_secure_wpa.attr,
320557 	&dev_attr_psa_max_data_size.attr,
321558 	&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,
322565 	NULL,
323566 };
324567 
....@@ -388,6 +631,16 @@
388631 	_ENM4_MAX_NUM_UNITS, 4);
389632 UFS_GEOMETRY_DESC_PARAM(enh4_memory_capacity_adjustment_factor,
390633 	_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
+
391644 
392645 static struct attribute *ufs_sysfs_geometry_descriptor[] = {
393646 	&dev_attr_raw_device_capacity.attr,
....@@ -419,6 +672,15 @@
419672 	&dev_attr_enh3_memory_capacity_adjustment_factor.attr,
420673 	&dev_attr_enh4_memory_max_alloc_units.attr,
421674 	&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,
422684 	NULL,
423685 };
424686 
....@@ -571,9 +833,11 @@
571833 	int ret;							\
572834 	int desc_len = QUERY_DESC_MAX_SIZE;				\
573835 	u8 *desc_buf;							\
836
+									\
574837 	desc_buf = kzalloc(QUERY_DESC_MAX_SIZE, GFP_ATOMIC);		\
575
-	if (!desc_buf)							\
576
-		return -ENOMEM;						\
838
+	if (!desc_buf)                                                  \
839
+		return -ENOMEM;                                         \
840
+	pm_runtime_get_sync(hba->dev);					\
577841 	ret = ufshcd_query_descriptor_retry(hba,			\
578842 		UPIU_QUERY_OPCODE_READ_DESC, QUERY_DESC_IDN_DEVICE,	\
579843 		0, 0, desc_buf, &desc_len);				\
....@@ -582,15 +846,15 @@
582846 		goto out;						\
583847 	}								\
584848 	index = desc_buf[DEVICE_DESC_PARAM##_pname];			\
585
-	memset(desc_buf, 0, QUERY_DESC_MAX_SIZE);			\
586
-	if (ufshcd_read_string_desc(hba, index, desc_buf,		\
587
-		QUERY_DESC_MAX_SIZE, true)) {				\
588
-		ret = -EINVAL;						\
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)							\
589854 		goto out;						\
590
-	}								\
591
-	ret = snprintf(buf, PAGE_SIZE, "%s\n",				\
592
-		desc_buf + QUERY_DESC_HDR_SIZE);			\
855
+	ret = sysfs_emit(buf, "%s\n", desc_buf);		\
593856 out:									\
857
+	pm_runtime_put_sync(hba->dev);					\
594858 	kfree(desc_buf);						\
595859 	return ret;							\
596860 }									\
....@@ -616,16 +880,29 @@
616880 	.attrs = ufs_sysfs_string_descriptors,
617881 };
618882 
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
+
619889 #define UFS_FLAG(_name, _uname)						\
620890 static ssize_t _name##_show(struct device *dev,				\
621891 	struct device_attribute *attr, char *buf)			\
622892 {									\
623893 	bool flag;							\
894
+	u8 index = 0;							\
895
+	int ret;							\
624896 	struct ufs_hba *hba = dev_get_drvdata(dev);			\
625
-	if (ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,		\
626
-		QUERY_FLAG_IDN##_uname, &flag))				\
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)							\
627904 		return -EINVAL;						\
628
-	return sprintf(buf, "%s\n", flag ? "true" : "false");		\
905
+	return sysfs_emit(buf, "%s\n", flag ? "true" : "false");	\
629906 }									\
630907 static DEVICE_ATTR_RO(_name)
631908 
....@@ -637,6 +914,10 @@
637914 UFS_FLAG(phy_resource_removal, _FPHYRESOURCEREMOVAL);
638915 UFS_FLAG(busy_rtc, _BUSY_RTC);
639916 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);
640921 
641922 static struct attribute *ufs_sysfs_device_flags[] = {
642923 	&dev_attr_device_init.attr,
....@@ -647,6 +928,10 @@
647928 	&dev_attr_phy_resource_removal.attr,
648929 	&dev_attr_busy_rtc.attr,
649930 	&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,
650935 	NULL,
651936 };
652937 
....@@ -655,20 +940,34 @@
655940 	.attrs = ufs_sysfs_device_flags,
656941 };
657942 
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
+
658949 #define UFS_ATTRIBUTE(_name, _uname)					\
659950 static ssize_t _name##_show(struct device *dev,				\
660951 	struct device_attribute *attr, char *buf)			\
661952 {									\
662953 	struct ufs_hba *hba = dev_get_drvdata(dev);			\
663954 	u32 value;							\
664
-	if (ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,		\
665
-		QUERY_ATTR_IDN##_uname, 0, 0, &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)							\
666964 		return -EINVAL;						\
667
-	return sprintf(buf, "0x%08X\n", value);				\
965
+	return sysfs_emit(buf, "0x%08X\n", value);			\
668966 }									\
669967 static DEVICE_ATTR_RO(_name)
670968 
671969 UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN);
970
+UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD);
672971 UFS_ATTRIBUTE(current_power_mode, _POWER_MODE);
673972 UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL);
674973 UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN);
....@@ -684,9 +983,15 @@
684983 UFS_ATTRIBUTE(ffu_status, _FFU_STATUS);
685984 UFS_ATTRIBUTE(psa_state, _PSA_STATE);
686985 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
+
687991 
688992 static struct attribute *ufs_sysfs_attributes[] = {
689993 	&dev_attr_boot_lun_enabled.attr,
994
+	&dev_attr_max_data_size_hpb_single_cmd.attr,
690995 	&dev_attr_current_power_mode.attr,
691996 	&dev_attr_active_icc_level.attr,
692997 	&dev_attr_ooo_data_enabled.attr,
....@@ -702,6 +1007,10 @@
7021007 	&dev_attr_ffu_status.attr,
7031008 	&dev_attr_psa_state.attr,
7041009 	&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,
7051014 	NULL,
7061015 };
7071016 
....@@ -712,6 +1021,7 @@
7121021 
7131022 static const struct attribute_group *ufs_sysfs_groups[] = {
7141023 	&ufs_sysfs_default_group,
1024
+	&ufs_sysfs_monitor_group,
7151025 	&ufs_sysfs_device_descriptor_group,
7161026 	&ufs_sysfs_interconnect_descriptor_group,
7171027 	&ufs_sysfs_geometry_descriptor_group,
....@@ -730,7 +1040,8 @@
7301040 	struct scsi_device *sdev = to_scsi_device(dev);			\
7311041 	struct ufs_hba *hba = shost_priv(sdev->host);			\
7321042 	u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);			\
733
-	if (!ufs_is_valid_unit_desc_lun(lun))				\
1043
+	if (!ufs_is_valid_unit_desc_lun(&hba->dev_info, lun,		\
1044
+				_duname##_DESC_PARAM##_puname))		\
7341045 		return -EINVAL;						\
7351046 	return ufs_sysfs_read_desc_param(hba, QUERY_DESC_IDN_##_duname,	\
7361047 		lun, _duname##_DESC_PARAM##_puname, buf, _size);	\
....@@ -753,6 +1064,11 @@
7531064 UFS_UNIT_DESC_PARAM(physical_memory_resourse_count, _PHY_MEM_RSRC_CNT, 8);
7541065 UFS_UNIT_DESC_PARAM(context_capabilities, _CTX_CAPABILITIES, 2);
7551066 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
+
7561072 
7571073 static struct attribute *ufs_sysfs_unit_descriptor[] = {
7581074 	&dev_attr_boot_lun_id.attr,
....@@ -768,6 +1084,10 @@
7681084 	&dev_attr_physical_memory_resourse_count.attr,
7691085 	&dev_attr_context_capabilities.attr,
7701086 	&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,
7711091 	NULL,
7721092 };
7731093 
....@@ -783,11 +1103,15 @@
7831103 	struct scsi_device *sdev = to_scsi_device(dev);
7841104 	struct ufs_hba *hba = shost_priv(sdev->host);
7851105 	u8 lun = ufshcd_scsi_to_upiu_lun(sdev->lun);
1106
+	int ret;
7861107 
787
-	if (ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_READ_ATTR,
788
-		QUERY_ATTR_IDN_DYN_CAP_NEEDED, lun, 0, &value))
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)
7891113 		return -EINVAL;
790
-	return sprintf(buf, "0x%08X\n", value);
1114
+	return sysfs_emit(buf, "0x%08X\n", value);
7911115 }
7921116 static DEVICE_ATTR_RO(dyn_cap_needed_attribute);
7931117 
....@@ -800,15 +1124,19 @@
8001124 	.attrs = ufs_sysfs_lun_attributes,
8011125 };
8021126 
803
-void ufs_sysfs_add_nodes(struct device *dev)
1127
+void ufs_sysfs_add_nodes(struct ufs_hba *hba)
8041128 {
8051129 	int ret;
8061130 
807
-	ret = sysfs_create_groups(&dev->kobj, ufs_sysfs_groups);
808
-	if (ret)
809
-		dev_err(dev,
1131
+	ret = sysfs_create_groups(&hba->dev->kobj, ufs_sysfs_groups);
1132
+	if (ret) {
1133
+		dev_err(hba->dev,
8101134 			"%s: sysfs groups creation failed (err = %d)\n",
8111135 			__func__, ret);
1136
+		return;
1137
+	}
1138
+
1139
+	trace_android_vh_ufs_update_sysfs(hba);
8121140 }
8131141 
8141142 void ufs_sysfs_remove_nodes(struct device *dev)