GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / greybus / greybus_trace.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Greybus driver and device API
4  *
5  * Copyright 2015 Google Inc.
6  * Copyright 2015 Linaro Ltd.
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;
17 struct gb_operation;
18 struct gb_connection;
19 struct gb_bundle;
20 struct gb_host_device;
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(
29                 __field(u16, size)
30                 __field(u16, operation_id)
31                 __field(u8, type)
32                 __field(u8, result)
33         ),
34
35         TP_fast_assign(
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;
41         ),
42
43         TP_printk("size=%u operation_id=0x%04x type=0x%02x result=0x%02x",
44                   __entry->size, __entry->operation_id,
45                   __entry->type, __entry->result)
46 );
47
48 #define DEFINE_MESSAGE_EVENT(name)                                      \
49                 DEFINE_EVENT(gb_message, name,                          \
50                                 TP_PROTO(struct gb_message *message),   \
51                                 TP_ARGS(message))
52
53 /*
54  * Occurs immediately before calling a host device's message_send()
55  * method.
56  */
57 DEFINE_MESSAGE_EVENT(gb_message_send);
58
59 /*
60  * Occurs after an incoming request message has been received
61  */
62 DEFINE_MESSAGE_EVENT(gb_message_recv_request);
63
64 /*
65  * Occurs after an incoming response message has been received,
66  * after its matching request has been found.
67  */
68 DEFINE_MESSAGE_EVENT(gb_message_recv_response);
69
70 /*
71  * Occurs after an operation has been canceled, possibly before the
72  * cancellation is complete.
73  */
74 DEFINE_MESSAGE_EVENT(gb_message_cancel_outgoing);
75
76 /*
77  * Occurs when an incoming request is cancelled; if the response has
78  * been queued for sending, this occurs after it is sent.
79  */
80 DEFINE_MESSAGE_EVENT(gb_message_cancel_incoming);
81
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
88 #undef DEFINE_MESSAGE_EVENT
89
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
132 /*
133  * Occurs after a new core operation has been created.
134  */
135 DEFINE_OPERATION_EVENT(gb_operation_create_core);
136
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
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
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
292 DECLARE_EVENT_CLASS(gb_interface,
293
294         TP_PROTO(struct gb_interface *intf),
295
296         TP_ARGS(intf),
297
298         TP_STRUCT__entry(
299                 __field(u8, module_id)
300                 __field(u8, id)         /* Interface id */
301                 __field(u8, device_id)
302                 __field(int, disconnected)      /* bool */
303                 __field(int, ejected)           /* bool */
304                 __field(int, active)            /* bool */
305                 __field(int, enabled)           /* bool */
306                 __field(int, mode_switch)       /* bool */
307         ),
308
309         TP_fast_assign(
310                 __entry->module_id = intf->module->module_id;
311                 __entry->id = intf->interface_id;
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;
317                 __entry->mode_switch = intf->mode_switch;
318         ),
319
320         TP_printk("intf_id=%u device_id=%u module_id=%u D=%d J=%d A=%d E=%d M=%d",
321                 __entry->id, __entry->device_id, __entry->module_id,
322                 __entry->disconnected, __entry->ejected, __entry->active,
323                 __entry->enabled, __entry->mode_switch)
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
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)
383                 __field(size_t, num_interfaces)
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;
390                 __entry->num_interfaces = module->num_interfaces;
391                 __entry->disconnected = module->disconnected;
392         ),
393
394         TP_printk("hd_bus_id=%d module_id=%u num_interfaces=%zu disconnected=%d",
395                 __entry->hd_bus_id, __entry->module_id,
396                 __entry->num_interfaces, __entry->disconnected)
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
429 DECLARE_EVENT_CLASS(gb_host_device,
430
431         TP_PROTO(struct gb_host_device *hd),
432
433         TP_ARGS(hd),
434
435         TP_STRUCT__entry(
436                 __field(int, bus_id)
437                 __field(size_t, num_cports)
438                 __field(size_t, buffer_size_max)
439         ),
440
441         TP_fast_assign(
442                 __entry->bus_id = hd->bus_id;
443                 __entry->num_cports = hd->num_cports;
444                 __entry->buffer_size_max = hd->buffer_size_max;
445         ),
446
447         TP_printk("bus_id=%d num_cports=%zu mtu=%zu",
448                 __entry->bus_id, __entry->num_cports,
449                 __entry->buffer_size_max)
450 );
451
452 #define DEFINE_HD_EVENT(name)                                           \
453                 DEFINE_EVENT(gb_host_device, name,                      \
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);
468
469 /*
470  * Occurs after a new host device has been added, after the
471  * connection to its SVC has been enabled.
472  */
473 DEFINE_HD_EVENT(gb_hd_add);
474
475 /*
476  * Occurs when a host device is being disconnected from the AP USB
477  * host controller.
478  */
479 DEFINE_HD_EVENT(gb_hd_del);
480
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
488 #undef DEFINE_HD_EVENT
489
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