Commit | Line | Data |
---|---|---|
baeeb02c | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
bb03ed92 BD |
2 | /* |
3 | * Greybus driver and device API | |
4 | * | |
5 | * Copyright 2015 Google Inc. | |
6 | * Copyright 2015 Linaro Ltd. | |
bb03ed92 BD |
7 | */ |
8 | #undef TRACE_SYSTEM | |
9 | #define TRACE_SYSTEM greybus | |
10 | ||
11 | #if !defined(_TRACE_GREYBUS_H) || defined(TRACE_HEADER_MULTI_READ) | |
12 | #define _TRACE_GREYBUS_H | |
13 | ||
14 | #include <linux/tracepoint.h> | |
15 | ||
16 | struct gb_message; | |
f866e66f | 17 | struct gb_operation; |
79c8c649 | 18 | struct gb_connection; |
4f9c5c0b | 19 | struct gb_bundle; |
2537636a | 20 | struct gb_host_device; |
bb03ed92 BD |
21 | |
22 | DECLARE_EVENT_CLASS(gb_message, | |
23 | ||
24 | TP_PROTO(struct gb_message *message), | |
25 | ||
26 | TP_ARGS(message), | |
27 | ||
28 | TP_STRUCT__entry( | |
0790c09a AE |
29 | __field(u16, size) |
30 | __field(u16, operation_id) | |
31 | __field(u8, type) | |
32 | __field(u8, result) | |
bb03ed92 BD |
33 | ), |
34 | ||
35 | TP_fast_assign( | |
0790c09a AE |
36 | __entry->size = le16_to_cpu(message->header->size); |
37 | __entry->operation_id = | |
38 | le16_to_cpu(message->header->operation_id); | |
39 | __entry->type = message->header->type; | |
40 | __entry->result = message->header->result; | |
bb03ed92 BD |
41 | ), |
42 | ||
c0b06a6d | 43 | TP_printk("size=%hu operation_id=0x%04x type=0x%02x result=0x%02x", |
0790c09a AE |
44 | __entry->size, __entry->operation_id, |
45 | __entry->type, __entry->result) | |
bb03ed92 BD |
46 | ); |
47 | ||
63017569 AE |
48 | #define DEFINE_MESSAGE_EVENT(name) \ |
49 | DEFINE_EVENT(gb_message, name, \ | |
50 | TP_PROTO(struct gb_message *message), \ | |
51 | TP_ARGS(message)) | |
52 | ||
bb03ed92 | 53 | /* |
206dc534 AE |
54 | * Occurs immediately before calling a host device's message_send() |
55 | * method. | |
bb03ed92 | 56 | */ |
63017569 | 57 | DEFINE_MESSAGE_EVENT(gb_message_send); |
bb03ed92 BD |
58 | |
59 | /* | |
206dc534 | 60 | * Occurs after an incoming request message has been received |
bb03ed92 | 61 | */ |
63017569 | 62 | DEFINE_MESSAGE_EVENT(gb_message_recv_request); |
bb03ed92 BD |
63 | |
64 | /* | |
206dc534 AE |
65 | * Occurs after an incoming response message has been received, |
66 | * after its matching request has been found. | |
bb03ed92 | 67 | */ |
63017569 | 68 | DEFINE_MESSAGE_EVENT(gb_message_recv_response); |
bb03ed92 BD |
69 | |
70 | /* | |
206dc534 AE |
71 | * Occurs after an operation has been canceled, possibly before the |
72 | * cancellation is complete. | |
bb03ed92 | 73 | */ |
63017569 | 74 | DEFINE_MESSAGE_EVENT(gb_message_cancel_outgoing); |
bb03ed92 BD |
75 | |
76 | /* | |
206dc534 AE |
77 | * Occurs when an incoming request is cancelled; if the response has |
78 | * been queued for sending, this occurs after it is sent. | |
bb03ed92 | 79 | */ |
63017569 | 80 | DEFINE_MESSAGE_EVENT(gb_message_cancel_incoming); |
bb03ed92 | 81 | |
495787a7 AE |
82 | /* |
83 | * Occurs in the host driver message_send() function just prior to | |
84 | * handing off the data to be processed by hardware. | |
85 | */ | |
86 | DEFINE_MESSAGE_EVENT(gb_message_submit); | |
87 | ||
63017569 | 88 | #undef DEFINE_MESSAGE_EVENT |
bb03ed92 | 89 | |
f866e66f AE |
90 | DECLARE_EVENT_CLASS(gb_operation, |
91 | ||
92 | TP_PROTO(struct gb_operation *operation), | |
93 | ||
94 | TP_ARGS(operation), | |
95 | ||
96 | TP_STRUCT__entry( | |
97 | __field(u16, cport_id) /* CPort of HD side of connection */ | |
98 | __field(u16, id) /* Operation ID */ | |
99 | __field(u8, type) | |
100 | __field(unsigned long, flags) | |
101 | __field(int, active) | |
102 | __field(int, waiters) | |
103 | __field(int, errno) | |
104 | ), | |
105 | ||
106 | TP_fast_assign( | |
107 | __entry->cport_id = operation->connection->hd_cport_id; | |
108 | __entry->id = operation->id; | |
109 | __entry->type = operation->type; | |
110 | __entry->flags = operation->flags; | |
111 | __entry->active = operation->active; | |
112 | __entry->waiters = atomic_read(&operation->waiters); | |
113 | __entry->errno = operation->errno; | |
114 | ), | |
115 | ||
116 | TP_printk("id=%04x type=0x%02x cport_id=%04x flags=0x%lx active=%d waiters=%d errno=%d", | |
117 | __entry->id, __entry->cport_id, __entry->type, __entry->flags, | |
118 | __entry->active, __entry->waiters, __entry->errno) | |
119 | ); | |
120 | ||
121 | #define DEFINE_OPERATION_EVENT(name) \ | |
122 | DEFINE_EVENT(gb_operation, name, \ | |
123 | TP_PROTO(struct gb_operation *operation), \ | |
124 | TP_ARGS(operation)) | |
125 | ||
126 | /* | |
127 | * Occurs after a new operation is created for an outgoing request | |
128 | * has been successfully created. | |
129 | */ | |
130 | DEFINE_OPERATION_EVENT(gb_operation_create); | |
131 | ||
18079ece JH |
132 | /* |
133 | * Occurs after a new core operation has been created. | |
134 | */ | |
135 | DEFINE_OPERATION_EVENT(gb_operation_create_core); | |
136 | ||
f866e66f AE |
137 | /* |
138 | * Occurs after a new operation has been created for an incoming | |
139 | * request has been successfully created and initialized. | |
140 | */ | |
141 | DEFINE_OPERATION_EVENT(gb_operation_create_incoming); | |
142 | ||
143 | /* | |
144 | * Occurs when the last reference to an operation has been dropped, | |
145 | * prior to freeing resources. | |
146 | */ | |
147 | DEFINE_OPERATION_EVENT(gb_operation_destroy); | |
148 | ||
149 | /* | |
150 | * Occurs when an operation has been marked active, after updating | |
151 | * its active count. | |
152 | */ | |
153 | DEFINE_OPERATION_EVENT(gb_operation_get_active); | |
154 | ||
155 | /* | |
156 | * Occurs when an operation has been marked active, before updating | |
157 | * its active count. | |
158 | */ | |
159 | DEFINE_OPERATION_EVENT(gb_operation_put_active); | |
160 | ||
161 | #undef DEFINE_OPERATION_EVENT | |
162 | ||
79c8c649 AE |
163 | DECLARE_EVENT_CLASS(gb_connection, |
164 | ||
165 | TP_PROTO(struct gb_connection *connection), | |
166 | ||
167 | TP_ARGS(connection), | |
168 | ||
169 | TP_STRUCT__entry( | |
170 | __field(int, hd_bus_id) | |
171 | __field(u8, bundle_id) | |
172 | /* name contains "hd_cport_id/intf_id:cport_id" */ | |
173 | __dynamic_array(char, name, sizeof(connection->name)) | |
174 | __field(enum gb_connection_state, state) | |
175 | __field(unsigned long, flags) | |
176 | ), | |
177 | ||
178 | TP_fast_assign( | |
179 | __entry->hd_bus_id = connection->hd->bus_id; | |
180 | __entry->bundle_id = connection->bundle ? | |
181 | connection->bundle->id : BUNDLE_ID_NONE; | |
182 | memcpy(__get_str(name), connection->name, | |
183 | sizeof(connection->name)); | |
184 | __entry->state = connection->state; | |
185 | __entry->flags = connection->flags; | |
186 | ), | |
187 | ||
188 | TP_printk("hd_bus_id=%d bundle_id=0x%02x name=\"%s\" state=%u flags=0x%lx", | |
189 | __entry->hd_bus_id, __entry->bundle_id, __get_str(name), | |
190 | (unsigned int)__entry->state, __entry->flags) | |
191 | ); | |
192 | ||
193 | #define DEFINE_CONNECTION_EVENT(name) \ | |
194 | DEFINE_EVENT(gb_connection, name, \ | |
195 | TP_PROTO(struct gb_connection *connection), \ | |
196 | TP_ARGS(connection)) | |
197 | ||
198 | /* | |
199 | * Occurs after a new connection is successfully created. | |
200 | */ | |
201 | DEFINE_CONNECTION_EVENT(gb_connection_create); | |
202 | ||
203 | /* | |
204 | * Occurs when the last reference to a connection has been dropped, | |
205 | * before its resources are freed. | |
206 | */ | |
207 | DEFINE_CONNECTION_EVENT(gb_connection_release); | |
208 | ||
209 | /* | |
210 | * Occurs when a new reference to connection is added, currently | |
211 | * only when a message over the connection is received. | |
212 | */ | |
213 | DEFINE_CONNECTION_EVENT(gb_connection_get); | |
214 | ||
215 | /* | |
216 | * Occurs when a new reference to connection is dropped, after a | |
217 | * a received message is handled, or when the connection is | |
218 | * destroyed. | |
219 | */ | |
220 | DEFINE_CONNECTION_EVENT(gb_connection_put); | |
221 | ||
222 | /* | |
223 | * Occurs when a request to enable a connection is made, either for | |
224 | * transmit only, or for both transmit and receive. | |
225 | */ | |
226 | DEFINE_CONNECTION_EVENT(gb_connection_enable); | |
227 | ||
228 | /* | |
229 | * Occurs when a request to disable a connection is made, either for | |
230 | * receive only, or for both transmit and receive. Also occurs when | |
231 | * a request to forcefully disable a connection is made. | |
232 | */ | |
233 | DEFINE_CONNECTION_EVENT(gb_connection_disable); | |
234 | ||
235 | #undef DEFINE_CONNECTION_EVENT | |
236 | ||
4f9c5c0b AE |
237 | DECLARE_EVENT_CLASS(gb_bundle, |
238 | ||
239 | TP_PROTO(struct gb_bundle *bundle), | |
240 | ||
241 | TP_ARGS(bundle), | |
242 | ||
243 | TP_STRUCT__entry( | |
244 | __field(u8, intf_id) | |
245 | __field(u8, id) | |
246 | __field(u8, class) | |
247 | __field(size_t, num_cports) | |
248 | ), | |
249 | ||
250 | TP_fast_assign( | |
251 | __entry->intf_id = bundle->intf->interface_id; | |
252 | __entry->id = bundle->id; | |
253 | __entry->class = bundle->class; | |
254 | __entry->num_cports = bundle->num_cports; | |
255 | ), | |
256 | ||
257 | TP_printk("intf_id=0x%02x id=%02x class=0x%02x num_cports=%zu", | |
258 | __entry->intf_id, __entry->id, __entry->class, | |
259 | __entry->num_cports) | |
260 | ); | |
261 | ||
262 | #define DEFINE_BUNDLE_EVENT(name) \ | |
263 | DEFINE_EVENT(gb_bundle, name, \ | |
264 | TP_PROTO(struct gb_bundle *bundle), \ | |
265 | TP_ARGS(bundle)) | |
266 | ||
267 | /* | |
268 | * Occurs after a new bundle is successfully created. | |
269 | */ | |
270 | DEFINE_BUNDLE_EVENT(gb_bundle_create); | |
271 | ||
272 | /* | |
273 | * Occurs when the last reference to a bundle has been dropped, | |
274 | * before its resources are freed. | |
275 | */ | |
276 | DEFINE_BUNDLE_EVENT(gb_bundle_release); | |
277 | ||
278 | /* | |
279 | * Occurs when a bundle is added to an interface when the interface | |
280 | * is enabled. | |
281 | */ | |
282 | DEFINE_BUNDLE_EVENT(gb_bundle_add); | |
283 | ||
284 | /* | |
285 | * Occurs when a registered bundle gets destroyed, normally at the | |
286 | * time an interface is disabled. | |
287 | */ | |
288 | DEFINE_BUNDLE_EVENT(gb_bundle_destroy); | |
289 | ||
290 | #undef DEFINE_BUNDLE_EVENT | |
291 | ||
cb4c8441 AE |
292 | DECLARE_EVENT_CLASS(gb_interface, |
293 | ||
294 | TP_PROTO(struct gb_interface *intf), | |
295 | ||
296 | TP_ARGS(intf), | |
297 | ||
298 | TP_STRUCT__entry( | |
cb4c8441 | 299 | __field(u8, module_id) |
14a36ae7 | 300 | __field(u8, id) /* Interface id */ |
cb4c8441 | 301 | __field(u8, device_id) |
e5f23c45 AE |
302 | __field(int, disconnected) /* bool */ |
303 | __field(int, ejected) /* bool */ | |
304 | __field(int, active) /* bool */ | |
305 | __field(int, enabled) /* bool */ | |
6879dbf1 | 306 | __field(int, mode_switch) /* bool */ |
cb4c8441 AE |
307 | ), |
308 | ||
309 | TP_fast_assign( | |
cb4c8441 | 310 | __entry->module_id = intf->module->module_id; |
14a36ae7 | 311 | __entry->id = intf->interface_id; |
cb4c8441 AE |
312 | __entry->device_id = intf->device_id; |
313 | __entry->disconnected = intf->disconnected; | |
314 | __entry->ejected = intf->ejected; | |
315 | __entry->active = intf->active; | |
316 | __entry->enabled = intf->enabled; | |
6879dbf1 | 317 | __entry->mode_switch = intf->mode_switch; |
cb4c8441 AE |
318 | ), |
319 | ||
c0b06a6d | 320 | TP_printk("intf_id=%hhu device_id=%hhu module_id=%hhu D=%d J=%d A=%d E=%d M=%d", |
cb4c8441 AE |
321 | __entry->id, __entry->device_id, __entry->module_id, |
322 | __entry->disconnected, __entry->ejected, __entry->active, | |
6879dbf1 | 323 | __entry->enabled, __entry->mode_switch) |
cb4c8441 AE |
324 | ); |
325 | ||
326 | #define DEFINE_INTERFACE_EVENT(name) \ | |
327 | DEFINE_EVENT(gb_interface, name, \ | |
328 | TP_PROTO(struct gb_interface *intf), \ | |
329 | TP_ARGS(intf)) | |
330 | ||
331 | /* | |
332 | * Occurs after a new interface is successfully created. | |
333 | */ | |
334 | DEFINE_INTERFACE_EVENT(gb_interface_create); | |
335 | ||
336 | /* | |
337 | * Occurs after the last reference to an interface has been dropped. | |
338 | */ | |
339 | DEFINE_INTERFACE_EVENT(gb_interface_release); | |
340 | ||
341 | /* | |
342 | * Occurs after an interface been registerd. | |
343 | */ | |
344 | DEFINE_INTERFACE_EVENT(gb_interface_add); | |
345 | ||
346 | /* | |
347 | * Occurs when a registered interface gets deregisterd. | |
348 | */ | |
349 | DEFINE_INTERFACE_EVENT(gb_interface_del); | |
350 | ||
351 | /* | |
352 | * Occurs when a registered interface has been successfully | |
353 | * activated. | |
354 | */ | |
355 | DEFINE_INTERFACE_EVENT(gb_interface_activate); | |
356 | ||
357 | /* | |
358 | * Occurs when an activated interface is being deactivated. | |
359 | */ | |
360 | DEFINE_INTERFACE_EVENT(gb_interface_deactivate); | |
361 | ||
362 | /* | |
363 | * Occurs when an interface has been successfully enabled. | |
364 | */ | |
365 | DEFINE_INTERFACE_EVENT(gb_interface_enable); | |
366 | ||
367 | /* | |
368 | * Occurs when an enabled interface is being disabled. | |
369 | */ | |
370 | DEFINE_INTERFACE_EVENT(gb_interface_disable); | |
371 | ||
372 | #undef DEFINE_INTERFACE_EVENT | |
373 | ||
1ea3ed54 AE |
374 | DECLARE_EVENT_CLASS(gb_module, |
375 | ||
376 | TP_PROTO(struct gb_module *module), | |
377 | ||
378 | TP_ARGS(module), | |
379 | ||
380 | TP_STRUCT__entry( | |
381 | __field(int, hd_bus_id) | |
382 | __field(u8, module_id) | |
c65fdf03 | 383 | __field(size_t, num_interfaces) |
1ea3ed54 AE |
384 | __field(int, disconnected) /* bool */ |
385 | ), | |
386 | ||
387 | TP_fast_assign( | |
388 | __entry->hd_bus_id = module->hd->bus_id; | |
389 | __entry->module_id = module->module_id; | |
c65fdf03 | 390 | __entry->num_interfaces = module->num_interfaces; |
1ea3ed54 AE |
391 | __entry->disconnected = module->disconnected; |
392 | ), | |
393 | ||
c0b06a6d | 394 | TP_printk("hd_bus_id=%d module_id=%hhu num_interfaces=%zu disconnected=%d", |
c65fdf03 AE |
395 | __entry->hd_bus_id, __entry->module_id, |
396 | __entry->num_interfaces, __entry->disconnected) | |
1ea3ed54 AE |
397 | ); |
398 | ||
399 | #define DEFINE_MODULE_EVENT(name) \ | |
400 | DEFINE_EVENT(gb_module, name, \ | |
401 | TP_PROTO(struct gb_module *module), \ | |
402 | TP_ARGS(module)) | |
403 | ||
404 | /* | |
405 | * Occurs after a new module is successfully created, before | |
406 | * creating any of its interfaces. | |
407 | */ | |
408 | DEFINE_MODULE_EVENT(gb_module_create); | |
409 | ||
410 | /* | |
411 | * Occurs after the last reference to a module has been dropped. | |
412 | */ | |
413 | DEFINE_MODULE_EVENT(gb_module_release); | |
414 | ||
415 | /* | |
416 | * Occurs after a module is successfully created, before registering | |
417 | * any of its interfaces. | |
418 | */ | |
419 | DEFINE_MODULE_EVENT(gb_module_add); | |
420 | ||
421 | /* | |
422 | * Occurs when a module is deleted, before deregistering its | |
423 | * interfaces. | |
424 | */ | |
425 | DEFINE_MODULE_EVENT(gb_module_del); | |
426 | ||
427 | #undef DEFINE_MODULE_EVENT | |
428 | ||
32b2b167 BD |
429 | DECLARE_EVENT_CLASS(gb_host_device, |
430 | ||
1f79046b | 431 | TP_PROTO(struct gb_host_device *hd), |
32b2b167 | 432 | |
1f79046b | 433 | TP_ARGS(hd), |
32b2b167 BD |
434 | |
435 | TP_STRUCT__entry( | |
1f79046b | 436 | __field(int, bus_id) |
c5073974 | 437 | __field(size_t, num_cports) |
1f79046b | 438 | __field(size_t, buffer_size_max) |
32b2b167 BD |
439 | ), |
440 | ||
441 | TP_fast_assign( | |
1f79046b AE |
442 | __entry->bus_id = hd->bus_id; |
443 | __entry->num_cports = hd->num_cports; | |
444 | __entry->buffer_size_max = hd->buffer_size_max; | |
32b2b167 BD |
445 | ), |
446 | ||
c0b06a6d | 447 | TP_printk("bus_id=%d num_cports=%zu mtu=%zu", |
1f79046b AE |
448 | __entry->bus_id, __entry->num_cports, |
449 | __entry->buffer_size_max) | |
32b2b167 BD |
450 | ); |
451 | ||
63017569 AE |
452 | #define DEFINE_HD_EVENT(name) \ |
453 | DEFINE_EVENT(gb_host_device, name, \ | |
1f79046b AE |
454 | TP_PROTO(struct gb_host_device *hd), \ |
455 | TP_ARGS(hd)) | |
456 | ||
457 | /* | |
458 | * Occurs after a new host device is successfully created, before | |
459 | * its SVC has been set up. | |
460 | */ | |
461 | DEFINE_HD_EVENT(gb_hd_create); | |
462 | ||
463 | /* | |
464 | * Occurs after the last reference to a host device has been | |
465 | * dropped. | |
466 | */ | |
467 | DEFINE_HD_EVENT(gb_hd_release); | |
63017569 | 468 | |
32b2b167 | 469 | /* |
1f79046b | 470 | * Occurs after a new host device has been added, after the |
495787a7 | 471 | * connection to its SVC has been enabled. |
32b2b167 | 472 | */ |
1f79046b | 473 | DEFINE_HD_EVENT(gb_hd_add); |
32b2b167 BD |
474 | |
475 | /* | |
1f79046b AE |
476 | * Occurs when a host device is being disconnected from the AP USB |
477 | * host controller. | |
32b2b167 | 478 | */ |
1f79046b | 479 | DEFINE_HD_EVENT(gb_hd_del); |
32b2b167 | 480 | |
495787a7 AE |
481 | /* |
482 | * Occurs when a host device has passed received data to the Greybus | |
483 | * core, after it has been determined it is destined for a valid | |
484 | * CPort. | |
485 | */ | |
486 | DEFINE_HD_EVENT(gb_hd_in); | |
487 | ||
63017569 | 488 | #undef DEFINE_HD_EVENT |
32b2b167 | 489 | |
bb03ed92 BD |
490 | #endif /* _TRACE_GREYBUS_H */ |
491 | ||
492 | /* This part must be outside protection */ | |
493 | #undef TRACE_INCLUDE_PATH | |
494 | #define TRACE_INCLUDE_PATH . | |
495 | ||
496 | /* | |
497 | * TRACE_INCLUDE_FILE is not needed if the filename and TRACE_SYSTEM are equal | |
498 | */ | |
499 | #undef TRACE_INCLUDE_FILE | |
500 | #define TRACE_INCLUDE_FILE greybus_trace | |
501 | #include <trace/define_trace.h> | |
502 |