diff options
Diffstat (limited to 'greybus_trace.patch')
| -rw-r--r-- | greybus_trace.patch | 538 |
1 files changed, 538 insertions, 0 deletions
diff --git a/greybus_trace.patch b/greybus_trace.patch new file mode 100644 index 00000000000000..c14c444932b89f --- /dev/null +++ b/greybus_trace.patch @@ -0,0 +1,538 @@ +--- + drivers/greybus/greybus_trace.h | 531 ++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 531 insertions(+) + +--- /dev/null ++++ b/drivers/greybus/greybus_trace.h +@@ -0,0 +1,531 @@ ++/* ++ * Greybus driver and device API ++ * ++ * Copyright 2015 Google Inc. ++ * Copyright 2015 Linaro Ltd. ++ * ++ * Released under the GPLv2 only. ++ */ ++#undef TRACE_SYSTEM ++#define TRACE_SYSTEM greybus ++ ++#if !defined(_TRACE_GREYBUS_H) || defined(TRACE_HEADER_MULTI_READ) ++#define _TRACE_GREYBUS_H ++ ++#include <linux/tracepoint.h> ++ ++struct gb_message; ++struct gb_operation; ++struct gb_connection; ++struct gb_bundle; ++struct gb_host_device; ++ ++DECLARE_EVENT_CLASS(gb_message, ++ ++ TP_PROTO(struct gb_message *message), ++ ++ TP_ARGS(message), ++ ++ TP_STRUCT__entry( ++ __field(u16, size) ++ __field(u16, operation_id) ++ __field(u8, type) ++ __field(u8, result) ++ ), ++ ++ TP_fast_assign( ++ __entry->size = le16_to_cpu(message->header->size); ++ __entry->operation_id = ++ le16_to_cpu(message->header->operation_id); ++ __entry->type = message->header->type; ++ __entry->result = message->header->result; ++ ), ++ ++ TP_printk("size=%hu operation_id=0x%04x type=0x%02x result=0x%02x", ++ __entry->size, __entry->operation_id, ++ __entry->type, __entry->result) ++); ++ ++#define DEFINE_MESSAGE_EVENT(name) \ ++ DEFINE_EVENT(gb_message, name, \ ++ TP_PROTO(struct gb_message *message), \ ++ TP_ARGS(message)) ++ ++/* ++ * Occurs immediately before calling a host device's message_send() ++ * method. ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_send); ++ ++/* ++ * Occurs after an incoming request message has been received ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_recv_request); ++ ++/* ++ * Occurs after an incoming response message has been received, ++ * after its matching request has been found. ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_recv_response); ++ ++/* ++ * Occurs after an operation has been canceled, possibly before the ++ * cancellation is complete. ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_cancel_outgoing); ++ ++/* ++ * Occurs when an incoming request is cancelled; if the response has ++ * been queued for sending, this occurs after it is sent. ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_cancel_incoming); ++ ++/* ++ * Occurs in the host driver message_send() function just prior to ++ * handing off the data to be processed by hardware. ++ */ ++DEFINE_MESSAGE_EVENT(gb_message_submit); ++ ++#undef DEFINE_MESSAGE_EVENT ++ ++DECLARE_EVENT_CLASS(gb_operation, ++ ++ TP_PROTO(struct gb_operation *operation), ++ ++ TP_ARGS(operation), ++ ++ TP_STRUCT__entry( ++ __field(u16, cport_id) /* CPort of HD side of connection */ ++ __field(u16, id) /* Operation ID */ ++ __field(u8, type) ++ __field(unsigned long, flags) ++ __field(int, active) ++ __field(int, waiters) ++ __field(int, errno) ++ ), ++ ++ TP_fast_assign( ++ __entry->cport_id = operation->connection->hd_cport_id; ++ __entry->id = operation->id; ++ __entry->type = operation->type; ++ __entry->flags = operation->flags; ++ __entry->active = operation->active; ++ __entry->waiters = atomic_read(&operation->waiters); ++ __entry->errno = operation->errno; ++ ), ++ ++ TP_printk("id=%04x type=0x%02x cport_id=%04x flags=0x%lx active=%d waiters=%d errno=%d", ++ __entry->id, __entry->cport_id, __entry->type, __entry->flags, ++ __entry->active, __entry->waiters, __entry->errno) ++); ++ ++#define DEFINE_OPERATION_EVENT(name) \ ++ DEFINE_EVENT(gb_operation, name, \ ++ TP_PROTO(struct gb_operation *operation), \ ++ TP_ARGS(operation)) ++ ++/* ++ * Occurs after a new operation is created for an outgoing request ++ * has been successfully created. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_create); ++ ++/* ++ * Occurs after a new core operation has been created. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_create_core); ++ ++/* ++ * Occurs after a new operation has been created for an incoming ++ * request has been successfully created and initialized. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_create_incoming); ++ ++/* ++ * Occurs when the last reference to an operation has been dropped, ++ * prior to freeing resources. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_destroy); ++ ++/* ++ * Occurs when an operation has been marked active, after updating ++ * its active count. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_get_active); ++ ++/* ++ * Occurs when an operation has been marked active, before updating ++ * its active count. ++ */ ++DEFINE_OPERATION_EVENT(gb_operation_put_active); ++ ++#undef DEFINE_OPERATION_EVENT ++ ++DECLARE_EVENT_CLASS(gb_connection, ++ ++ TP_PROTO(struct gb_connection *connection), ++ ++ TP_ARGS(connection), ++ ++ TP_STRUCT__entry( ++ __field(int, hd_bus_id) ++ __field(u8, bundle_id) ++ /* name contains "hd_cport_id/intf_id:cport_id" */ ++ __dynamic_array(char, name, sizeof(connection->name)) ++ __field(enum gb_connection_state, state) ++ __field(unsigned long, flags) ++ ), ++ ++ TP_fast_assign( ++ __entry->hd_bus_id = connection->hd->bus_id; ++ __entry->bundle_id = connection->bundle ? ++ connection->bundle->id : BUNDLE_ID_NONE; ++ memcpy(__get_str(name), connection->name, ++ sizeof(connection->name)); ++ __entry->state = connection->state; ++ __entry->flags = connection->flags; ++ ), ++ ++ TP_printk("hd_bus_id=%d bundle_id=0x%02x name=\"%s\" state=%u flags=0x%lx", ++ __entry->hd_bus_id, __entry->bundle_id, __get_str(name), ++ (unsigned int)__entry->state, __entry->flags) ++); ++ ++#define DEFINE_CONNECTION_EVENT(name) \ ++ DEFINE_EVENT(gb_connection, name, \ ++ TP_PROTO(struct gb_connection *connection), \ ++ TP_ARGS(connection)) ++ ++/* ++ * Occurs after a new connection is successfully created. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_create); ++ ++/* ++ * Occurs when the last reference to a connection has been dropped, ++ * before its resources are freed. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_release); ++ ++/* ++ * Occurs when a new reference to connection is added, currently ++ * only when a message over the connection is received. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_get); ++ ++/* ++ * Occurs when a new reference to connection is dropped, after a ++ * a received message is handled, or when the connection is ++ * destroyed. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_put); ++ ++/* ++ * Occurs when a request to enable a connection is made, either for ++ * transmit only, or for both transmit and receive. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_enable); ++ ++/* ++ * Occurs when a request to disable a connection is made, either for ++ * receive only, or for both transmit and receive. Also occurs when ++ * a request to forcefully disable a connection is made. ++ */ ++DEFINE_CONNECTION_EVENT(gb_connection_disable); ++ ++#undef DEFINE_CONNECTION_EVENT ++ ++DECLARE_EVENT_CLASS(gb_bundle, ++ ++ TP_PROTO(struct gb_bundle *bundle), ++ ++ TP_ARGS(bundle), ++ ++ TP_STRUCT__entry( ++ __field(u8, intf_id) ++ __field(u8, id) ++ __field(u8, class) ++ __field(size_t, num_cports) ++ ), ++ ++ TP_fast_assign( ++ __entry->intf_id = bundle->intf->interface_id; ++ __entry->id = bundle->id; ++ __entry->class = bundle->class; ++ __entry->num_cports = bundle->num_cports; ++ ), ++ ++ TP_printk("intf_id=0x%02x id=%02x class=0x%02x num_cports=%zu", ++ __entry->intf_id, __entry->id, __entry->class, ++ __entry->num_cports) ++); ++ ++#define DEFINE_BUNDLE_EVENT(name) \ ++ DEFINE_EVENT(gb_bundle, name, \ ++ TP_PROTO(struct gb_bundle *bundle), \ ++ TP_ARGS(bundle)) ++ ++/* ++ * Occurs after a new bundle is successfully created. ++ */ ++DEFINE_BUNDLE_EVENT(gb_bundle_create); ++ ++/* ++ * Occurs when the last reference to a bundle has been dropped, ++ * before its resources are freed. ++ */ ++DEFINE_BUNDLE_EVENT(gb_bundle_release); ++ ++/* ++ * Occurs when a bundle is added to an interface when the interface ++ * is enabled. ++ */ ++DEFINE_BUNDLE_EVENT(gb_bundle_add); ++ ++/* ++ * Occurs when a registered bundle gets destroyed, normally at the ++ * time an interface is disabled. ++ */ ++DEFINE_BUNDLE_EVENT(gb_bundle_destroy); ++ ++#undef DEFINE_BUNDLE_EVENT ++ ++DECLARE_EVENT_CLASS(gb_interface, ++ ++ TP_PROTO(struct gb_interface *intf), ++ ++ TP_ARGS(intf), ++ ++ TP_STRUCT__entry( ++ __field(u8, module_id) ++ __field(u8, id) /* Interface id */ ++ __field(u8, device_id) ++ __field(int, disconnected) /* bool */ ++ __field(int, ejected) /* bool */ ++ __field(int, active) /* bool */ ++ __field(int, enabled) /* bool */ ++ __field(int, mode_switch) /* bool */ ++ ), ++ ++ TP_fast_assign( ++ __entry->module_id = intf->module->module_id; ++ __entry->id = intf->interface_id; ++ __entry->device_id = intf->device_id; ++ __entry->disconnected = intf->disconnected; ++ __entry->ejected = intf->ejected; ++ __entry->active = intf->active; ++ __entry->enabled = intf->enabled; ++ __entry->mode_switch = intf->mode_switch; ++ ), ++ ++ TP_printk("intf_id=%hhu device_id=%hhu module_id=%hhu D=%d J=%d A=%d E=%d M=%d", ++ __entry->id, __entry->device_id, __entry->module_id, ++ __entry->disconnected, __entry->ejected, __entry->active, ++ __entry->enabled, __entry->mode_switch) ++); ++ ++#define DEFINE_INTERFACE_EVENT(name) \ ++ DEFINE_EVENT(gb_interface, name, \ ++ TP_PROTO(struct gb_interface *intf), \ ++ TP_ARGS(intf)) ++ ++/* ++ * Occurs after a new interface is successfully created. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_create); ++ ++/* ++ * Occurs after the last reference to an interface has been dropped. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_release); ++ ++/* ++ * Occurs after an interface been registerd. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_add); ++ ++/* ++ * Occurs when a registered interface gets deregisterd. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_del); ++ ++/* ++ * Occurs when a registered interface has been successfully ++ * activated. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_activate); ++ ++/* ++ * Occurs when an activated interface is being deactivated. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_deactivate); ++ ++/* ++ * Occurs when an interface has been successfully enabled. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_enable); ++ ++/* ++ * Occurs when an enabled interface is being disabled. ++ */ ++DEFINE_INTERFACE_EVENT(gb_interface_disable); ++ ++#undef DEFINE_INTERFACE_EVENT ++ ++DECLARE_EVENT_CLASS(gb_module, ++ ++ TP_PROTO(struct gb_module *module), ++ ++ TP_ARGS(module), ++ ++ TP_STRUCT__entry( ++ __field(int, hd_bus_id) ++ __field(u8, module_id) ++ __field(size_t, num_interfaces) ++ __field(int, disconnected) /* bool */ ++ ), ++ ++ TP_fast_assign( ++ __entry->hd_bus_id = module->hd->bus_id; ++ __entry->module_id = module->module_id; ++ __entry->num_interfaces = module->num_interfaces; ++ __entry->disconnected = module->disconnected; ++ ), ++ ++ TP_printk("hd_bus_id=%d module_id=%hhu num_interfaces=%zu disconnected=%d", ++ __entry->hd_bus_id, __entry->module_id, ++ __entry->num_interfaces, __entry->disconnected) ++); ++ ++#define DEFINE_MODULE_EVENT(name) \ ++ DEFINE_EVENT(gb_module, name, \ ++ TP_PROTO(struct gb_module *module), \ ++ TP_ARGS(module)) ++ ++/* ++ * Occurs after a new module is successfully created, before ++ * creating any of its interfaces. ++ */ ++DEFINE_MODULE_EVENT(gb_module_create); ++ ++/* ++ * Occurs after the last reference to a module has been dropped. ++ */ ++DEFINE_MODULE_EVENT(gb_module_release); ++ ++/* ++ * Occurs after a module is successfully created, before registering ++ * any of its interfaces. ++ */ ++DEFINE_MODULE_EVENT(gb_module_add); ++ ++/* ++ * Occurs when a module is deleted, before deregistering its ++ * interfaces. ++ */ ++DEFINE_MODULE_EVENT(gb_module_del); ++ ++#undef DEFINE_MODULE_EVENT ++ ++DECLARE_EVENT_CLASS(gb_host_device, ++ ++ TP_PROTO(struct gb_host_device *hd), ++ ++ TP_ARGS(hd), ++ ++ TP_STRUCT__entry( ++ __field(int, bus_id) ++ __field(size_t, num_cports) ++ __field(size_t, buffer_size_max) ++ ), ++ ++ TP_fast_assign( ++ __entry->bus_id = hd->bus_id; ++ __entry->num_cports = hd->num_cports; ++ __entry->buffer_size_max = hd->buffer_size_max; ++ ), ++ ++ TP_printk("bus_id=%d num_cports=%zu mtu=%zu", ++ __entry->bus_id, __entry->num_cports, ++ __entry->buffer_size_max) ++); ++ ++#define DEFINE_HD_EVENT(name) \ ++ DEFINE_EVENT(gb_host_device, name, \ ++ TP_PROTO(struct gb_host_device *hd), \ ++ TP_ARGS(hd)) ++ ++/* ++ * Occurs after a new host device is successfully created, before ++ * its SVC has been set up. ++ */ ++DEFINE_HD_EVENT(gb_hd_create); ++ ++/* ++ * Occurs after the last reference to a host device has been ++ * dropped. ++ */ ++DEFINE_HD_EVENT(gb_hd_release); ++ ++/* ++ * Occurs after a new host device has been added, after the ++ * connection to its SVC has been enabled. ++ */ ++DEFINE_HD_EVENT(gb_hd_add); ++ ++/* ++ * Occurs when a host device is being disconnected from the AP USB ++ * host controller. ++ */ ++DEFINE_HD_EVENT(gb_hd_del); ++ ++/* ++ * Occurs when a host device has passed received data to the Greybus ++ * core, after it has been determined it is destined for a valid ++ * CPort. ++ */ ++DEFINE_HD_EVENT(gb_hd_in); ++ ++#undef DEFINE_HD_EVENT ++ ++/* ++ * Occurs on a TimeSync synchronization event or a TimeSync ping event. ++ */ ++TRACE_EVENT(gb_timesync_irq, ++ ++ TP_PROTO(u8 ping, u8 strobe, u8 count, u64 frame_time), ++ ++ TP_ARGS(ping, strobe, count, frame_time), ++ ++ TP_STRUCT__entry( ++ __field(u8, ping) ++ __field(u8, strobe) ++ __field(u8, count) ++ __field(u64, frame_time) ++ ), ++ ++ TP_fast_assign( ++ __entry->ping = ping; ++ __entry->strobe = strobe; ++ __entry->count = count; ++ __entry->frame_time = frame_time; ++ ), ++ ++ TP_printk("%s %d/%d frame-time %llu\n", ++ __entry->ping ? "ping" : "strobe", __entry->strobe, ++ __entry->count, __entry->frame_time) ++); ++ ++#endif /* _TRACE_GREYBUS_H */ ++ ++/* This part must be outside protection */ ++#undef TRACE_INCLUDE_PATH ++#define TRACE_INCLUDE_PATH . ++ ++/* ++ * TRACE_INCLUDE_FILE is not needed if the filename and TRACE_SYSTEM are equal ++ */ ++#undef TRACE_INCLUDE_FILE ++#define TRACE_INCLUDE_FILE greybus_trace ++#include <trace/define_trace.h> ++ |