Commit | Line | Data |
---|---|---|
c8377adf TV |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Wakeup statistics in sysfs | |
4 | * | |
5 | * Copyright (c) 2019 Linux Foundation | |
6 | * Copyright (c) 2019 Greg Kroah-Hartman <gregkh@linuxfoundation.org> | |
7 | * Copyright (c) 2019 Google Inc. | |
8 | */ | |
9 | ||
10 | #include <linux/device.h> | |
11 | #include <linux/idr.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/kdev_t.h> | |
14 | #include <linux/kernel.h> | |
15 | #include <linux/kobject.h> | |
16 | #include <linux/slab.h> | |
17 | #include <linux/timekeeping.h> | |
18 | ||
19 | #include "power.h" | |
20 | ||
21 | static struct class *wakeup_class; | |
22 | ||
23 | #define wakeup_attr(_name) \ | |
24 | static ssize_t _name##_show(struct device *dev, \ | |
25 | struct device_attribute *attr, char *buf) \ | |
26 | { \ | |
27 | struct wakeup_source *ws = dev_get_drvdata(dev); \ | |
28 | \ | |
948b3edb | 29 | return sysfs_emit(buf, "%lu\n", ws->_name); \ |
c8377adf TV |
30 | } \ |
31 | static DEVICE_ATTR_RO(_name) | |
32 | ||
33 | wakeup_attr(active_count); | |
34 | wakeup_attr(event_count); | |
35 | wakeup_attr(wakeup_count); | |
36 | wakeup_attr(expire_count); | |
37 | ||
38 | static ssize_t active_time_ms_show(struct device *dev, | |
39 | struct device_attribute *attr, char *buf) | |
40 | { | |
41 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
42 | ktime_t active_time = | |
43 | ws->active ? ktime_sub(ktime_get(), ws->last_time) : 0; | |
44 | ||
aa838896 | 45 | return sysfs_emit(buf, "%lld\n", ktime_to_ms(active_time)); |
c8377adf TV |
46 | } |
47 | static DEVICE_ATTR_RO(active_time_ms); | |
48 | ||
49 | static ssize_t total_time_ms_show(struct device *dev, | |
50 | struct device_attribute *attr, char *buf) | |
51 | { | |
52 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
53 | ktime_t active_time; | |
54 | ktime_t total_time = ws->total_time; | |
55 | ||
56 | if (ws->active) { | |
57 | active_time = ktime_sub(ktime_get(), ws->last_time); | |
58 | total_time = ktime_add(total_time, active_time); | |
59 | } | |
948b3edb | 60 | |
aa838896 | 61 | return sysfs_emit(buf, "%lld\n", ktime_to_ms(total_time)); |
c8377adf TV |
62 | } |
63 | static DEVICE_ATTR_RO(total_time_ms); | |
64 | ||
65 | static ssize_t max_time_ms_show(struct device *dev, | |
66 | struct device_attribute *attr, char *buf) | |
67 | { | |
68 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
69 | ktime_t active_time; | |
70 | ktime_t max_time = ws->max_time; | |
71 | ||
72 | if (ws->active) { | |
73 | active_time = ktime_sub(ktime_get(), ws->last_time); | |
74 | if (active_time > max_time) | |
75 | max_time = active_time; | |
76 | } | |
948b3edb | 77 | |
aa838896 | 78 | return sysfs_emit(buf, "%lld\n", ktime_to_ms(max_time)); |
c8377adf TV |
79 | } |
80 | static DEVICE_ATTR_RO(max_time_ms); | |
81 | ||
82 | static ssize_t last_change_ms_show(struct device *dev, | |
83 | struct device_attribute *attr, char *buf) | |
84 | { | |
85 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
86 | ||
aa838896 | 87 | return sysfs_emit(buf, "%lld\n", ktime_to_ms(ws->last_time)); |
c8377adf TV |
88 | } |
89 | static DEVICE_ATTR_RO(last_change_ms); | |
90 | ||
91 | static ssize_t name_show(struct device *dev, struct device_attribute *attr, | |
92 | char *buf) | |
93 | { | |
94 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
95 | ||
aa838896 | 96 | return sysfs_emit(buf, "%s\n", ws->name); |
c8377adf TV |
97 | } |
98 | static DEVICE_ATTR_RO(name); | |
99 | ||
100 | static ssize_t prevent_suspend_time_ms_show(struct device *dev, | |
101 | struct device_attribute *attr, | |
102 | char *buf) | |
103 | { | |
104 | struct wakeup_source *ws = dev_get_drvdata(dev); | |
105 | ktime_t prevent_sleep_time = ws->prevent_sleep_time; | |
106 | ||
107 | if (ws->active && ws->autosleep_enabled) { | |
108 | prevent_sleep_time = ktime_add(prevent_sleep_time, | |
109 | ktime_sub(ktime_get(), ws->start_prevent_time)); | |
110 | } | |
948b3edb | 111 | |
aa838896 | 112 | return sysfs_emit(buf, "%lld\n", ktime_to_ms(prevent_sleep_time)); |
c8377adf TV |
113 | } |
114 | static DEVICE_ATTR_RO(prevent_suspend_time_ms); | |
115 | ||
116 | static struct attribute *wakeup_source_attrs[] = { | |
117 | &dev_attr_name.attr, | |
118 | &dev_attr_active_count.attr, | |
119 | &dev_attr_event_count.attr, | |
120 | &dev_attr_wakeup_count.attr, | |
121 | &dev_attr_expire_count.attr, | |
122 | &dev_attr_active_time_ms.attr, | |
123 | &dev_attr_total_time_ms.attr, | |
124 | &dev_attr_max_time_ms.attr, | |
125 | &dev_attr_last_change_ms.attr, | |
126 | &dev_attr_prevent_suspend_time_ms.attr, | |
127 | NULL, | |
128 | }; | |
129 | ATTRIBUTE_GROUPS(wakeup_source); | |
130 | ||
131 | static void device_create_release(struct device *dev) | |
132 | { | |
133 | kfree(dev); | |
134 | } | |
135 | ||
136 | static struct device *wakeup_source_device_create(struct device *parent, | |
137 | struct wakeup_source *ws) | |
138 | { | |
139 | struct device *dev = NULL; | |
e4880233 | 140 | int retval; |
c8377adf TV |
141 | |
142 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); | |
143 | if (!dev) { | |
144 | retval = -ENOMEM; | |
145 | goto error; | |
146 | } | |
147 | ||
148 | device_initialize(dev); | |
149 | dev->devt = MKDEV(0, 0); | |
150 | dev->class = wakeup_class; | |
151 | dev->parent = parent; | |
152 | dev->groups = wakeup_source_groups; | |
153 | dev->release = device_create_release; | |
154 | dev_set_drvdata(dev, ws); | |
155 | device_set_pm_not_required(dev); | |
156 | ||
4da6d76f | 157 | retval = dev_set_name(dev, "wakeup%d", ws->id); |
c8377adf TV |
158 | if (retval) |
159 | goto error; | |
160 | ||
161 | retval = device_add(dev); | |
162 | if (retval) | |
163 | goto error; | |
164 | ||
165 | return dev; | |
166 | ||
167 | error: | |
168 | put_device(dev); | |
169 | return ERR_PTR(retval); | |
170 | } | |
171 | ||
172 | /** | |
173 | * wakeup_source_sysfs_add - Add wakeup_source attributes to sysfs. | |
174 | * @parent: Device given wakeup source is associated with (or NULL if virtual). | |
175 | * @ws: Wakeup source to be added in sysfs. | |
176 | */ | |
177 | int wakeup_source_sysfs_add(struct device *parent, struct wakeup_source *ws) | |
178 | { | |
179 | struct device *dev; | |
180 | ||
181 | dev = wakeup_source_device_create(parent, ws); | |
182 | if (IS_ERR(dev)) | |
183 | return PTR_ERR(dev); | |
184 | ws->dev = dev; | |
185 | ||
186 | return 0; | |
187 | } | |
c8377adf | 188 | |
2ca3d1ec SB |
189 | /** |
190 | * pm_wakeup_source_sysfs_add - Add wakeup_source attributes to sysfs | |
191 | * for a device if they're missing. | |
192 | * @parent: Device given wakeup source is associated with | |
193 | */ | |
194 | int pm_wakeup_source_sysfs_add(struct device *parent) | |
195 | { | |
196 | if (!parent->power.wakeup || parent->power.wakeup->dev) | |
197 | return 0; | |
198 | ||
199 | return wakeup_source_sysfs_add(parent, parent->power.wakeup); | |
200 | } | |
201 | ||
c8377adf TV |
202 | /** |
203 | * wakeup_source_sysfs_remove - Remove wakeup_source attributes from sysfs. | |
204 | * @ws: Wakeup source to be removed from sysfs. | |
205 | */ | |
206 | void wakeup_source_sysfs_remove(struct wakeup_source *ws) | |
207 | { | |
208 | device_unregister(ws->dev); | |
209 | } | |
c8377adf TV |
210 | |
211 | static int __init wakeup_sources_sysfs_init(void) | |
212 | { | |
1aaba11d | 213 | wakeup_class = class_create("wakeup"); |
c8377adf TV |
214 | |
215 | return PTR_ERR_OR_ZERO(wakeup_class); | |
216 | } | |
217 | postcore_initcall(wakeup_sources_sysfs_init); |