[mirror_ubuntu-jammy-kernel.git] / include / trace / events / power.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM power

#if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_POWER_H

#include <linux/ktime.h>
#include <linux/pm_qos.h>
#include <linux/tracepoint.h>
#include <linux/trace_events.h>

#define TPS(x)  tracepoint_string(x)

DECLARE_EVENT_CLASS(cpu,

	TP_PROTO(unsigned int state, unsigned int cpu_id),

	TP_ARGS(state, cpu_id),

	TP_STRUCT__entry(
		__field(	u32,		state		)
		__field(	u32,		cpu_id		)
	),

	TP_fast_assign(
		__entry->state = state;
		__entry->cpu_id = cpu_id;
	),

	TP_printk("state=%lu cpu_id=%lu", (unsigned long)__entry->state,
		  (unsigned long)__entry->cpu_id)
);

DEFINE_EVENT(cpu, cpu_idle,

	TP_PROTO(unsigned int state, unsigned int cpu_id),

	TP_ARGS(state, cpu_id)
);

TRACE_EVENT(powernv_throttle,

	TP_PROTO(int chip_id, const char *reason, int pmax),

	TP_ARGS(chip_id, reason, pmax),

	TP_STRUCT__entry(
		__field(int, chip_id)
		__string(reason, reason)
		__field(int, pmax)
	),

	TP_fast_assign(
		__entry->chip_id = chip_id;
		__assign_str(reason, reason);
		__entry->pmax = pmax;
	),

	TP_printk("Chip %d Pmax %d %s", __entry->chip_id,
		  __entry->pmax, __get_str(reason))
);

TRACE_EVENT(pstate_sample,

	TP_PROTO(u32 core_busy,
		u32 scaled_busy,
		u32 from,
		u32 to,
		u64 mperf,
		u64 aperf,
		u64 tsc,
		u32 freq,
		u32 io_boost
		),

	TP_ARGS(core_busy,
		scaled_busy,
		from,
		to,
		mperf,
		aperf,
		tsc,
		freq,
		io_boost
		),

	TP_STRUCT__entry(
		__field(u32, core_busy)
		__field(u32, scaled_busy)
		__field(u32, from)
		__field(u32, to)
		__field(u64, mperf)
		__field(u64, aperf)
		__field(u64, tsc)
		__field(u32, freq)
		__field(u32, io_boost)
		),

	TP_fast_assign(
		__entry->core_busy = core_busy;
		__entry->scaled_busy = scaled_busy;
		__entry->from = from;
		__entry->to = to;
		__entry->mperf = mperf;
		__entry->aperf = aperf;
		__entry->tsc = tsc;
		__entry->freq = freq;
		__entry->io_boost = io_boost;
		),

	TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%lu io_boost=%lu",
		(unsigned long)__entry->core_busy,
		(unsigned long)__entry->scaled_busy,
		(unsigned long)__entry->from,
		(unsigned long)__entry->to,
		(unsigned long long)__entry->mperf,
		(unsigned long long)__entry->aperf,
		(unsigned long long)__entry->tsc,
		(unsigned long)__entry->freq,
		(unsigned long)__entry->io_boost
		)

);

/* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */
#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING
#define _PWR_EVENT_AVOID_DOUBLE_DEFINING

#define PWR_EVENT_EXIT -1
#endif

#define pm_verb_symbolic(event) \
	__print_symbolic(event, \
		{ PM_EVENT_SUSPEND, "suspend" }, \
		{ PM_EVENT_RESUME, "resume" }, \
		{ PM_EVENT_FREEZE, "freeze" }, \
		{ PM_EVENT_QUIESCE, "quiesce" }, \
		{ PM_EVENT_HIBERNATE, "hibernate" }, \
		{ PM_EVENT_THAW, "thaw" }, \
		{ PM_EVENT_RESTORE, "restore" }, \
		{ PM_EVENT_RECOVER, "recover" })

DEFINE_EVENT(cpu, cpu_frequency,

	TP_PROTO(unsigned int frequency, unsigned int cpu_id),

	TP_ARGS(frequency, cpu_id)
);

