rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/wifi_driver/aic8800/aic8800_fdrv/rwnx_events.h

1327 lines
34 KiB
C
Raw Normal View History

initial
2024-06-22 08:45:49 -04:00
/**
******************************************************************************
*
* @file rwnx_events.h
*
* @brief Trace events definition
*
* Copyright (C) RivieraWaves 2012-2019
*
******************************************************************************
*/
#undef TRACE_SYSTEM
#define TRACE_SYSTEM rwnx
#if !defined(_RWNX_EVENTS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _RWNX_EVENTS_H
#include <linux/tracepoint.h>
#ifndef CONFIG_RWNX_FHOST
#include "rwnx_tx.h"
#endif
#include "rwnx_compat.h"
/*****************************************************************************
* TRACE function for MGMT TX (FULLMAC)
****************************************************************************/
#ifdef CONFIG_RWNX_FULLMAC
#include "linux/ieee80211.h"
#if defined(CONFIG_TRACEPOINTS) && defined(CREATE_TRACE_POINTS)
#include <linux/trace_seq.h>
/* P2P Public Action Frames Definitions (see WiFi P2P Technical Specification, section 4.2.8) */
/* IEEE 802.11 Public Action Usage Category - Define P2P public action frames */
#define MGMT_ACTION_PUBLIC_CAT (0x04)
/* Offset of OUI Subtype field in P2P Action Frame format */
#define MGMT_ACTION_OUI_SUBTYPE_OFFSET (6)
/* P2P Public Action Frame Types */
enum p2p_action_type {
P2P_ACTION_GO_NEG_REQ = 0, /* GO Negociation Request */
P2P_ACTION_GO_NEG_RSP, /* GO Negociation Response */
P2P_ACTION_GO_NEG_CFM, /* GO Negociation Confirmation */
P2P_ACTION_INVIT_REQ, /* P2P Invitation Request */
P2P_ACTION_INVIT_RSP, /* P2P Invitation Response */
P2P_ACTION_DEV_DISC_REQ, /* Device Discoverability Request */
P2P_ACTION_DEV_DISC_RSP, /* Device Discoverability Response */
P2P_ACTION_PROV_DISC_REQ, /* Provision Discovery Request */
P2P_ACTION_PROV_DISC_RSP, /* Provision Discovery Response */
};
const char *ftrace_print_mgmt_info(struct trace_seq *p, u16 frame_control, u8 cat, u8 type, u8 p2p)
{
const char *ret = trace_seq_buffer_ptr(p);
switch (frame_control & IEEE80211_FCTL_STYPE) {
case (IEEE80211_STYPE_ASSOC_REQ):
trace_seq_printf(p, "Association Request");
break;
case (IEEE80211_STYPE_ASSOC_RESP):
trace_seq_printf(p, "Association Response");
break;
case (IEEE80211_STYPE_REASSOC_REQ):
trace_seq_printf(p, "Reassociation Request");
break;
case (IEEE80211_STYPE_REASSOC_RESP):
trace_seq_printf(p, "Reassociation Response");
break;
case (IEEE80211_STYPE_PROBE_REQ):
trace_seq_printf(p, "Probe Request");
break;
case (IEEE80211_STYPE_PROBE_RESP):
trace_seq_printf(p, "Probe Response");
break;
case (IEEE80211_STYPE_BEACON):
trace_seq_printf(p, "Beacon");
break;
case (IEEE80211_STYPE_ATIM):
trace_seq_printf(p, "ATIM");
break;
case (IEEE80211_STYPE_DISASSOC):
trace_seq_printf(p, "Disassociation");
break;
case (IEEE80211_STYPE_AUTH):
trace_seq_printf(p, "Authentication");
break;
case (IEEE80211_STYPE_DEAUTH):
trace_seq_printf(p, "Deauthentication");
break;
case (IEEE80211_STYPE_ACTION):
trace_seq_printf(p, "Action");
if (cat == MGMT_ACTION_PUBLIC_CAT && type == 0x9) {
switch (p2p) {
case (P2P_ACTION_GO_NEG_REQ):
trace_seq_printf(p, ": GO Negociation Request");
break;
case (P2P_ACTION_GO_NEG_RSP):
trace_seq_printf(p, ": GO Negociation Response");
break;
case (P2P_ACTION_GO_NEG_CFM):
trace_seq_printf(p, ": GO Negociation Confirmation");
break;
case (P2P_ACTION_INVIT_REQ):
trace_seq_printf(p, ": P2P Invitation Request");
break;
case (P2P_ACTION_INVIT_RSP):
trace_seq_printf(p, ": P2P Invitation Response");
break;
case (P2P_ACTION_DEV_DISC_REQ):
trace_seq_printf(p, ": Device Discoverability Request");
break;
case (P2P_ACTION_DEV_DISC_RSP):
trace_seq_printf(p, ": Device Discoverability Response");
break;
case (P2P_ACTION_PROV_DISC_REQ):
trace_seq_printf(p, ": Provision Discovery Request");
break;
case (P2P_ACTION_PROV_DISC_RSP):
trace_seq_printf(p, ": Provision Discovery Response");
break;
default:
trace_seq_printf(p, "Unknown p2p %d", p2p);
break;
}
} else {
switch (cat) {
case 0:
trace_seq_printf(p, ":Spectrum %d", type);
break;
case 1:
trace_seq_printf(p, ":QOS %d", type); break;
case 2:
trace_seq_printf(p, ":DLS %d", type);
break;
case 3:
trace_seq_printf(p, ":BA %d", type);
break;
case 4:
trace_seq_printf(p, ":Public %d", type);
break;
case 5:
trace_seq_printf(p, ":Radio Measure %d", type);
break;
case 6:
trace_seq_printf(p, ":Fast BSS %d", type);
break;
case 7:
trace_seq_printf(p, ":HT Action %d", type);
break;
case 8:
trace_seq_printf(p, ":SA Query %d", type);
break;
case 9:
trace_seq_printf(p, ":Protected Public %d", type);
break;
case 10:
trace_seq_printf(p, ":WNM %d", type);
break;
case 11:
trace_seq_printf(p, ":Unprotected WNM %d", type);
break;
case 12:
trace_seq_printf(p, ":TDLS %d", type);
break;
case 13:
trace_seq_printf(p, ":Mesh %d", type);
break;
case 14:
trace_seq_printf(p, ":MultiHop %d", type);
break;
case 15:
trace_seq_printf(p, ":Self Protected %d", type);
break;
case 126:
trace_seq_printf(p, ":Vendor protected");
break;
case 127:
trace_seq_printf(p, ":Vendor");
break;
default:
trace_seq_printf(p, ":Unknown category %d", cat);
break;
}
}
break;
default:
trace_seq_printf(p, "Unknown subtype %d", frame_control & IEEE80211_FCTL_STYPE);
break;
}
trace_seq_putc(p, 0);
return ret;
}
#endif /* defined(CONFIG_TRACEPOINTS) && defined(CREATE_TRACE_POINTS) */
#undef __print_mgmt_info
#define __print_mgmt_info(frame_control, cat, type, p2p) ftrace_print_mgmt_info(p, frame_control, cat, type, p2p)
TRACE_EVENT(
roc,
TP_PROTO(u8 vif_idx, u16 freq, unsigned int duration),
TP_ARGS(vif_idx, freq, duration),
TP_STRUCT__entry(
__field(u8, vif_idx)
__field(u16, freq)
__field(unsigned int, duration)
),
TP_fast_assign(
__entry->vif_idx = vif_idx;
__entry->freq = freq;
__entry->duration = duration;
),
TP_printk("f=%d vif=%d dur=%d",
__entry->freq, __entry->vif_idx, __entry->duration)
);
TRACE_EVENT(
cancel_roc,
TP_PROTO(u8 vif_idx),
TP_ARGS(vif_idx),
TP_STRUCT__entry(
__field(u8, vif_idx)
),
TP_fast_assign(
__entry->vif_idx = vif_idx;
),
TP_printk("vif=%d", __entry->vif_idx)
);
TRACE_EVENT(
roc_exp,
TP_PROTO(u8 vif_idx),
TP_ARGS(vif_idx),
TP_STRUCT__entry(
__field(u8, vif_idx)
),
TP_fast_assign(
__entry->vif_idx = vif_idx;
),
TP_printk("vif=%d", __entry->vif_idx)
);
TRACE_EVENT(
switch_roc,
TP_PROTO(u8 vif_idx),
TP_ARGS(vif_idx),
TP_STRUCT__entry(
__field(u8, vif_idx)
),
TP_fast_assign(
__entry->vif_idx = vif_idx;
),
TP_printk("vif=%d", __entry->vif_idx)
);
DECLARE_EVENT_CLASS(
mgmt_template,
TP_PROTO(u16 freq, u8 vif_idx, u8 sta_idx, struct ieee80211_mgmt *mgmt),
TP_ARGS(freq, vif_idx, sta_idx, mgmt),
TP_STRUCT__entry(
__field(u16, freq)
__field(u8, vif_idx)
__field(u8, sta_idx)
__field(u16, frame_control)
__field(u8, action_cat)
__field(u8, action_type)
__field(u8, action_p2p)
),
TP_fast_assign(
__entry->freq = freq;
__entry->vif_idx = vif_idx;
__entry->sta_idx = sta_idx;
__entry->frame_control = mgmt->frame_control;
__entry->action_cat = mgmt->u.action.category;
__entry->action_type = mgmt->u.action.u.wme_action.action_code;
__entry->action_p2p = *((u8 *)&mgmt->u.action.category
+ MGMT_ACTION_OUI_SUBTYPE_OFFSET);
),
TP_printk("f=%d vif=%d sta=%d -> %s",
__entry->freq, __entry->vif_idx, __entry->sta_idx,
__print_mgmt_info(__entry->frame_control, __entry->action_cat,
__entry->action_type, __entry->action_p2p))
);
DEFINE_EVENT(mgmt_template, mgmt_tx,
TP_PROTO(u16 freq, u8 vif_idx, u8 sta_idx, struct ieee80211_mgmt *mgmt),
TP_ARGS(freq, vif_idx, sta_idx, mgmt));
DEFINE_EVENT(mgmt_template, mgmt_rx,
TP_PROTO(u16 freq, u8 vif_idx, u8 sta_idx, struct ieee80211_mgmt *mgmt),
TP_ARGS(freq, vif_idx, sta_idx, mgmt));
TRACE_EVENT(
mgmt_cfm,
TP_PROTO(u8 vif_idx, u8 sta_idx, bool acked),
TP_ARGS(vif_idx, sta_idx, acked),
TP_STRUCT__entry(
__field(u8, vif_idx)
__field(u8, sta_idx)
__field(bool, acked)
),
TP_fast_assign(
__entry->vif_idx = vif_idx;
__entry->sta_idx = sta_idx;
__entry->acked = acked;
),
TP_printk("vif=%d sta=%d ack=%d",
__entry->vif_idx, __entry->sta_idx, __entry->acked)
);
#endif /* CONFIG_RWNX_FULLMAC */
/*****************************************************************************
* TRACE function for TXQ
****************************************************************************/
#ifndef CONFIG_RWNX_FHOST
#if defined(CONFIG_TRACEPOINTS) && defined(CREATE_TRACE_POINTS)
#include <linux/trace_seq.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
#include <linux/trace_events.h>
#else
#include <linux/ftrace_event.h>
#endif
const char *
ftrace_print_txq(struct trace_seq *p, int txq_idx)
{
const char *ret = trace_seq_buffer_ptr(p);
if (txq_idx == TXQ_INACTIVE) {
trace_seq_printf(p, "[INACTIVE]");
} else if (txq_idx < NX_FIRST_VIF_TXQ_IDX) {
trace_seq_printf(p, "[STA %d/%d]",
txq_idx / NX_NB_TXQ_PER_STA,
txq_idx % NX_NB_TXQ_PER_STA);
#ifdef CONFIG_RWNX_FULLMAC
} else if (txq_idx < NX_FIRST_UNK_TXQ_IDX) {
trace_seq_printf(p, "[BC/MC %d]",
txq_idx - NX_FIRST_BCMC_TXQ_IDX);
} else if (txq_idx < NX_OFF_CHAN_TXQ_IDX) {
trace_seq_printf(p, "[UNKNOWN %d]",
txq_idx - NX_FIRST_UNK_TXQ_IDX);
} else if (txq_idx == NX_OFF_CHAN_TXQ_IDX) {
trace_seq_printf(p, "[OFFCHAN]");
#else
} else if (txq_idx < NX_NB_TXQ) {
txq_idx -= NX_FIRST_VIF_TXQ_IDX;
trace_seq_printf(p, "[VIF %d/%d]",
txq_idx / NX_NB_TXQ_PER_VIF,
txq_idx % NX_NB_TXQ_PER_VIF);
#endif
} else {
trace_seq_printf(p, "[ERROR %d]", txq_idx);
}
trace_seq_putc(p, 0);
return ret;
}
const char *
ftrace_print_sta(struct trace_seq *p, int sta_idx)
{
const char *ret = trace_seq_buffer_ptr(p);
if (sta_idx < NX_REMOTE_STA_MAX) {
trace_seq_printf(p, "[STA %d]", sta_idx);
} else {
trace_seq_printf(p, "[BC/MC %d]", sta_idx - NX_REMOTE_STA_MAX);
}
trace_seq_putc(p, 0);
return ret;
}
const char *
ftrace_print_hwq(struct trace_seq *p, int hwq_idx)
{
static const struct trace_print_flags symbols[] = {
{RWNX_HWQ_BK, "BK"},
{RWNX_HWQ_BE, "BE"},
{RWNX_HWQ_VI, "VI"},
{RWNX_HWQ_VO, "VO"},
#ifdef CONFIG_RWNX_FULLMAC
{RWNX_HWQ_BCMC, "BCMC"},
#else
{RWNX_HWQ_BCN, "BCN"},
#endif
{ -1, NULL } };
return trace_print_symbols_seq(p, hwq_idx, symbols);
}
const char *
ftrace_print_hwq_cred(struct trace_seq *p, u8 *cred)
{
const char *ret = trace_seq_buffer_ptr(p);
#if CONFIG_USER_MAX == 1
trace_seq_printf(p, "%d", cred[0]);
#else
int i;
for (i = 0; i < CONFIG_USER_MAX - 1; i++)
trace_seq_printf(p, "%d-", cred[i]);
trace_seq_printf(p, "%d", cred[i]);
#endif
trace_seq_putc(p, 0);
return ret;
}
const char *
ftrace_print_mu_info(struct trace_seq *p, u8 mu_info)
{
const char *ret = trace_seq_buffer_ptr(p);
if (mu_info)
trace_seq_printf(p, "MU: %d-%d", (mu_info & 0x3f), (mu_info >> 6));
trace_seq_putc(p, 0);
return ret;
}
const char *
ftrace_print_mu_group(struct trace_seq *p, int nb_user, u8 *users)
{
const char *ret = trace_seq_buffer_ptr(p);
int i;
if (users[0] != 0xff)
trace_seq_printf(p, "(%d", users[0]);
else
trace_seq_printf(p, "(-");
for (i = 1; i < CONFIG_USER_MAX ; i++) {
if (users[i] != 0xff)
trace_seq_printf(p, ",%d", users[i]);
else
trace_seq_printf(p, ",-");
}
trace_seq_printf(p, ")");
trace_seq_putc(p, 0);
return ret;
}
const char *
ftrace_print_amsdu(struct trace_seq *p, u16 nb_pkt)
{
const char *ret = trace_seq_buffer_ptr(p);
if (nb_pkt > 1)
trace_seq_printf(p, "(AMSDU %d)", nb_pkt);
trace_seq_putc(p, 0);
return ret;
}
#endif /* defined(CONFIG_TRACEPOINTS) && defined(CREATE_TRACE_POINTS) */
#undef __print_txq
#define __print_txq(txq_idx) ftrace_print_txq(p, txq_idx)
#undef __print_sta
#define __print_sta(sta_idx) ftrace_print_sta(p, sta_idx)
#undef __print_hwq
#define __print_hwq(hwq) ftrace_print_hwq(p, hwq)
#undef __print_hwq_cred
#define __print_hwq_cred(cred) ftrace_print_hwq_cred(p, cred)
#undef __print_mu_info
#define __print_mu_info(mu_info) ftrace_print_mu_info(p, mu_info)
#undef __print_mu_group
#define __print_mu_group(nb, users) ftrace_print_mu_group(p, nb, users)
#undef __print_amsdu
#define __print_amsdu(nb_pkt) ftrace_print_amsdu(p, nb_pkt)
#ifdef CONFIG_RWNX_FULLMAC
TRACE_EVENT(
txq_select,
TP_PROTO(int txq_idx, u16 pkt_ready_up, struct sk_buff *skb),
TP_ARGS(txq_idx, pkt_ready_up, skb),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u16, pkt_ready)
__field(struct sk_buff *, skb)
),
TP_fast_assign(
__entry->txq_idx = txq_idx;
__entry->pkt_ready = pkt_ready_up;
__entry->skb = skb;
),
TP_printk("%s pkt_ready_up=%d skb=%p", __print_txq(__entry->txq_idx),
__entry->pkt_ready, __entry->skb)
);
#endif /* CONFIG_RWNX_FULLMAC */
DECLARE_EVENT_CLASS(
hwq_template,
TP_PROTO(u8 hwq_idx),
TP_ARGS(hwq_idx),
TP_STRUCT__entry(
__field(u8, hwq_idx)
),
TP_fast_assign(
__entry->hwq_idx = hwq_idx;
),
TP_printk("%s", __print_hwq(__entry->hwq_idx))
);
DEFINE_EVENT(hwq_template, hwq_flowctrl_stop,
TP_PROTO(u8 hwq_idx),
TP_ARGS(hwq_idx));
DEFINE_EVENT(hwq_template, hwq_flowctrl_start,
TP_PROTO(u8 hwq_idx),
TP_ARGS(hwq_idx));
DECLARE_EVENT_CLASS(
txq_template,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq),
TP_STRUCT__entry(
__field(u16, txq_idx)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
),
TP_printk("%s", __print_txq(__entry->txq_idx))
);
DEFINE_EVENT(txq_template, txq_add_to_hw,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq));
DEFINE_EVENT(txq_template, txq_del_from_hw,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq));
#ifdef CONFIG_RWNX_FULLMAC
DEFINE_EVENT(txq_template, txq_flowctrl_stop,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq));
DEFINE_EVENT(txq_template, txq_flowctrl_restart,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq));
#endif /* CONFIG_RWNX_FULLMAC */
TRACE_EVENT(
process_txq,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u16, len)
__field(u16, len_retry)
__field(s8, credit)
#ifdef CONFIG_RWNX_FULLMAC
__field(u16, limit)
#endif /* CONFIG_RWNX_FULLMAC*/
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->len = skb_queue_len(&txq->sk_list);
#ifdef CONFIG_MAC80211_TXQ
__entry->len += txq->nb_ready_mac80211;
#endif
__entry->len_retry = txq->nb_retry;
__entry->credit = txq->credits;
#ifdef CONFIG_RWNX_FULLMAC
__entry->limit = txq->push_limit;
#endif /* CONFIG_RWNX_FULLMAC*/
),
#ifdef CONFIG_RWNX_FULLMAC
TP_printk("%s txq_credits=%d, len=%d, retry_len=%d, push_limit=%d",
__print_txq(__entry->txq_idx), __entry->credit,
__entry->len, __entry->len_retry, __entry->limit)
#else
TP_printk("%s txq_credits=%d, len=%d, retry_len=%d",
__print_txq(__entry->txq_idx), __entry->credit,
__entry->len, __entry->len_retry)
#endif /* CONFIG_RWNX_FULLMAC*/
);
DECLARE_EVENT_CLASS(
txq_reason_template,
TP_PROTO(struct rwnx_txq *txq, u16 reason),
TP_ARGS(txq, reason),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u16, reason)
__field(u16, status)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->reason = reason;
__entry->status = txq->status;
),
TP_printk("%s reason=%s status=%s",
__print_txq(__entry->txq_idx),
__print_symbolic(__entry->reason,
{RWNX_TXQ_STOP_FULL, "FULL"},
{RWNX_TXQ_STOP_CSA, "CSA"},
{RWNX_TXQ_STOP_STA_PS, "PS"},
{RWNX_TXQ_STOP_VIF_PS, "VPS"},
{RWNX_TXQ_STOP_CHAN, "CHAN"},
{RWNX_TXQ_STOP_MU_POS, "MU"}),
__print_flags(__entry->status, "|",
{RWNX_TXQ_IN_HWQ_LIST, "IN LIST"},
{RWNX_TXQ_STOP_FULL, "FULL"},
{RWNX_TXQ_STOP_CSA, "CSA"},
{RWNX_TXQ_STOP_STA_PS, "PS"},
{RWNX_TXQ_STOP_VIF_PS, "VPS"},
{RWNX_TXQ_STOP_CHAN, "CHAN"},
{RWNX_TXQ_STOP_MU_POS, "MU"},
{RWNX_TXQ_NDEV_FLOW_CTRL, "FLW_CTRL"}))
);
DEFINE_EVENT(txq_reason_template, txq_start,
TP_PROTO(struct rwnx_txq *txq, u16 reason),
TP_ARGS(txq, reason));
DEFINE_EVENT(txq_reason_template, txq_stop,
TP_PROTO(struct rwnx_txq *txq, u16 reason),
TP_ARGS(txq, reason));
TRACE_EVENT(
push_desc,
TP_PROTO(struct sk_buff *skb, struct rwnx_sw_txhdr *sw_txhdr, int push_flags),
TP_ARGS(skb, sw_txhdr, push_flags),
TP_STRUCT__entry(
__field(struct sk_buff *, skb)
__field(unsigned int, len)
__field(u16, tx_queue)
__field(u8, hw_queue)
__field(u8, push_flag)
__field(u32, flag)
__field(s8, txq_cred)
__field(u8, hwq_cred)
__field(u16, pkt_cnt)
__field(u8, mu_info)
),
TP_fast_assign(
__entry->skb = skb;
__entry->tx_queue = sw_txhdr->txq->idx;
__entry->push_flag = push_flags;
__entry->hw_queue = sw_txhdr->txq->hwq->id;
__entry->txq_cred = sw_txhdr->txq->credits;
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
__entry->pkt_cnt = sw_txhdr->desc.host.packet_cnt;
#endif
#ifdef CONFIG_RWNX_FULLMAC
__entry->flag = sw_txhdr->desc.host.flags;
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
#ifdef CONFIG_RWNX_AMSDUS_TX
if (sw_txhdr->amsdu.len)
__entry->len = sw_txhdr->amsdu.len;
else
#endif /* CONFIG_RWNX_AMSDUS_TX */
__entry->len = sw_txhdr->desc.host.packet_len[0];
#else
__entry->len = sw_txhdr->desc.host.packet_len;
#endif /* CONFIG_RWNX_SPLIT_TX_BUF */
#else /* !CONFIG_RWNX_FULLMAC */
__entry->flag = sw_txhdr->desc.umac.flags;
__entry->len = sw_txhdr->frame_len;
__entry->sn = sw_txhdr->sn;
#endif /* CONFIG_RWNX_FULLMAC */
#ifdef CONFIG_RWNX_MUMIMO_TX
__entry->mu_info = sw_txhdr->desc.host.mumimo_info;
#else
__entry->mu_info = 0;
#endif
),
#ifdef CONFIG_RWNX_FULLMAC
TP_printk("%s skb=%p (len=%d) hw_queue=%s cred_txq=%d cred_hwq=%d %s flag=%s %s%s%s",
__print_txq(__entry->tx_queue), __entry->skb, __entry->len,
__print_hwq(__entry->hw_queue),
__entry->txq_cred, __entry->hwq_cred,
__print_mu_info(__entry->mu_info),
__print_flags(__entry->flag, "|",
{TXU_CNTRL_RETRY, "RETRY"},
{TXU_CNTRL_MORE_DATA, "MOREDATA"},
{TXU_CNTRL_MGMT, "MGMT"},
{TXU_CNTRL_MGMT_NO_CCK, "NO_CCK"},
{TXU_CNTRL_MGMT_ROBUST, "ROBUST"},
{TXU_CNTRL_AMSDU, "AMSDU"},
{TXU_CNTRL_USE_4ADDR, "4ADDR"},
{TXU_CNTRL_EOSP, "EOSP"},
{TXU_CNTRL_MESH_FWD, "MESH_FWD"},
{TXU_CNTRL_TDLS, "TDLS"}),
(__entry->push_flag & RWNX_PUSH_IMMEDIATE) ? "(IMMEDIATE)" : "",
(!(__entry->flag & TXU_CNTRL_RETRY) &&
(__entry->push_flag & RWNX_PUSH_RETRY)) ? "(SW_RETRY)" : "",
__print_amsdu(__entry->pkt_cnt))
#else
TP_printk("%s skb=%p (len=%d) hw_queue=%s cred_txq=%d cred_hwq=%d %s flag=%x (%s) sn=%d %s",
__print_txq(__entry->tx_queue), __entry->skb, __entry->len,
__print_hwq(__entry->hw_queue), __entry->txq_cred, __entry->hwq_cred,
__print_mu_info(__entry->mu_info),
__entry->flag,
__print_flags(__entry->push_flag, "|",
{RWNX_PUSH_RETRY, "RETRY"},
{RWNX_PUSH_IMMEDIATE, "IMMEDIATE"}),
__entry->sn, __print_amsdu(__entry->pkt_cnt))
#endif /* CONFIG_RWNX_FULLMAC */
);
TRACE_EVENT(
txq_queue_skb,
TP_PROTO(struct sk_buff *skb, struct rwnx_txq *txq, bool retry),
TP_ARGS(skb, txq, retry),
TP_STRUCT__entry(
__field(struct sk_buff *, skb)
__field(u16, txq_idx)
__field(s8, credit)
__field(u16, q_len)
__field(u16, q_len_retry)
__field(bool, retry)
),
TP_fast_assign(
__entry->skb = skb;
__entry->txq_idx = txq->idx;
__entry->credit = txq->credits;
__entry->q_len = skb_queue_len(&txq->sk_list);
__entry->q_len_retry = txq->nb_retry;
__entry->retry = retry;
),
TP_printk("%s skb=%p retry=%d txq_credits=%d queue_len=%d (retry = %d)",
__print_txq(__entry->txq_idx), __entry->skb, __entry->retry,
__entry->credit, __entry->q_len, __entry->q_len_retry)
);
#ifdef CONFIG_MAC80211_TXQ
TRACE_EVENT(
txq_wake,
TP_PROTO(struct rwnx_txq *txq),
TP_ARGS(txq),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u16, q_len)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->q_len = txq->nb_ready_mac80211;
),
TP_printk("%s mac80211_queue_len=%d", __print_txq(__entry->txq_idx), __entry->q_len)
);
TRACE_EVENT(
txq_drop,
TP_PROTO(struct rwnx_txq *txq, unsigned long nb_drop),
TP_ARGS(txq, nb_drop),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u16, nb_drop)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->nb_drop = nb_drop;
),
TP_printk("%s %u pkt have been dropped by codel in mac80211 txq",
__print_txq(__entry->txq_idx), __entry->nb_drop)
);
#endif
DECLARE_EVENT_CLASS(
idx_template,
TP_PROTO(u16 idx),
TP_ARGS(idx),
TP_STRUCT__entry(
__field(u16, idx)
),
TP_fast_assign(
__entry->idx = idx;
),
TP_printk("idx=%d", __entry->idx)
);
DEFINE_EVENT(idx_template, txq_vif_start,
TP_PROTO(u16 idx),
TP_ARGS(idx));
DEFINE_EVENT(idx_template, txq_vif_stop,
TP_PROTO(u16 idx),
TP_ARGS(idx));
TRACE_EVENT(
process_hw_queue,
TP_PROTO(struct rwnx_hwq *hwq),
TP_ARGS(hwq),
TP_STRUCT__entry(
__field(u16, hwq)
__array(u8, credits, CONFIG_USER_MAX)
),
TP_fast_assign(
__entry->hwq = hwq->id;
),
TP_printk("hw_queue=%s hw_credits=%s",
__print_hwq(__entry->hwq), __print_hwq_cred(__entry->credits))
);
DECLARE_EVENT_CLASS(
sta_idx_template,
TP_PROTO(u16 idx),
TP_ARGS(idx),
TP_STRUCT__entry(
__field(u16, idx)
),
TP_fast_assign(
__entry->idx = idx;
),
TP_printk("%s", __print_sta(__entry->idx))
);
DEFINE_EVENT(sta_idx_template, txq_sta_start,
TP_PROTO(u16 idx),
TP_ARGS(idx));
DEFINE_EVENT(sta_idx_template, txq_sta_stop,
TP_PROTO(u16 idx),
TP_ARGS(idx));
#ifdef CONFIG_RWNX_FULLMAC
DEFINE_EVENT(sta_idx_template, ps_disable,
TP_PROTO(u16 idx),
TP_ARGS(idx));
#endif /* CONFIG_RWNX_FULLMAC */
TRACE_EVENT(
skb_confirm,
TP_PROTO(struct sk_buff *skb, struct rwnx_txq *txq, struct rwnx_hwq *hwq,
#ifdef CONFIG_RWNX_FULLMAC
struct tx_cfm_tag *cfm
#else
u8 cfm
#endif
),
TP_ARGS(skb, txq, hwq, cfm),
TP_STRUCT__entry(
__field(struct sk_buff *, skb)
__field(u16, txq_idx)
__field(u8, hw_queue)
__array(u8, hw_credit, CONFIG_USER_MAX)
__field(s8, sw_credit)
__field(s8, sw_credit_up)
#ifdef CONFIG_RWNX_FULLMAC
__field(u8, ampdu_size)
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
__field(u16, amsdu)
#endif /* CONFIG_RWNX_SPLIT_TX_BUF */
__field(u16, sn)
#endif /* CONFIG_RWNX_FULLMAC*/
),
TP_fast_assign(
__entry->skb = skb;
__entry->txq_idx = txq->idx;
__entry->hw_queue = hwq->id;
__entry->sw_credit = txq->credits;
#if defined CONFIG_RWNX_FULLMAC
__entry->sw_credit_up = cfm->credits;
__entry->ampdu_size = cfm->ampdu_size;
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
__entry->amsdu = cfm->amsdu_size;
__entry->sn = cfm->sn;
#endif
#else
__entry->sw_credit_up = cfm
#endif /* CONFIG_RWNX_FULLMAC */
),
TP_printk("%s skb=%p hw_queue=%s, hw_credits=%s, txq_credits=%d (+%d)"
#ifdef CONFIG_RWNX_FULLMAC
" sn=%u ampdu=%d"
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
" amsdu=%u"
#endif
#endif
, __print_txq(__entry->txq_idx), __entry->skb,
__print_hwq(__entry->hw_queue),
__print_hwq_cred(__entry->hw_credit),
__entry->sw_credit, __entry->sw_credit_up
#ifdef CONFIG_RWNX_FULLMAC
, __entry->sn, __entry->ampdu_size
#ifdef CONFIG_RWNX_SPLIT_TX_BUF
, __entry->amsdu
#endif
#endif
)
);
TRACE_EVENT(
credit_update,
TP_PROTO(struct rwnx_txq *txq, s8_l cred_up),
TP_ARGS(txq, cred_up),
TP_STRUCT__entry(
__field(struct sk_buff *, skb)
__field(u16, txq_idx)
__field(s8, sw_credit)
__field(s8, sw_credit_up)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->sw_credit = txq->credits;
__entry->sw_credit_up = cred_up;
),
TP_printk("%s txq_credits=%d (%+d)", __print_txq(__entry->txq_idx),
__entry->sw_credit, __entry->sw_credit_up)
)
#ifdef CONFIG_RWNX_FULLMAC
DECLARE_EVENT_CLASS(
ps_template,
TP_PROTO(struct rwnx_sta *sta),
TP_ARGS(sta),
TP_STRUCT__entry(
__field(u16, idx)
__field(u16, ready_ps)
__field(u16, sp_ps)
__field(u16, ready_uapsd)
__field(u16, sp_uapsd)
),
TP_fast_assign(
__entry->idx = sta->sta_idx;
__entry->ready_ps = sta->ps.pkt_ready[LEGACY_PS_ID];
__entry->sp_ps = sta->ps.sp_cnt[LEGACY_PS_ID];
__entry->ready_uapsd = sta->ps.pkt_ready[UAPSD_ID];
__entry->sp_uapsd = sta->ps.sp_cnt[UAPSD_ID];
),
TP_printk("%s [PS] ready=%d sp=%d [UAPSD] ready=%d sp=%d",
__print_sta(__entry->idx), __entry->ready_ps, __entry->sp_ps,
__entry->ready_uapsd, __entry->sp_uapsd)
);
DEFINE_EVENT(ps_template, ps_queue,
TP_PROTO(struct rwnx_sta *sta),
TP_ARGS(sta));
DEFINE_EVENT(ps_template, ps_push,
TP_PROTO(struct rwnx_sta *sta),
TP_ARGS(sta));
DEFINE_EVENT(ps_template, ps_enable,
TP_PROTO(struct rwnx_sta *sta),
TP_ARGS(sta));
TRACE_EVENT(
ps_traffic_update,
TP_PROTO(u16 sta_idx, u8 traffic, bool uapsd),
TP_ARGS(sta_idx, traffic, uapsd),
TP_STRUCT__entry(
__field(u16, sta_idx)
__field(u8, traffic)
__field(bool, uapsd)
),
TP_fast_assign(
__entry->sta_idx = sta_idx;
__entry->traffic = traffic;
__entry->uapsd = uapsd;
),
TP_printk("%s %s%s traffic available ", __print_sta(__entry->sta_idx),
__entry->traffic ? "" : "no more ",
__entry->uapsd ? "U-APSD" : "legacy PS")
);
TRACE_EVENT(
ps_traffic_req,
TP_PROTO(struct rwnx_sta *sta, u16 pkt_req, u8 ps_id),
TP_ARGS(sta, pkt_req, ps_id),
TP_STRUCT__entry(
__field(u16, idx)
__field(u16, pkt_req)
__field(u8, ps_id)
__field(u16, ready)
__field(u16, sp)
),
TP_fast_assign(
__entry->idx = sta->sta_idx;
__entry->pkt_req = pkt_req;
__entry->ps_id = ps_id;
__entry->ready = sta->ps.pkt_ready[ps_id];
__entry->sp = sta->ps.sp_cnt[ps_id];
),
TP_printk("%s %s traffic request %d pkt (ready=%d, sp=%d)",
__print_sta(__entry->idx),
__entry->ps_id == UAPSD_ID ? "U-APSD" : "legacy PS",
__entry->pkt_req, __entry->ready, __entry->sp)
);
#ifdef CONFIG_RWNX_AMSDUS_TX
TRACE_EVENT(
amsdu_subframe,
TP_PROTO(struct rwnx_sw_txhdr *sw_txhdr),
TP_ARGS(sw_txhdr),
TP_STRUCT__entry(
__field(struct sk_buff *, skb)
__field(u16, txq_idx)
__field(u8, nb)
__field(u32, len)
),
TP_fast_assign(
__entry->skb = sw_txhdr->skb;
__entry->nb = sw_txhdr->amsdu.nb;
__entry->len = sw_txhdr->amsdu.len;
__entry->txq_idx = sw_txhdr->txq->idx;
),
TP_printk("%s skb=%p %s nb_subframe=%d, len=%u",
__print_txq(__entry->txq_idx), __entry->skb,
(__entry->nb == 2) ? "Start new AMSDU" : "Add subframe",
__entry->nb, __entry->len)
);
#endif
#endif /* CONFIG_RWNX_FULLMAC */
#ifdef CONFIG_RWNX_MUMIMO_TX
TRACE_EVENT(
mu_group_update,
TP_PROTO(struct rwnx_mu_group *group),
TP_ARGS(group),
TP_STRUCT__entry(
__field(u8, nb_user)
__field(u8, group_id)
__array(u8, users, CONFIG_USER_MAX)
),
TP_fast_assign(
int i;
__entry->nb_user = group->user_cnt;
for (i = 0; i < CONFIG_USER_MAX ; i++) {
if (group->users[i]) {
__entry->users[i] = group->users[i]->sta_idx;
} else {
__entry->users[i] = 0xff;
}
}
__entry->group_id = group->group_id;
),
TP_printk("Group-id = %d, Users = %s",
__entry->group_id,
__print_mu_group(__entry->nb_user, __entry->users))
);
TRACE_EVENT(
mu_group_delete,
TP_PROTO(int group_id),
TP_ARGS(group_id),
TP_STRUCT__entry(
__field(u8, group_id)
),
TP_fast_assign(
__entry->group_id = group_id;
),
TP_printk("Group-id = %d", __entry->group_id)
);
TRACE_EVENT(
mu_group_selection,
TP_PROTO(struct rwnx_sta *sta, int group_id),
TP_ARGS(sta, group_id),
TP_STRUCT__entry(
__field(u8, sta_idx)
__field(u8, group_id)
),
TP_fast_assign(
__entry->sta_idx = sta->sta_idx;
__entry->group_id = group_id;
),
TP_printk("[Sta %d] Group-id = %d", __entry->sta_idx, __entry->group_id)
);
TRACE_EVENT(
txq_select_mu_group,
TP_PROTO(struct rwnx_txq *txq, int group_id, int pos),
TP_ARGS(txq, group_id, pos),
TP_STRUCT__entry(
__field(u16, txq_idx)
__field(u8, group_id)
__field(u8, pos)
),
TP_fast_assign(
__entry->txq_idx = txq->idx;
__entry->group_id = group_id;
__entry->pos = pos;
),
TP_printk("%s: group=%d pos=%d", __print_txq(__entry->txq_idx),
__entry->group_id, __entry->pos)
);
#endif /* CONFIG_RWNX_MUMIMO_TX */
#endif /* ! CONFIG_RWNX_FHOST */
/*****************************************************************************
* TRACE functions for MESH
****************************************************************************/
#ifdef CONFIG_RWNX_FULLMAC
DECLARE_EVENT_CLASS(
mesh_path_template,
TP_PROTO(struct rwnx_mesh_path *mesh_path),
TP_ARGS(mesh_path),
TP_STRUCT__entry(
__field(u8, idx)
__field(u8, next_hop_sta)
__array(u8, tgt_mac, ETH_ALEN)
),
TP_fast_assign(
__entry->idx = mesh_path->path_idx;
memcpy(__entry->tgt_mac, &mesh_path->tgt_mac_addr, ETH_ALEN);
if (mesh_path->p_nhop_sta)
__entry->next_hop_sta = mesh_path->p_nhop_sta->sta_idx;
else
__entry->next_hop_sta = 0xff;
),
TP_printk("Mpath(%d): target=%pM next_hop=STA-%d",
__entry->idx, __entry->tgt_mac, __entry->next_hop_sta)
);
DEFINE_EVENT(mesh_path_template, mesh_create_path,
TP_PROTO(struct rwnx_mesh_path *mesh_path),
TP_ARGS(mesh_path));
DEFINE_EVENT(mesh_path_template, mesh_delete_path,
TP_PROTO(struct rwnx_mesh_path *mesh_path),
TP_ARGS(mesh_path));
DEFINE_EVENT(mesh_path_template, mesh_update_path,
TP_PROTO(struct rwnx_mesh_path *mesh_path),
TP_ARGS(mesh_path));
#endif /* CONFIG_RWNX_FULLMAC */
/*****************************************************************************
* TRACE functions for RADAR
****************************************************************************/
#ifdef CONFIG_RWNX_RADAR
TRACE_EVENT(
radar_pulse,
TP_PROTO(u8 chain, struct radar_pulse *pulse),
TP_ARGS(chain, pulse),
TP_STRUCT__entry(
__field(u8, chain)
__field(s16, freq)
__field(u16, pri)
__field(u8, len)
__field(u8, fom)
),
TP_fast_assign(
__entry->freq = pulse->freq * 2;
__entry->len = pulse->len * 2;
__entry->fom = pulse->fom * 6;
__entry->pri = pulse->rep;
__entry->chain = chain;
),
TP_printk("%s: PRI=%.5d LEN=%.3d FOM=%.2d%% freq=%dMHz ",
__print_symbolic(__entry->chain,
{RWNX_RADAR_RIU, "RIU"},
{RWNX_RADAR_FCU, "FCU"}),
__entry->pri, __entry->len, __entry->fom, __entry->freq)
);
TRACE_EVENT(
radar_detected,
TP_PROTO(u8 chain, u8 region, s16 freq, u8 type, u16 pri),
TP_ARGS(chain, region, freq, type, pri),
TP_STRUCT__entry(
__field(u8, chain)
__field(u8, region)
__field(s16, freq)
__field(u8, type)
__field(u16, pri)
),
TP_fast_assign(
__entry->chain = chain;
__entry->region = region;
__entry->freq = freq;
__entry->type = type;
__entry->pri = pri;
),
TP_printk("%s: region=%s type=%d freq=%dMHz (pri=%dus)",
__print_symbolic(__entry->chain,
{RWNX_RADAR_RIU, "RIU"},
{RWNX_RADAR_FCU, "FCU"}),
__print_symbolic(__entry->region,
{NL80211_DFS_UNSET, "UNSET"},
{NL80211_DFS_FCC, "FCC"},
{NL80211_DFS_ETSI, "ETSI"},
{NL80211_DFS_JP, "JP"}),
__entry->type, __entry->freq, __entry->pri)
);
TRACE_EVENT(
radar_set_region,
TP_PROTO(u8 region),
TP_ARGS(region),
TP_STRUCT__entry(
__field(u8, region)
),
TP_fast_assign(
__entry->region = region;
),
TP_printk("region=%s",
__print_symbolic(__entry->region,
{NL80211_DFS_UNSET, "UNSET"},
{NL80211_DFS_FCC, "FCC"},
{NL80211_DFS_ETSI, "ETSI"},
{NL80211_DFS_JP, "JP"}))
);
TRACE_EVENT(
radar_enable_detection,
TP_PROTO(u8 region, u8 enable, u8 chain),
TP_ARGS(region, enable, chain),
TP_STRUCT__entry(
__field(u8, region)
__field(u8, chain)
__field(u8, enable)
),
TP_fast_assign(
__entry->chain = chain;
__entry->enable = enable;
__entry->region = region;
),
TP_printk("%s: %s radar detection %s",
__print_symbolic(__entry->chain,
{RWNX_RADAR_RIU, "RIU"},
{RWNX_RADAR_FCU, "FCU"}),
__print_symbolic(__entry->enable,
{RWNX_RADAR_DETECT_DISABLE, "Disable"},
{RWNX_RADAR_DETECT_ENABLE, "Enable (no report)"},
{RWNX_RADAR_DETECT_REPORT, "Enable"}),
__entry->enable == RWNX_RADAR_DETECT_DISABLE ? "" :
__print_symbolic(__entry->region,
{NL80211_DFS_UNSET, "UNSET"},
{NL80211_DFS_FCC, "FCC"},
{NL80211_DFS_ETSI, "ETSI"},
{NL80211_DFS_JP, "JP"}))
);
#endif /* CONFIG_RWNX_RADAR */
/*****************************************************************************
* TRACE functions for IPC message
****************************************************************************/
#include "rwnx_strs.h"
DECLARE_EVENT_CLASS(
ipc_msg_template,
TP_PROTO(u16 id),
TP_ARGS(id),
TP_STRUCT__entry(
__field(u16, id)
),
TP_fast_assign(
__entry->id = id;
),
TP_printk("%s (%d - %d)", RWNX_ID2STR(__entry->id),
MSG_T(__entry->id), MSG_I(__entry->id))
);
DEFINE_EVENT(ipc_msg_template, msg_send,
TP_PROTO(u16 id),
TP_ARGS(id));
DEFINE_EVENT(ipc_msg_template, msg_recv,
TP_PROTO(u16 id),
TP_ARGS(id));
#endif /* !defined(_RWNX_EVENTS_H) || defined(TRACE_HEADER_MULTI_READ) */
#undef TRACE_INCLUDE_PATH
#undef TRACE_INCLUDE_FILE
//#define TRACE_INCLUDE_PATH .
#define TRACE_INCLUDE_PATH AIC_TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_FILE rwnx_events
#include <trace/define_trace.h>