[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>

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

/* 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_EVENT(cpu, cpu_frequency,

	TP_PROTO(unsigned int frequency, unsigned int cpu_id),

	TP_ARGS(frequency, cpu_id)
);

TRACE_EVENT(machine_suspend,

	TP_PROTO(unsigned int state),

	TP_ARGS(state),

	TP_STRUCT__entry(
		__field(	u32,		state		)
	),

	TP_fast_assign(
		__entry->state = state;
	),

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

TRACE_EVENT(device_pm_report_time,

	TP_PROTO(struct device *dev, const char *pm_ops, s64 ops_time,
		 char *pm_event_str, int error),

	TP_ARGS(dev, pm_ops, ops_time, pm_event_str, error),

	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 ")
		__string(pm_event_str, pm_event_str)
		__field(s64, ops_time)
		__field(int, error)
	),

	TP_fast_assign(
		const char *tmp = dev->parent ? dev_name(dev->parent) : "none";
		const char *tmp_i = pm_ops ? pm_ops : "none ";

		__assign_str(device, dev_name(dev));
		__assign_str(driver, dev_driver_string(dev));
		__assign_str(parent, tmp);
		__assign_str(pm_ops, tmp_i);
		__assign_str(pm_event_str, pm_event_str);
		__entry->ops_time = ops_time;
		__entry->error = error;
	),

	/* ops_str has an extra space at the end */
	TP_printk("%s %s parent=%s state=%s ops=%snsecs=%lld err=%d",
		__get_str(driver), __get_str(device), __get_str(parent),
		__get_str(pm_event_str), __get_str(pm_ops),
		__entry->ops_time, __entry->error)
);

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_LATENCY,	"DEV_PM_QOS_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 AV	9	#include <linux/tracepoint.h>
61613521 AV	10
25e41933 TR	11	DECLARE_EVENT_CLASS(cpu,
	12
	13	TP_PROTO(unsigned int state, unsigned int cpu_id),
	14
	15	TP_ARGS(state, cpu_id),
	16
	17	TP_STRUCT__entry(
	18	__field( u32, state )
	19	__field( u32, cpu_id )
	20	),
	21
	22	TP_fast_assign(
	23	__entry->state = state;
	24	__entry->cpu_id = cpu_id;
	25	),
	26
	27	TP_printk("state=%lu cpu_id=%lu", (unsigned long)__entry->state,
	28	(unsigned long)__entry->cpu_id)
	29	);
	30
	31	DEFINE_EVENT(cpu, cpu_idle,
	32
	33	TP_PROTO(unsigned int state, unsigned int cpu_id),
	34
	35	TP_ARGS(state, cpu_id)
	36	);
	37
	38	/* This file can get included multiple times, TRACE_HEADER_MULTI_READ at top */
	39	#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING
	40	#define _PWR_EVENT_AVOID_DOUBLE_DEFINING
	41
	42	#define PWR_EVENT_EXIT -1
61613521 AV	43	#endif
61613521 AV	44
25e41933 TR	45	DEFINE_EVENT(cpu, cpu_frequency,
	46
	47	TP_PROTO(unsigned int frequency, unsigned int cpu_id),
	48
	49	TP_ARGS(frequency, cpu_id)
	50	);
	51
	52	TRACE_EVENT(machine_suspend,
	53
	54	TP_PROTO(unsigned int state),
	55
	56	TP_ARGS(state),
	57
	58	TP_STRUCT__entry(
	59	__field( u32, state )
	60	),
	61
	62	TP_fast_assign(
	63	__entry->state = state;
	64	),
	65
	66	TP_printk("state=%lu", (unsigned long)__entry->state)
	67	);
	68
53644677 SK	69	TRACE_EVENT(device_pm_report_time,
	70
	71	TP_PROTO(struct device dev, const char pm_ops, s64 ops_time,
	72	char *pm_event_str, int error),
	73
	74	TP_ARGS(dev, pm_ops, ops_time, pm_event_str, error),
	75
	76	TP_STRUCT__entry(
	77	__string(device, dev_name(dev))
	78	__string(driver, dev_driver_string(dev))
	79	__string(parent, dev->parent ? dev_name(dev->parent) : "none")
	80	__string(pm_ops, pm_ops ? pm_ops : "none ")
	81	__string(pm_event_str, pm_event_str)
	82	__field(s64, ops_time)
	83	__field(int, error)
	84	),
	85
	86	TP_fast_assign(
	87	const char *tmp = dev->parent ? dev_name(dev->parent) : "none";
	88	const char *tmp_i = pm_ops ? pm_ops : "none ";
	89
	90	__assign_str(device, dev_name(dev));
	91	__assign_str(driver, dev_driver_string(dev));
	92	__assign_str(parent, tmp);
	93	__assign_str(pm_ops, tmp_i);
	94	__assign_str(pm_event_str, pm_event_str);
	95	__entry->ops_time = ops_time;
	96	__entry->error = error;
	97	),
	98
	99	/* ops_str has an extra space at the end */
	100	TP_printk("%s %s parent=%s state=%s ops=%snsecs=%lld err=%d",
	101	__get_str(driver), __get_str(device), __get_str(parent),
	102	__get_str(pm_event_str), __get_str(pm_ops),
	103	__entry->ops_time, __entry->error)
	104	);
	105