TRACE_EVENT(device_pm_callback_start,

	TP_PROTO(struct device *dev, const char *pm_ops, int event),

	TP_ARGS(dev, pm_ops, event),

	TP_STRUCT__entry(
		__string(device, dev_name(dev))
		__string(driver, dev_driver_string(dev))
		__string(parent, dev->parent ? dev_name(dev->parent) : "none")
		__string(pm_ops, pm_ops ? pm_ops : "none ")
		__field(int, event)
	),

	TP_fast_assign(
		__assign_str(device, dev_name(dev));
		__assign_str(driver, dev_driver_string(dev));
		__assign_str(parent,
			dev->parent ? dev_name(dev->parent) : "none");
		__assign_str(pm_ops, pm_ops ? pm_ops : "none ");
		__entry->event = event;
	),

	TP_printk("%s %s, parent: %s, %s[%s]", __get_str(driver),
		__get_str(device), __get_str(parent), __get_str(pm_ops),
		pm_verb_symbolic(__entry->event))
);

TRACE_EVENT(device_pm_callback_end,

	TP_PROTO(struct device *dev, int error),

	TP_ARGS(dev, error),

	TP_STRUCT__entry(
		__string(device, dev_name(dev))
		__string(driver, dev_driver_string(dev))
		__field(int, error)
	),

	TP_fast_assign(
		__assign_str(device, dev_name(dev));
		__assign_str(driver, dev_driver_string(dev));
		__entry->error = error;
	),

	TP_printk("%s %s, err=%d",
		__get_str(driver), __get_str(device), __entry->error)
);

TRACE_EVENT(suspend_resume,

	TP_PROTO(const char *action, int val, bool start),

	TP_ARGS(action, val, start),

	TP_STRUCT__entry(
		__field(const char *, action)
		__field(int, val)
		__field(bool, start)
	),

	TP_fast_assign(
		__entry->action = action;
		__entry->val = val;
		__entry->start = start;
	),

	TP_printk("%s[%u] %s", __entry->action, (unsigned int)__entry->val,
		(__entry->start)?"begin":"end")
);

DECLARE_EVENT_CLASS(wakeup_source,

	TP_PROTO(const char *name, unsigned int state),

	TP_ARGS(name, state),

	TP_STRUCT__entry(
		__string(       name,           name            )
		__field(        u64,            state           )
	),

	TP_fast_assign(
		__assign_str(name, name);
		__entry->state = state;
	),

	TP_printk("%s state=0x%lx", __get_str(name),
		(unsigned long)__entry->state)
);

DEFINE_EVENT(wakeup_source, wakeup_source_activate,

	TP_PROTO(const char *name, unsigned int state),

	TP_ARGS(name, state)
);

DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,

	TP_PROTO(const char *name, unsigned int state),

	TP_ARGS(name, state)
);

/*
 * The clock events are used for clock enable/disable and for
 *  clock rate change
 */
DECLARE_EVENT_CLASS(clock,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id),

	TP_STRUCT__entry(
		__string(       name,           name            )
		__field(        u64,            state           )
		__field(        u64,            cpu_id          )
	),

	TP_fast_assign(
		__assign_str(name, name);
		__entry->state = state;
		__entry->cpu_id = cpu_id;
	),

	TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
		(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
);

DEFINE_EVENT(clock, clock_enable,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id)
);

DEFINE_EVENT(clock, clock_disable,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id)
);

DEFINE_EVENT(clock, clock_set_rate,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id)
);

/*
 * The power domain events are used for power domains transitions
 */
DECLARE_EVENT_CLASS(power_domain,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id),

	TP_STRUCT__entry(
		__string(       name,           name            )
		__field(        u64,            state           )
		__field(        u64,            cpu_id          )
	),

	TP_fast_assign(
		__assign_str(name, name);
		__entry->state = state;
		__entry->cpu_id = cpu_id;
),

	TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
		(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
);

DEFINE_EVENT(power_domain, power_domain_target,

	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),

	TP_ARGS(name, state, cpu_id)
);

/*
 * The pm qos events are used for pm qos update
 */
DECLARE_EVENT_CLASS(pm_qos_request,

	TP_PROTO(int pm_qos_class, s32 value),

	TP_ARGS(pm_qos_class, value),

	TP_STRUCT__entry(
		__field( int,                    pm_qos_class   )
		__field( s32,                    value          )
	),

	TP_fast_assign(
		__entry->pm_qos_class = pm_qos_class;
		__entry->value = value;
	),

	TP_printk("pm_qos_class=%s value=%d",
		  __print_symbolic(__entry->pm_qos_class,
			{ PM_QOS_CPU_DMA_LATENCY,	"CPU_DMA_LATENCY" },
			{ PM_QOS_NETWORK_LATENCY,	"NETWORK_LATENCY" },
			{ PM_QOS_NETWORK_THROUGHPUT,	"NETWORK_THROUGHPUT" }),
		  __entry->value)
);

