diff options
Diffstat (limited to 'include/trace')
-rw-r--r-- | include/trace/events/gk20a.h | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/include/trace/events/gk20a.h b/include/trace/events/gk20a.h new file mode 100644 index 00000000..c2cf5f81 --- /dev/null +++ b/include/trace/events/gk20a.h | |||
@@ -0,0 +1,275 @@ | |||
1 | /* | ||
2 | * gk20a event logging to ftrace. | ||
3 | * | ||
4 | * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify it | ||
7 | * under the terms and conditions of the GNU General Public License, | ||
8 | * version 2, as published by the Free Software Foundation. | ||
9 | * | ||
10 | * This program is distributed in the hope it will be useful, but WITHOUT | ||
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
13 | * more details. | ||
14 | */ | ||
15 | |||
16 | #undef TRACE_SYSTEM | ||
17 | #define TRACE_SYSTEM gk20a | ||
18 | |||
19 | #if !defined(_TRACE_GK20A_H) || defined(TRACE_HEADER_MULTI_READ) | ||
20 | #define _TRACE_GK20A_H | ||
21 | |||
22 | #include <linux/ktime.h> | ||
23 | #include <linux/tracepoint.h> | ||
24 | |||
25 | DECLARE_EVENT_CLASS(gk20a, | ||
26 | TP_PROTO(const char *name), | ||
27 | TP_ARGS(name), | ||
28 | TP_STRUCT__entry(__field(const char *, name)), | ||
29 | TP_fast_assign(__entry->name = name;), | ||
30 | TP_printk("name=%s", __entry->name) | ||
31 | ); | ||
32 | |||
33 | DEFINE_EVENT(gk20a, gk20a_channel_open, | ||
34 | TP_PROTO(const char *name), | ||
35 | TP_ARGS(name) | ||
36 | ); | ||
37 | |||
38 | DEFINE_EVENT(gk20a, gk20a_channel_release, | ||
39 | TP_PROTO(const char *name), | ||
40 | TP_ARGS(name) | ||
41 | ); | ||
42 | |||
43 | TRACE_EVENT(gk20a_push_cmdbuf, | ||
44 | TP_PROTO(const char *name, u32 mem_id, | ||
45 | u32 words, u32 offset, void *cmdbuf), | ||
46 | |||
47 | TP_ARGS(name, mem_id, words, offset, cmdbuf), | ||
48 | |||
49 | TP_STRUCT__entry( | ||
50 | __field(const char *, name) | ||
51 | __field(u32, mem_id) | ||
52 | __field(u32, words) | ||
53 | __field(u32, offset) | ||
54 | __field(bool, cmdbuf) | ||
55 | __dynamic_array(u32, cmdbuf, words) | ||
56 | ), | ||
57 | |||
58 | TP_fast_assign( | ||
59 | if (cmdbuf) { | ||
60 | memcpy(__get_dynamic_array(cmdbuf), cmdbuf+offset, | ||
61 | words * sizeof(u32)); | ||
62 | } | ||
63 | __entry->cmdbuf = cmdbuf; | ||
64 | __entry->name = name; | ||
65 | __entry->mem_id = mem_id; | ||
66 | __entry->words = words; | ||
67 | __entry->offset = offset; | ||
68 | ), | ||
69 | |||
70 | TP_printk("name=%s, mem_id=%08x, words=%u, offset=%d, contents=[%s]", | ||
71 | __entry->name, __entry->mem_id, | ||
72 | __entry->words, __entry->offset, | ||
73 | __print_hex(__get_dynamic_array(cmdbuf), | ||
74 | __entry->cmdbuf ? __entry->words * 4 : 0)) | ||
75 | ); | ||
76 | |||
77 | TRACE_EVENT(gk20a_channel_submit_gpfifo, | ||
78 | TP_PROTO(const char *name, u32 hw_chid, u32 num_entries, | ||
79 | u32 flags, u32 wait_id, u32 wait_value, | ||
80 | u32 incr_id), | ||
81 | |||
82 | TP_ARGS(name, hw_chid, num_entries, flags, wait_id, wait_value, | ||
83 | incr_id), | ||
84 | |||
85 | TP_STRUCT__entry( | ||
86 | __field(const char *, name) | ||
87 | __field(u32, hw_chid) | ||
88 | __field(u32, num_entries) | ||
89 | __field(u32, flags) | ||
90 | __field(u32, wait_id) | ||
91 | __field(u32, wait_value) | ||
92 | __field(u32, incr_id) | ||
93 | ), | ||
94 | |||
95 | TP_fast_assign( | ||
96 | __entry->name = name; | ||
97 | __entry->hw_chid = hw_chid; | ||
98 | __entry->num_entries = num_entries; | ||
99 | __entry->flags = flags; | ||
100 | __entry->wait_id = wait_id; | ||
101 | __entry->wait_value = wait_value; | ||
102 | __entry->incr_id = incr_id; | ||
103 | ), | ||
104 | |||
105 | TP_printk("name=%s, hw_chid=%d, num_entries=%u, flags=%u, wait_id=%d," | ||
106 | " wait_value=%u, incr_id=%u", | ||
107 | __entry->name, __entry->hw_chid, __entry->num_entries, | ||
108 | __entry->flags, __entry->wait_id, __entry->wait_value, | ||
109 | __entry->incr_id) | ||
110 | ); | ||
111 | |||
112 | TRACE_EVENT(gk20a_channel_submitted_gpfifo, | ||
113 | TP_PROTO(const char *name, u32 hw_chid, u32 num_entries, | ||
114 | u32 flags, u32 wait_id, u32 wait_value, | ||
115 | u32 incr_id, u32 incr_value), | ||
116 | |||
117 | TP_ARGS(name, hw_chid, num_entries, flags, wait_id, wait_value, | ||
118 | incr_id, incr_value), | ||
119 | |||
120 | TP_STRUCT__entry( | ||
121 | __field(const char *, name) | ||
122 | __field(u32, hw_chid) | ||
123 | __field(u32, num_entries) | ||
124 | __field(u32, flags) | ||
125 | __field(u32, wait_id) | ||
126 | __field(u32, wait_value) | ||
127 | __field(u32, incr_id) | ||
128 | __field(u32, incr_value) | ||
129 | ), | ||
130 | |||
131 | TP_fast_assign( | ||
132 | __entry->name = name; | ||
133 | __entry->hw_chid = hw_chid; | ||
134 | __entry->num_entries = num_entries; | ||
135 | __entry->flags = flags; | ||
136 | __entry->wait_id = wait_id; | ||
137 | __entry->wait_value = wait_value; | ||
138 | __entry->incr_id = incr_id; | ||
139 | __entry->incr_value = incr_value; | ||
140 | ), | ||
141 | |||
142 | TP_printk("name=%s, hw_chid=%d, num_entries=%u, flags=%u, wait_id=%d," | ||
143 | " wait_value=%u, incr_id=%u, incr_value=%u", | ||
144 | __entry->name, __entry->hw_chid, __entry->num_entries, | ||
145 | __entry->flags, __entry->wait_id, __entry->wait_value, | ||
146 | __entry->incr_id, __entry->incr_value) | ||
147 | ); | ||
148 | |||
149 | |||
150 | TRACE_EVENT(gk20a_as_dev_open, | ||
151 | TP_PROTO(const char *name), | ||
152 | TP_ARGS(name), | ||
153 | TP_STRUCT__entry( | ||
154 | __field(const char *, name) | ||
155 | ), | ||
156 | TP_fast_assign( | ||
157 | __entry->name = name; | ||
158 | ), | ||
159 | TP_printk("name=%s ", __entry->name) | ||
160 | ); | ||
161 | |||
162 | TRACE_EVENT(gk20a_as_dev_release, | ||
163 | TP_PROTO(const char *name), | ||
164 | TP_ARGS(name), | ||
165 | TP_STRUCT__entry( | ||
166 | __field(const char *, name) | ||
167 | ), | ||
168 | TP_fast_assign( | ||
169 | __entry->name = name; | ||
170 | ), | ||
171 | TP_printk("name=%s ", __entry->name) | ||
172 | ); | ||
173 | |||
174 | |||
175 | TRACE_EVENT(gk20a_as_ioctl_bind_channel, | ||
176 | TP_PROTO(const char *name), | ||
177 | TP_ARGS(name), | ||
178 | TP_STRUCT__entry( | ||
179 | __field(const char *, name) | ||
180 | ), | ||
181 | TP_fast_assign( | ||
182 | __entry->name = name; | ||
183 | ), | ||
184 | TP_printk("name=%s ", __entry->name) | ||
185 | ); | ||
186 | |||
187 | |||
188 | TRACE_EVENT(gk20a_as_ioctl_alloc_space, | ||
189 | TP_PROTO(const char *name), | ||
190 | TP_ARGS(name), | ||
191 | TP_STRUCT__entry( | ||
192 | __field(const char *, name) | ||
193 | ), | ||
194 | TP_fast_assign( | ||
195 | __entry->name = name; | ||
196 | ), | ||
197 | TP_printk("name=%s ", __entry->name) | ||
198 | ); | ||
199 | |||
200 | TRACE_EVENT(gk20a_as_ioctl_free_space, | ||
201 | TP_PROTO(const char *name), | ||
202 | TP_ARGS(name), | ||
203 | TP_STRUCT__entry( | ||
204 | __field(const char *, name) | ||
205 | ), | ||
206 | TP_fast_assign( | ||
207 | __entry->name = name; | ||
208 | ), | ||
209 | TP_printk("name=%s ", __entry->name) | ||
210 | ); | ||
211 | |||
212 | TRACE_EVENT(gk20a_as_ioctl_map_buffer, | ||
213 | TP_PROTO(const char *name), | ||
214 | TP_ARGS(name), | ||
215 | TP_STRUCT__entry( | ||
216 | __field(const char *, name) | ||
217 | ), | ||
218 | TP_fast_assign( | ||
219 | __entry->name = name; | ||
220 | ), | ||
221 | TP_printk("name=%s ", __entry->name) | ||
222 | ); | ||
223 | |||
224 | TRACE_EVENT(gk20a_as_ioctl_unmap_buffer, | ||
225 | TP_PROTO(const char *name), | ||
226 | TP_ARGS(name), | ||
227 | TP_STRUCT__entry( | ||
228 | __field(const char *, name) | ||
229 | ), | ||
230 | TP_fast_assign( | ||
231 | __entry->name = name; | ||
232 | ), | ||
233 | TP_printk("name=%s ", __entry->name) | ||
234 | ); | ||
235 | |||
236 | TRACE_EVENT(gk20a_mmu_fault, | ||
237 | TP_PROTO(u32 fault_hi, u32 fault_lo, | ||
238 | u32 fault_info, | ||
239 | u32 instance, | ||
240 | u32 engine_id, | ||
241 | const char *engine, | ||
242 | const char *client, | ||
243 | const char *fault_type), | ||
244 | TP_ARGS(fault_hi, fault_lo, fault_info, | ||
245 | instance, engine_id, engine, client, fault_type), | ||
246 | TP_STRUCT__entry( | ||
247 | __field(u32, fault_hi) | ||
248 | __field(u32, fault_lo) | ||
249 | __field(u32, fault_info) | ||
250 | __field(u32, instance) | ||
251 | __field(u32, engine_id) | ||
252 | __field(const char *, engine) | ||
253 | __field(const char *, client) | ||
254 | __field(const char *, fault_type) | ||
255 | ), | ||
256 | TP_fast_assign( | ||
257 | __entry->fault_hi = fault_hi; | ||
258 | __entry->fault_lo = fault_lo; | ||
259 | __entry->fault_info = fault_info; | ||
260 | __entry->instance = instance; | ||
261 | __entry->engine_id = engine_id; | ||
262 | __entry->engine = engine; | ||
263 | __entry->client = client; | ||
264 | __entry->fault_type = fault_type; | ||
265 | ), | ||
266 | TP_printk("fault=0x%x,%08x info=0x%x instance=0x%x engine_id=%d engine=%s client=%s type=%s", | ||
267 | __entry->fault_hi, __entry->fault_lo, | ||
268 | __entry->fault_info, __entry->instance, __entry->engine_id, | ||
269 | __entry->engine, __entry->client, __entry->fault_type) | ||
270 | ); | ||
271 | |||
272 | #endif /* _TRACE_GK20A_H */ | ||
273 | |||
274 | /* This part must be outside protection */ | ||
275 | #include <trace/define_trace.h> | ||