[linux-block.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/cpufreq.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(cpu_idle_miss,

	TP_PROTO(unsigned int cpu_id, unsigned int state, bool below),

	TP_ARGS(cpu_id, state, below),

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

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

	TP_printk("cpu_id=%lu state=%lu type=%s", (unsigned long)__entry->cpu_id,
		(unsigned long)__entry->state, (__entry->below)?"below":"above")
);

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);
		__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(cpu_frequency_limits,

	TP_PROTO(struct cpufreq_policy *policy),

	TP_ARGS(policy),

	TP_STRUCT__entry(
		__field(u32, min_freq)
		__field(u32, max_freq)
		__field(u32, cpu_id)
	),

	TP_fast_assign(
		__entry->min_freq = policy->min;
		__entry->max_freq = policy->max;
		__entry->cpu_id = policy->cpu;
	),

	TP_printk("min=%lu max=%lu cpu_id=%lu",
		  (unsigned long)__entry->min_freq,
		  (unsigned long)__entry->max_freq,
		  (unsigned long)__entry->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);
		__assign_str(driver);
		__assign_str(parent);
		__assign_str(pm_ops);
		__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);
		__assign_str(driver);
		__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);
		__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);
		__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);
		__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)
);

/*
 * CPU latency QoS events used for global CPU latency QoS list updates
 */
DECLARE_EVENT_CLASS(cpu_latency_qos_request,

	TP_PROTO(s32 value),

	TP_ARGS(value),

	TP_STRUCT__entry(
		__field( s32,                    value          )
	),

	TP_fast_assign(
		__entry->value = value;
	),

	TP_printk("CPU_DMA_LATENCY value=%d",
		  __entry->value)
);

DEFINE_EVENT(cpu_latency_qos_request, pm_qos_add_request,

	TP_PROTO(s32 value),

	TP_ARGS(value)
);

DEFINE_EVENT(cpu_latency_qos_request, pm_qos_update_request,

	TP_PROTO(s32 value),

	TP_ARGS(value)
);

DEFINE_EVENT(cpu_latency_qos_request, pm_qos_remove_request,

	TP_PROTO(s32 value),

	TP_ARGS(value)
);

/*
 * General PM QoS events used for updates of PM QoS request lists
 */
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);
		__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)
);

TRACE_EVENT(guest_halt_poll_ns,

	TP_PROTO(bool grow, unsigned int new, unsigned int old),

	TP_ARGS(grow, new, old),

	TP_STRUCT__entry(
		__field(bool, grow)
		__field(unsigned int, new)
		__field(unsigned int, old)
	),

	TP_fast_assign(
		__entry->grow   = grow;
		__entry->new    = new;
		__entry->old    = old;
	),

	TP_printk("halt_poll_ns %u (%s %u)",
		__entry->new,
		__entry->grow ? "grow" : "shrink",
		__entry->old)
);

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