path: root/qcwcn/wifi_hal/pkt_stats.h

/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of The Linux Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _PKT_STATS_H_
#define _PKT_STATS_H_

/* Types of packet log events.
 * Tx stats will be sent from driver with the help of multiple events.
 * Need to parse the events PKTLOG_TYPE_TX_CTRL and PKTLOG_TYPE_TX_STAT
 * as of now for the required stats. Rest of the events can ignored.
 */
#define PKTLOG_TYPE_TX_CTRL         1
#define PKTLOG_TYPE_TX_STAT         2
#define PKTLOG_TYPE_TX_MSDU_ID      3
#define PKTLOG_TYPE_TX_FRM_HDR      4
/* Rx stats will be sent from driver with event ID- PKTLOG_TYPE_RX_STAT */
#define PKTLOG_TYPE_RX_STAT         5
#define PKTLOG_TYPE_RC_FIND         6
#define PKTLOG_TYPE_RC_UPDATE       7
#define PKTLOG_TYPE_TX_VIRT_ADDR    8
#define PKTLOG_TYPE_PKT_STATS       9
#define PKTLOG_TYPE_PKT_DUMP        10
#define PKTLOG_TYPE_PKT_DUMP_V2     11
#define PKTLOG_TYPE_MAX             12
#define BW_OFFSET 8
#define INVALID_RSSI 255

/* Based on pkt log V2, this type of event will triggered */
#define PKTLOG_TYPE_PKT_SW_EVENT    10

#define PKT_INFO_FLG_TX_LOCAL_S          0x1
#define PKT_INFO_FLG_RX_HOST_RXD         0x2
#define PKT_INFO_FLG_TX_REMOTE_S         0x4
#define PKT_INFO_FLG_RX_LOCAL_S          0x8
#define PKT_INFO_FLG_RX_REMOTE_S         0x10
#define PKT_INFO_FLG_RX_LOCAL_DISCARD_S  0x20
#define PKT_INFO_FLG_RX_REMOTE_DISCARD_S 0x40
#define PKT_INFO_FLG_RX_REORDER_STORE_S  0x80
#define PKT_INFO_FLG_RX_REORDER_DROP_S   0x100
#define PKT_INFO_FLG_RX_PEER_INFO_S      0x200
#define PKT_INFO_FLG_UNKNOWN_S           0x400
#define PKT_INFO_FLG_PKT_DUMP_V2         0x8000

/* Depend on packet log version V2 this
 * offset are define, for more info need to
 * check from firmware side.
 */
#define TX_SUCCESS_TMS_OFFSET 56
#define LINK_LAYER_TX_SQN_OFFSET 66
#define RATE_CODE_OFFSET 68
#define TX_STATUS_OFFSET 70
#define TX_RSSI_OFFSET 71
#define NO_RETRIES_OFFSET 75
#define EXT_FLAGS_OFFSET 76
#define BMAP_FAILED_OFFSET 84
#define BMAP_ENQUEUED_OFFSET 92
#define FRAME_CTRL_OFFSET 216
#define QOS_CTRL_OFFSET 218

/* MAX HT/VHT mcs index */
#define MAX_VHT_MCS_IDX 10
#define MAX_HT_MCS_IDX 8

/* MAX CCK/OFDM rate index */
#define MAX_CCK_MCS_IDX 4
#define MAX_OFDM_MCS_IDX 8

/* MASK value of flags based on RX_STAT content.
 * These are the events that carry Rx decriptor
 */
#define PKT_INFO_FLG_RX_RXDESC_MASK \
        (PKT_INFO_FLG_RX_HOST_RXD | \
         PKT_INFO_FLG_RX_LOCAL_S | \
         PKT_INFO_FLG_RX_REMOTE_S | \
         PKT_INFO_FLG_RX_LOCAL_DISCARD_S | \
         PKT_INFO_FLG_RX_REMOTE_DISCARD_S)

/* Format of the packet stats event*/
typedef struct {
    u16 flags;
    u16 missed_cnt;
    u16 log_type;
    u16 size;
    u32 timestamp;
} __attribute__((packed)) wh_pktlog_hdr_t;

