drivers/platform/surface/aggregator/trace.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Trace points for SSAM/SSH.
   4  *
   5  * Copyright (C) 2020-2021 Maximilian Luz <[email protected]>
   6  */
   7
   8 #undef TRACE_SYSTEM
   9 #define TRACE_SYSTEM surface_aggregator
  10
  11 #if !defined(_SURFACE_AGGREGATOR_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
  12 #define _SURFACE_AGGREGATOR_TRACE_H
  13
  14 #include <linux/surface_aggregator/serial_hub.h>
  15
  16 #include <asm/unaligned.h>
  17 #include <linux/tracepoint.h>
  18
  19 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_SEQ);
  20 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_DATA_NSQ);
  21 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_ACK);
  22 TRACE_DEFINE_ENUM(SSH_FRAME_TYPE_NAK);
  23
  24 TRACE_DEFINE_ENUM(SSH_PACKET_SF_LOCKED_BIT);
  25 TRACE_DEFINE_ENUM(SSH_PACKET_SF_QUEUED_BIT);
  26 TRACE_DEFINE_ENUM(SSH_PACKET_SF_PENDING_BIT);
  27 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTING_BIT);
  28 TRACE_DEFINE_ENUM(SSH_PACKET_SF_TRANSMITTED_BIT);
  29 TRACE_DEFINE_ENUM(SSH_PACKET_SF_ACKED_BIT);
  30 TRACE_DEFINE_ENUM(SSH_PACKET_SF_CANCELED_BIT);
  31 TRACE_DEFINE_ENUM(SSH_PACKET_SF_COMPLETED_BIT);
  32
  33 TRACE_DEFINE_ENUM(SSH_PACKET_TY_FLUSH_BIT);
  34 TRACE_DEFINE_ENUM(SSH_PACKET_TY_SEQUENCED_BIT);
  35 TRACE_DEFINE_ENUM(SSH_PACKET_TY_BLOCKING_BIT);
  36
  37 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_SF_MASK);
  38 TRACE_DEFINE_ENUM(SSH_PACKET_FLAGS_TY_MASK);
  39
  40 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_LOCKED_BIT);
  41 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_QUEUED_BIT);
  42 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_PENDING_BIT);
  43 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTING_BIT);
  44 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_TRANSMITTED_BIT);
  45 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_RSPRCVD_BIT);
  46 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_CANCELED_BIT);
  47 TRACE_DEFINE_ENUM(SSH_REQUEST_SF_COMPLETED_BIT);
  48
  49 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_FLUSH_BIT);
  50 TRACE_DEFINE_ENUM(SSH_REQUEST_TY_HAS_RESPONSE_BIT);
  51
  52 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_SF_MASK);
  53 TRACE_DEFINE_ENUM(SSH_REQUEST_FLAGS_TY_MASK);
  54
  55 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SAM);
  56 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAT);
  57 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TMP);
  58 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PMC);
  59 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FAN);
  60 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PoM);
  61 TRACE_DEFINE_ENUM(SSAM_SSH_TC_DBG);
  62 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KBD);
  63 TRACE_DEFINE_ENUM(SSAM_SSH_TC_FWU);
  64 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UNI);
  65 TRACE_DEFINE_ENUM(SSAM_SSH_TC_LPC);
  66 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCL);
  67 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SFL);
  68 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KIP);
  69 TRACE_DEFINE_ENUM(SSAM_SSH_TC_EXT);
  70 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BLD);
  71 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BAS);
  72 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SEN);
  73 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SRQ);
  74 TRACE_DEFINE_ENUM(SSAM_SSH_TC_MCU);
  75 TRACE_DEFINE_ENUM(SSAM_SSH_TC_HID);
  76 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TCH);
  77 TRACE_DEFINE_ENUM(SSAM_SSH_TC_BKL);
  78 TRACE_DEFINE_ENUM(SSAM_SSH_TC_TAM);
  79 TRACE_DEFINE_ENUM(SSAM_SSH_TC_ACC);
  80 TRACE_DEFINE_ENUM(SSAM_SSH_TC_UFI);
  81 TRACE_DEFINE_ENUM(SSAM_SSH_TC_USC);
  82 TRACE_DEFINE_ENUM(SSAM_SSH_TC_PEN);
  83 TRACE_DEFINE_ENUM(SSAM_SSH_TC_VID);
  84 TRACE_DEFINE_ENUM(SSAM_SSH_TC_AUD);
  85 TRACE_DEFINE_ENUM(SSAM_SSH_TC_SMC);
  86 TRACE_DEFINE_ENUM(SSAM_SSH_TC_KPD);
  87 TRACE_DEFINE_ENUM(SSAM_SSH_TC_REG);
  88
  89 #define SSAM_PTR_UID_LEN                9
  90 #define SSAM_U8_FIELD_NOT_APPLICABLE    ((u16)-1)
  91 #define SSAM_SEQ_NOT_APPLICABLE         ((u16)-1)
  92 #define SSAM_RQID_NOT_APPLICABLE        ((u32)-1)
  93 #define SSAM_SSH_TC_NOT_APPLICABLE      0
  94
  95 #ifndef _SURFACE_AGGREGATOR_TRACE_HELPERS
  96 #define _SURFACE_AGGREGATOR_TRACE_HELPERS
  97
  98 /**
  99  * ssam_trace_ptr_uid() - Convert the pointer to a non-pointer UID string.
 100  * @ptr: The pointer to convert.
 101  * @uid_str: A buffer of length SSAM_PTR_UID_LEN where the UID will be stored.
 102  *
 103  * Converts the given pointer into a UID string that is safe to be shared
 104  * with userspace and logs, i.e. doesn't give away the real memory location.
 105  */
 106 static inline void ssam_trace_ptr_uid(const void *ptr, char *uid_str)
 107 {
 108         char buf[2 * sizeof(void *) + 1];
 109
 110         BUILD_BUG_ON(ARRAY_SIZE(buf) < SSAM_PTR_UID_LEN);
 111
 112         snprintf(buf, ARRAY_SIZE(buf), "%p", ptr);
 113         memcpy(uid_str, &buf[ARRAY_SIZE(buf) - SSAM_PTR_UID_LEN],
 114                SSAM_PTR_UID_LEN);
 115 }
 116
 117 /**
 118  * ssam_trace_get_packet_seq() - Read the packet's sequence ID.
 119  * @p: The packet.
 120  *
 121  * Return: Returns the packet's sequence ID (SEQ) field if present, or
 122  * %SSAM_SEQ_NOT_APPLICABLE if not (e.g. flush packet).
 123  */
 124 static inline u16 ssam_trace_get_packet_seq(const struct ssh_packet *p)
 125 {
 126         if (!p->data.ptr || p->data.len < SSH_MESSAGE_LENGTH(0))
 127                 return SSAM_SEQ_NOT_APPLICABLE;
 128
 129         return p->data.ptr[SSH_MSGOFFSET_FRAME(seq)];
 130 }
 131
 132 /**
 133  * ssam_trace_get_request_id() - Read the packet's request ID.
 134  * @p: The packet.
 135  *
 136  * Return: Returns the packet's request ID (RQID) field if the packet
 137  * represents a request with command data, or %SSAM_RQID_NOT_APPLICABLE if not
 138  * (e.g. flush request, control packet).
 139  */
 140 static inline u32 ssam_trace_get_request_id(const struct ssh_packet *p)
 141 {
 142         if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
 143                 return SSAM_RQID_NOT_APPLICABLE;
 144
 145         return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(rqid)]);
 146 }
 147
 148 /**
 149  * ssam_trace_get_request_tc() - Read the packet's request target category.
 150  * @p: The packet.
 151  *
 152  * Return: Returns the packet's request target category (TC) field if the
 153  * packet represents a request with command data, or %SSAM_TC_NOT_APPLICABLE
 154  * if not (e.g. flush request, control packet).
 155  */
 156 static inline u32 ssam_trace_get_request_tc(const struct ssh_packet *p)
 157 {
 158         if (!p->data.ptr || p->data.len < SSH_COMMAND_MESSAGE_LENGTH(0))
 159                 return SSAM_SSH_TC_NOT_APPLICABLE;
 160
 161         return get_unaligned_le16(&p->data.ptr[SSH_MSGOFFSET_COMMAND(tc)]);
 162 }
 163
 164 #endif /* _SURFACE_AGGREGATOR_TRACE_HELPERS */
 165
 166 #define ssam_trace_get_command_field_u8(packet, field) \
 167         ((!(packet) || (packet)->data.len < SSH_COMMAND_MESSAGE_LENGTH(0)) \
 168          ? 0 : (packet)->data.ptr[SSH_MSGOFFSET_COMMAND(field)])
 169
 170 #define ssam_show_generic_u8_field(value)                               \
 171         __print_symbolic(value,                                         \
 172                 { SSAM_U8_FIELD_NOT_APPLICABLE,         "N/A" }         \
 173         )
 174
 175 #define ssam_show_frame_type(ty)                                        \
 176         __print_symbolic(ty,                                            \
 177                 { SSH_FRAME_TYPE_DATA_SEQ,              "DSEQ" },       \
 178                 { SSH_FRAME_TYPE_DATA_NSQ,              "DNSQ" },       \
 179                 { SSH_FRAME_TYPE_ACK,                   "ACK"  },       \
 180                 { SSH_FRAME_TYPE_NAK,                   "NAK"  }        \
 181         )
 182
 183 #define ssam_show_packet_type(type)                                     \
 184         __print_flags(flags & SSH_PACKET_FLAGS_TY_MASK, "",             \
 185                 { BIT(SSH_PACKET_TY_FLUSH_BIT),         "F" },          \
 186                 { BIT(SSH_PACKET_TY_SEQUENCED_BIT),     "S" },          \
 187                 { BIT(SSH_PACKET_TY_BLOCKING_BIT),      "B" }           \
 188         )
 189
 190 #define ssam_show_packet_state(state)                                   \
 191         __print_flags(flags & SSH_PACKET_FLAGS_SF_MASK, "",             \
 192                 { BIT(SSH_PACKET_SF_LOCKED_BIT),        "L" },          \
 193                 { BIT(SSH_PACKET_SF_QUEUED_BIT),        "Q" },          \
 194                 { BIT(SSH_PACKET_SF_PENDING_BIT),       "P" },          \
 195                 { BIT(SSH_PACKET_SF_TRANSMITTING_BIT),  "S" },          \
 196                 { BIT(SSH_PACKET_SF_TRANSMITTED_BIT),   "T" },          \
 197                 { BIT(SSH_PACKET_SF_ACKED_BIT),         "A" },          \
 198                 { BIT(SSH_PACKET_SF_CANCELED_BIT),      "C" },          \
 199                 { BIT(SSH_PACKET_SF_COMPLETED_BIT),     "F" }           \
 200         )
 201
 202 #define ssam_show_packet_seq(seq)                                       \
 203         __print_symbolic(seq,                                           \
 204                 { SSAM_SEQ_NOT_APPLICABLE,              "N/A" }         \
 205         )
 206
 207 #define ssam_show_request_type(flags)                                   \
 208         __print_flags((flags) & SSH_REQUEST_FLAGS_TY_MASK, "",          \
 209                 { BIT(SSH_REQUEST_TY_FLUSH_BIT),        "F" },          \
 210                 { BIT(SSH_REQUEST_TY_HAS_RESPONSE_BIT), "R" }           \
 211         )
 212
 213 #define ssam_show_request_state(flags)                                  \
 214         __print_flags((flags) & SSH_REQUEST_FLAGS_SF_MASK, "",          \
 215                 { BIT(SSH_REQUEST_SF_LOCKED_BIT),       "L" },          \
 216                 { BIT(SSH_REQUEST_SF_QUEUED_BIT),       "Q" },          \
 217                 { BIT(SSH_REQUEST_SF_PENDING_BIT),      "P" },          \
 218                 { BIT(SSH_REQUEST_SF_TRANSMITTING_BIT), "S" },          \
 219                 { BIT(SSH_REQUEST_SF_TRANSMITTED_BIT),  "T" },          \
 220                 { BIT(SSH_REQUEST_SF_RSPRCVD_BIT),      "A" },          \
 221                 { BIT(SSH_REQUEST_SF_CANCELED_BIT),     "C" },          \
 222                 { BIT(SSH_REQUEST_SF_COMPLETED_BIT),    "F" }           \
 223         )
 224
 225 #define ssam_show_request_id(rqid)                                      \
 226         __print_symbolic(rqid,                                          \
 227                 { SSAM_RQID_NOT_APPLICABLE,             "N/A" }         \
 228         )
 229
 230 #define ssam_show_ssh_tc(rqid)                                          \
 231         __print_symbolic(rqid,                                          \
 232                 { SSAM_SSH_TC_NOT_APPLICABLE,           "N/A" },        \
 233                 { SSAM_SSH_TC_SAM,                      "SAM" },        \
 234                 { SSAM_SSH_TC_BAT,                      "BAT" },        \
 235                 { SSAM_SSH_TC_TMP,                      "TMP" },        \
 236                 { SSAM_SSH_TC_PMC,                      "PMC" },        \
 237                 { SSAM_SSH_TC_FAN,                      "FAN" },        \
 238                 { SSAM_SSH_TC_PoM,                      "PoM" },        \
 239                 { SSAM_SSH_TC_DBG,                      "DBG" },        \
 240                 { SSAM_SSH_TC_KBD,                      "KBD" },        \
 241                 { SSAM_SSH_TC_FWU,                      "FWU" },        \
 242                 { SSAM_SSH_TC_UNI,                      "UNI" },        \
 243                 { SSAM_SSH_TC_LPC,                      "LPC" },        \
 244                 { SSAM_SSH_TC_TCL,                      "TCL" },        \
 245                 { SSAM_SSH_TC_SFL,                      "SFL" },        \
 246                 { SSAM_SSH_TC_KIP,                      "KIP" },        \
 247                 { SSAM_SSH_TC_EXT,                      "EXT" },        \
 248                 { SSAM_SSH_TC_BLD,                      "BLD" },        \
 249                 { SSAM_SSH_TC_BAS,                      "BAS" },        \
 250                 { SSAM_SSH_TC_SEN,                      "SEN" },        \
 251                 { SSAM_SSH_TC_SRQ,                      "SRQ" },        \
 252                 { SSAM_SSH_TC_MCU,                      "MCU" },        \
 253                 { SSAM_SSH_TC_HID,                      "HID" },        \
 254                 { SSAM_SSH_TC_TCH,                      "TCH" },        \
 255                 { SSAM_SSH_TC_BKL,                      "BKL" },        \
 256                 { SSAM_SSH_TC_TAM,                      "TAM" },        \
 257                 { SSAM_SSH_TC_ACC,                      "ACC" },        \
 258                 { SSAM_SSH_TC_UFI,                      "UFI" },        \
 259                 { SSAM_SSH_TC_USC,                      "USC" },        \
 260                 { SSAM_SSH_TC_PEN,                      "PEN" },        \
 261                 { SSAM_SSH_TC_VID,                      "VID" },        \
 262                 { SSAM_SSH_TC_AUD,                      "AUD" },        \
 263                 { SSAM_SSH_TC_SMC,                      "SMC" },        \
 264                 { SSAM_SSH_TC_KPD,                      "KPD" },        \
 265                 { SSAM_SSH_TC_REG,                      "REG" }         \
 266         )
 267
 268 DECLARE_EVENT_CLASS(ssam_frame_class,
 269         TP_PROTO(const struct ssh_frame *frame),
 270
 271         TP_ARGS(frame),
 272
 273         TP_STRUCT__entry(
 274                 __field(u8, type)
 275                 __field(u8, seq)
 276                 __field(u16, len)
 277         ),
 278
 279         TP_fast_assign(
 280                 __entry->type = frame->type;
 281                 __entry->seq = frame->seq;
 282                 __entry->len = get_unaligned_le16(&frame->len);
 283         ),
 284
 285         TP_printk("ty=%s, seq=%#04x, len=%u",
 286                 ssam_show_frame_type(__entry->type),
 287                 __entry->seq,
 288                 __entry->len
 289         )
 290 );
 291
 292 #define DEFINE_SSAM_FRAME_EVENT(name)                           \
 293         DEFINE_EVENT(ssam_frame_class, ssam_##name,             \
 294                 TP_PROTO(const struct ssh_frame *frame),        \
 295                 TP_ARGS(frame)                                  \
 296         )
 297
 298 DECLARE_EVENT_CLASS(ssam_command_class,
 299         TP_PROTO(const struct ssh_command *cmd, u16 len),
 300
 301         TP_ARGS(cmd, len),
 302
 303         TP_STRUCT__entry(
 304                 __field(u16, rqid)
 305                 __field(u16, len)
 306                 __field(u8, tc)
 307                 __field(u8, cid)
 308                 __field(u8, iid)
 309         ),
 310
 311         TP_fast_assign(
 312                 __entry->rqid = get_unaligned_le16(&cmd->rqid);
 313                 __entry->tc = cmd->tc;
 314                 __entry->cid = cmd->cid;
 315                 __entry->iid = cmd->iid;
 316                 __entry->len = len;
 317         ),
 318
 319         TP_printk("rqid=%#06x, tc=%s, cid=%#04x, iid=%#04x, len=%u",
 320                 __entry->rqid,
 321                 ssam_show_ssh_tc(__entry->tc),
 322                 __entry->cid,
 323                 __entry->iid,
 324                 __entry->len
 325         )
 326 );
 327
 328 #define DEFINE_SSAM_COMMAND_EVENT(name)                                 \
 329         DEFINE_EVENT(ssam_command_class, ssam_##name,                   \
 330                 TP_PROTO(const struct ssh_command *cmd, u16 len),       \
 331                 TP_ARGS(cmd, len)                                       \
 332         )
 333
 334 DECLARE_EVENT_CLASS(ssam_packet_class,
 335         TP_PROTO(const struct ssh_packet *packet),
 336
 337         TP_ARGS(packet),
 338
 339         TP_STRUCT__entry(
 340                 __field(unsigned long, state)
 341                 __array(char, uid, SSAM_PTR_UID_LEN)
 342                 __field(u8, priority)
 343                 __field(u16, length)
 344                 __field(u16, seq)
 345         ),
 346
 347         TP_fast_assign(
 348                 __entry->state = READ_ONCE(packet->state);
 349                 ssam_trace_ptr_uid(packet, __entry->uid);
 350                 __entry->priority = READ_ONCE(packet->priority);
 351                 __entry->length = packet->data.len;
 352                 __entry->seq = ssam_trace_get_packet_seq(packet);
 353         ),
 354
 355         TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s",
 356                 __entry->uid,
 357                 ssam_show_packet_seq(__entry->seq),
 358                 ssam_show_packet_type(__entry->state),
 359                 __entry->priority,
 360                 __entry->length,
 361                 ssam_show_packet_state(__entry->state)
 362         )
 363 );
 364
 365 #define DEFINE_SSAM_PACKET_EVENT(name)                          \
 366         DEFINE_EVENT(ssam_packet_class, ssam_##name,            \
 367                 TP_PROTO(const struct ssh_packet *packet),      \
 368                 TP_ARGS(packet)                                 \
 369         )
 370
 371 DECLARE_EVENT_CLASS(ssam_packet_status_class,
 372         TP_PROTO(const struct ssh_packet *packet, int status),
 373
 374         TP_ARGS(packet, status),
 375
 376         TP_STRUCT__entry(
 377                 __field(unsigned long, state)
 378                 __field(int, status)
 379                 __array(char, uid, SSAM_PTR_UID_LEN)
 380                 __field(u8, priority)
 381                 __field(u16, length)
 382                 __field(u16, seq)
 383         ),
 384
 385         TP_fast_assign(
 386                 __entry->state = READ_ONCE(packet->state);
 387                 __entry->status = status;
 388                 ssam_trace_ptr_uid(packet, __entry->uid);
 389                 __entry->priority = READ_ONCE(packet->priority);
 390                 __entry->length = packet->data.len;
 391                 __entry->seq = ssam_trace_get_packet_seq(packet);
 392         ),
 393
 394         TP_printk("uid=%s, seq=%s, ty=%s, pri=%#04x, len=%u, sta=%s, status=%d",
 395                 __entry->uid,
 396                 ssam_show_packet_seq(__entry->seq),
 397                 ssam_show_packet_type(__entry->state),
 398                 __entry->priority,
 399                 __entry->length,
 400                 ssam_show_packet_state(__entry->state),
 401                 __entry->status
 402         )
 403 );
 404
 405 #define DEFINE_SSAM_PACKET_STATUS_EVENT(name)                           \
 406         DEFINE_EVENT(ssam_packet_status_class, ssam_##name,             \
 407                 TP_PROTO(const struct ssh_packet *packet, int status),  \
 408                 TP_ARGS(packet, status)                                 \
 409         )
 410
 411 DECLARE_EVENT_CLASS(ssam_request_class,
 412         TP_PROTO(const struct ssh_request *request),
 413
 414         TP_ARGS(request),
 415
 416         TP_STRUCT__entry(
 417                 __field(unsigned long, state)
 418                 __field(u32, rqid)
 419                 __array(char, uid, SSAM_PTR_UID_LEN)
 420                 __field(u8, tc)
 421                 __field(u16, cid)
 422                 __field(u16, iid)
 423         ),
 424
 425         TP_fast_assign(
 426                 const struct ssh_packet *p = &request->packet;
 427
 428                 /* Use packet for UID so we can match requests to packets. */
 429                 __entry->state = READ_ONCE(request->state);
 430                 __entry->rqid = ssam_trace_get_request_id(p);
 431                 ssam_trace_ptr_uid(p, __entry->uid);
 432                 __entry->tc = ssam_trace_get_request_tc(p);
 433                 __entry->cid = ssam_trace_get_command_field_u8(p, cid);
 434                 __entry->iid = ssam_trace_get_command_field_u8(p, iid);
 435         ),
 436
 437         TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s",
 438                 __entry->uid,
 439                 ssam_show_request_id(__entry->rqid),
 440                 ssam_show_request_type(__entry->state),
 441                 ssam_show_request_state(__entry->state),
 442                 ssam_show_ssh_tc(__entry->tc),
 443                 ssam_show_generic_u8_field(__entry->cid),
 444                 ssam_show_generic_u8_field(__entry->iid)
 445         )
 446 );
 447
 448 #define DEFINE_SSAM_REQUEST_EVENT(name)                         \
 449         DEFINE_EVENT(ssam_request_class, ssam_##name,           \
 450                 TP_PROTO(const struct ssh_request *request),    \
 451                 TP_ARGS(request)                                \
 452         )
 453
 454 DECLARE_EVENT_CLASS(ssam_request_status_class,
 455         TP_PROTO(const struct ssh_request *request, int status),
 456
 457         TP_ARGS(request, status),
 458
 459         TP_STRUCT__entry(
 460                 __field(unsigned long, state)
 461                 __field(u32, rqid)
 462                 __field(int, status)
 463                 __array(char, uid, SSAM_PTR_UID_LEN)
 464                 __field(u8, tc)
 465                 __field(u16, cid)
 466                 __field(u16, iid)
 467         ),
 468
 469         TP_fast_assign(
 470                 const struct ssh_packet *p = &request->packet;
 471
 472                 /* Use packet for UID so we can match requests to packets. */
 473                 __entry->state = READ_ONCE(request->state);
 474                 __entry->rqid = ssam_trace_get_request_id(p);
 475                 __entry->status = status;
 476                 ssam_trace_ptr_uid(p, __entry->uid);
 477                 __entry->tc = ssam_trace_get_request_tc(p);
 478                 __entry->cid = ssam_trace_get_command_field_u8(p, cid);
 479                 __entry->iid = ssam_trace_get_command_field_u8(p, iid);
 480         ),
 481
 482         TP_printk("uid=%s, rqid=%s, ty=%s, sta=%s, tc=%s, cid=%s, iid=%s, status=%d",
 483                 __entry->uid,
 484                 ssam_show_request_id(__entry->rqid),
 485                 ssam_show_request_type(__entry->state),
 486                 ssam_show_request_state(__entry->state),
 487                 ssam_show_ssh_tc(__entry->tc),
 488                 ssam_show_generic_u8_field(__entry->cid),
 489                 ssam_show_generic_u8_field(__entry->iid),
 490                 __entry->status
 491         )
 492 );
 493
 494 #define DEFINE_SSAM_REQUEST_STATUS_EVENT(name)                          \
 495         DEFINE_EVENT(ssam_request_status_class, ssam_##name,            \
 496                 TP_PROTO(const struct ssh_request *request, int status),\
 497                 TP_ARGS(request, status)                                \
 498         )
 499
 500 DECLARE_EVENT_CLASS(ssam_alloc_class,
 501         TP_PROTO(void *ptr, size_t len),
 502
 503         TP_ARGS(ptr, len),
 504
 505         TP_STRUCT__entry(
 506                 __field(size_t, len)
 507                 __array(char, uid, SSAM_PTR_UID_LEN)
 508         ),
 509
 510         TP_fast_assign(
 511                 __entry->len = len;
 512                 ssam_trace_ptr_uid(ptr, __entry->uid);
 513         ),
 514
 515         TP_printk("uid=%s, len=%zu", __entry->uid, __entry->len)
 516 );
 517
 518 #define DEFINE_SSAM_ALLOC_EVENT(name)                                   \
 519         DEFINE_EVENT(ssam_alloc_class, ssam_##name,                     \
 520                 TP_PROTO(void *ptr, size_t len),                        \
 521                 TP_ARGS(ptr, len)                                       \
 522         )
 523
 524 DECLARE_EVENT_CLASS(ssam_free_class,
 525         TP_PROTO(void *ptr),
 526
 527         TP_ARGS(ptr),
 528
 529         TP_STRUCT__entry(
 530                 __array(char, uid, SSAM_PTR_UID_LEN)
 531         ),
 532
 533         TP_fast_assign(
 534                 ssam_trace_ptr_uid(ptr, __entry->uid);
 535         ),
 536
 537         TP_printk("uid=%s", __entry->uid)
 538 );
 539
 540 #define DEFINE_SSAM_FREE_EVENT(name)                                    \
 541         DEFINE_EVENT(ssam_free_class, ssam_##name,                      \
 542                 TP_PROTO(void *ptr),                                    \
 543                 TP_ARGS(ptr)                                            \
 544         )
 545
 546 DECLARE_EVENT_CLASS(ssam_pending_class,
 547         TP_PROTO(unsigned int pending),
 548
 549         TP_ARGS(pending),
 550
 551         TP_STRUCT__entry(
 552                 __field(unsigned int, pending)
 553         ),
 554
 555         TP_fast_assign(
 556                 __entry->pending = pending;
 557         ),
 558
 559         TP_printk("pending=%u", __entry->pending)
 560 );
 561
 562 #define DEFINE_SSAM_PENDING_EVENT(name)                                 \
 563         DEFINE_EVENT(ssam_pending_class, ssam_##name,                   \
 564                 TP_PROTO(unsigned int pending),                         \
 565                 TP_ARGS(pending)                                        \
 566         )
 567
 568 DECLARE_EVENT_CLASS(ssam_data_class,
 569         TP_PROTO(size_t length),
 570
 571         TP_ARGS(length),
 572
 573         TP_STRUCT__entry(
 574                 __field(size_t, length)
 575         ),
 576
 577         TP_fast_assign(
 578                 __entry->length = length;
 579         ),
 580
 581         TP_printk("length=%zu", __entry->length)
 582 );
 583
 584 #define DEFINE_SSAM_DATA_EVENT(name)                                    \
 585         DEFINE_EVENT(ssam_data_class, ssam_##name,                      \
 586                 TP_PROTO(size_t length),                                \
 587                 TP_ARGS(length)                                         \
 588         )
 589
 590 DEFINE_SSAM_FRAME_EVENT(rx_frame_received);
 591 DEFINE_SSAM_COMMAND_EVENT(rx_response_received);
 592 DEFINE_SSAM_COMMAND_EVENT(rx_event_received);
 593
 594 DEFINE_SSAM_PACKET_EVENT(packet_release);
 595 DEFINE_SSAM_PACKET_EVENT(packet_submit);
 596 DEFINE_SSAM_PACKET_EVENT(packet_resubmit);
 597 DEFINE_SSAM_PACKET_EVENT(packet_timeout);
 598 DEFINE_SSAM_PACKET_EVENT(packet_cancel);
 599 DEFINE_SSAM_PACKET_STATUS_EVENT(packet_complete);
 600 DEFINE_SSAM_PENDING_EVENT(ptl_timeout_reap);
 601
 602 DEFINE_SSAM_REQUEST_EVENT(request_submit);
 603 DEFINE_SSAM_REQUEST_EVENT(request_timeout);
 604 DEFINE_SSAM_REQUEST_EVENT(request_cancel);
 605 DEFINE_SSAM_REQUEST_STATUS_EVENT(request_complete);
 606 DEFINE_SSAM_PENDING_EVENT(rtl_timeout_reap);
 607
 608 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_ack_packet);
 609 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_nak_packet);
 610 DEFINE_SSAM_PACKET_EVENT(ei_tx_drop_dsq_packet);
 611 DEFINE_SSAM_PACKET_STATUS_EVENT(ei_tx_fail_write);
 612 DEFINE_SSAM_PACKET_EVENT(ei_tx_corrupt_data);
 613 DEFINE_SSAM_DATA_EVENT(ei_rx_corrupt_syn);
 614 DEFINE_SSAM_FRAME_EVENT(ei_rx_corrupt_data);
 615 DEFINE_SSAM_REQUEST_EVENT(ei_rx_drop_response);
 616
 617 DEFINE_SSAM_ALLOC_EVENT(ctrl_packet_alloc);
 618 DEFINE_SSAM_FREE_EVENT(ctrl_packet_free);
 619
 620 DEFINE_SSAM_ALLOC_EVENT(event_item_alloc);
 621 DEFINE_SSAM_FREE_EVENT(event_item_free);
 622
 623 #endif /* _SURFACE_AGGREGATOR_TRACE_H */
 624
 625 /* This part must be outside protection */
 626 #undef TRACE_INCLUDE_PATH
 627 #undef TRACE_INCLUDE_FILE
 628
 629 #define TRACE_INCLUDE_PATH .
 630 #define TRACE_INCLUDE_FILE trace
 631
 632 #include <trace/define_trace.h>