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

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