/* Format of the v2 packet stats event*/
typedef struct {
    u16 flags;
    u16 missed_cnt;
    u16 log_type        : 8; //[7:0]
    u16 mac_id          : 8; //[15:8]
    u16 size;
    u32 timestamp;
    u32 reserved;
} __attribute__((packed)) wh_pktlog_hdr_v2_t;

/*Rx stats specific structures. */
struct rx_attention {
    u32 first_mpdu                      :  1; //[0]
    u32 last_mpdu                       :  1; //[1]
    u32 reserved1                       :  6; //[7:2]
    u32 mgmt_type                       :  1; //[8]
    u32 ctrl_type                       :  1; //[9]
    u32 reserved2                       :  6; //[15:10]
    u32 overflow_err                    :  1; //[16]
    u32 msdu_length_err                 :  1; //[17]
    u32 tcp_udp_chksum_fail             :  1; //[18]
    u32 ip_chksum_fail                  :  1; //[19]
    u32 reserved3                       :  7; //[26:20]
    u32 mpdu_length_err                 :  1; //[27]
    u32 tkip_mic_err                    :  1; //[28]
    u32 decrypt_err                     :  1; //[29]
    u32 fcs_err                         :  1; //[30]
    u32 msdu_done                       :  1; //[31]
} __attribute__((packed));

struct rx_mpdu_start {
    u32 reserved1                       : 13; //[12:0]
    u32 encrypted                       :  1; //[13]
    u32 retry                           :  1; //[14]
    u32 reserved2                       :  1; //[15]
    u32 seq_num                         : 12; //[27:16]
    u32 reserved3                       :  4; //[31:28]
    u32 reserved4;
    u32 reserved5                       : 28; //[27:0]
    u32 tid                             :  4; //[31:28]
} __attribute__((packed));

/*Indicates the decap-format of the packet*/
enum {
    RAW=0,      // RAW: No decapsulation
    NATIVEWIFI,
    ETHERNET2,  // (DIX)
    ETHERNET    // (SNAP/LLC)
};

struct rx_msdu_start {
    u32 reserved1[2];
    u32 reserved2                       :  8; //[7:0]
    u32 decap_format                    :  2; //[9:8]
    u32 reserved3                       : 22; //[31:10]
} __attribute__((packed));

struct rx_msdu_end {
    u32 reserved1[4];
    u32 reserved2                       : 15;
    u32 last_msdu                       :  1; //[15]
    u32 reserved3                       : 16; //[31:16]
} __attribute__((packed));

struct rx_mpdu_end {
    u32 reserved1                       : 13; //[12:0]
    u32 overflow_err                    :  1; //[13]
    u32 last_mpdu                       :  1; //[14]
    u32 post_delim_err                  :  1; //[15]
    u32 reserved2                       : 12; //[27:16]
    u32 mpdu_length_err                 :  1; //[28]
    u32 tkip_mic_err                    :  1; //[29]
    u32 decrypt_err                     :  1; //[30]
    u32 fcs_err                         :  1; //[31]
} __attribute__((packed));

/* structure implemented w.r.t PKT_LOG_V2 Version */
struct rx_msdu_start_v1 {
    u32 reserved1[2];
    u32 reserved2                       :  8; //[7:0]
    u32 decap_format                    :  2; //[9:8]
    u32 reserved3                       : 22; //[31:10]
    u32 reserved4[2];
} __attribute__((packed));

struct rx_msdu_end_v1 {
    u32 reserved1[4];
    u32 reserved2                       : 15; //[14:0]
    u32 last_msdu                       :  1; //[15]
    u32 reserved3                       : 16; //[31:16]
    u32 reserved4[9];
} __attribute__((packed));
/************************************************************/

#define PREAMBLE_L_SIG_RATE     0x04
#define PREAMBLE_VHT_SIG_A_1    0x08
#define PREAMBLE_VHT_SIG_A_2    0x0c

/* Wifi Logger preamble */
#define WL_PREAMBLE_CCK  0
#define WL_PREAMBLE_OFDM 1
#define WL_PREAMBLE_HT   2
#define WL_PREAMBLE_VHT  3

#define BITMASK(x) ((1<<(x)) - 1 )
#define MAX_BA_WINDOW_SIZE 64
#define SEQ_NUM_RANGE 4096
#define BITMAP_VAR_SIZE 32

