Quelle  trace.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM mhi_host

#if !defined(_TRACE_EVENT_MHI_HOST_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_EVENT_MHI_HOST_H

#include <linux/byteorder/generic.h>
#include <linux/tracepoint.h>
#include <linux/trace_seq.h>
#include "../common.h"
#include "internal.h"

#undef mhi_state
#undef mhi_state_end

#define mhi_state(a, b)  TRACE_DEFINE_ENUM(MHI_STATE_##a);
#define mhi_state_end(a, b) TRACE_DEFINE_ENUM(MHI_STATE_##a);

MHI_STATE_LIST

#undef mhi_state
#undef mhi_state_end

#define mhi_state(a, b)  { MHI_STATE_##a, b },
#define mhi_state_end(a, b) { MHI_STATE_##a, b }

#undef mhi_pm_state
#undef mhi_pm_state_end

#define mhi_pm_state(a, b)  TRACE_DEFINE_ENUM(MHI_PM_STATE_##a);
#define mhi_pm_state_end(a, b)  TRACE_DEFINE_ENUM(MHI_PM_STATE_##a);

MHI_PM_STATE_LIST

#undef mhi_pm_state
#undef mhi_pm_state_end

#define mhi_pm_state(a, b)  { MHI_PM_STATE_##a, b },
#define mhi_pm_state_end(a, b)  { MHI_PM_STATE_##a, b }

#undef mhi_ee
#undef mhi_ee_end

#define mhi_ee(a, b)   TRACE_DEFINE_ENUM(MHI_EE_##a);
#define mhi_ee_end(a, b)  TRACE_DEFINE_ENUM(MHI_EE_##a);

MHI_EE_LIST

#undef mhi_ee
#undef mhi_ee_end

#define mhi_ee(a, b)   { MHI_EE_##a, b },
#define mhi_ee_end(a, b)  { MHI_EE_##a, b }

#undef ch_state_type
#undef ch_state_type_end

#define ch_state_type(a, b)  TRACE_DEFINE_ENUM(MHI_CH_STATE_TYPE_##a);
#define ch_state_type_end(a, b)  TRACE_DEFINE_ENUM(MHI_CH_STATE_TYPE_##a);

MHI_CH_STATE_TYPE_LIST

#undef ch_state_type
#undef ch_state_type_end

#define ch_state_type(a, b)  { MHI_CH_STATE_TYPE_##a, b },
#define ch_state_type_end(a, b)  { MHI_CH_STATE_TYPE_##a, b }

#undef dev_st_trans
#undef dev_st_trans_end

#define dev_st_trans(a, b)  TRACE_DEFINE_ENUM(DEV_ST_TRANSITION_##a);
#define dev_st_trans_end(a, b)  TRACE_DEFINE_ENUM(DEV_ST_TRANSITION_##a);

DEV_ST_TRANSITION_LIST

#undef dev_st_trans
#undef dev_st_trans_end

#define dev_st_trans(a, b)  { DEV_ST_TRANSITION_##a, b },
#define dev_st_trans_end(a, b)  { DEV_ST_TRANSITION_##a, b }

#define TPS(x) tracepoint_string(x)

TRACE_EVENT(mhi_gen_tre,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan,
   struct mhi_ring_element *mhi_tre),

 TP_ARGS(mhi_cntrl, mhi_chan, mhi_tre),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(int, ch_num)
  __field(void *, wp)
  __field(uint64_t, tre_ptr)
  __field(uint32_t, dword0)
  __field(uint32_t, dword1)
 ),

 TP_fast_assign(
  __assign_str(name);
  __entry->ch_num = mhi_chan->chan;
  __entry->wp = mhi_tre;
  __entry->tre_ptr = le64_to_cpu(mhi_tre->ptr);
  __entry->dword0 = le32_to_cpu(mhi_tre->dword[0]);
  __entry->dword1 = le32_to_cpu(mhi_tre->dword[1]);
 ),

 TP_printk("%s: Chan: %d TRE: 0x%p TRE buf: 0x%llx DWORD0: 0x%08x DWORD1: 0x%08x\n",
    __get_str(name), __entry->ch_num, __entry->wp, __entry->tre_ptr,
    __entry->dword0, __entry->dword1)
);

