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
16struct gb_message;
17struct gb_operation;
18struct gb_connection;
19struct gb_bundle;
20struct gb_host_device;
21
22DECLARE_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 */
57DEFINE_MESSAGE_EVENT(gb_message_send);
58
59/*
60 * Occurs after an incoming request message has been received
61 */
62DEFINE_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 */
68DEFINE_MESSAGE_EVENT(gb_message_recv_response);
69
70/*
71 * Occurs after an operation has been canceled, possibly before the
72 * cancellation is complete.
73 */
74DEFINE_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 */
80DEFINE_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 */
86DEFINE_MESSAGE_EVENT(gb_message_submit);
87
88#undef DEFINE_MESSAGE_EVENT
89
90DECLARE_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 */
130DEFINE_OPERATION_EVENT(gb_operation_create);
131
132/*
133 * Occurs after a new core operation has been created.
134 */
135DEFINE_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 */
141DEFINE_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 */
147DEFINE_OPERATION_EVENT(gb_operation_destroy);
148
149/*
150 * Occurs when an operation has been marked active, after updating
151 * its active count.
152 */
153DEFINE_OPERATION_EVENT(gb_operation_get_active);
154
155/*
156 * Occurs when an operation has been marked active, before updating
157 * its active count.
158 */
159DEFINE_OPERATION_EVENT(gb_operation_put_active);
160
161#undef DEFINE_OPERATION_EVENT
162
163DECLARE_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 */
201DEFINE_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 */
207DEFINE_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 */
213DEFINE_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 */
220DEFINE_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 */
226DEFINE_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 */
233DEFINE_CONNECTION_EVENT(gb_connection_disable);
234
235#undef DEFINE_CONNECTION_EVENT
236
237DECLARE_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 */
270DEFINE_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 */
276DEFINE_BUNDLE_EVENT(gb_bundle_release);
277
278/*
279 * Occurs when a bundle is added to an interface when the interface
280 * is enabled.
281 */
282DEFINE_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 */
288DEFINE_BUNDLE_EVENT(gb_bundle_destroy);
289
290#undef DEFINE_BUNDLE_EVENT
291
292DECLARE_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 */
334DEFINE_INTERFACE_EVENT(gb_interface_create);
335
336/*
337 * Occurs after the last reference to an interface has been dropped.
338 */
339DEFINE_INTERFACE_EVENT(gb_interface_release);
340
341/*
342 * Occurs after an interface been registerd.
343 */
344DEFINE_INTERFACE_EVENT(gb_interface_add);
345
346/*
347 * Occurs when a registered interface gets deregisterd.
348 */
349DEFINE_INTERFACE_EVENT(gb_interface_del);
350
351/*
352 * Occurs when a registered interface has been successfully
353 * activated.
354 */
355DEFINE_INTERFACE_EVENT(gb_interface_activate);
356
357/*
358 * Occurs when an activated interface is being deactivated.
359 */
360DEFINE_INTERFACE_EVENT(gb_interface_deactivate);
361
362/*
363 * Occurs when an interface has been successfully enabled.
364 */
365DEFINE_INTERFACE_EVENT(gb_interface_enable);
366
367/*
368 * Occurs when an enabled interface is being disabled.
369 */
370DEFINE_INTERFACE_EVENT(gb_interface_disable);
371
372#undef DEFINE_INTERFACE_EVENT
373
374DECLARE_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 */
408DEFINE_MODULE_EVENT(gb_module_create);
409
410/*
411 * Occurs after the last reference to a module has been dropped.
412 */
413DEFINE_MODULE_EVENT(gb_module_release);
414
415/*
416 * Occurs after a module is successfully created, before registering
417 * any of its interfaces.
418 */
419DEFINE_MODULE_EVENT(gb_module_add);
420
421/*
422 * Occurs when a module is deleted, before deregistering its
423 * interfaces.
424 */
425DEFINE_MODULE_EVENT(gb_module_del);
426
427#undef DEFINE_MODULE_EVENT
428
429DECLARE_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 */
461DEFINE_HD_EVENT(gb_hd_create);
462
463/*
464 * Occurs after the last reference to a host device has been
465 * dropped.
466 */
467DEFINE_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 */
473DEFINE_HD_EVENT(gb_hd_add);
474
475/*
476 * Occurs when a host device is being disconnected from the AP USB
477 * host controller.
478 */
479DEFINE_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 */
486DEFINE_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
503

source code of linux/drivers/greybus/greybus_trace.h