/* Contains MCS related stats */
struct rx_ppdu_start {
    u32 reserved1[4];
    u32 rssi_comb                       :  8; //[7:0]
    u32 reserved2                       : 24; //[31:8]
    u32 l_sig_rate                      :  4; //[3:0]
    u32 l_sig_rate_select               :  1; //[4]
    u32 reserved3                       : 19; //[23:5]
    u32 preamble_type                   :  8; //[31:24]
    u32 ht_sig_vht_sig_a_1              : 24; //[23:0]
    u32 reserved4                       :  8; //[31:24]
    u32 ht_sig_vht_sig_a_2              : 24; //[23:0]
    u32 reserved5                       :  8; //[31:25]
    u32 reserved6[2];
} __attribute__((packed));

struct rx_ppdu_end {
    u32 reserved1[16];
    u32 tsf_timestamp;
    u32 reserved2[5];
} __attribute__((packed));

struct rx_ppdu_end_V1 {
    u32 reserved1[18];
    u32 wb_timestamp_lower_32;
    u32 reserved2[18];
} __attribute__((packed));

#define MAX_MSDUS_PER_MPDU 3
#define MAX_RXMPDUS_PER_AMPDU 64
#define RX_HTT_HDR_STATUS_LEN 64
/* RX Data length is 256 for PKT_LOG_V2 Version */
#define RX_HTT_HDR_STATUS_LEN_V1 256

typedef struct {
    struct rx_attention attention;
    u32 reserved1;
    struct rx_mpdu_start mpdu_start;
    struct rx_msdu_start msdu_start;
    struct rx_msdu_end   msdu_end;
    struct rx_mpdu_end   mpdu_end;
    struct rx_ppdu_start ppdu_start;
    struct rx_ppdu_end   ppdu_end;
    char rx_hdr_status[RX_HTT_HDR_STATUS_LEN];
}__attribute__((packed)) rb_pkt_stats_t;

/* structure implemented w.r.t PKT_LOG_V2 Version */
typedef struct {
    struct rx_attention attention;
    u32 reserved1[2];
    struct rx_mpdu_start    mpdu_start;
    struct rx_msdu_start_v1 msdu_start;
    struct rx_msdu_end_v1   msdu_end;
    struct rx_mpdu_end      mpdu_end;
    struct rx_ppdu_start    ppdu_start;
    struct rx_ppdu_end_V1    ppdu_end;
    char rx_hdr_status[RX_HTT_HDR_STATUS_LEN_V1];
}__attribute__((packed)) rb_pkt_stats_t_v1;
/************************************************************/

/*Tx stats specific structures. */
struct ppdu_status {
    u32 ba_start_seq_num                : 12; //[11:0]
    u32 reserved1                       :  3; //[14:12]
    u32 ba_status                       :  1; //[15]
    u32 reserved2                       : 15; //[30:16]
    u32 tx_ok                           :  1; //[31]
    u32 ba_bitmap_31_0                  : 32; //[31:0]
    u32 ba_bitmap_63_32                 : 32; //[31:0]
    u32 reserved3[8];
    u32 ack_rssi_ave                    :  8; //[7:0]
    u32 reserved4                       : 16; //[23:8]
    u32 total_tries                     :  5; //[28:24]
    u32 reserved5                       :  3; //[31:29]
    u32 reserved6[4];
} __attribute__((packed));

/*Contains tx timestamp*/
struct try_status {
    u32 timestamp                       : 23; //[22:0]
    u32 reserved1                       :  1; //[23]
    u32 series                          :  1; //[24]
    u32 reserved2                       :  3; //[27:25]
    u32 packet_bw                       :  2; //[29:28]
    u32 reserved3                       :  1; //[30]
    u32 tx_packet                       :  1; //[31]
} __attribute__((packed));

struct try_list {
    struct try_status try_st[16];
} __attribute__((packed));


struct tx_ppdu_end {
    struct try_list try_list;
    struct ppdu_status stat;
} __attribute__((packed));

/*Tx MCS and data rate ralated stats */
struct series_bw {
    u32 reserved1                       : 28; //[27:0]
    u32 short_gi                        :  1; //[28]
    u32 reserved2                       :  3; //[31:29]
    u32 reserved3                       : 24; //[23:21]
    u32 rate                            :  4; //[27:24]
    u32 nss                             :  2; //[29:28]
    u32 preamble_type                   :  2; //[31:30]
    u32 reserved4[2];
} __attribute__((packed));

