diff --git a/dp/inc/cdp_txrx_extd_struct.h b/dp/inc/cdp_txrx_extd_struct.h index 0971a9327b..220e7a1abf 100644 --- a/dp/inc/cdp_txrx_extd_struct.h +++ b/dp/inc/cdp_txrx_extd_struct.h @@ -27,6 +27,10 @@ #define RX_ENH_CB_BUF_RESERVATION 256 #define RX_ENH_CB_BUF_ALIGNMENT 4 +#define RX_ENH_CAPTURE_TRAILER_LEN 8 +#define RX_ENH_CAPTURE_MODE_MASK 0x0F +#define RX_ENH_CAPTURE_TRAILER_ENABLE_MASK 0x10 + /** * struct cdp_rx_indication_mpdu_info - Rx MPDU info * @ppdu_id: PPDU Id diff --git a/dp/wifi3.0/dp_rx_mon_feature.c b/dp/wifi3.0/dp_rx_mon_feature.c index ad5eb9e6b2..b9e5ebc78f 100644 --- a/dp/wifi3.0/dp_rx_mon_feature.c +++ b/dp/wifi3.0/dp_rx_mon_feature.c @@ -103,6 +103,173 @@ dp_rx_populate_cdp_indication_mpdu_info( cdp_mpdu_info->per_chain_rssi[i] = ppdu_info->rx_status.rssi[i]; } +#ifdef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG +/* + * dp_rx_mon_enh_capture_set_protocol_tag() - Tags the actual nbuf with + * cached data read from TLV + * @pdev: pdev structure + * @ppdu_info: ppdu info structure from monitor status ring + * @user_id: user ID on which the PPDU is received + * @nbuf: packet buffer on which metadata have to be updated + * + * Return: none + */ +static void +dp_rx_mon_enh_capture_set_protocol_tag(struct dp_pdev *pdev, + struct hal_rx_ppdu_info *ppdu_info, + uint32_t user_id, + qdf_nbuf_t nbuf) +{ + uint32_t cce_metadata = 0; + uint16_t protocol_tag = 0; + + /** + * Since skb->cb is memset to 0, we can skip setting protocol tag to 0 + * in all the error paths. + */ + + cce_metadata = ppdu_info->rx_msdu_info[user_id].cce_metadata; + + /** + * Received CCE metadata should be + * within the valid limits + */ + if (qdf_unlikely((cce_metadata < RX_PROTOCOL_TAG_START_OFFSET) || + (cce_metadata >= (RX_PROTOCOL_TAG_START_OFFSET + + RX_PROTOCOL_TAG_MAX)))) + return; + + /** + * The CCE metadata received is just the + * packet_type + RX_PROTOCOL_TAG_START_OFFSET + */ + cce_metadata -= RX_PROTOCOL_TAG_START_OFFSET; + + /** + * Update the QDF packet with the user specified tag/metadata + * by looking up tag value for received protocol type. + */ + protocol_tag = pdev->rx_proto_tag_map[cce_metadata].tag; + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_LOW, + "%s: Setting ProtoID:%d Tag %u", __func__, + cce_metadata, protocol_tag); + qdf_nbuf_set_rx_protocol_tag(nbuf, protocol_tag); +} + +/* + * dp_rx_mon_enh_capture_tag_protocol_type() - Support protocol tagging + * for packets captured in enhanced capture mode + * @pdev: pdev structure + * @ppdu_info: ppdu info structure from monitor status ring + * @user_id: user ID on which the PPDU is received + * @nbuf: packet buffer on which tag should be updated + * + * Return: none + */ +static void +dp_rx_mon_enh_capture_tag_protocol_type(struct dp_pdev *pdev, + struct hal_rx_ppdu_info *ppdu_info, + uint32_t user_id, qdf_nbuf_t nbuf) +{ + /** + * Since skb->cb is memset to 0, we can skip setting protocol tag to 0 + * in all the error paths. + */ + if (!pdev->is_rx_protocol_tagging_enabled) + return; + + /** + * It is assumed that we have already received RX Header/ MSDU + * Start TLV for this MSDU. + */ + dp_rx_mon_enh_capture_set_protocol_tag(pdev, ppdu_info, + user_id, nbuf); + + /* Reset MSDU tag variables on completion of every MSDU tag */ + ppdu_info->rx_msdu_info[user_id].cce_metadata = 0; +} + +/* + * dp_rx_mon_enh_capture_set_protocol_tag_in_trailer - update msdu trailer + * with protocol tag + * @nbuf: packet buffer on which metadata have to be updated + * @trailer: pointer to rx monitor-lite trailer + * + * Return: void + */ +static inline +void dp_rx_mon_enh_capture_set_protocol_tag_in_trailer(qdf_nbuf_t nbuf, + void *trailer) +{ + uint16_t protocol_tag = qdf_nbuf_get_rx_protocol_tag(nbuf); + struct dp_rx_mon_enh_trailer_data *nbuf_trailer = + (struct dp_rx_mon_enh_trailer_data *)trailer; + + if (protocol_tag != 0) + nbuf_trailer->protocol_tag = protocol_tag; +} + +#else +static void +dp_rx_mon_enh_capture_tag_protocol_type(struct dp_pdev *pdev, + struct hal_rx_ppdu_info *ppdu_info, + uint32_t user_id, qdf_nbuf_t nbuf) +{ +} + +static void +dp_rx_mon_enh_capture_set_protocol_tag(struct dp_pdev *pdev, + struct hal_rx_ppdu_info *ppdu_info, + uint32_t user_id, qdf_nbuf_t nbuf) +{ +} + +static inline +void dp_rx_mon_enh_capture_set_protocol_tag_in_trailer(qdf_nbuf_t nbuf, + void *trailer) +{ +} +#endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG */ + +/* + * dp_rx_mon_enh_capture_update_trailer() - Update trailer with custom data + * @pdev: pdev structure + * @nbuf: packet buffer on which metadata have to be updated + * + * Return: return number of bytes updated in the tail + */ +static inline +uint16_t dp_rx_mon_enh_capture_update_trailer(struct dp_pdev *pdev, + qdf_nbuf_t nbuf) +{ + uint64_t trailer; + uint8_t *dest; + struct dp_rx_mon_enh_trailer_data *nbuf_trailer = + (struct dp_rx_mon_enh_trailer_data *)&trailer; + + if (qdf_unlikely(qdf_nbuf_len(nbuf) < sizeof(trailer))) + return 0; + + trailer = RX_MON_CAP_ENH_TRAILER; + + dp_rx_mon_enh_capture_set_protocol_tag_in_trailer(nbuf, nbuf_trailer); + + /** + * Overwrite last 8 bytes of data with trailer. This is ok since we + * do not care about the data in this debug mode. + */ + qdf_nbuf_trim_tail(nbuf, sizeof(trailer)); + dest = qdf_nbuf_put_tail(nbuf, sizeof(trailer)); + if (qdf_likely(dest)) { + qdf_mem_copy(dest, &trailer, sizeof(trailer)); + } else { + dp_err("Unable to add tail room"); + return 0; + } + + return sizeof(trailer); +} + /* * dp_rx_handle_enh_capture() - Deliver Rx enhanced capture data * @pdev: pdev ctx @@ -129,6 +296,7 @@ dp_rx_handle_enh_capture(struct dp_soc *soc, struct dp_pdev *pdev, dp_rx_free_msdu_list(msdu_list); mpdu_ind = &pdev->mpdu_ind[user]; mpdu_info = &mpdu_ind->mpdu_info; + pdev->is_mpdu_hdr[user] = true; dp_rx_populate_cdp_indication_mpdu_info( pdev, &pdev->ppdu_info, mpdu_info, user); @@ -148,16 +316,14 @@ dp_rx_handle_enh_capture(struct dp_soc *soc, struct dp_pdev *pdev, } return QDF_STATUS_SUCCESS; } - /* * dp_rx_mon_enh_capture_process() - Rx enhanced capture mode - * processing. + * processing. * @pdev: pdev structure * @tlv_status: processed TLV status * @status_nbuf: monitor status ring buffer * @ppdu_info: ppdu info structure from monitor status ring * @nbuf_used: nbuf need a clone - * @rx_enh_capture_mode: Rx enhanced capture mode * * Return: none */ @@ -165,8 +331,7 @@ void dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, qdf_nbuf_t status_nbuf, struct hal_rx_ppdu_info *ppdu_info, - bool *nbuf_used, - uint32_t rx_enh_capture_mode) + bool *nbuf_used) { qdf_nbuf_t nbuf; struct msdu_list *msdu_list; @@ -174,14 +339,14 @@ dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, struct dp_soc *soc; qdf_nbuf_t mpdu_head; - if (rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_DISABLED) + if (pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_DISABLED) return; user_id = ppdu_info->user_id; if ((tlv_status == HAL_TLV_STATUS_HEADER) && ( - (rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU_MSDU) || - ((rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) && + (pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU_MSDU) || + ((pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) && pdev->is_mpdu_hdr[user_id]))) { if (*nbuf_used) { @@ -194,9 +359,10 @@ dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, if (!nbuf) return; + /* Truncate 4 bytes containing PPDU ID */ dp_nbuf_set_data_and_len(nbuf, ppdu_info->data, - ppdu_info->hdr_len - - 4); + ppdu_info->hdr_len - 4); + if (pdev->is_mpdu_hdr[user_id]) { soc = pdev->soc; mpdu_head = qdf_nbuf_alloc(soc->osdev, @@ -239,6 +405,44 @@ dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, } pdev->is_mpdu_hdr[user_id] = true; } + + /* Tag the MSDU/MPDU if a cce_metadata is valid */ + if ((tlv_status == HAL_TLV_STATUS_MSDU_END) && + (pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU_MSDU)) { + /** + * Proceed only if this is a data frame. + * We could also rx probes, etc. + */ + if (!(ppdu_info->nac_info.fc_valid && + (IEEE80211_FC0_TYPE_DATA == + (ppdu_info->nac_info.frame_control & + IEEE80211_FC0_TYPE_MASK)))) + return; + + msdu_list = &pdev->msdu_list[user_id]; + qdf_assert_always(msdu_list->head); + + /** + * Directly move the last MSDU and fetch the same. + * The earlier MSDUs should already be tagged as the + * packets are tagged at the end of every RX + * MSDU. + */ + nbuf = msdu_list->tail; + + /** + * Set the protocol tag value from CCE metadata. + */ + dp_rx_mon_enh_capture_tag_protocol_type(pdev, ppdu_info, + user_id, nbuf); + + if (!pdev->is_rx_enh_capture_trailer_enabled) + return; + /** + * Update necessary information in trailer (for debug purpose) + */ + dp_rx_mon_enh_capture_update_trailer(pdev, nbuf); + } } /* @@ -249,20 +453,33 @@ dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, * Return: 0 for success. nonzero for failure. */ QDF_STATUS -dp_config_enh_rx_capture(struct cdp_pdev *pdev_handle, int val) +dp_config_enh_rx_capture(struct cdp_pdev *pdev_handle, uint8_t val) { struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle; + uint8_t rx_cap_mode = (val & RX_ENH_CAPTURE_MODE_MASK); + bool is_mpdu_hdr = false; + uint8_t user_id; - if (pdev->mcopy_mode || (val < CDP_RX_ENH_CAPTURE_DISABLED) || - (val > CDP_RX_ENH_CAPTURE_MPDU_MSDU)) { - dp_err("Invalid mode"); + if (pdev->mcopy_mode || (rx_cap_mode < CDP_RX_ENH_CAPTURE_DISABLED) || + (rx_cap_mode > CDP_RX_ENH_CAPTURE_MPDU_MSDU)) { + dp_err("Invalid mode: %d", rx_cap_mode); return QDF_STATUS_E_INVAL; } - if (pdev->rx_enh_capture_mode) - dp_reset_monitor_mode(pdev_handle); + dp_reset_monitor_mode(pdev_handle); - pdev->rx_enh_capture_mode = val; + pdev->rx_enh_capture_mode = rx_cap_mode; + + if (rx_cap_mode != CDP_RX_ENH_CAPTURE_DISABLED) + is_mpdu_hdr = true; + + for (user_id = 0; user_id < MAX_MU_USERS; user_id++) + pdev->is_mpdu_hdr[user_id] = is_mpdu_hdr; + + /* Use a bit from val to enable MSDU trailer for internal debug use */ + pdev->is_rx_enh_capture_trailer_enabled = + (val & RX_ENH_CAPTURE_TRAILER_ENABLE_MASK) ? true : false; return dp_pdev_configure_monitor_rings(pdev); } -#endif + +#endif /* WLAN_RX_PKT_CAPTURE_ENH */ diff --git a/dp/wifi3.0/dp_rx_mon_feature.h b/dp/wifi3.0/dp_rx_mon_feature.h index db8bd58cf0..0d27222592 100644 --- a/dp/wifi3.0/dp_rx_mon_feature.h +++ b/dp/wifi3.0/dp_rx_mon_feature.h @@ -55,7 +55,6 @@ dp_rx_handle_enh_capture(struct dp_soc *soc, struct dp_pdev *pdev, * @status_nbuf: monitor status ring buffer * @ppdu_info: ppdu info structure from monitor status ring * @nbuf_used: nbuf need a clone - * @rx_enh_capture_mode: Rx enhanced capture mode * * Return: none */ @@ -63,8 +62,7 @@ void dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, qdf_nbuf_t status_nbuf, struct hal_rx_ppdu_info *ppdu_info, - bool *nbuf_used, - uint32_t rx_enh_capture_mode); + bool *nbuf_used); /* * dp_config_enh_rx_capture()- API to enable/disable enhanced rx capture @@ -74,6 +72,6 @@ dp_rx_mon_enh_capture_process(struct dp_pdev *pdev, uint32_t tlv_status, * Return: 0 for success. nonzero for failure. */ QDF_STATUS -dp_config_enh_rx_capture(struct cdp_pdev *pdev_handle, int val); -#endif -#endif +dp_config_enh_rx_capture(struct cdp_pdev *pdev_handle, uint8_t val); +#endif /* WLAN_RX_PKT_CAPTURE_ENH */ +#endif /* _DP_RX_MON_FEATURE_H_ */