TRACE_EVENT(mhi_intvec_states,

 TP_PROTO(struct mhi_controller *mhi_cntrl, int dev_ee, int dev_state),

 TP_ARGS(mhi_cntrl, dev_ee, dev_state),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(int, local_ee)
  __field(int, state)
  __field(int, dev_ee)
  __field(int, dev_state)
 ),

 TP_fast_assign(
  __assign_str(name);
  __entry->local_ee = mhi_cntrl->ee;
  __entry->state = mhi_cntrl->dev_state;
  __entry->dev_ee = dev_ee;
  __entry->dev_state = dev_state;
 ),

 TP_printk("%s: Local EE: %s State: %s Device EE: %s Dev State: %s\n",
    __get_str(name),
    __print_symbolic(__entry->local_ee, MHI_EE_LIST),
    __print_symbolic(__entry->state, MHI_STATE_LIST),
    __print_symbolic(__entry->dev_ee, MHI_EE_LIST),
    __print_symbolic(__entry->dev_state, MHI_STATE_LIST))
);

TRACE_EVENT(mhi_tryset_pm_state,

 TP_PROTO(struct mhi_controller *mhi_cntrl, int pm_state),

 TP_ARGS(mhi_cntrl, pm_state),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(int, pm_state)
 ),

 TP_fast_assign(
  __assign_str(name);
  if (pm_state)
   pm_state = __fls(pm_state);
  __entry->pm_state = pm_state;
 ),

 TP_printk("%s: PM state: %s\n", __get_str(name),
    __print_symbolic(__entry->pm_state, MHI_PM_STATE_LIST))
);

DECLARE_EVENT_CLASS(mhi_process_event_ring,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),

 TP_ARGS(mhi_cntrl, rp),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(uint32_t, dword0)
  __field(uint32_t, dword1)
  __field(int, state)
  __field(uint64_t, ptr)
  __field(void *, rp)
 ),

 TP_fast_assign(
  __assign_str(name);
  __entry->rp = rp;
  __entry->ptr = le64_to_cpu(rp->ptr);
  __entry->dword0 = le32_to_cpu(rp->dword[0]);
  __entry->dword1 = le32_to_cpu(rp->dword[1]);
  __entry->state = MHI_TRE_GET_EV_STATE(rp);
 ),

 TP_printk("%s: TRE: 0x%p TRE buf: 0x%llx DWORD0: 0x%08x DWORD1: 0x%08x State: %s\n",
    __get_str(name), __entry->rp, __entry->ptr, __entry->dword0,
    __entry->dword1, __print_symbolic(__entry->state, MHI_STATE_LIST))
);

DEFINE_EVENT(mhi_process_event_ring, mhi_data_event,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),

 TP_ARGS(mhi_cntrl, rp)
);

DEFINE_EVENT(mhi_process_event_ring, mhi_ctrl_event,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),

 TP_ARGS(mhi_cntrl, rp)
);

DECLARE_EVENT_CLASS(mhi_update_channel_state,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
   const char *reason),

 TP_ARGS(mhi_cntrl, mhi_chan, state, reason),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(int, ch_num)
  __field(int, state)
  __field(const char *, reason)
 ),

 TP_fast_assign(
  __assign_str(name);
  __entry->ch_num = mhi_chan->chan;
  __entry->state = state;
  __entry->reason = reason;
 ),

 TP_printk("%s: chan%d: %s state to: %s\n",
    __get_str(name),  __entry->ch_num, __entry->reason,
    __print_symbolic(__entry->state, MHI_CH_STATE_TYPE_LIST))
);

DEFINE_EVENT(mhi_update_channel_state, mhi_channel_command_start,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
   const char *reason),

 TP_ARGS(mhi_cntrl, mhi_chan, state, reason)
);

DEFINE_EVENT(mhi_update_channel_state, mhi_channel_command_end,

 TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
   const char *reason),

 TP_ARGS(mhi_cntrl, mhi_chan, state, reason)
);

TRACE_EVENT(mhi_pm_st_transition,

 TP_PROTO(struct mhi_controller *mhi_cntrl, int state),

 TP_ARGS(mhi_cntrl, state),

 TP_STRUCT__entry(
  __string(name, mhi_cntrl->mhi_dev->name)
  __field(int, state)
 ),

 TP_fast_assign(
  __assign_str(name);
  __entry->state = state;
 ),

 TP_printk("%s: Handling state transition: %s\n", __get_str(name),
    __print_symbolic(__entry->state, DEV_ST_TRANSITION_LIST))
);

#endif
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH ../../drivers/bus/mhi/host
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE trace

#include <trace/define_trace.h>