enum tx_bw {
    BW_20_MHZ,
    BW_40_MHZ,
    BW_80_MHZ,
    BW_160_MHZ
};

#define DATA_PROTECTED 14
struct tx_ppdu_start {
    u32 reserved1[2];
    u32 start_seq_num                   : 12; //[11:0]
    u32 reserved2                       : 20; //[31:12]
    u32 seqnum_bitmap_31_0              : 32; //[31:0]
    u32 seqnum_bitmap_63_32             : 32; //[31:0]
    u32 reserved3[8];
    u32 reserved4                       : 15; //[14:0]
    u32 ampdu                           :  1; //[15]
    u32 no_ack                          :  1; //[16]
    u32 reserved5                       : 15; //[31:17]
    u32 reserved6                       : 16; //[15:0]
    u32 frame_control                   : 16; //[31:16]
    u32 reserved7                       : 16; //[23:21]
    u32 qos_ctl                         : 16; //[31:16]
    u32 reserved8[4];
    u32 reserved9                       : 24; //[23:21]
    u32 valid_s0_bw20                   :  1; //[24]
    u32 valid_s0_bw40                   :  1; //[25]
    u32 valid_s0_bw80                   :  1; //[26]
    u32 valid_s0_bw160                  :  1; //[27]
    u32 valid_s1_bw20                   :  1; //[28]
    u32 valid_s1_bw40                   :  1; //[29]
    u32 valid_s1_bw80                   :  1; //[30]
    u32 valid_s1_bw160                  :  1; //[31]
    struct series_bw s0_bw20;
    struct series_bw s0_bw40;
    struct series_bw s0_bw80;
    struct series_bw s0_bw160;
    struct series_bw s1_bw20;
    struct series_bw s1_bw40;
    struct series_bw s1_bw80;
    struct series_bw s1_bw160;
    u32 reserved10[3];
} __attribute__((packed));

#define PKTLOG_MAX_TXCTL_WORDS 57 /* +2 words for bitmap */
typedef struct {
    u32 reserved1[3];
    union {
        u32 txdesc_ctl[PKTLOG_MAX_TXCTL_WORDS];
        struct tx_ppdu_start ppdu_start;
    }u;
} __attribute__((packed)) wh_pktlog_txctl;

/* Required stats are spread across multiple
 * events(PKTLOG_TYPE_TX_CTRL and PKTLOG_TYPE_TX_STAT here).
 * Need to aggregate the stats collected in each event and write to the
 * ring buffer only after receiving all the expected stats.
 * Need to preserve the stats in hal_info till then and use tx_stats_events
 * flag to track the events.
 * prev_seq_no: Can used to track the events that come from driver and identify
 * if any event is missed.
 */

/* PKT_LOG_V2 Base strcuture used to parse buffer */
typedef struct {
    u16 frm_ctrl;
    u8  tx_ok;
    u16 qos_ctrl;
    u64 bmap_failed;
    u64 bmap_enqueued;
} __attribute__((packed)) node_pkt_stats;

typedef u8 A_RATECODE;

/* Rate Code as per PKT_LOG_V2 Version */
typedef struct {
    A_RATECODE rateCode;
    u8 flags;
} RATE_CODE;

/* bandwidht type*/
typedef enum {
    BW_20MHZ,
    BW_40MHZ,
    BW_80MHZ,
    BW_160MHZ,
} bandwidth;

/* Preamble type*/
typedef enum {
    WIFI_HW_RATECODE_PREAM_OFDM = 0,
    WIFI_HW_RATECODE_PREAM_CCK  = 1,
    WIFI_HW_RATECODE_PREAM_HT   = 2,
    WIFI_HW_RATECODE_PREAM_VHT  = 3,
    WIFI_HW_RATECODE_PREAM_COUNT,
} WIFI_HW_RATECODE_PREAM_TYPE;

/**
 * struct index_data_rate_type - non vht data rate type
 * @rate_index: cck  rate index
 * @cck_rate: CCK supported rate table
 */
struct index_data_rate_cck_type {
    uint8_t  rate_index;
    uint16_t cck_rate[2];
};

/**
 * struct index_data_rate_type - non vht data rate type
 * @rate_index: ofdm  rate index
 * @ofdm__rate: OFDM supported rate table
 */