6791e36c AH	106	DECLARE_EVENT_CLASS(wakeup_source,
	107
	108	TP_PROTO(const char *name, unsigned int state),
	109
	110	TP_ARGS(name, state),
	111
	112	TP_STRUCT__entry(
	113	__string( name, name )
	114	__field( u64, state )
	115	),
	116
	117	TP_fast_assign(
	118	__assign_str(name, name);
	119	__entry->state = state;
	120	),
	121
	122	TP_printk("%s state=0x%lx", __get_str(name),
	123	(unsigned long)__entry->state)
	124	);
	125
	126	DEFINE_EVENT(wakeup_source, wakeup_source_activate,
	127
	128	TP_PROTO(const char *name, unsigned int state),
	129
	130	TP_ARGS(name, state)
	131	);
	132
	133	DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
	134
	135	TP_PROTO(const char *name, unsigned int state),
	136
	137	TP_ARGS(name, state)
	138	);
	139
74704ac6 JP	140	/*
	141	* The clock events are used for clock enable/disable and for
	142	* clock rate change
	143	*/
	144	DECLARE_EVENT_CLASS(clock,
	145
	146	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
	147
	148	TP_ARGS(name, state, cpu_id),
	149
	150	TP_STRUCT__entry(
	151	__string( name, name )
	152	__field( u64, state )
	153	__field( u64, cpu_id )
	154	),
	155
	156	TP_fast_assign(
	157	__assign_str(name, name);
	158	__entry->state = state;
	159	__entry->cpu_id = cpu_id;
	160	),
	161
	162	TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
	163	(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
	164	);
	165
	166	DEFINE_EVENT(clock, clock_enable,
	167
	168	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
	169
	170	TP_ARGS(name, state, cpu_id)
	171	);
	172
	173	DEFINE_EVENT(clock, clock_disable,
	174
	175	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
	176
	177	TP_ARGS(name, state, cpu_id)
	178	);
	179
	180	DEFINE_EVENT(clock, clock_set_rate,
	181
	182	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
	183
	184	TP_ARGS(name, state, cpu_id)
	185	);
	186
	187	/*
	188	* The power domain events are used for power domains transitions
	189	*/
	190	DECLARE_EVENT_CLASS(power_domain,
	191
	192	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
	193
	194	TP_ARGS(name, state, cpu_id),
	195
	196	TP_STRUCT__entry(
	197	__string( name, name )
	198	__field( u64, state )
	199	__field( u64, cpu_id )
	200	),
	201
	202	TP_fast_assign(
	203	__assign_str(name, name);
204	__entry->state = state;
205	__entry->cpu_id = cpu_id;
206	),
207
208	TP_printk("%s state=%lu cpu_id=%lu", __get_str(name),
209	(unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
210	);
211
212	DEFINE_EVENT(power_domain, power_domain_target,
213
214	TP_PROTO(const char *name, unsigned int state, unsigned int cpu_id),
215
216	TP_ARGS(name, state, cpu_id)
217	);
247e9ee0 S	218
	219	/*
	220	* The pm qos events are used for pm qos update
	221	*/
ae8822b8 S	222	DECLARE_EVENT_CLASS(pm_qos_request,
	223
	224	TP_PROTO(int pm_qos_class, s32 value),
	225
	226	TP_ARGS(pm_qos_class, value),
	227
	228	TP_STRUCT__entry(
	229	__field( int, pm_qos_class )
	230	__field( s32, value )
	231	),
	232
	233	TP_fast_assign(
	234	__entry->pm_qos_class = pm_qos_class;
	235	__entry->value = value;
	236	),
	237
	238	TP_printk("pm_qos_class=%s value=%d",
	239	__print_symbolic(__entry->pm_qos_class,
	240	{ PM_QOS_CPU_DMA_LATENCY, "CPU_DMA_LATENCY" },
	241	{ PM_QOS_NETWORK_LATENCY, "NETWORK_LATENCY" },
	242	{ PM_QOS_NETWORK_THROUGHPUT, "NETWORK_THROUGHPUT" }),
	243	__entry->value)
	244	);
	245
	246	DEFINE_EVENT(pm_qos_request, pm_qos_add_request,
	247
	248	TP_PROTO(int pm_qos_class, s32 value),
	249
	250	TP_ARGS(pm_qos_class, value)
	251	);
	252
	253	DEFINE_EVENT(pm_qos_request, pm_qos_update_request,
	254
	255	TP_PROTO(int pm_qos_class, s32 value),
	256
	257	TP_ARGS(pm_qos_class, value)
	258	);
	259
	260	DEFINE_EVENT(pm_qos_request, pm_qos_remove_request,
	261
	262	TP_PROTO(int pm_qos_class, s32 value),
	263
	264	TP_ARGS(pm_qos_class, value)
	265	);
	266
	267	TRACE_EVENT(pm_qos_update_request_timeout,
	268
	269	TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us),
	270
	271	TP_ARGS(pm_qos_class, value, timeout_us),
	272
	273	TP_STRUCT__entry(
	274	__field( int, pm_qos_class )
	275	__field( s32, value )
	276	__field( unsigned long, timeout_us )
	277	),
	278
	279	TP_fast_assign(
	280	__entry->pm_qos_class = pm_qos_class;
	281	__entry->value = value;
	282	__entry->timeout_us = timeout_us;
	283	),
	284
	285	TP_printk("pm_qos_class=%s value=%d, timeout_us=%ld",
286	__print_symbolic(__entry->pm_qos_class,
287	{ PM_QOS_CPU_DMA_LATENCY, "CPU_DMA_LATENCY" },
288	{ PM_QOS_NETWORK_LATENCY, "NETWORK_LATENCY" },
289	{ PM_QOS_NETWORK_THROUGHPUT, "NETWORK_THROUGHPUT" }),
290	__entry->value, __entry->timeout_us)
291	);
292
247e9ee0 S	293	DECLARE_EVENT_CLASS(pm_qos_update,
	294
	295	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
	296
	297	TP_ARGS(action, prev_value, curr_value),
	298
	299	TP_STRUCT__entry(
	300	__field( enum pm_qos_req_action, action )
	301	__field( int, prev_value )
	302	__field( int, curr_value )
	303	),
	304
	305	TP_fast_assign(
	306	__entry->action = action;
	307	__entry->prev_value = prev_value;
	308	__entry->curr_value = curr_value;
	309	),
	310
	311	TP_printk("action=%s prev_value=%d curr_value=%d",
	312	__print_symbolic(__entry->action,
	313	{ PM_QOS_ADD_REQ, "ADD_REQ" },
	314	{ PM_QOS_UPDATE_REQ, "UPDATE_REQ" },
	315	{ PM_QOS_REMOVE_REQ, "REMOVE_REQ" }),
	316	__entry->prev_value, __entry->curr_value)
	317	);
	318
	319	DEFINE_EVENT(pm_qos_update, pm_qos_update_target,
	320
	321	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
	322
	323	TP_ARGS(action, prev_value, curr_value)
	324	);
	325
	326	DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags,
	327
	328	TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value),
	329
	330	TP_ARGS(action, prev_value, curr_value),
	331
	332	TP_printk("action=%s prev_value=0x%x curr_value=0x%x",
	333	__print_symbolic(__entry->action,
	334	{ PM_QOS_ADD_REQ, "ADD_REQ" },
	335	{ PM_QOS_UPDATE_REQ, "UPDATE_REQ" },
	336	{ PM_QOS_REMOVE_REQ, "REMOVE_REQ" }),
	337	__entry->prev_value, __entry->curr_value)
	338	);