DEFINE_EVENT(pm_qos_request, pm_qos_add_request,

	TP_PROTO(int pm_qos_class, s32 value),

	TP_ARGS(pm_qos_class, value)
);

DEFINE_EVENT(pm_qos_request, pm_qos_update_request,

	TP_PROTO(int pm_qos_class, s32 value),

	TP_ARGS(pm_qos_class, value)
);

DEFINE_EVENT(pm_qos_request, pm_qos_remove_request,

	TP_PROTO(int pm_qos_class, s32 value),

	TP_ARGS(pm_qos_class, value)
);

TRACE_EVENT(pm_qos_update_request_timeout,

	TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us),

	TP_ARGS(pm_qos_class, value, timeout_us),

	TP_STRUCT__entry(
		__field( int,                    pm_qos_class   )
		__field( s32,                    value          )
		__field( unsigned long,          timeout_us     )
	),

	TP_fast_assign(
		__entry->pm_qos_class = pm_qos_class;
		__entry->value = value;
		__entry->timeout_us = timeout_us;
	),

	TP_printk("pm_qos_class=%s value=%d, timeout_us=%ld",
		  __print_symbolic(__entry->pm_qos_class,
			{ PM_QOS_CPU_DMA_LATENCY,	"CPU_DMA_LATENCY" },
			{ PM_QOS_NETWORK_LATENCY,	"NETWORK_LATENCY" },
			{ PM_QOS_NETWORK_THROUGHPUT,	"NETWORK_THROUGHPUT" }),
		  __entry->value, __entry->timeout_us)
);

DECLARE_EVENT_CLASS(pm_qos_update,

	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),

	TP_ARGS(action, prev_value, curr_value),

	TP_STRUCT__entry(
		__field( enum pm_qos_req_action, action         )
		__field( int,                    prev_value     )
		__field( int,                    curr_value     )
	),

	TP_fast_assign(
		__entry->action = action;
		__entry->prev_value = prev_value;
		__entry->curr_value = curr_value;
	),

	TP_printk("action=%s prev_value=%d curr_value=%d",
		  __print_symbolic(__entry->action,
			{ PM_QOS_ADD_REQ,	"ADD_REQ" },
			{ PM_QOS_UPDATE_REQ,	"UPDATE_REQ" },
			{ PM_QOS_REMOVE_REQ,	"REMOVE_REQ" }),
		  __entry->prev_value, __entry->curr_value)
);

DEFINE_EVENT(pm_qos_update, pm_qos_update_target,

	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),

	TP_ARGS(action, prev_value, curr_value)
);

DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,

	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),

	TP_ARGS(action, prev_value, curr_value),

	TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
		  __print_symbolic(__entry->action,
			{ PM_QOS_ADD_REQ,	"ADD_REQ" },
			{ PM_QOS_UPDATE_REQ,	"UPDATE_REQ" },
			{ PM_QOS_REMOVE_REQ,	"REMOVE_REQ" }),
		  __entry->prev_value, __entry->curr_value)
);

DECLARE_EVENT_CLASS(dev_pm_qos_request,

	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
		 s32 new_value),

	TP_ARGS(name, type, new_value),

	TP_STRUCT__entry(
		__string( name,                    name         )
		__field( enum dev_pm_qos_req_type, type         )
		__field( s32,                      new_value    )
	),

	TP_fast_assign(
		__assign_str(name, name);
		__entry->type = type;
		__entry->new_value = new_value;
	),

	TP_printk("device=%s type=%s new_value=%d",
		  __get_str(name),
		  __print_symbolic(__entry->type,
			{ DEV_PM_QOS_RESUME_LATENCY, "DEV_PM_QOS_RESUME_LATENCY" },
			{ DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
		  __entry->new_value)
);

DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,

	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
		 s32 new_value),

	TP_ARGS(name, type, new_value)
);

DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,

	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
		 s32 new_value),

	TP_ARGS(name, type, new_value)
);

DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,

	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
		 s32 new_value),

	TP_ARGS(name, type, new_value)
);
#endif /* _TRACE_POWER_H */

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