struct index_data_rate_ofdm_type {
    uint8_t  rate_index;
    uint16_t ofdm_rate[2];
};

/*Below CCK/OFDM table refer from firmware Arch */
/* Rate Table Based on CCK */
static struct index_data_rate_cck_type cck_mcs_nss1[] = {
    /*RC     LKbps   SKbps */
    {0x40,  {11000,  11000} },
    {0x41,  {5500,   5500} },
    {0x42,  {2000,   2000} },
    {0x43,  {1000,   1000} }
};

/* Rate Table Based on OFDM */
static struct index_data_rate_ofdm_type ofdm_mcs_nss1[] = {
    /*RC     LKbps   SKbps */
    {0x00,  {48000,  48000} },
    {0x01,  {34000,  24000} },
    {0x02,  {12000,  12000} },
    {0x03,  {6000,   6000} },
    {0x04,  {54000,  54000} },
    {0x05,  {36000,  36000} },
    {0x06,  {18000,  18000} },
    {0x07,  {9000,   9000} }
};

/**
 * struct index_data_rate_type - non vht data rate type
 * @mcs_index: mcs rate index
 * @ht20_rate: HT20 supported rate table
 * @ht40_rate: HT40 supported rate table
 */
struct index_data_rate_type {
    uint8_t  mcs_index;
    uint16_t ht20_rate[2];
    uint16_t ht40_rate[2];
};

/**
 * struct index_vht_data_rate_type - vht data rate type
 * @mcs_index: mcs rate index
 * @ht20_rate: VHT20 supported rate table
 * @ht40_rate: VHT40 supported rate table
 * @ht80_rate: VHT80 supported rate table
 */
struct index_vht_data_rate_type {
    uint8_t mcs_index;
    uint16_t ht20_rate[2];
    uint16_t ht40_rate[2];
    uint16_t ht80_rate[2];
};

/*Below HT/VHT table refer from Host Driver
 * MCS Based rate table
 * HT MCS parameters with Nss = 1
 */
static struct index_data_rate_type mcs_nss1[] = {
    /* MCS L20  S20   L40   S40 */
    {0,  {65,  72},  {135,  150 } },
    {1,  {130, 144}, {270,  300 } },
    {2,  {195, 217}, {405,  450 } },
    {3,  {260, 289}, {540,  600 } },
    {4,  {390, 433}, {815,  900 } },
    {5,  {520, 578}, {1080, 1200} },
    {6,  {585, 650}, {1215, 1350} },
    {7,  {650, 722}, {1350, 1500} }
};

/* HT MCS parameters with Nss = 2 */
static struct index_data_rate_type mcs_nss2[] = {
    /* MCS L20  S20    L40   S40 */
    {0,  {130,  144},  {270,  300 } },
    {1,  {260,  289},  {540,  600 } },
    {2,  {390,  433},  {810,  900 } },
    {3,  {520,  578},  {1080, 1200} },
    {4,  {780,  867},  {1620, 1800} },
    {5,  {1040, 1156}, {2160, 2400} },
    {6,  {1170, 1300}, {2430, 2700} },
    {7,  {1300, 1440}, {2700, 3000} }
};

/* MCS Based VHT rate table
 * MCS parameters with Nss = 1
 */
static struct index_vht_data_rate_type vht_mcs_nss1[] = {
    /* MCS L20  S20    L40   S40    L80   S80 */
    {0,  {65,   72 }, {135,  150},  {293,  325} },
    {1,  {130,  144}, {270,  300},  {585,  650} },
    {2,  {195,  217}, {405,  450},  {878,  975} },
    {3,  {260,  289}, {540,  600},  {1170, 1300} },
    {4,  {390,  433}, {810,  900},  {1755, 1950} },
    {5,  {520,  578}, {1080, 1200}, {2340, 2600} },
    {6,  {585,  650}, {1215, 1350}, {2633, 2925} },
    {7,  {650,  722}, {1350, 1500}, {2925, 3250} },
    {8,  {780,  867}, {1620, 1800}, {3510, 3900} },
    {9,  {865,  960}, {1800, 2000}, {3900, 4333} }
};

