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=%hu 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=%hhu device_id=%hhu module_id=%hhu 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=%hhu 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 503