diff options
Diffstat (limited to 'include/trace/events')
-rw-r--r-- | include/trace/events/gk20a.h | 579 |
1 files changed, 579 insertions, 0 deletions
diff --git a/include/trace/events/gk20a.h b/include/trace/events/gk20a.h new file mode 100644 index 00000000..9600b201 --- /dev/null +++ b/include/trace/events/gk20a.h | |||
@@ -0,0 +1,579 @@ | |||
1 | /* | ||
2 | * gk20a event logging to ftrace. | ||
3 | * | ||
4 | * Copyright (c) 2014-2016, 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 | DEFINE_EVENT(gk20a, gk20a_pm_unrailgate, | ||
44 | TP_PROTO(const char *name), | ||
45 | TP_ARGS(name) | ||
46 | ); | ||
47 | |||
48 | DEFINE_EVENT(gk20a, gk20a_finalize_poweron, | ||
49 | TP_PROTO(const char *name), | ||
50 | TP_ARGS(name) | ||
51 | ); | ||
52 | |||
53 | DEFINE_EVENT(gk20a, gk20a_finalize_poweron_done, | ||
54 | TP_PROTO(const char *name), | ||
55 | TP_ARGS(name) | ||
56 | ); | ||
57 | |||
58 | DEFINE_EVENT(gk20a, gk20a_mm_l2_invalidate, | ||
59 | TP_PROTO(const char *name), | ||
60 | TP_ARGS(name) | ||
61 | ); | ||
62 | |||
63 | DEFINE_EVENT(gk20a, gk20a_mm_l2_invalidate_done, | ||
64 | TP_PROTO(const char *name), | ||
65 | TP_ARGS(name) | ||
66 | ); | ||
67 | |||
68 | DEFINE_EVENT(gk20a, gk20a_mm_l2_flush, | ||
69 | TP_PROTO(const char *name), | ||
70 | TP_ARGS(name) | ||
71 | ); | ||
72 | |||
73 | DEFINE_EVENT(gk20a, gk20a_mm_l2_flush_done, | ||
74 | TP_PROTO(const char *name), | ||
75 | TP_ARGS(name) | ||
76 | ); | ||
77 | |||
78 | DEFINE_EVENT(gk20a, gk20a_mm_tlb_invalidate, | ||
79 | TP_PROTO(const char *name), | ||
80 | TP_ARGS(name) | ||
81 | ); | ||
82 | |||
83 | DEFINE_EVENT(gk20a, gk20a_mm_tlb_invalidate_done, | ||
84 | TP_PROTO(const char *name), | ||
85 | TP_ARGS(name) | ||
86 | ); | ||
87 | |||
88 | DEFINE_EVENT(gk20a, gk20a_mm_fb_flush, | ||
89 | TP_PROTO(const char *name), | ||
90 | TP_ARGS(name) | ||
91 | ); | ||
92 | |||
93 | DEFINE_EVENT(gk20a, gk20a_mm_fb_flush_done, | ||
94 | TP_PROTO(const char *name), | ||
95 | TP_ARGS(name) | ||
96 | ); | ||
97 | |||
98 | DEFINE_EVENT(gk20a, mc_gk20a_intr_thread_stall, | ||
99 | TP_PROTO(const char *name), | ||
100 | TP_ARGS(name) | ||
101 | ); | ||
102 | |||
103 | DEFINE_EVENT(gk20a, mc_gk20a_intr_thread_stall_done, | ||
104 | TP_PROTO(const char *name), | ||
105 | TP_ARGS(name) | ||
106 | ); | ||
107 | |||
108 | DEFINE_EVENT(gk20a, mc_gk20a_intr_stall, | ||
109 | TP_PROTO(const char *name), | ||
110 | TP_ARGS(name) | ||
111 | ); | ||
112 | |||
113 | DEFINE_EVENT(gk20a, mc_gk20a_intr_stall_done, | ||
114 | TP_PROTO(const char *name), | ||
115 | TP_ARGS(name) | ||
116 | ); | ||
117 | |||
118 | DEFINE_EVENT(gk20a, gr_gk20a_handle_sw_method, | ||
119 | TP_PROTO(const char *name), | ||
120 | TP_ARGS(name) | ||
121 | ); | ||
122 | |||
123 | DECLARE_EVENT_CLASS(gk20a_channel, | ||
124 | TP_PROTO(int channel), | ||
125 | TP_ARGS(channel), | ||
126 | TP_STRUCT__entry(__field(int, channel)), | ||
127 | TP_fast_assign(__entry->channel = channel;), | ||
128 | TP_printk("ch id %d", __entry->channel) | ||
129 | ); | ||
130 | DEFINE_EVENT(gk20a_channel, gk20a_channel_update, | ||
131 | TP_PROTO(int channel), | ||
132 | TP_ARGS(channel) | ||
133 | ); | ||
134 | DEFINE_EVENT(gk20a_channel, gk20a_free_channel, | ||
135 | TP_PROTO(int channel), | ||
136 | TP_ARGS(channel) | ||
137 | ); | ||
138 | DEFINE_EVENT(gk20a_channel, gk20a_open_new_channel, | ||
139 | TP_PROTO(int channel), | ||
140 | TP_ARGS(channel) | ||
141 | ); | ||
142 | DEFINE_EVENT(gk20a_channel, gk20a_release_used_channel, | ||
143 | TP_PROTO(int channel), | ||
144 | TP_ARGS(channel) | ||
145 | ); | ||
146 | |||
147 | DECLARE_EVENT_CLASS(gk20a_channel_getput, | ||
148 | TP_PROTO(int channel, const char *caller), | ||
149 | TP_ARGS(channel, caller), | ||
150 | TP_STRUCT__entry( | ||
151 | __field(int, channel) | ||
152 | __field(const char *, caller) | ||
153 | ), | ||
154 | TP_fast_assign( | ||
155 | __entry->channel = channel; | ||
156 | __entry->caller = caller; | ||
157 | ), | ||
158 | TP_printk("channel %d caller %s", __entry->channel, __entry->caller) | ||
159 | ); | ||
160 | DEFINE_EVENT(gk20a_channel_getput, gk20a_channel_get, | ||
161 | TP_PROTO(int channel, const char *caller), | ||
162 | TP_ARGS(channel, caller) | ||
163 | ); | ||
164 | DEFINE_EVENT(gk20a_channel_getput, gk20a_channel_put, | ||
165 | TP_PROTO(int channel, const char *caller), | ||
166 | TP_ARGS(channel, caller) | ||
167 | ); | ||
168 | DEFINE_EVENT(gk20a_channel_getput, gk20a_channel_put_nofree, | ||
169 | TP_PROTO(int channel, const char *caller), | ||
170 | TP_ARGS(channel, caller) | ||
171 | ); | ||
172 | |||
173 | DECLARE_EVENT_CLASS(gk20a_channel_sched_params, | ||
174 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
175 | u32 timeout, const char *interleave, | ||
176 | const char *graphics_preempt_mode, | ||
177 | const char *compute_preempt_mode), | ||
178 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
179 | interleave, graphics_preempt_mode, compute_preempt_mode), | ||
180 | TP_STRUCT__entry( | ||
181 | __field(int, chid) | ||
182 | __field(int, tsgid) | ||
183 | __field(pid_t, pid) | ||
184 | __field(u32, timeslice) | ||
185 | __field(u32, timeout) | ||
186 | __field(const char *, interleave) /* no need to copy */ | ||
187 | __field(const char *, graphics_preempt_mode) /* no need to copy */ | ||
188 | __field(const char *, compute_preempt_mode) /* no need to copy */ | ||
189 | ), | ||
190 | TP_fast_assign( | ||
191 | __entry->chid = chid; | ||
192 | __entry->tsgid = tsgid; | ||
193 | __entry->pid = pid; | ||
194 | __entry->timeslice = timeslice; | ||
195 | __entry->timeout = timeout; | ||
196 | __entry->interleave = interleave; | ||
197 | __entry->graphics_preempt_mode = graphics_preempt_mode; | ||
198 | __entry->compute_preempt_mode = compute_preempt_mode; | ||
199 | ), | ||
200 | TP_printk("chid=%d tsgid=%d pid=%d timeslice=%u timeout=%u interleave=%s graphics_preempt=%s compute_preempt=%s", | ||
201 | __entry->chid, __entry->tsgid, __entry->pid, | ||
202 | __entry->timeslice, __entry->timeout, | ||
203 | __entry->interleave, __entry->graphics_preempt_mode, | ||
204 | __entry->compute_preempt_mode) | ||
205 | ); | ||
206 | |||
207 | DEFINE_EVENT(gk20a_channel_sched_params, gk20a_channel_sched_defaults, | ||
208 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
209 | u32 timeout, const char *interleave, | ||
210 | const char *graphics_preempt_mode, | ||
211 | const char *compute_preempt_mode), | ||
212 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
213 | interleave, graphics_preempt_mode, compute_preempt_mode) | ||
214 | ); | ||
215 | |||
216 | DEFINE_EVENT(gk20a_channel_sched_params, gk20a_channel_set_priority, | ||
217 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
218 | u32 timeout, const char *interleave, | ||
219 | const char *graphics_preempt_mode, | ||
220 | const char *compute_preempt_mode), | ||
221 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
222 | interleave, graphics_preempt_mode, compute_preempt_mode) | ||
223 | ); | ||
224 | |||
225 | DEFINE_EVENT(gk20a_channel_sched_params, gk20a_channel_set_runlist_interleave, | ||
226 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
227 | u32 timeout, const char *interleave, | ||
228 | const char *graphics_preempt_mode, | ||
229 | const char *compute_preempt_mode), | ||
230 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
231 | interleave, graphics_preempt_mode, compute_preempt_mode) | ||
232 | ); | ||
233 | |||
234 | DEFINE_EVENT(gk20a_channel_sched_params, gk20a_channel_set_timeslice, | ||
235 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
236 | u32 timeout, const char *interleave, | ||
237 | const char *graphics_preempt_mode, | ||
238 | const char *compute_preempt_mode), | ||
239 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
240 | interleave, graphics_preempt_mode, compute_preempt_mode) | ||
241 | ); | ||
242 | |||
243 | DEFINE_EVENT(gk20a_channel_sched_params, gk20a_channel_set_timeout, | ||
244 | TP_PROTO(int chid, int tsgid, pid_t pid, u32 timeslice, | ||
245 | u32 timeout, const char *interleave, | ||
246 | const char *graphics_preempt_mode, | ||
247 | const char *compute_preempt_mode), | ||
248 | TP_ARGS(chid, tsgid, pid, timeslice, timeout, | ||
249 | interleave, graphics_preempt_mode, compute_preempt_mode) | ||
250 | ); | ||
251 | |||
252 | TRACE_EVENT(gk20a_push_cmdbuf, | ||
253 | TP_PROTO(const char *name, u32 mem_id, | ||
254 | u32 words, u32 offset, void *cmdbuf), | ||
255 | |||
256 | TP_ARGS(name, mem_id, words, offset, cmdbuf), | ||
257 | |||
258 | TP_STRUCT__entry( | ||
259 | __field(const char *, name) | ||
260 | __field(u32, mem_id) | ||
261 | __field(u32, words) | ||
262 | __field(u32, offset) | ||
263 | __field(bool, cmdbuf) | ||
264 | __dynamic_array(u32, cmdbuf, words) | ||
265 | ), | ||
266 | |||
267 | TP_fast_assign( | ||
268 | if (cmdbuf) { | ||
269 | memcpy(__get_dynamic_array(cmdbuf), cmdbuf+offset, | ||
270 | words * sizeof(u32)); | ||
271 | } | ||
272 | __entry->cmdbuf = cmdbuf; | ||
273 | __entry->name = name; | ||
274 | __entry->mem_id = mem_id; | ||
275 | __entry->words = words; | ||
276 | __entry->offset = offset; | ||
277 | ), | ||
278 | |||
279 | TP_printk("name=%s, mem_id=%08x, words=%u, offset=%d, contents=[%s]", | ||
280 | __entry->name, __entry->mem_id, | ||
281 | __entry->words, __entry->offset, | ||
282 | __print_hex(__get_dynamic_array(cmdbuf), | ||
283 | __entry->cmdbuf ? __entry->words * 4 : 0)) | ||
284 | ); | ||
285 | |||
286 | TRACE_EVENT(gk20a_channel_submit_gpfifo, | ||
287 | TP_PROTO(const char *name, u32 chid, u32 num_entries, | ||
288 | u32 flags, u32 wait_id, u32 wait_value), | ||
289 | |||
290 | TP_ARGS(name, chid, num_entries, flags, wait_id, wait_value), | ||
291 | |||
292 | TP_STRUCT__entry( | ||
293 | __field(const char *, name) | ||
294 | __field(u32, chid) | ||
295 | __field(u32, num_entries) | ||
296 | __field(u32, flags) | ||
297 | __field(u32, wait_id) | ||
298 | __field(u32, wait_value) | ||
299 | ), | ||
300 | |||
301 | TP_fast_assign( | ||
302 | __entry->name = name; | ||
303 | __entry->chid = chid; | ||
304 | __entry->num_entries = num_entries; | ||
305 | __entry->flags = flags; | ||
306 | __entry->wait_id = wait_id; | ||
307 | __entry->wait_value = wait_value; | ||
308 | ), | ||
309 | |||
310 | TP_printk("name=%s, chid=%d, num_entries=%u, flags=%u, wait_id=%d," | ||
311 | " wait_value=%u", | ||
312 | __entry->name, __entry->chid, __entry->num_entries, | ||
313 | __entry->flags, __entry->wait_id, __entry->wait_value) | ||
314 | ); | ||
315 | |||
316 | TRACE_EVENT(gk20a_channel_submitted_gpfifo, | ||
317 | TP_PROTO(const char *name, u32 chid, u32 num_entries, | ||
318 | u32 flags, u32 incr_id, u32 incr_value), | ||
319 | |||
320 | TP_ARGS(name, chid, num_entries, flags, | ||
321 | incr_id, incr_value), | ||
322 | |||
323 | TP_STRUCT__entry( | ||
324 | __field(const char *, name) | ||
325 | __field(u32, chid) | ||
326 | __field(u32, num_entries) | ||
327 | __field(u32, flags) | ||
328 | __field(u32, incr_id) | ||
329 | __field(u32, incr_value) | ||
330 | ), | ||
331 | |||
332 | TP_fast_assign( | ||
333 | __entry->name = name; | ||
334 | __entry->chid = chid; | ||
335 | __entry->num_entries = num_entries; | ||
336 | __entry->flags = flags; | ||
337 | __entry->incr_id = incr_id; | ||
338 | __entry->incr_value = incr_value; | ||
339 | ), | ||
340 | |||
341 | TP_printk("name=%s, chid=%d, num_entries=%u, flags=%u," | ||
342 | " incr_id=%u, incr_value=%u", | ||
343 | __entry->name, __entry->chid, __entry->num_entries, | ||
344 | __entry->flags, __entry->incr_id, __entry->incr_value) | ||
345 | ); | ||
346 | |||
347 | TRACE_EVENT(gk20a_channel_reset, | ||
348 | TP_PROTO(u32 chid, u32 tsgid), | ||
349 | |||
350 | TP_ARGS(chid, tsgid), | ||
351 | |||
352 | TP_STRUCT__entry( | ||
353 | __field(u32, chid) | ||
354 | __field(u32, tsgid) | ||
355 | ), | ||
356 | |||
357 | TP_fast_assign( | ||
358 | __entry->chid = chid; | ||
359 | __entry->tsgid = tsgid; | ||
360 | ), | ||
361 | |||
362 | TP_printk("chid=%d, tsgid=%d", | ||
363 | __entry->chid, __entry->tsgid) | ||
364 | ); | ||
365 | |||
366 | |||
367 | TRACE_EVENT(gk20a_as_dev_open, | ||
368 | TP_PROTO(const char *name), | ||
369 | TP_ARGS(name), | ||
370 | TP_STRUCT__entry( | ||
371 | __field(const char *, name) | ||
372 | ), | ||
373 | TP_fast_assign( | ||
374 | __entry->name = name; | ||
375 | ), | ||
376 | TP_printk("name=%s ", __entry->name) | ||
377 | ); | ||
378 | |||
379 | TRACE_EVENT(gk20a_as_dev_release, | ||
380 | TP_PROTO(const char *name), | ||
381 | TP_ARGS(name), | ||
382 | TP_STRUCT__entry( | ||
383 | __field(const char *, name) | ||
384 | ), | ||
385 | TP_fast_assign( | ||
386 | __entry->name = name; | ||
387 | ), | ||
388 | TP_printk("name=%s ", __entry->name) | ||
389 | ); | ||
390 | |||
391 | |||
392 | TRACE_EVENT(gk20a_as_ioctl_bind_channel, | ||
393 | TP_PROTO(const char *name), | ||
394 | TP_ARGS(name), | ||
395 | TP_STRUCT__entry( | ||
396 | __field(const char *, name) | ||
397 | ), | ||
398 | TP_fast_assign( | ||
399 | __entry->name = name; | ||
400 | ), | ||
401 | TP_printk("name=%s ", __entry->name) | ||
402 | ); | ||
403 | |||
404 | |||
405 | TRACE_EVENT(gk20a_as_ioctl_alloc_space, | ||
406 | TP_PROTO(const char *name), | ||
407 | TP_ARGS(name), | ||
408 | TP_STRUCT__entry( | ||
409 | __field(const char *, name) | ||
410 | ), | ||
411 | TP_fast_assign( | ||
412 | __entry->name = name; | ||
413 | ), | ||
414 | TP_printk("name=%s ", __entry->name) | ||
415 | ); | ||
416 | |||
417 | TRACE_EVENT(gk20a_as_ioctl_free_space, | ||
418 | TP_PROTO(const char *name), | ||
419 | TP_ARGS(name), | ||
420 | TP_STRUCT__entry( | ||
421 | __field(const char *, name) | ||
422 | ), | ||
423 | TP_fast_assign( | ||
424 | __entry->name = name; | ||
425 | ), | ||
426 | TP_printk("name=%s ", __entry->name) | ||
427 | ); | ||
428 | |||
429 | TRACE_EVENT(gk20a_as_ioctl_map_buffer, | ||
430 | TP_PROTO(const char *name), | ||
431 | TP_ARGS(name), | ||
432 | TP_STRUCT__entry( | ||
433 | __field(const char *, name) | ||
434 | ), | ||
435 | TP_fast_assign( | ||
436 | __entry->name = name; | ||
437 | ), | ||
438 | TP_printk("name=%s ", __entry->name) | ||
439 | ); | ||
440 | |||
441 | TRACE_EVENT(gk20a_as_ioctl_unmap_buffer, | ||
442 | TP_PROTO(const char *name), | ||
443 | TP_ARGS(name), | ||
444 | TP_STRUCT__entry( | ||
445 | __field(const char *, name) | ||
446 | ), | ||
447 | TP_fast_assign( | ||
448 | __entry->name = name; | ||
449 | ), | ||
450 | TP_printk("name=%s ", __entry->name) | ||
451 | ); | ||
452 | |||
453 | TRACE_EVENT(gk20a_as_ioctl_get_va_regions, | ||
454 | TP_PROTO(const char *name), | ||
455 | TP_ARGS(name), | ||
456 | TP_STRUCT__entry( | ||
457 | __field(const char *, name) | ||
458 | ), | ||
459 | TP_fast_assign( | ||
460 | __entry->name = name; | ||
461 | ), | ||
462 | TP_printk("name=%s ", __entry->name) | ||
463 | ); | ||
464 | |||
465 | TRACE_EVENT(gk20a_mmu_fault, | ||
466 | TP_PROTO(u64 fault_addr, | ||
467 | u32 fault_type, | ||
468 | u32 access_type, | ||
469 | u64 inst_ptr, | ||
470 | u32 engine_id, | ||
471 | const char *client_type_desc, | ||
472 | const char *client_id_desc, | ||
473 | const char *fault_type_desc), | ||
474 | TP_ARGS(fault_addr, fault_type, access_type, | ||
475 | inst_ptr, engine_id, client_type_desc, | ||
476 | client_id_desc, fault_type_desc), | ||
477 | TP_STRUCT__entry( | ||
478 | __field(u64, fault_addr) | ||
479 | __field(u32, fault_type) | ||
480 | __field(u32, access_type) | ||
481 | __field(u64, inst_ptr) | ||
482 | __field(u32, engine_id) | ||
483 | __field(const char *, client_type_desc) | ||
484 | __field(const char *, client_id_desc) | ||
485 | __field(const char *, fault_type_desc) | ||
486 | ), | ||
487 | TP_fast_assign( | ||
488 | __entry->fault_addr = fault_addr; | ||
489 | __entry->fault_type = fault_type; | ||
490 | __entry->access_type = access_type; | ||
491 | __entry->inst_ptr = inst_ptr; | ||
492 | __entry->engine_id = engine_id; | ||
493 | __entry->client_type_desc = client_type_desc; | ||
494 | __entry->client_id_desc = client_id_desc; | ||
495 | __entry->fault_type_desc = fault_type_desc; | ||
496 | ), | ||
497 | TP_printk("fault addr=0x%llx type=0x%x access_type=0x%x " | ||
498 | "instance=0x%llx engine_id=%d client_type=%s " | ||
499 | "client_id=%s fault type=%s", | ||
500 | __entry->fault_addr, __entry->fault_type, | ||
501 | __entry->access_type, __entry->inst_ptr, | ||
502 | __entry->engine_id, __entry->client_type_desc, | ||
503 | __entry->client_id_desc, __entry->fault_type_desc) | ||
504 | ); | ||
505 | |||
506 | TRACE_EVENT(gk20a_ltc_cbc_ctrl_start, | ||
507 | TP_PROTO(const char *name, u32 cbc_ctrl, u32 min_value, | ||
508 | u32 max_value), | ||
509 | TP_ARGS(name, cbc_ctrl, min_value, max_value), | ||
510 | |||
511 | TP_STRUCT__entry( | ||
512 | __field(const char *, name) | ||
513 | __field(u32, cbc_ctrl) | ||
514 | __field(u32, min_value) | ||
515 | __field(u32, max_value) | ||
516 | ), | ||
517 | |||
518 | TP_fast_assign( | ||
519 | __entry->name = name; | ||
520 | __entry->cbc_ctrl = cbc_ctrl; | ||
521 | __entry->min_value = min_value; | ||
522 | __entry->max_value = max_value; | ||
523 | ), | ||
524 | |||
525 | TP_printk("name=%s, cbc_ctrl=%d, min_value=%u, max_value=%u", | ||
526 | __entry->name, __entry->cbc_ctrl, __entry->min_value, | ||
527 | __entry->max_value) | ||
528 | ); | ||
529 | |||
530 | TRACE_EVENT(gk20a_ltc_cbc_ctrl_done, | ||
531 | TP_PROTO(const char *name), | ||
532 | TP_ARGS(name), | ||
533 | TP_STRUCT__entry( | ||
534 | __field(const char *, name) | ||
535 | ), | ||
536 | TP_fast_assign( | ||
537 | __entry->name = name; | ||
538 | ), | ||
539 | TP_printk("name=%s ", __entry->name) | ||
540 | |||
541 | ); | ||
542 | |||
543 | DECLARE_EVENT_CLASS(gk20a_cde, | ||
544 | TP_PROTO(const void *ctx), | ||
545 | TP_ARGS(ctx), | ||
546 | TP_STRUCT__entry(__field(const void *, ctx)), | ||
547 | TP_fast_assign(__entry->ctx = ctx;), | ||
548 | TP_printk("ctx=%p", __entry->ctx) | ||
549 | ); | ||
550 | |||
551 | DEFINE_EVENT(gk20a_cde, gk20a_cde_remove_ctx, | ||
552 | TP_PROTO(const void *ctx), | ||
553 | TP_ARGS(ctx) | ||
554 | ); | ||
555 | |||
556 | DEFINE_EVENT(gk20a_cde, gk20a_cde_release, | ||
557 | TP_PROTO(const void *ctx), | ||
558 | TP_ARGS(ctx) | ||
559 | ); | ||
560 | |||
561 | DEFINE_EVENT(gk20a_cde, gk20a_cde_get_context, | ||
562 | TP_PROTO(const void *ctx), | ||
563 | TP_ARGS(ctx) | ||
564 | ); | ||
565 | |||
566 | DEFINE_EVENT(gk20a_cde, gk20a_cde_allocate_context, | ||
567 | TP_PROTO(const void *ctx), | ||
568 | TP_ARGS(ctx) | ||
569 | ); | ||
570 | |||
571 | DEFINE_EVENT(gk20a_cde, gk20a_cde_finished_ctx_cb, | ||
572 | TP_PROTO(const void *ctx), | ||
573 | TP_ARGS(ctx) | ||
574 | ); | ||
575 | |||
576 | #endif /* _TRACE_GK20A_H */ | ||
577 | |||
578 | /* This part must be outside protection */ | ||
579 | #include <trace/define_trace.h> | ||