96d9d0b5 S	339
	340	DECLARE_EVENT_CLASS(dev_pm_qos_request,
	341
	342	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
	343	s32 new_value),
	344
	345	TP_ARGS(name, type, new_value),
	346
	347	TP_STRUCT__entry(
	348	__string( name, name )
	349	__field( enum dev_pm_qos_req_type, type )
	350	__field( s32, new_value )
	351	),
	352
	353	TP_fast_assign(
	354	__assign_str(name, name);
	355	__entry->type = type;
	356	__entry->new_value = new_value;
	357	),
	358
	359	TP_printk("device=%s type=%s new_value=%d",
	360	__get_str(name),
	361	__print_symbolic(__entry->type,
	362	{ DEV_PM_QOS_LATENCY, "DEV_PM_QOS_LATENCY" },
	363	{ DEV_PM_QOS_FLAGS, "DEV_PM_QOS_FLAGS" }),
	364	__entry->new_value)
	365	);
	366
	367	DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request,
	368
	369	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
	370	s32 new_value),
	371
	372	TP_ARGS(name, type, new_value)
	373	);
	374
	375	DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request,
	376
	377	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
	378	s32 new_value),
	379
	380	TP_ARGS(name, type, new_value)
	381	);
	382
	383	DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request,
	384
	385	TP_PROTO(const char *name, enum dev_pm_qos_req_type type,
	386	s32 new_value),
	387
	388	TP_ARGS(name, type, new_value)
	389	);
61613521 AV	390	#endif /* _TRACE_POWER_H */
	391
	392	/* This part must be outside protection */
	393	#include <trace/define_trace.h>