/*MCS parameters with Nss = 2*/
static struct index_vht_data_rate_type vht_mcs_nss2[] = {
    /* MCS L20  S20    L40    S40    L80    S80 */
    {0,  {130,  144},  {270,  300},  { 585,  650} },
    {1,  {260,  289},  {540,  600},  {1170, 1300} },
    {2,  {390,  433},  {810,  900},  {1755, 1950} },
    {3,  {520,  578},  {1080, 1200}, {2340, 2600} },
    {4,  {780,  867},  {1620, 1800}, {3510, 3900} },
    {5,  {1040, 1156}, {2160, 2400}, {4680, 5200} },
    {6,  {1170, 1300}, {2430, 2700}, {5265, 5850} },
    {7,  {1300, 1444}, {2700, 3000}, {5850, 6500} },
    {8,  {1560, 1733}, {3240, 3600}, {7020, 7800} },
    {9,  {1730, 1920}, {3600, 4000}, {7800, 8667} }
};
/*********************************************************/

#define RING_BUF_ENTRY_SIZE 512
#define PKT_STATS_BUF_SIZE 128
struct pkt_stats_s {
    u8 tx_stats_events;
    /* TODO: Need to handle the case if size of the stats are more
     * than 512 bytes. Currently, the tx size is 34 bytes and ring buffer entry
     * size is 12 bytes.
     */
    u8 tx_stats[PKT_STATS_BUF_SIZE];
    u8 num_msdu;
    u16 start_seq_num;
    u16 ba_seq_num;
    u32 ba_bitmap_31_0;
    u32 ba_bitmap_63_32;
    u32 tx_seqnum_bitmap_31_0;
    u32 tx_seqnum_bitmap_63_32;
    u32 shifted_bitmap_31_0;
    u32 shifted_bitmap_63_32;
    bool isBlockAck;
    u8 tx_bandwidth;
    u8 series;
};

typedef union {
    struct {
        u16 rate                            :  4;
        u16 nss                             :  2;
        u16 preamble                        :  2;
        u16 bw                              :  2;
        u16 short_gi                        :  1;
        u16 reserved                        :  5;
    } mcs_s;
    u16 mcs;
} MCS;

typedef struct {
    MCS RxMCS;
    u16 last_transmit_rate;
    u16 rssi;
    u32 timestamp;
    u8  tid;
} rx_aggr_stats;


typedef struct drv_msg_s
{
    u16 length;
    u16 event_type;
    u32 timestamp_low;
    u32 timestamp_high;
    union {
        struct {
            u32 version;
            u32 msg_seq_no;
            u32 payload_len;
            u8  payload[0];
        } __attribute__((packed)) pkt_stats_event;
    } u;
} __attribute__((packed)) drv_msg_t;

typedef enum {
    START_MONITOR = 1,
    STOP_MONITOR,
    TX_MGMT_PKT,
    TX_DATA_PKT,
    RX_MGMT_PKT,
    RX_DATA_PKT,
} pktdump_event_type;

typedef struct {
    u8 status;
    u8 type;
    u32 driver_ts;
    u16 fw_ts;
} __attribute__((packed)) pktdump_hdr;

typedef struct {
    frame_type payload_type;
    u32 driver_timestamp_usec;
    u32 firmware_timestamp_usec;
    size_t frame_len;
    char *frame_content;
} frame_info_i;

typedef struct {
    // Prefix of MD5 hash of |frame_inf.frame_content|. If frame
    // content is not provided, prefix of MD5 hash over the same data
    // that would be in frame_content, if frame content were provided.
    char md5_prefix[MD5_PREFIX_LEN];  // Prefix of MD5 hash of packet bytes
    wifi_tx_packet_fate fate;
    frame_info_i frame_inf;
} wifi_tx_report_i;

typedef struct {
    // Prefix of MD5 hash of |frame_inf.frame_content|. If frame
    // content is not provided, prefix of MD5 hash over the same data
    // that would be in frame_content, if frame content were provided.
    char md5_prefix[MD5_PREFIX_LEN];
    wifi_rx_packet_fate fate;
    frame_info_i frame_inf;
} wifi_rx_report_i;

typedef struct {
    wifi_tx_report_i tx_fate_stats[MAX_FATE_LOG_LEN];
    size_t n_tx_stats_collected;
    wifi_rx_report_i rx_fate_stats[MAX_FATE_LOG_LEN];
    size_t n_rx_stats_collected;
} packet_fate_monitor_info;

#endif