include/trace/events/ufs.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #undef TRACE_SYSTEM
   7 #define TRACE_SYSTEM ufs
   8
   9 #if !defined(_TRACE_UFS_H) || defined(TRACE_HEADER_MULTI_READ)
  10 #define _TRACE_UFS_H
  11
  12 #include <linux/tracepoint.h>
  13
  14 #define UFS_LINK_STATES                 \
  15         EM(UIC_LINK_OFF_STATE)          \
  16         EM(UIC_LINK_ACTIVE_STATE)       \
  17         EMe(UIC_LINK_HIBERN8_STATE)
  18
  19 #define UFS_PWR_MODES                   \
  20         EM(UFS_ACTIVE_PWR_MODE)         \
  21         EM(UFS_SLEEP_PWR_MODE)          \
  22         EM(UFS_POWERDOWN_PWR_MODE)      \
  23         EMe(UFS_DEEPSLEEP_PWR_MODE)
  24
  25 #define UFSCHD_CLK_GATING_STATES        \
  26         EM(CLKS_OFF)                    \
  27         EM(CLKS_ON)                     \
  28         EM(REQ_CLKS_OFF)                \
  29         EMe(REQ_CLKS_ON)
  30
  31 /* Enums require being exported to userspace, for user tool parsing */
  32 #undef EM
  33 #undef EMe
  34 #define EM(a)   TRACE_DEFINE_ENUM(a);
  35 #define EMe(a)  TRACE_DEFINE_ENUM(a);
  36
  37 UFS_LINK_STATES;
  38 UFS_PWR_MODES;
  39 UFSCHD_CLK_GATING_STATES;
  40
  41 /*
  42  * Now redefine the EM() and EMe() macros to map the enums to the strings
  43  * that will be printed in the output.
  44  */
  45 #undef EM
  46 #undef EMe
  47 #define EM(a)   { a, #a },
  48 #define EMe(a)  { a, #a }
  49
  50 TRACE_EVENT(ufshcd_clk_gating,
  51
  52         TP_PROTO(const char *dev_name, int state),
  53
  54         TP_ARGS(dev_name, state),
  55
  56         TP_STRUCT__entry(
  57                 __string(dev_name, dev_name)
  58                 __field(int, state)
  59         ),
  60
  61         TP_fast_assign(
  62                 __assign_str(dev_name, dev_name);
  63                 __entry->state = state;
  64         ),
  65
  66         TP_printk("%s: gating state changed to %s",
  67                 __get_str(dev_name),
  68                 __print_symbolic(__entry->state, UFSCHD_CLK_GATING_STATES))
  69 );
  70
  71 TRACE_EVENT(ufshcd_clk_scaling,
  72
  73         TP_PROTO(const char *dev_name, const char *state, const char *clk,
  74                 u32 prev_state, u32 curr_state),
  75
  76         TP_ARGS(dev_name, state, clk, prev_state, curr_state),
  77
  78         TP_STRUCT__entry(
  79                 __string(dev_name, dev_name)
  80                 __string(state, state)
  81                 __string(clk, clk)
  82                 __field(u32, prev_state)
  83                 __field(u32, curr_state)
  84         ),
  85
  86         TP_fast_assign(
  87                 __assign_str(dev_name, dev_name);
  88                 __assign_str(state, state);
  89                 __assign_str(clk, clk);
  90                 __entry->prev_state = prev_state;
  91                 __entry->curr_state = curr_state;
  92         ),
  93
  94         TP_printk("%s: %s %s from %u to %u Hz",
  95                 __get_str(dev_name), __get_str(state), __get_str(clk),
  96                 __entry->prev_state, __entry->curr_state)
  97 );
  98
  99 TRACE_EVENT(ufshcd_auto_bkops_state,
 100
 101         TP_PROTO(const char *dev_name, const char *state),
 102
 103         TP_ARGS(dev_name, state),
 104
 105         TP_STRUCT__entry(
 106                 __string(dev_name, dev_name)
 107                 __string(state, state)
 108         ),
 109
 110         TP_fast_assign(
 111                 __assign_str(dev_name, dev_name);
 112                 __assign_str(state, state);
 113         ),
 114
 115         TP_printk("%s: auto bkops - %s",
 116                 __get_str(dev_name), __get_str(state))
 117 );
 118
 119 DECLARE_EVENT_CLASS(ufshcd_profiling_template,
 120         TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
 121                  int err),
 122
 123         TP_ARGS(dev_name, profile_info, time_us, err),
 124
 125         TP_STRUCT__entry(
 126                 __string(dev_name, dev_name)
 127                 __string(profile_info, profile_info)
 128                 __field(s64, time_us)
 129                 __field(int, err)
 130         ),
 131
 132         TP_fast_assign(
 133                 __assign_str(dev_name, dev_name);
 134                 __assign_str(profile_info, profile_info);
 135                 __entry->time_us = time_us;
 136                 __entry->err = err;
 137         ),
 138
 139         TP_printk("%s: %s: took %lld usecs, err %d",
 140                 __get_str(dev_name), __get_str(profile_info),
 141                 __entry->time_us, __entry->err)
 142 );
 143
 144 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_hibern8,
 145         TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
 146                  int err),
 147         TP_ARGS(dev_name, profile_info, time_us, err));
 148
 149 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_clk_gating,
 150         TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
 151                  int err),
 152         TP_ARGS(dev_name, profile_info, time_us, err));
 153
 154 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_clk_scaling,
 155         TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
 156                  int err),
 157         TP_ARGS(dev_name, profile_info, time_us, err));
 158
 159 DECLARE_EVENT_CLASS(ufshcd_template,
 160         TP_PROTO(const char *dev_name, int err, s64 usecs,
 161                  int dev_state, int link_state),
 162
 163         TP_ARGS(dev_name, err, usecs, dev_state, link_state),
 164
 165         TP_STRUCT__entry(
 166                 __field(s64, usecs)
 167                 __field(int, err)
 168                 __string(dev_name, dev_name)
 169                 __field(int, dev_state)
 170                 __field(int, link_state)
 171         ),
 172
 173         TP_fast_assign(
 174                 __entry->usecs = usecs;
 175                 __entry->err = err;
 176                 __assign_str(dev_name, dev_name);
 177                 __entry->dev_state = dev_state;
 178                 __entry->link_state = link_state;
 179         ),
 180
 181         TP_printk(
 182                 "%s: took %lld usecs, dev_state: %s, link_state: %s, err %d",
 183                 __get_str(dev_name),
 184                 __entry->usecs,
 185                 __print_symbolic(__entry->dev_state, UFS_PWR_MODES),
 186                 __print_symbolic(__entry->link_state, UFS_LINK_STATES),
 187                 __entry->err
 188         )
 189 );
 190
 191 DEFINE_EVENT(ufshcd_template, ufshcd_system_suspend,
 192              TP_PROTO(const char *dev_name, int err, s64 usecs,
 193                       int dev_state, int link_state),
 194              TP_ARGS(dev_name, err, usecs, dev_state, link_state));
 195
 196 DEFINE_EVENT(ufshcd_template, ufshcd_system_resume,
 197              TP_PROTO(const char *dev_name, int err, s64 usecs,
 198                       int dev_state, int link_state),
 199              TP_ARGS(dev_name, err, usecs, dev_state, link_state));
 200
 201 DEFINE_EVENT(ufshcd_template, ufshcd_runtime_suspend,
 202              TP_PROTO(const char *dev_name, int err, s64 usecs,
 203                       int dev_state, int link_state),
 204              TP_ARGS(dev_name, err, usecs, dev_state, link_state));
 205
 206 DEFINE_EVENT(ufshcd_template, ufshcd_runtime_resume,
 207              TP_PROTO(const char *dev_name, int err, s64 usecs,
 208                       int dev_state, int link_state),
 209              TP_ARGS(dev_name, err, usecs, dev_state, link_state));
 210
 211 DEFINE_EVENT(ufshcd_template, ufshcd_init,
 212              TP_PROTO(const char *dev_name, int err, s64 usecs,
 213                       int dev_state, int link_state),
 214              TP_ARGS(dev_name, err, usecs, dev_state, link_state));
 215
 216 TRACE_EVENT(ufshcd_command,
 217         TP_PROTO(const char *dev_name, const char *str, unsigned int tag,
 218                         u32 doorbell, int transfer_len, u32 intr, u64 lba,
 219                         u8 opcode),
 220
 221         TP_ARGS(dev_name, str, tag, doorbell, transfer_len, intr, lba, opcode),
 222
 223         TP_STRUCT__entry(
 224                 __string(dev_name, dev_name)
 225                 __string(str, str)
 226                 __field(unsigned int, tag)
 227                 __field(u32, doorbell)
 228                 __field(int, transfer_len)
 229                 __field(u32, intr)
 230                 __field(u64, lba)
 231                 __field(u8, opcode)
 232         ),
 233
 234         TP_fast_assign(
 235                 __assign_str(dev_name, dev_name);
 236                 __assign_str(str, str);
 237                 __entry->tag = tag;
 238                 __entry->doorbell = doorbell;
 239                 __entry->transfer_len = transfer_len;
 240                 __entry->intr = intr;
 241                 __entry->lba = lba;
 242                 __entry->opcode = opcode;
 243         ),
 244
 245         TP_printk(
 246                 "%s: %s: tag: %u, DB: 0x%x, size: %d, IS: %u, LBA: %llu, opcode: 0x%x",
 247                 __get_str(str), __get_str(dev_name), __entry->tag,
 248                 __entry->doorbell, __entry->transfer_len,
 249                 __entry->intr, __entry->lba, (u32)__entry->opcode
 250         )
 251 );
 252
 253 TRACE_EVENT(ufshcd_uic_command,
 254         TP_PROTO(const char *dev_name, const char *str, u32 cmd,
 255                  u32 arg1, u32 arg2, u32 arg3),
 256
 257         TP_ARGS(dev_name, str, cmd, arg1, arg2, arg3),
 258
 259         TP_STRUCT__entry(
 260                 __string(dev_name, dev_name)
 261                 __string(str, str)
 262                 __field(u32, cmd)
 263                 __field(u32, arg1)
 264                 __field(u32, arg2)
 265                 __field(u32, arg3)
 266         ),
 267
 268         TP_fast_assign(
 269                 __assign_str(dev_name, dev_name);
 270                 __assign_str(str, str);
 271                 __entry->cmd = cmd;
 272                 __entry->arg1 = arg1;
 273                 __entry->arg2 = arg2;
 274                 __entry->arg3 = arg3;
 275         ),
 276
 277         TP_printk(
 278                 "%s: %s: cmd: 0x%x, arg1: 0x%x, arg2: 0x%x, arg3: 0x%x",
 279                 __get_str(str), __get_str(dev_name), __entry->cmd,
 280                 __entry->arg1, __entry->arg2, __entry->arg3
 281         )
 282 );
 283
 284 TRACE_EVENT(ufshcd_upiu,
 285         TP_PROTO(const char *dev_name, const char *str, void *hdr, void *tsf),
 286
 287         TP_ARGS(dev_name, str, hdr, tsf),
 288
 289         TP_STRUCT__entry(
 290                 __string(dev_name, dev_name)
 291                 __string(str, str)
 292                 __array(unsigned char, hdr, 12)
 293                 __array(unsigned char, tsf, 16)
 294         ),
 295
 296         TP_fast_assign(
 297                 __assign_str(dev_name, dev_name);
 298                 __assign_str(str, str);
 299                 memcpy(__entry->hdr, hdr, sizeof(__entry->hdr));
 300                 memcpy(__entry->tsf, tsf, sizeof(__entry->tsf));
 301         ),
 302
 303         TP_printk(
 304                 "%s: %s: HDR:%s, CDB:%s",
 305                 __get_str(str), __get_str(dev_name),
 306                 __print_hex(__entry->hdr, sizeof(__entry->hdr)),
 307                 __print_hex(__entry->tsf, sizeof(__entry->tsf))
 308         )
 309 );
 310
 311 #endif /* if !defined(_TRACE_UFS_H) || defined(TRACE_HEADER_MULTI_READ) */
 312
 313 /* This part must be outside protection */
 314 #include <trace/define_trace.h>