Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-only */
0002 /*
0003  * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
0004  */
0005 
0006 #undef TRACE_SYSTEM
0007 #define TRACE_SYSTEM ufs
0008 
0009 #if !defined(_TRACE_UFS_H) || defined(TRACE_HEADER_MULTI_READ)
0010 #define _TRACE_UFS_H
0011 
0012 #include <linux/tracepoint.h>
0013 
0014 #define str_opcode(opcode)                      \
0015     __print_symbolic(opcode,                    \
0016         { WRITE_16,     "WRITE_16" },           \
0017         { WRITE_10,     "WRITE_10" },           \
0018         { READ_16,      "READ_16" },            \
0019         { READ_10,      "READ_10" },            \
0020         { SYNCHRONIZE_CACHE,    "SYNC" },           \
0021         { UNMAP,        "UNMAP" })
0022 
0023 #define UFS_LINK_STATES                     \
0024     EM(UIC_LINK_OFF_STATE,      "UIC_LINK_OFF_STATE")       \
0025     EM(UIC_LINK_ACTIVE_STATE,   "UIC_LINK_ACTIVE_STATE")    \
0026     EMe(UIC_LINK_HIBERN8_STATE, "UIC_LINK_HIBERN8_STATE")
0027 
0028 #define UFS_PWR_MODES                           \
0029     EM(UFS_ACTIVE_PWR_MODE,     "UFS_ACTIVE_PWR_MODE")      \
0030     EM(UFS_SLEEP_PWR_MODE,      "UFS_SLEEP_PWR_MODE")       \
0031     EM(UFS_POWERDOWN_PWR_MODE,  "UFS_POWERDOWN_PWR_MODE")   \
0032     EMe(UFS_DEEPSLEEP_PWR_MODE, "UFS_DEEPSLEEP_PWR_MODE")
0033 
0034 #define UFSCHD_CLK_GATING_STATES                \
0035     EM(CLKS_OFF,            "CLKS_OFF")     \
0036     EM(CLKS_ON,         "CLKS_ON")      \
0037     EM(REQ_CLKS_OFF,        "REQ_CLKS_OFF")     \
0038     EMe(REQ_CLKS_ON,        "REQ_CLKS_ON")
0039 
0040 #define UFS_CMD_TRACE_STRINGS                   \
0041     EM(UFS_CMD_SEND,    "send_req")         \
0042     EM(UFS_CMD_COMP,    "complete_rsp")         \
0043     EM(UFS_DEV_COMP,    "dev_complete")         \
0044     EM(UFS_QUERY_SEND,  "query_send")           \
0045     EM(UFS_QUERY_COMP,  "query_complete")       \
0046     EM(UFS_QUERY_ERR,   "query_complete_err")       \
0047     EM(UFS_TM_SEND,     "tm_send")          \
0048     EM(UFS_TM_COMP,     "tm_complete")          \
0049     EMe(UFS_TM_ERR,     "tm_complete_err")
0050 
0051 #define UFS_CMD_TRACE_TSF_TYPES                 \
0052     EM(UFS_TSF_CDB,     "CDB")                      \
0053     EM(UFS_TSF_OSF,     "OSF")                      \
0054     EM(UFS_TSF_TM_INPUT,    "TM_INPUT")                     \
0055     EMe(UFS_TSF_TM_OUTPUT,  "TM_OUTPUT")
0056 
0057 /* Enums require being exported to userspace, for user tool parsing */
0058 #undef EM
0059 #undef EMe
0060 #define EM(a, b)    TRACE_DEFINE_ENUM(a);
0061 #define EMe(a, b)   TRACE_DEFINE_ENUM(a);
0062 
0063 UFS_LINK_STATES;
0064 UFS_PWR_MODES;
0065 UFSCHD_CLK_GATING_STATES;
0066 UFS_CMD_TRACE_STRINGS
0067 UFS_CMD_TRACE_TSF_TYPES
0068 
0069 /*
0070  * Now redefine the EM() and EMe() macros to map the enums to the strings
0071  * that will be printed in the output.
0072  */
0073 #undef EM
0074 #undef EMe
0075 #define EM(a, b)    {a, b},
0076 #define EMe(a, b)   {a, b}
0077 
0078 #define show_ufs_cmd_trace_str(str_t)   \
0079                 __print_symbolic(str_t, UFS_CMD_TRACE_STRINGS)
0080 #define show_ufs_cmd_trace_tsf(tsf) \
0081                 __print_symbolic(tsf, UFS_CMD_TRACE_TSF_TYPES)
0082 
0083 TRACE_EVENT(ufshcd_clk_gating,
0084 
0085     TP_PROTO(const char *dev_name, int state),
0086 
0087     TP_ARGS(dev_name, state),
0088 
0089     TP_STRUCT__entry(
0090         __string(dev_name, dev_name)
0091         __field(int, state)
0092     ),
0093 
0094     TP_fast_assign(
0095         __assign_str(dev_name, dev_name);
0096         __entry->state = state;
0097     ),
0098 
0099     TP_printk("%s: gating state changed to %s",
0100         __get_str(dev_name),
0101         __print_symbolic(__entry->state, UFSCHD_CLK_GATING_STATES))
0102 );
0103 
0104 TRACE_EVENT(ufshcd_clk_scaling,
0105 
0106     TP_PROTO(const char *dev_name, const char *state, const char *clk,
0107         u32 prev_state, u32 curr_state),
0108 
0109     TP_ARGS(dev_name, state, clk, prev_state, curr_state),
0110 
0111     TP_STRUCT__entry(
0112         __string(dev_name, dev_name)
0113         __string(state, state)
0114         __string(clk, clk)
0115         __field(u32, prev_state)
0116         __field(u32, curr_state)
0117     ),
0118 
0119     TP_fast_assign(
0120         __assign_str(dev_name, dev_name);
0121         __assign_str(state, state);
0122         __assign_str(clk, clk);
0123         __entry->prev_state = prev_state;
0124         __entry->curr_state = curr_state;
0125     ),
0126 
0127     TP_printk("%s: %s %s from %u to %u Hz",
0128         __get_str(dev_name), __get_str(state), __get_str(clk),
0129         __entry->prev_state, __entry->curr_state)
0130 );
0131 
0132 TRACE_EVENT(ufshcd_auto_bkops_state,
0133 
0134     TP_PROTO(const char *dev_name, const char *state),
0135 
0136     TP_ARGS(dev_name, state),
0137 
0138     TP_STRUCT__entry(
0139         __string(dev_name, dev_name)
0140         __string(state, state)
0141     ),
0142 
0143     TP_fast_assign(
0144         __assign_str(dev_name, dev_name);
0145         __assign_str(state, state);
0146     ),
0147 
0148     TP_printk("%s: auto bkops - %s",
0149         __get_str(dev_name), __get_str(state))
0150 );
0151 
0152 DECLARE_EVENT_CLASS(ufshcd_profiling_template,
0153     TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
0154          int err),
0155 
0156     TP_ARGS(dev_name, profile_info, time_us, err),
0157 
0158     TP_STRUCT__entry(
0159         __string(dev_name, dev_name)
0160         __string(profile_info, profile_info)
0161         __field(s64, time_us)
0162         __field(int, err)
0163     ),
0164 
0165     TP_fast_assign(
0166         __assign_str(dev_name, dev_name);
0167         __assign_str(profile_info, profile_info);
0168         __entry->time_us = time_us;
0169         __entry->err = err;
0170     ),
0171 
0172     TP_printk("%s: %s: took %lld usecs, err %d",
0173         __get_str(dev_name), __get_str(profile_info),
0174         __entry->time_us, __entry->err)
0175 );
0176 
0177 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_hibern8,
0178     TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
0179          int err),
0180     TP_ARGS(dev_name, profile_info, time_us, err));
0181 
0182 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_clk_gating,
0183     TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
0184          int err),
0185     TP_ARGS(dev_name, profile_info, time_us, err));
0186 
0187 DEFINE_EVENT(ufshcd_profiling_template, ufshcd_profile_clk_scaling,
0188     TP_PROTO(const char *dev_name, const char *profile_info, s64 time_us,
0189          int err),
0190     TP_ARGS(dev_name, profile_info, time_us, err));
0191 
0192 DECLARE_EVENT_CLASS(ufshcd_template,
0193     TP_PROTO(const char *dev_name, int err, s64 usecs,
0194          int dev_state, int link_state),
0195 
0196     TP_ARGS(dev_name, err, usecs, dev_state, link_state),
0197 
0198     TP_STRUCT__entry(
0199         __field(s64, usecs)
0200         __field(int, err)
0201         __string(dev_name, dev_name)
0202         __field(int, dev_state)
0203         __field(int, link_state)
0204     ),
0205 
0206     TP_fast_assign(
0207         __entry->usecs = usecs;
0208         __entry->err = err;
0209         __assign_str(dev_name, dev_name);
0210         __entry->dev_state = dev_state;
0211         __entry->link_state = link_state;
0212     ),
0213 
0214     TP_printk(
0215         "%s: took %lld usecs, dev_state: %s, link_state: %s, err %d",
0216         __get_str(dev_name),
0217         __entry->usecs,
0218         __print_symbolic(__entry->dev_state, UFS_PWR_MODES),
0219         __print_symbolic(__entry->link_state, UFS_LINK_STATES),
0220         __entry->err
0221     )
0222 );
0223 
0224 DEFINE_EVENT(ufshcd_template, ufshcd_system_suspend,
0225          TP_PROTO(const char *dev_name, int err, s64 usecs,
0226               int dev_state, int link_state),
0227          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0228 
0229 DEFINE_EVENT(ufshcd_template, ufshcd_system_resume,
0230          TP_PROTO(const char *dev_name, int err, s64 usecs,
0231               int dev_state, int link_state),
0232          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0233 
0234 DEFINE_EVENT(ufshcd_template, ufshcd_runtime_suspend,
0235          TP_PROTO(const char *dev_name, int err, s64 usecs,
0236               int dev_state, int link_state),
0237          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0238 
0239 DEFINE_EVENT(ufshcd_template, ufshcd_runtime_resume,
0240          TP_PROTO(const char *dev_name, int err, s64 usecs,
0241               int dev_state, int link_state),
0242          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0243 
0244 DEFINE_EVENT(ufshcd_template, ufshcd_init,
0245          TP_PROTO(const char *dev_name, int err, s64 usecs,
0246               int dev_state, int link_state),
0247          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0248 
0249 DEFINE_EVENT(ufshcd_template, ufshcd_wl_suspend,
0250          TP_PROTO(const char *dev_name, int err, s64 usecs,
0251               int dev_state, int link_state),
0252          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0253 
0254 DEFINE_EVENT(ufshcd_template, ufshcd_wl_resume,
0255          TP_PROTO(const char *dev_name, int err, s64 usecs,
0256               int dev_state, int link_state),
0257          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0258 
0259 DEFINE_EVENT(ufshcd_template, ufshcd_wl_runtime_suspend,
0260          TP_PROTO(const char *dev_name, int err, s64 usecs,
0261               int dev_state, int link_state),
0262          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0263 
0264 DEFINE_EVENT(ufshcd_template, ufshcd_wl_runtime_resume,
0265          TP_PROTO(const char *dev_name, int err, s64 usecs,
0266               int dev_state, int link_state),
0267          TP_ARGS(dev_name, err, usecs, dev_state, link_state));
0268 
0269 TRACE_EVENT(ufshcd_command,
0270     TP_PROTO(const char *dev_name, enum ufs_trace_str_t str_t,
0271          unsigned int tag, u32 doorbell, int transfer_len, u32 intr,
0272          u64 lba, u8 opcode, u8 group_id),
0273 
0274     TP_ARGS(dev_name, str_t, tag, doorbell, transfer_len,
0275                 intr, lba, opcode, group_id),
0276 
0277     TP_STRUCT__entry(
0278         __string(dev_name, dev_name)
0279         __field(enum ufs_trace_str_t, str_t)
0280         __field(unsigned int, tag)
0281         __field(u32, doorbell)
0282         __field(int, transfer_len)
0283         __field(u32, intr)
0284         __field(u64, lba)
0285         __field(u8, opcode)
0286         __field(u8, group_id)
0287     ),
0288 
0289     TP_fast_assign(
0290         __assign_str(dev_name, dev_name);
0291         __entry->str_t = str_t;
0292         __entry->tag = tag;
0293         __entry->doorbell = doorbell;
0294         __entry->transfer_len = transfer_len;
0295         __entry->intr = intr;
0296         __entry->lba = lba;
0297         __entry->opcode = opcode;
0298         __entry->group_id = group_id;
0299     ),
0300 
0301     TP_printk(
0302         "%s: %s: tag: %u, DB: 0x%x, size: %d, IS: %u, LBA: %llu, opcode: 0x%x (%s), group_id: 0x%x",
0303         show_ufs_cmd_trace_str(__entry->str_t), __get_str(dev_name),
0304         __entry->tag, __entry->doorbell, __entry->transfer_len,
0305         __entry->intr, __entry->lba, (u32)__entry->opcode,
0306         str_opcode(__entry->opcode), (u32)__entry->group_id
0307     )
0308 );
0309 
0310 TRACE_EVENT(ufshcd_uic_command,
0311     TP_PROTO(const char *dev_name, enum ufs_trace_str_t str_t, u32 cmd,
0312          u32 arg1, u32 arg2, u32 arg3),
0313 
0314     TP_ARGS(dev_name, str_t, cmd, arg1, arg2, arg3),
0315 
0316     TP_STRUCT__entry(
0317         __string(dev_name, dev_name)
0318         __field(enum ufs_trace_str_t, str_t)
0319         __field(u32, cmd)
0320         __field(u32, arg1)
0321         __field(u32, arg2)
0322         __field(u32, arg3)
0323     ),
0324 
0325     TP_fast_assign(
0326         __assign_str(dev_name, dev_name);
0327         __entry->str_t = str_t;
0328         __entry->cmd = cmd;
0329         __entry->arg1 = arg1;
0330         __entry->arg2 = arg2;
0331         __entry->arg3 = arg3;
0332     ),
0333 
0334     TP_printk(
0335         "%s: %s: cmd: 0x%x, arg1: 0x%x, arg2: 0x%x, arg3: 0x%x",
0336         show_ufs_cmd_trace_str(__entry->str_t), __get_str(dev_name),
0337         __entry->cmd, __entry->arg1, __entry->arg2, __entry->arg3
0338     )
0339 );
0340 
0341 TRACE_EVENT(ufshcd_upiu,
0342     TP_PROTO(const char *dev_name, enum ufs_trace_str_t str_t, void *hdr,
0343          void *tsf, enum ufs_trace_tsf_t tsf_t),
0344 
0345     TP_ARGS(dev_name, str_t, hdr, tsf, tsf_t),
0346 
0347     TP_STRUCT__entry(
0348         __string(dev_name, dev_name)
0349         __field(enum ufs_trace_str_t, str_t)
0350         __array(unsigned char, hdr, 12)
0351         __array(unsigned char, tsf, 16)
0352         __field(enum ufs_trace_tsf_t, tsf_t)
0353     ),
0354 
0355     TP_fast_assign(
0356         __assign_str(dev_name, dev_name);
0357         __entry->str_t = str_t;
0358         memcpy(__entry->hdr, hdr, sizeof(__entry->hdr));
0359         memcpy(__entry->tsf, tsf, sizeof(__entry->tsf));
0360         __entry->tsf_t = tsf_t;
0361     ),
0362 
0363     TP_printk(
0364         "%s: %s: HDR:%s, %s:%s",
0365         show_ufs_cmd_trace_str(__entry->str_t), __get_str(dev_name),
0366         __print_hex(__entry->hdr, sizeof(__entry->hdr)),
0367         show_ufs_cmd_trace_tsf(__entry->tsf_t),
0368         __print_hex(__entry->tsf, sizeof(__entry->tsf))
0369     )
0370 );
0371 
0372 TRACE_EVENT(ufshcd_exception_event,
0373 
0374     TP_PROTO(const char *dev_name, u16 status),
0375 
0376     TP_ARGS(dev_name, status),
0377 
0378     TP_STRUCT__entry(
0379         __string(dev_name, dev_name)
0380         __field(u16, status)
0381     ),
0382 
0383     TP_fast_assign(
0384         __assign_str(dev_name, dev_name);
0385         __entry->status = status;
0386     ),
0387 
0388     TP_printk("%s: status 0x%x",
0389         __get_str(dev_name), __entry->status
0390     )
0391 );
0392 
0393 #endif /* if !defined(_TRACE_UFS_H) || defined(TRACE_HEADER_MULTI_READ) */
0394 
0395 /* This part must be outside protection */
0396 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!