Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #undef TRACE_SYSTEM
3 : #define TRACE_SYSTEM power
4 :
5 : #if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
6 : #define _TRACE_POWER_H
7 :
8 : #include <linux/cpufreq.h>
9 : #include <linux/ktime.h>
10 : #include <linux/pm_qos.h>
11 : #include <linux/tracepoint.h>
12 : #include <linux/trace_events.h>
13 :
14 : #define TPS(x) tracepoint_string(x)
15 :
16 0 : DECLARE_EVENT_CLASS(cpu,
17 :
18 : TP_PROTO(unsigned int state, unsigned int cpu_id),
19 :
20 : TP_ARGS(state, cpu_id),
21 :
22 : TP_STRUCT__entry(
23 : __field( u32, state )
24 : __field( u32, cpu_id )
25 : ),
26 :
27 : TP_fast_assign(
28 : __entry->state = state;
29 : __entry->cpu_id = cpu_id;
30 : ),
31 :
32 : TP_printk("state=%lu cpu_id=%lu", (unsigned long)__entry->state,
33 : (unsigned long)__entry->cpu_id)
34 : );
35 :
36 61383 : DEFINE_EVENT(cpu, cpu_idle,
37 :
38 : TP_PROTO(unsigned int state, unsigned int cpu_id),
39 :
40 : TP_ARGS(state, cpu_id)
41 : );
42 :
43 0 : TRACE_EVENT(powernv_throttle,
44 :
45 : TP_PROTO(int chip_id, const char *reason, int pmax),
46 :
47 : TP_ARGS(chip_id, reason, pmax),
48 :
49 : TP_STRUCT__entry(
50 : __field(int, chip_id)
51 : __string(reason, reason)
52 : __field(int, pmax)
53 : ),
54 :
55 : TP_fast_assign(
56 : __entry->chip_id = chip_id;
57 : __assign_str(reason, reason);
58 : __entry->pmax = pmax;
59 : ),
60 :
61 : TP_printk("Chip %d Pmax %d %s", __entry->chip_id,
62 : __entry->pmax, __get_str(reason))
63 : );
64 :
65 0 : TRACE_EVENT(pstate_sample,
66 :
67 : TP_PROTO(u32 core_busy,
68 : u32 scaled_busy,
69 : u32 from,
70 : u32 to,
71 : u64 mperf,
72 : u64 aperf,
73 : u64 tsc,
74 : u32 freq,
75 : u32 io_boost
76 : ),
77 :
78 : TP_ARGS(core_busy,
79 : scaled_busy,
80 : from,
81 : to,
82 : mperf,
83 : aperf,
84 : tsc,
85 : freq,
86 : io_boost
87 : ),
88 :
89 : TP_STRUCT__entry(
90 : __field(u32, core_busy)
91 : __field(u32, scaled_busy)
92 : __field(u32, from)
93 : __field(u32, to)
94 : __field(u64, mperf)
95 : __field(u64, aperf)
96 : __field(u64, tsc)
97 : __field(u32, freq)
98 : __field(u32, io_boost)
99 : ),
100 :
101 : TP_fast_assign(
102 : __entry->core_busy = core_busy;
103 : __entry->scaled_busy = scaled_busy;
104 : __entry->from = from;
105 : __entry->to = to;
106 : __entry->mperf = mperf;
107 : __entry->aperf = aperf;
108 : __entry->tsc = tsc;
109 : __entry->freq = freq;
110 : __entry->io_boost = io_boost;
111 : ),
112 :
113 : TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%lu io_boost=%lu",
114 : (unsigned long)__entry->core_busy,
115 : (unsigned long)__entry->scaled_busy,
116 : (unsigned long)__entry->from,
117 : (unsigned long)__entry->to,
118 : (unsigned long long)__entry->mperf,
119 : (unsigned long long)__entry->aperf,
120 : (unsigned long long)__entry->tsc,
121 : (unsigned long)__entry->freq,
122 : (unsigned long)__entry->io_boost
123 : )
124 :
125 : );
126 :
127 : /* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */
128 : #ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING
129 : #define _PWR_EVENT_AVOID_DOUBLE_DEFINING
130 :
131 : #define PWR_EVENT_EXIT -1
132 : #endif
133 :
134 : #define pm_verb_symbolic(event) \
135 : __print_symbolic(event, \
136 : { PM_EVENT_SUSPEND, "suspend" }, \
137 : { PM_EVENT_RESUME, "resume" }, \
138 : { PM_EVENT_FREEZE, "freeze" }, \
139 : { PM_EVENT_QUIESCE, "quiesce" }, \
140 : { PM_EVENT_HIBERNATE, "hibernate" }, \
141 : { PM_EVENT_THAW, "thaw" }, \
142 : { PM_EVENT_RESTORE, "restore" }, \
143 : { PM_EVENT_RECOVER, "recover" })
144 :
145 0 : DEFINE_EVENT(cpu, cpu_frequency,
146 :
147 : TP_PROTO(unsigned int frequency, unsigned int cpu_id),
148 :
149 : TP_ARGS(frequency, cpu_id)
150 : );
151 :
152 0 : TRACE_EVENT(cpu_frequency_limits,
153 :
154 : TP_PROTO(struct cpufreq_policy *policy),
155 :
156 : TP_ARGS(policy),
157 :
158 : TP_STRUCT__entry(
159 : __field(u32, min_freq)
160 : __field(u32, max_freq)
161 : __field(u32, cpu_id)
162 : ),
163 :
164 : TP_fast_assign(
165 : __entry->min_freq = policy->min;
166 : __entry->max_freq = policy->max;
167 : __entry->cpu_id = policy->cpu;
168 : ),
169 :
170 : TP_printk("min=%lu max=%lu cpu_id=%lu",
171 : (unsigned long)__entry->min_freq,
172 : (unsigned long)__entry->max_freq,
173 : (unsigned long)__entry->cpu_id)
174 : );
175 :
176 0 : TRACE_EVENT(device_pm_callback_start,
177 :
178 : TP_PROTO(struct device *dev, const char *pm_ops, int event),
179 :
180 : TP_ARGS(dev, pm_ops, event),
181 :
182 : TP_STRUCT__entry(
183 : __string(device, dev_name(dev))
184 : __string(driver, dev_driver_string(dev))
185 : __string(parent, dev->parent ? dev_name(dev->parent) : "none")
186 : __string(pm_ops, pm_ops ? pm_ops : "none ")
187 : __field(int, event)
188 : ),
189 :
190 : TP_fast_assign(
191 : __assign_str(device, dev_name(dev));
192 : __assign_str(driver, dev_driver_string(dev));
193 : __assign_str(parent,
194 : dev->parent ? dev_name(dev->parent) : "none");
195 : __assign_str(pm_ops, pm_ops ? pm_ops : "none ");
196 : __entry->event = event;
197 : ),
198 :
199 : TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
200 : __get_str(device), __get_str(parent), __get_str(pm_ops),
201 : pm_verb_symbolic(__entry->event))
202 : );
203 :
204 0 : TRACE_EVENT(device_pm_callback_end,
205 :
206 : TP_PROTO(struct device *dev, int error),
207 :
208 : TP_ARGS(dev, error),
209 :
210 : TP_STRUCT__entry(
211 : __string(device, dev_name(dev))
212 : __string(driver, dev_driver_string(dev))
213 : __field(int, error)
214 : ),
215 :
216 : TP_fast_assign(
217 : __assign_str(device, dev_name(dev));
218 : __assign_str(driver, dev_driver_string(dev));
219 : __entry->error = error;
220 : ),
221 :
222 : TP_printk("%s %s, err=%d",
223 : __get_str(driver), __get_str(device), __entry->error)
224 : );
225 :
226 0 : TRACE_EVENT(suspend_resume,
227 :
228 : TP_PROTO(const char *action, int val, bool start),
229 :
230 : TP_ARGS(action, val, start),
231 :
232 : TP_STRUCT__entry(
233 : __field(const char *, action)
234 : __field(int, val)
235 : __field(bool, start)
236 : ),
237 :
238 : TP_fast_assign(
239 : __entry->action = action;
240 : __entry->val = val;
241 : __entry->start = start;
242 : ),
243 :
244 : TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
245 : (__entry->start)?"begin":"end")
246 : );
247 :
248 0 : DECLARE_EVENT_CLASS(wakeup_source,
249 :
250 : TP_PROTO(const char *name, unsigned int state),
251 :
252 : TP_ARGS(name, state),
253 :
254 : TP_STRUCT__entry(
255 : __string( name, name )
256 : __field( u64, state )
257 : ),
258 :
259 : TP_fast_assign(
260 : __assign_str(name, name);
261 : __entry->state = state;
262 : ),
263 :
264 : TP_printk("%s state=0x%lx", __get_str(name),
265 : (unsigned long)__entry->state)
266 : );
267 :
268 0 : DEFINE_EVENT(wakeup_source, wakeup_source_activate,
269 :
270 : TP_PROTO(const char *name, unsigned int state),
271 :
272 : TP_ARGS(name, state)
273 : );
274 :
275 0 : DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
276 :
277 : TP_PROTO(const char *name, unsigned int state),
278 :
279 : TP_ARGS(name, state)
280 : );
281 :
282 : /*
283 : * The clock events are used for clock enable/disable and for
284 : * clock rate change
285 : */
286 0 : DECLARE_EVENT_CLASS(clock,
287 :
288 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
289 :
290 : TP_ARGS(name, state, cpu_id),
291 :
292 : TP_STRUCT__entry(
293 : __string( name, name )
294 : __field( u64, state )
295 : __field( u64, cpu_id )
296 : ),
297 :
298 : TP_fast_assign(
299 : __assign_str(name, name);
300 : __entry->state = state;
301 : __entry->cpu_id = cpu_id;
302 : ),
303 :
304 : TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
305 : (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
306 : );
307 :
308 0 : DEFINE_EVENT(clock, clock_enable,
309 :
310 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
311 :
312 : TP_ARGS(name, state, cpu_id)
313 : );
314 :
315 0 : DEFINE_EVENT(clock, clock_disable,
316 :
317 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
318 :
319 : TP_ARGS(name, state, cpu_id)
320 : );
321 :
322 0 : DEFINE_EVENT(clock, clock_set_rate,
323 :
324 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
325 :
326 : TP_ARGS(name, state, cpu_id)
327 : );
328 :
329 : /*
330 : * The power domain events are used for power domains transitions
331 : */
332 0 : DECLARE_EVENT_CLASS(power_domain,
333 :
334 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
335 :
336 : TP_ARGS(name, state, cpu_id),
337 :
338 : TP_STRUCT__entry(
339 : __string( name, name )
340 : __field( u64, state )
341 : __field( u64, cpu_id )
342 : ),
343 :
344 : TP_fast_assign(
345 : __assign_str(name, name);
346 : __entry->state = state;
347 : __entry->cpu_id = cpu_id;
348 : ),
349 :
350 : TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
351 : (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
352 : );
353 :
354 0 : DEFINE_EVENT(power_domain, power_domain_target,
355 :
356 : TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
357 :
358 : TP_ARGS(name, state, cpu_id)
359 : );
360 :
361 : /*
362 : * CPU latency QoS events used for global CPU latency QoS list updates
363 : */
364 0 : DECLARE_EVENT_CLASS(cpu_latency_qos_request,
365 :
366 : TP_PROTO(s32 value),
367 :
368 : TP_ARGS(value),
369 :
370 : TP_STRUCT__entry(
371 : __field( s32, value )
372 : ),
373 :
374 : TP_fast_assign(
375 : __entry->value = value;
376 : ),
377 :
378 : TP_printk("CPU_DMA_LATENCY value=%d",
379 : __entry->value)
380 : );
381 :
382 0 : DEFINE_EVENT(cpu_latency_qos_request, pm_qos_add_request,
383 :
384 : TP_PROTO(s32 value),
385 :
386 : TP_ARGS(value)
387 : );
388 :
389 0 : DEFINE_EVENT(cpu_latency_qos_request, pm_qos_update_request,
390 :
391 : TP_PROTO(s32 value),
392 :
393 : TP_ARGS(value)
394 : );
395 :
396 0 : DEFINE_EVENT(cpu_latency_qos_request, pm_qos_remove_request,
397 :
398 : TP_PROTO(s32 value),
399 :
400 : TP_ARGS(value)
401 : );
402 :
403 : /*
404 : * General PM QoS events used for updates of PM QoS request lists
405 : */
406 0 : DECLARE_EVENT_CLASS(pm_qos_update,
407 :
408 : TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
409 :
410 : TP_ARGS(action, prev_value, curr_value),
411 :
412 : TP_STRUCT__entry(
413 : __field( enum pm_qos_req_action, action )
414 : __field( int, prev_value )
415 : __field( int, curr_value )
416 : ),
417 :
418 : TP_fast_assign(
419 : __entry->action = action;
420 : __entry->prev_value = prev_value;
421 : __entry->curr_value = curr_value;
422 : ),
423 :
424 : TP_printk("action=%s prev_value=%d curr_value=%d",
425 : __print_symbolic(__entry->action,
426 : { PM_QOS_ADD_REQ, "ADD_REQ" },
427 : { PM_QOS_UPDATE_REQ, "UPDATE_REQ" },
428 : { PM_QOS_REMOVE_REQ, "REMOVE_REQ" }),
429 : __entry->prev_value, __entry->curr_value)
430 : );
431 :
432 0 : DEFINE_EVENT(pm_qos_update, pm_qos_update_target,
433 :
434 : TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
435 :
436 : TP_ARGS(action, prev_value, curr_value)
437 : );
438 :
439 0 : DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,
440 :
441 : TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
442 :
443 : TP_ARGS(action, prev_value, curr_value),
444 :
445 : TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
446 : __print_symbolic(__entry->action,
447 : { PM_QOS_ADD_REQ, "ADD_REQ" },
448 : { PM_QOS_UPDATE_REQ, "UPDATE_REQ" },
449 : { PM_QOS_REMOVE_REQ, "REMOVE_REQ" }),
450 : __entry->prev_value, __entry->curr_value)
451 : );
452 :
453 0 : DECLARE_EVENT_CLASS(dev_pm_qos_request,
454 :
455 : TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
456 : s32 new_value),
457 :
458 : TP_ARGS(name, type, new_value),
459 :
460 : TP_STRUCT__entry(
461 : __string( name, name )
462 : __field( enum dev_pm_qos_req_type, type )
463 : __field( s32, new_value )
464 : ),
465 :
466 : TP_fast_assign(
467 : __assign_str(name, name);
468 : __entry->type = type;
469 : __entry->new_value = new_value;
470 : ),
471 :
472 : TP_printk("device=%s type=%s new_value=%d",
473 : __get_str(name),
474 : __print_symbolic(__entry->type,
475 : { DEV_PM_QOS_RESUME_LATENCY, "DEV_PM_QOS_RESUME_LATENCY" },
476 : { DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
477 : __entry->new_value)
478 : );
479 :
480 0 : DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,
481 :
482 : TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
483 : s32 new_value),
484 :
485 : TP_ARGS(name, type, new_value)
486 : );
487 :
488 0 : DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,
489 :
490 : TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
491 : s32 new_value),
492 :
493 : TP_ARGS(name, type, new_value)
494 : );
495 :
496 0 : DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
497 :
498 : TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
499 : s32 new_value),
500 :
501 : TP_ARGS(name, type, new_value)
502 : );
503 : #endif /* _TRACE_POWER_H */
504 :
505 : /* This part must be outside protection */
506 : #include <trace/define_trace.h>
|
