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