| /* 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 |
