[linux-2.6-block.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/ftrace_event.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(pstate_sample,

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

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

	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)
		),

	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;
		),

	TP_printk("core_busy=%lu scaled=%lu from=%lu to=%lu mperf=%llu aperf=%llu tsc=%llu freq=%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
		)

);

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