forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c 
 kernel/drivers/base/power/sysfs.c
....@@ -1,8 +1,7 @@
1
-/*
2
- * drivers/base/power/sysfs.c - sysfs entries for device PM
3
- */
4
-
1
+// SPDX-License-Identifier: GPL-2.0
2
+/* sysfs entries for device PM */
53 #include <linux/device.h>
4
+#include <linux/kobject.h>
65 #include <linux/string.h>
76 #include <linux/export.h>
87 #include <linux/pm_qos.h>
....@@ -102,8 +101,8 @@
102101 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
103102 			    char *buf)
104103 {
105
-	return sprintf(buf, "%s\n",
106
-				dev->power.runtime_auto ? ctrl_auto : ctrl_on);
104
+	return sysfs_emit(buf, "%s\n",
105
+			  dev->power.runtime_auto ? ctrl_auto : ctrl_on);
107106 }
108107 
109108 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
....@@ -123,70 +122,71 @@
123122 static DEVICE_ATTR_RW(control);
124123 
125124 static ssize_t runtime_active_time_show(struct device *dev,
126
-				struct device_attribute *attr, char *buf)
125
+					struct device_attribute *attr,
126
+					char *buf)
127127 {
128
-	int ret;
129
-	spin_lock_irq(&dev->power.lock);
130
-	update_pm_runtime_accounting(dev);
131
-	ret = sprintf(buf, "%i\n", jiffies_to_msecs(dev->power.active_jiffies));
132
-	spin_unlock_irq(&dev->power.lock);
133
-	return ret;
128
+	u64 tmp = pm_runtime_active_time(dev);
129
+
130
+	do_div(tmp, NSEC_PER_MSEC);
131
+
132
+	return sysfs_emit(buf, "%llu\n", tmp);
134133 }
135134 
136135 static DEVICE_ATTR_RO(runtime_active_time);
137136 
138137 static ssize_t runtime_suspended_time_show(struct device *dev,
139
-				struct device_attribute *attr, char *buf)
138
+					   struct device_attribute *attr,
139
+					   char *buf)
140140 {
141
-	int ret;
142
-	spin_lock_irq(&dev->power.lock);
143
-	update_pm_runtime_accounting(dev);
144
-	ret = sprintf(buf, "%i\n",
145
-		jiffies_to_msecs(dev->power.suspended_jiffies));
146
-	spin_unlock_irq(&dev->power.lock);
147
-	return ret;
141
+	u64 tmp = pm_runtime_suspended_time(dev);
142
+
143
+	do_div(tmp, NSEC_PER_MSEC);
144
+
145
+	return sysfs_emit(buf, "%llu\n", tmp);
148146 }
149147 
150148 static DEVICE_ATTR_RO(runtime_suspended_time);
151149 
152150 static ssize_t runtime_status_show(struct device *dev,
153
-				struct device_attribute *attr, char *buf)
151
+				   struct device_attribute *attr, char *buf)
154152 {
155
-	const char *p;
153
+	const char *output;
156154 
157155 	if (dev->power.runtime_error) {
158
-		p = "error\n";
156
+		output = "error";
159157 	} else if (dev->power.disable_depth) {
160
-		p = "unsupported\n";
158
+		output = "unsupported";
161159 	} else {
162160 		switch (dev->power.runtime_status) {
163161 		case RPM_SUSPENDED:
164
-			p = "suspended\n";
162
+			output = "suspended";
165163 			break;
166164 		case RPM_SUSPENDING:
167
-			p = "suspending\n";
165
+			output = "suspending";
168166 			break;
169167 		case RPM_RESUMING:
170
-			p = "resuming\n";
168
+			output = "resuming";
171169 			break;
172170 		case RPM_ACTIVE:
173
-			p = "active\n";
171
+			output = "active";
174172 			break;
175173 		default:
176174 			return -EIO;
177175 		}
178176 	}
179
-	return sprintf(buf, p);
177
+	return sysfs_emit(buf, "%s\n", output);
180178 }
181179 
182180 static DEVICE_ATTR_RO(runtime_status);
183181 
184182 static ssize_t autosuspend_delay_ms_show(struct device *dev,
185
-		struct device_attribute *attr, char *buf)
183
+					 struct device_attribute *attr,
184
+					 char *buf)
186185 {
187186 	if (!dev->power.use_autosuspend)
188187 		return -EIO;
189
-	return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
188
+
189
+	return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
190190 }
191191 
192192 static ssize_t autosuspend_delay_ms_store(struct device *dev,
....@@ -215,11 +215,11 @@
215215 	s32 value = dev_pm_qos_requested_resume_latency(dev);
216216 
217217 	if (value == 0)
218
-		return sprintf(buf, "n/a\n");
218
+		return sysfs_emit(buf, "n/a\n");
219219 	if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
220220 		value = 0;
221221 
222
-	return sprintf(buf, "%d\n", value);
222
+	return sysfs_emit(buf, "%d\n", value);
223223 }
224224 
225225 static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
....@@ -259,11 +259,11 @@
259259 	s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
260260 
261261 	if (value < 0)
262
-		return sprintf(buf, "auto\n");
262
+		return sysfs_emit(buf, "%s\n", "auto");
263263 	if (value == PM_QOS_LATENCY_ANY)
264
-		return sprintf(buf, "any\n");
264
+		return sysfs_emit(buf, "%s\n", "any");
265265 
266
-	return sprintf(buf, "%d\n", value);
266
+	return sysfs_emit(buf, "%d\n", value);
267267 }
268268 
269269 static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
....@@ -295,8 +295,8 @@
295295 					struct device_attribute *attr,
296296 					char *buf)
297297 {
298
-	return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
299
-					& PM_QOS_FLAG_NO_POWER_OFF));
298
+	return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
299
+					  & PM_QOS_FLAG_NO_POWER_OFF));
300300 }
301301 
302302 static ssize_t pm_qos_no_power_off_store(struct device *dev,
....@@ -324,9 +324,9 @@
324324 static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
325325 			   char *buf)
326326 {
327
-	return sprintf(buf, "%s\n", device_can_wakeup(dev)
328
-		? (device_may_wakeup(dev) ? _enabled : _disabled)
329
-		: "");
327
+	return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
328
+			  ? (device_may_wakeup(dev) ? _enabled : _disabled)
329
+			  : "");
330330 }
331331 
332332 static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
....@@ -349,7 +349,7 @@
349349 static ssize_t wakeup_count_show(struct device *dev,
350350 				 struct device_attribute *attr, char *buf)
351351 {
352
-	unsigned long count = 0;
352
+	unsigned long count;
353353 	bool enabled = false;
354354 
355355 	spin_lock_irq(&dev->power.lock);
....@@ -358,7 +358,10 @@
358358 		enabled = true;
359359 	}
360360 	spin_unlock_irq(&dev->power.lock);
361
-	return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
361
+
362
+	if (!enabled)
363
+		return sysfs_emit(buf, "\n");
364
+	return sysfs_emit(buf, "%lu\n", count);
362365 }
363366 
364367 static DEVICE_ATTR_RO(wakeup_count);
....@@ -367,7 +370,7 @@
367370 					struct device_attribute *attr,
368371 					char *buf)
369372 {
370
-	unsigned long count = 0;
373
+	unsigned long count;
371374 	bool enabled = false;
372375 
373376 	spin_lock_irq(&dev->power.lock);
....@@ -376,7 +379,10 @@
376379 		enabled = true;
377380 	}
378381 	spin_unlock_irq(&dev->power.lock);
379
-	return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
382
+
383
+	if (!enabled)
384
+		return sysfs_emit(buf, "\n");
385
+	return sysfs_emit(buf, "%lu\n", count);
380386 }
381387 
382388 static DEVICE_ATTR_RO(wakeup_active_count);
....@@ -385,7 +391,7 @@
385391 				       struct device_attribute *attr,
386392 				       char *buf)
387393 {
388
-	unsigned long count = 0;
394
+	unsigned long count;
389395 	bool enabled = false;
390396 
391397 	spin_lock_irq(&dev->power.lock);
....@@ -394,7 +400,10 @@
394400 		enabled = true;
395401 	}
396402 	spin_unlock_irq(&dev->power.lock);
397
-	return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
403
+
404
+	if (!enabled)
405
+		return sysfs_emit(buf, "\n");
406
+	return sysfs_emit(buf, "%lu\n", count);
398407 }
399408 
400409 static DEVICE_ATTR_RO(wakeup_abort_count);
....@@ -403,7 +412,7 @@
403412 					struct device_attribute *attr,
404413 					char *buf)
405414 {
406
-	unsigned long count = 0;
415
+	unsigned long count;
407416 	bool enabled = false;
408417 
409418 	spin_lock_irq(&dev->power.lock);
....@@ -412,7 +421,10 @@
412421 		enabled = true;
413422 	}
414423 	spin_unlock_irq(&dev->power.lock);
415
-	return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
424
+
425
+	if (!enabled)
426
+		return sysfs_emit(buf, "\n");
427
+	return sysfs_emit(buf, "%lu\n", count);
416428 }
417429 
418430 static DEVICE_ATTR_RO(wakeup_expire_count);
....@@ -420,7 +432,7 @@
420432 static ssize_t wakeup_active_show(struct device *dev,
421433 				  struct device_attribute *attr, char *buf)
422434 {
423
-	unsigned int active = 0;
435
+	unsigned int active;
424436 	bool enabled = false;
425437 
426438 	spin_lock_irq(&dev->power.lock);
....@@ -429,7 +441,10 @@
429441 		enabled = true;
430442 	}
431443 	spin_unlock_irq(&dev->power.lock);
432
-	return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
444
+
445
+	if (!enabled)
446
+		return sysfs_emit(buf, "\n");
447
+	return sysfs_emit(buf, "%u\n", active);
433448 }
434449 
435450 static DEVICE_ATTR_RO(wakeup_active);
....@@ -438,7 +453,7 @@
438453 					 struct device_attribute *attr,
439454 					 char *buf)
440455 {
441
-	s64 msec = 0;
456
+	s64 msec;
442457 	bool enabled = false;
443458 
444459 	spin_lock_irq(&dev->power.lock);
....@@ -447,7 +462,10 @@
447462 		enabled = true;
448463 	}
449464 	spin_unlock_irq(&dev->power.lock);
450
-	return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
465
+
466
+	if (!enabled)
467
+		return sysfs_emit(buf, "\n");
468
+	return sysfs_emit(buf, "%lld\n", msec);
451469 }
452470 
453471 static DEVICE_ATTR_RO(wakeup_total_time_ms);
....@@ -455,7 +473,7 @@
455473 static ssize_t wakeup_max_time_ms_show(struct device *dev,
456474 				       struct device_attribute *attr, char *buf)
457475 {
458
-	s64 msec = 0;
476
+	s64 msec;
459477 	bool enabled = false;
460478 
461479 	spin_lock_irq(&dev->power.lock);
....@@ -464,7 +482,10 @@
464482 		enabled = true;
465483 	}
466484 	spin_unlock_irq(&dev->power.lock);
467
-	return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
485
+
486
+	if (!enabled)
487
+		return sysfs_emit(buf, "\n");
488
+	return sysfs_emit(buf, "%lld\n", msec);
468489 }
469490 
470491 static DEVICE_ATTR_RO(wakeup_max_time_ms);
....@@ -473,7 +494,7 @@
473494 					struct device_attribute *attr,
474495 					char *buf)
475496 {
476
-	s64 msec = 0;
497
+	s64 msec;
477498 	bool enabled = false;
478499 
479500 	spin_lock_irq(&dev->power.lock);
....@@ -482,7 +503,18 @@
482503 		enabled = true;
483504 	}
484505 	spin_unlock_irq(&dev->power.lock);
485
-	return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
506
+
507
+	if (!enabled)
508
+		return sysfs_emit(buf, "\n");
509
+	return sysfs_emit(buf, "%lld\n", msec);
510
+}
511
+
512
+static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
513
+						kgid_t kgid)
514
+{
515
+	if (dev->power.wakeup && dev->power.wakeup->dev)
516
+		return device_change_owner(dev->power.wakeup->dev, kuid, kgid);
517
+	return 0;
486518 }
487519 
488520 static DEVICE_ATTR_RO(wakeup_last_time_ms);
....@@ -492,7 +524,7 @@
492524 						 struct device_attribute *attr,
493525 						 char *buf)
494526 {
495
-	s64 msec = 0;
527
+	s64 msec;
496528 	bool enabled = false;
497529 
498530 	spin_lock_irq(&dev->power.lock);
....@@ -501,18 +533,27 @@
501533 		enabled = true;
502534 	}
503535 	spin_unlock_irq(&dev->power.lock);
504
-	return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
536
+
537
+	if (!enabled)
538
+		return sysfs_emit(buf, "\n");
539
+	return sysfs_emit(buf, "%lld\n", msec);
505540 }
506541 
507542 static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
508543 #endif /* CONFIG_PM_AUTOSLEEP */
509
-#endif /* CONFIG_PM_SLEEP */
544
+#else /* CONFIG_PM_SLEEP */
545
+static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
546
+						kgid_t kgid)
547
+{
548
+	return 0;
549
+}
550
+#endif
510551 
511552 #ifdef CONFIG_PM_ADVANCED_DEBUG
512553 static ssize_t runtime_usage_show(struct device *dev,
513554 				  struct device_attribute *attr, char *buf)
514555 {
515
-	return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
556
+	return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
516557 }
517558 static DEVICE_ATTR_RO(runtime_usage);
518559 
....@@ -520,21 +561,26 @@
520561 					struct device_attribute *attr,
521562 					char *buf)
522563 {
523
-	return sprintf(buf, "%d\n", dev->power.ignore_children ?
524
-		0 : atomic_read(&dev->power.child_count));
564
+	return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
565
+			  0 : atomic_read(&dev->power.child_count));
525566 }
526567 static DEVICE_ATTR_RO(runtime_active_kids);
527568 
528569 static ssize_t runtime_enabled_show(struct device *dev,
529570 				    struct device_attribute *attr, char *buf)
530571 {
531
-	if (dev->power.disable_depth && (dev->power.runtime_auto == false))
532
-		return sprintf(buf, "disabled & forbidden\n");
533
-	if (dev->power.disable_depth)
534
-		return sprintf(buf, "disabled\n");
535
-	if (dev->power.runtime_auto == false)
536
-		return sprintf(buf, "forbidden\n");
537
-	return sprintf(buf, "enabled\n");
572
+	const char *output;
573
+
574
+	if (dev->power.disable_depth && !dev->power.runtime_auto)
575
+		output = "disabled & forbidden";
576
+	else if (dev->power.disable_depth)
577
+		output = "disabled";
578
+	else if (!dev->power.runtime_auto)
579
+		output = "forbidden";
580
+	else
581
+		output = "enabled";
582
+
583
+	return sysfs_emit(buf, "%s\n", output);
538584 }
539585 static DEVICE_ATTR_RO(runtime_enabled);
540586 
....@@ -542,9 +588,9 @@
542588 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
543589 			  char *buf)
544590 {
545
-	return sprintf(buf, "%s\n",
546
-			device_async_suspend_enabled(dev) ?
547
-				_enabled : _disabled);
591
+	return sysfs_emit(buf, "%s\n",
592
+			  device_async_suspend_enabled(dev) ?
593
+			  _enabled : _disabled);
548594 }
549595 
550596 static ssize_t async_store(struct device *dev, struct device_attribute *attr,
....@@ -657,7 +703,7 @@
657703 	if (rc)
658704 		return rc;
659705 
660
-	if (pm_runtime_callbacks_present(dev)) {
706
+	if (!pm_runtime_has_no_callbacks(dev)) {
661707 		rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
662708 		if (rc)
663709 			goto err_out;
....@@ -689,14 +735,59 @@
689735 	return rc;
690736 }
691737 
738
+int dpm_sysfs_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
739
+{
740
+	int rc;
741
+
742
+	if (device_pm_not_required(dev))
743
+		return 0;
744
+
745
+	rc = sysfs_group_change_owner(&dev->kobj, &pm_attr_group, kuid, kgid);
746
+	if (rc)
747
+		return rc;
748
+
749
+	if (!pm_runtime_has_no_callbacks(dev)) {
750
+		rc = sysfs_group_change_owner(
751
+			&dev->kobj, &pm_runtime_attr_group, kuid, kgid);
752
+		if (rc)
753
+			return rc;
754
+	}
755
+
756
+	if (device_can_wakeup(dev)) {
757
+		rc = sysfs_group_change_owner(&dev->kobj, &pm_wakeup_attr_group,
758
+					      kuid, kgid);
759
+		if (rc)
760
+			return rc;
761
+
762
+		rc = dpm_sysfs_wakeup_change_owner(dev, kuid, kgid);
763
+		if (rc)
764
+			return rc;
765
+	}
766
+
767
+	if (dev->power.set_latency_tolerance) {
768
+		rc = sysfs_group_change_owner(
769
+			&dev->kobj, &pm_qos_latency_tolerance_attr_group, kuid,
770
+			kgid);
771
+		if (rc)
772
+			return rc;
773
+	}
774
+	return 0;
775
+}
776
+
692777 int wakeup_sysfs_add(struct device *dev)
693778 {
694
-	return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
779
+	int ret = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
780
+
781
+	if (!ret)
782
+		kobject_uevent(&dev->kobj, KOBJ_CHANGE);
783
+
784
+	return ret;
695785 }
696786 
697787 void wakeup_sysfs_remove(struct device *dev)
698788 {
699789 	sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
790
+	kobject_uevent(&dev->kobj, KOBJ_CHANGE);
700791 }
701792 
702793 int pm_qos_sysfs_add_resume_latency(struct device *dev)