samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Modify set 2 of ctrl_ops in dp to for umac-dp decoupling

Browse Source 
Change set 2 of ctrl_ops APIs to replace pdev, vdev and peer
dp handles with pdev_id, vdev_id and peer mac address
along with dp soc handle

Change-Id: I3f180c9c360d564f0b229b447074ad23b7c0a737
This commit is contained in:
Pavankumar Nandeshwar
2019-09-30 18:43:03 +05:30
committed by nshrivas
parent e6f443f27a
commit 0ce3870654
18 changed files with 759 additions and 1564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
dp/inc/cdp_txrx_cmn.h
View File

@@ -127,40 +127,6 @@ cdp_soc_attach_target(ol_txrx_soc_handle soc)
}
static inline int
cdp_soc_get_nss_cfg(ol_txrx_soc_handle soc)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg)
return 0;
return soc->ops->cmn_drv_ops->txrx_soc_get_nss_cfg(soc);
}
static inline void
cdp_soc_set_nss_cfg(ol_txrx_soc_handle soc, uint32_t config)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg)
return;
soc->ops->cmn_drv_ops->txrx_soc_set_nss_cfg(soc, config);
}
static inline struct cdp_vdev *
cdp_vdev_attach(ol_txrx_soc_handle soc, uint8_t pdev_id,
uint8_t *vdev_mac_addr, uint8_t vdev_id,
@@ -820,11 +786,12 @@ cdp_set_privacy_filters(ol_txrx_soc_handle soc, uint8_t vdev_id,
}
static inline int
cdp_set_monitor_filter(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
cdp_set_monitor_filter(ol_txrx_soc_handle soc, uint8_t pdev_id,
struct cdp_monitor_filter *filter_val)
{
if (soc->ops->mon_ops->txrx_set_advance_monitor_filter)
return soc->ops->mon_ops->txrx_set_advance_monitor_filter(pdev,
return soc->ops->mon_ops->txrx_set_advance_monitor_filter(soc,
pdev_id,
filter_val);
return 0;
}
@@ -944,24 +911,6 @@ cdp_peer_unmap_sync_cb_set(ol_txrx_soc_handle soc,
unmap_resp_cb);
}
static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->txrx_get_tx_pending)
return 0;
return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev);
}
/*
* cdp_data_tx_cb_set(): set the callback for non standard tx
* @soc - datapath soc handle
@@ -1590,56 +1539,6 @@ static inline void cdp_set_pdev_dscp_tid_map(ol_txrx_soc_handle soc,
map_id, tos, tid);
}
/**
* cdp_hmmc_tid_override_en(): Function to enable hmmc tid override.
* @soc : soc handle
* @pdev: pdev handle
* @val: hmmc-dscp flag value
*
* Return: void
*/
static inline void cdp_hmmc_tid_override_en(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, bool val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->hmmc_tid_override_en)
return;
soc->ops->cmn_drv_ops->hmmc_tid_override_en(pdev, val);
}
/**
* cdp_set_hmmc_tid_val(): Function to set hmmc tid value.
* @soc : soc handle
* @pdev: pdev handle
* @tid: tid value
*
* Return: void
*/
static inline void cdp_set_hmmc_tid_val(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, uint8_t tid)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->set_hmmc_tid_val)
return;
soc->ops->cmn_drv_ops->set_hmmc_tid_val(pdev, tid);
}
/**
* cdp_flush_cache_rx_queue() - flush cache rx queue frame
*
@@ -2060,89 +1959,6 @@ cdp_tx_send(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf)
soc->ops->cmn_drv_ops->tx_send(soc, vdev_id, nbuf);
}
/*
* cdp_get_pdev_id_frm_pdev() - return pdev_id from pdev
* @soc: opaque soc handle
* @pdev: data path pdev handle
*
* Return: pdev_id
*/
static inline
uint8_t cdp_get_pdev_id_frm_pdev(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev)
return soc->ops->cmn_drv_ops->txrx_get_pdev_id_frm_pdev(pdev);
return 0;
}
/*
* cdp_get_vow_config_frm_pdev() - return carrier_vow_config from pdev
* @soc: opaque soc handle
* @pdev: data path pdev handle
*
* Return: carrier_vow_config
*/
static inline
bool cdp_get_vow_config_frm_pdev(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev)
return soc->ops->cmn_drv_ops->txrx_get_vow_config_frm_pdev(
pdev);
return 0;
}
/**
* cdp_pdev_set_chan_noise_floor() - Set channel noise floor to DP layer
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @chan_noise_floor: Channel Noise Floor (in dbM) obtained from control path
*
* Return: None
*/
static inline
void cdp_pdev_set_chan_noise_floor(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev,
int16_t chan_noise_floor)
{
if (soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor)
return soc->ops->cmn_drv_ops->txrx_pdev_set_chan_noise_floor(
pdev, chan_noise_floor);
}
/**
* cdp_set_nac() - set nac
* @soc: opaque soc handle
* @vdev_id: id of vdev handle
* @peer_mac: mac of data path peer handle
*
*/
static inline
void cdp_set_nac(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac)
{
if (soc->ops->cmn_drv_ops->txrx_set_nac)
soc->ops->cmn_drv_ops->txrx_set_nac(soc, vdev_id, peer_mac);
}
/**
* cdp_set_pdev_tx_capture() - set pdev tx_capture
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @val: value of pdev_tx_capture
*
* Return: status: 0 - Success, non-zero: Failure
*/
static inline
QDF_STATUS cdp_set_pdev_tx_capture(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, int val)
{
if (soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture)
return soc->ops->cmn_drv_ops->txrx_set_pdev_tx_capture(pdev,
val);
return QDF_STATUS_SUCCESS;
}
/**
* cdp_set_pdev_pcp_tid_map() - set pdev pcp-tid-map
* @soc: opaque soc handle
@@ -2174,37 +1990,6 @@ QDF_STATUS cdp_set_pdev_pcp_tid_map(ol_txrx_soc_handle soc,
pcp, tid);
}
/**
* cdp_set_pdev_pcp_tidmap_prty() - set pdev tidmap priority
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @val: priority value
*
* This API is used to configure the tidmap priority for a pdev.
* The tidmap priority decides which mapping, namely DSCP-TID, SVLAN_PCP-TID,
* CVLAN_PCP-TID will be used.
*
* Return: QDF_STATUS_SUCCESS if value set successfully
* QDF_STATUS_E_INVAL false if error
*/
static inline
QDF_STATUS cdp_set_pdev_tidmap_prty(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev_handle,
uint32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
return QDF_STATUS_E_INVAL;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->set_pdev_tidmap_prty)
return QDF_STATUS_E_INVAL;
return soc->ops->cmn_drv_ops->set_pdev_tidmap_prty(pdev_handle, val);
}
/**
* cdp_get_peer_mac_from_peer_id() - get peer mac addr from peer id
* @soc: opaque soc handle
@@ -2643,70 +2428,6 @@ QDF_STATUS cdp_set_vdev_pcp_tid_map(ol_txrx_soc_handle soc,
pcp, tid);
}
/**
* cdp_set_vdev_tidmap_tbl_id() - set vdev tidmap table id
*
* @soc: opaque soc handle
* @vdev: data path vdev handle
* @mapid: value of mapid
*
* This API is used to configure the table-id of the tid-mapping for a vdev.
* Table '0' is for using the pdev's pcp-tid mapping and '1' is for using
* the vdev's pcp-tid mapping.
*
* Return: QDF_STATUS_SUCCESS if value set successfully
* QDF_STATUS_E_INVAL false if error
*/
static inline
QDF_STATUS cdp_set_vdev_tidmap_tbl_id(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev_handle,
uint8_t mapid)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
return QDF_STATUS_E_INVAL;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->set_vdev_tidmap_tbl_id)
return QDF_STATUS_E_INVAL;
return soc->ops->cmn_drv_ops->set_vdev_tidmap_tbl_id(vdev_handle,
mapid);
}
/**
* cdp_set_vdev_tidmap_prty() - set vdev tidmap priority
* @soc: opaque soc handle
* @vdev: data path vdev handle
* @prio: tidmap priority value
*
* This API is used to configure the tidmap priority for a vdev.
* The tidmap priority decides which mapping, namely DSCP-TID, SVLAN_PCP-TID,
* CVLAN_PCP-TID will be used.
* The vdev tidmap priority will be used only when the tidmap_tbl_id is '1'.
*
* Return: QDF_STATUS_SUCCESS if value set successfully
* QDF_STATUS_E_INVAL false if error
*/
static inline
QDF_STATUS cdp_set_vdev_tidmap_prty(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev_handle, uint8_t prio)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
return QDF_STATUS_E_INVAL;
}
if (!soc->ops->cmn_drv_ops ||
!soc->ops->cmn_drv_ops->set_vdev_tidmap_prty)
return QDF_STATUS_E_INVAL;
return soc->ops->cmn_drv_ops->set_vdev_tidmap_prty(vdev_handle, prio);
}
/**
* cdp_tx_send_exc() - Transmit a frame on a given vdev in exception path
*

13
dp/inc/cdp_txrx_cmn_reg.h
View File

@@ -77,8 +77,8 @@ void *dp_soc_init_wifi3(struct cdp_soc_t *soc,
HTC_HANDLE htc_handle, qdf_device_t qdf_osdev,
struct ol_if_ops *ol_ops, uint16_t device_id);
#else
static inline
struct cdp_soc_t *dp_soc_attach_wifi3(struct cdp_ctrl_objmgr_psoc *ctrl_psoc,
static inline struct cdp_soc_t *
dp_soc_attach_wifi3(struct cdp_ctrl_objmgr_psoc *ctrl_psoc,
struct hif_opaque_softc *hif_handle,
HTC_HANDLE htc_handle,
qdf_device_t qdf_osdev,
@@ -99,9 +99,12 @@ void *dp_soc_init_wifi3(struct cdp_soc_t *soc,
}
#endif /* QCA_WIFI_QCA8074 */
static inline ol_txrx_soc_handle cdp_soc_attach(
u_int16_t devid, void *hif_handle, void *psoc,
HTC_HANDLE htc_handle, qdf_device_t qdf_dev,
static inline
ol_txrx_soc_handle cdp_soc_attach(u_int16_t devid,
struct hif_opaque_softc *hif_handle,
struct cdp_ctrl_objmgr_psoc *psoc,
HTC_HANDLE htc_handle,
qdf_device_t qdf_dev,
struct ol_if_ops *dp_ol_if_ops)
{
switch (devid) {

12
dp/inc/cdp_txrx_cmn_struct.h
View File

@@ -774,12 +774,12 @@ typedef QDF_STATUS(*ol_txrx_get_key_fp)(void *osif_dev, uint8_t *key_buf, uint8_
* @osif_dev - the virtual device's OS shim object
* @list_head - poniter to head of receive packet queue to decap
* @list_tail - poniter to tail of receive packet queue to decap
* @peer - Peer handler
* @peer_mac - mac address of peer handler
*/
typedef QDF_STATUS(*ol_txrx_rsim_rx_decap_fp)(void *osif_dev,
qdf_nbuf_t *list_head,
qdf_nbuf_t *list_tail,
struct cdp_peer *peer);
uint8_t *peer_mac);
/* ol_txrx_rx_fp - external tx free function to read per packet stats and
* free tx buffer externally
@@ -997,6 +997,8 @@ enum cdp_peer_param_type {
* @CDP_FILTER_MCAST_DATA: filter multicast data
* @CDP_FILTER_NO_DATA: filter no data
* @CDP_MONITOR_CHANNEL: monitor channel
* @CDP_MONITOR_FREQUENCY: monitor frequency
* @CDP_CONFIG_BSS_COLOR: configure bss color
*/
enum cdp_pdev_param_type {
CDP_CONFIG_DEBUG_SNIFFER,
@@ -1024,6 +1026,8 @@ enum cdp_pdev_param_type {
CDP_FILTER_MCAST_DATA,
CDP_FILTER_NO_DATA,
CDP_MONITOR_CHANNEL,
CDP_MONITOR_FREQUENCY,
CDP_CONFIG_BSS_COLOR,
};
/*
@@ -1069,6 +1073,8 @@ enum cdp_pdev_param_type {
* @cdp_pdev_param_chn_noise_flr: set channel noise floor
* @cdp_pdev_param_cfg_vow: set/get vow config
* @cdp_pdev_param_tidq_override: set/get tid queue override
* @cdp_pdev_param_mon_freq: set monitor frequency
* @cdp_pdev_param_bss_color: configure bss color
* @cdp_pdev_param_tidmap_prty: set/get tid map prty
* @cdp_pdev_param_tx_pending: get tx pending
* @cdp_pdev_param_fltr_neigh_peers: filter neighbour peers
@@ -1125,7 +1131,9 @@ typedef union cdp_config_param_t {
uint8_t cdp_pdev_param_igmpmld_tid;
uint8_t cdp_pdev_param_arp_dbg_conf;
uint8_t cdp_pdev_param_tidq_override;
uint8_t cdp_pdev_param_bss_color;
uint16_t cdp_pdev_param_chn_noise_flr;
qdf_freq_t cdp_pdev_param_mon_freq;
int cdp_pdev_param_dbg_snf;
int cdp_pdev_param_bpr_enable;
int cdp_pdev_param_monitor_chan;

417
dp/inc/cdp_txrx_ctrl.h
View File

@@ -49,7 +49,7 @@ static inline int cdp_is_target_ar900b
/* WIN */
static inline int
cdp_mempools_attach(ol_txrx_soc_handle soc, void *ctrl_pdev)
cdp_mempools_attach(ol_txrx_soc_handle soc)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -62,36 +62,7 @@ cdp_mempools_attach(ol_txrx_soc_handle soc, void *ctrl_pdev)
!soc->ops->ctrl_ops->txrx_mempools_attach)
return 0;
return soc->ops->ctrl_ops->txrx_mempools_attach(ctrl_pdev);
}
/**
* @brief set filter neighbour peers
* @details
* This defines interface function to set neighbour peer filtering.
*
* @param soc - the pointer to soc object
* @param pdev - the pointer physical device object
* @param val - the enable/disable value
* @return - int
*/
static inline int
cdp_set_filter_neighbour_peers(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, u_int32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_filter_neighbour_peers)
return 0;
return soc->ops->ctrl_ops->txrx_set_filter_neighbour_peers
(pdev, val);
return soc->ops->ctrl_ops->txrx_mempools_attach(soc);
}
/**
@@ -125,143 +96,6 @@ cdp_update_filter_neighbour_peers(ol_txrx_soc_handle soc,
(soc, vdev_id, cmd, macaddr);
}
/**
* @brief set the safemode of the device
* @details
* This flag is used to bypass the encrypt and decrypt processes when send and
* receive packets. It works like open AUTH mode, HW will treate all packets
* as non-encrypt frames because no key installed. For rx fragmented frames,
* it bypasses all the rx defragmentaion.
*
* @param vdev - the data virtual device object
* @param val - the safemode state
* @return - void
*/
static inline void
cdp_set_safemode(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, u_int32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_safemode)
return;
soc->ops->ctrl_ops->txrx_set_safemode(vdev, val);
}
/**
* @brief configure the drop unencrypted frame flag
* @details
* Rx related. When set this flag, all the unencrypted frames
* received over a secure connection will be discarded
*
* @param vdev - the data virtual device object
* @param val - flag
* @return - void
*/
static inline void
cdp_set_drop_unenc(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, u_int32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_drop_unenc)
return;
soc->ops->ctrl_ops->txrx_set_drop_unenc(vdev, val);
}
/**
* @brief set the Tx encapsulation type of the VDEV
* @details
* This will be used to populate the HTT desc packet type field during Tx
*
* @param vdev - the data virtual device object
* @param val - the Tx encap type (htt_cmn_pkt_type)
* @return - void
*/
static inline void
cdp_set_tx_encap_type(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, enum htt_cmn_pkt_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_tx_encap_type)
return;
soc->ops->ctrl_ops->txrx_set_tx_encap_type(vdev, val);
}
/**
* @brief set the Rx decapsulation type of the VDEV
* @details
* This will be used to configure into firmware and hardware which format to
* decap all Rx packets into, for all peers under the VDEV.
*
* @param vdev - the data virtual device object
* @param val - the Rx decap mode (htt_cmn_pkt_type)
* @return - void
*/
static inline void
cdp_set_vdev_rx_decap_type(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, enum htt_cmn_pkt_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_vdev_rx_decap_type)
return;
soc->ops->ctrl_ops->txrx_set_vdev_rx_decap_type
(vdev, val);
}
/**
* @brief get the Rx decapsulation type of the VDEV
*
* @param vdev - the data virtual device object
* @return - the Rx decap type (htt_cmn_pkt_type)
*/
static inline enum htt_cmn_pkt_type
cdp_get_vdev_rx_decap_type(ol_txrx_soc_handle soc, struct cdp_vdev *vdev)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_get_vdev_rx_decap_type)
return 0;
return soc->ops->ctrl_ops->txrx_get_vdev_rx_decap_type(vdev);
}
/**
* @brief set the Reo Destination ring for the pdev
* @details
@@ -323,77 +157,34 @@ cdp_get_pdev_reo_dest(ol_txrx_soc_handle soc, uint8_t pdev_id)
* updates the peer/node-related parameters within rate-control
* context of the peer at association.
*
* @param peer - pointer to the node's object
* @param soc - pointer to the soc
* @param vdev_id - id of the pointer to vdev
* @param peer_mac - mac address of the node's object
* @authorize - either to authorize or unauthorize peer
*
* @return none
* @return QDF_STATUS
*/
static inline void
cdp_peer_authorize(ol_txrx_soc_handle soc,
struct cdp_peer *peer, u_int32_t authorize)
static inline QDF_STATUS
cdp_peer_authorize(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *peer_mac,
u_int32_t authorize)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_peer_authorize)
return;
return QDF_STATUS_E_FAILURE;
soc->ops->ctrl_ops->txrx_peer_authorize
(peer, authorize);
}
/* Should be ol_txrx_ctrl_api.h */
static inline void cdp_set_mesh_mode
(ol_txrx_soc_handle soc, struct cdp_vdev *vdev, u_int32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_mesh_mode)
return;
soc->ops->ctrl_ops->txrx_set_mesh_mode(vdev, val);
}
/**
* @brief set mesh rx filter
* @details based on the bits enabled in the filter packets has to be dropped.
*
* @param soc - pointer to the soc
* @param vdev - the data virtual device object
* @param val - value to be set
* @return - void
*/
static inline
void cdp_set_mesh_rx_filter(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, uint32_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_mesh_rx_filter)
return;
soc->ops->ctrl_ops->txrx_set_mesh_rx_filter(vdev, val);
return soc->ops->ctrl_ops->txrx_peer_authorize
(soc, vdev_id, peer_mac, authorize);
}
static inline void cdp_tx_flush_buffers
(ol_txrx_soc_handle soc, struct cdp_vdev *vdev)
(ol_txrx_soc_handle soc, uint8_t vdev_id)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -406,65 +197,179 @@ static inline void cdp_tx_flush_buffers
!soc->ops->ctrl_ops->tx_flush_buffers)
return;
soc->ops->ctrl_ops->tx_flush_buffers(vdev);
soc->ops->ctrl_ops->tx_flush_buffers(soc, vdev_id);
}
static inline uint32_t cdp_txrx_get_vdev_param(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev,
enum cdp_vdev_param_type type)
static inline QDF_STATUS cdp_txrx_get_vdev_param(ol_txrx_soc_handle soc,
uint8_t vdev_id,
enum cdp_vdev_param_type type,
cdp_config_param_type *val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return -1;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_get_vdev_param) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: callback not registered:", __func__);
return -1;
return QDF_STATUS_E_FAILURE;
}
return soc->ops->ctrl_ops->txrx_get_vdev_param(vdev, type);
return soc->ops->ctrl_ops->txrx_get_vdev_param(soc, vdev_id,
type, val);
}
static inline void cdp_txrx_set_vdev_param(ol_txrx_soc_handle soc,
struct cdp_vdev *vdev, enum cdp_vdev_param_type type,
uint32_t val)
static inline QDF_STATUS
cdp_txrx_set_vdev_param(ol_txrx_soc_handle soc,
uint8_t vdev_id, enum cdp_vdev_param_type type,
cdp_config_param_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_vdev_param)
return;
return QDF_STATUS_E_FAILURE;
soc->ops->ctrl_ops->txrx_set_vdev_param(vdev, type, val);
return soc->ops->ctrl_ops->txrx_set_vdev_param(soc, vdev_id,
type, val);
}
static inline void
cdp_peer_set_nawds(ol_txrx_soc_handle soc,
struct cdp_peer *peer, uint8_t value)
static inline QDF_STATUS
cdp_txrx_set_psoc_param(ol_txrx_soc_handle soc,
enum cdp_psoc_param_type type,
cdp_config_param_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_peer_set_nawds)
return;
!soc->ops->ctrl_ops->txrx_set_psoc_param)
return QDF_STATUS_E_FAILURE;
soc->ops->ctrl_ops->txrx_peer_set_nawds
(peer, value);
return soc->ops->ctrl_ops->txrx_set_psoc_param(soc, type, val);
}
static inline QDF_STATUS
cdp_txrx_get_psoc_param(ol_txrx_soc_handle soc,
enum cdp_psoc_param_type type,
cdp_config_param_type *val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_get_psoc_param)
return QDF_STATUS_E_FAILURE;
return soc->ops->ctrl_ops->txrx_get_psoc_param(soc, type, val);
}
/**
* cdp_txrx_set_pdev_param() - set pdev parameter
* @soc: opaque soc handle
* @pdev_id: id of data path pdev handle
* @type: param type
* @val: value
*
* Return: status: 0 - Success, non-zero: Failure
*/
static inline QDF_STATUS cdp_txrx_set_pdev_param(ol_txrx_soc_handle soc,
uint8_t pdev_id,
enum cdp_pdev_param_type type,
cdp_config_param_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_pdev_param)
return QDF_STATUS_E_FAILURE;
return soc->ops->ctrl_ops->txrx_set_pdev_param
(soc, pdev_id, type, val);
}
/**
* cdp_txrx_set_peer_param() - set pdev parameter
* @soc: opaque soc handle
* @vdev_id: id of data path vdev handle
* @peer_mac: peer mac address
* @type: param type
* @val: value
*
* Return: status: 0 - Success, non-zero: Failure
*/
static inline QDF_STATUS cdp_txrx_set_peer_param(ol_txrx_soc_handle soc,
uint8_t vdev_id,
uint8_t *peer_mac,
enum cdp_peer_param_type type,
cdp_config_param_type val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_peer_param)
return QDF_STATUS_E_FAILURE;
return soc->ops->ctrl_ops->txrx_set_peer_param
(soc, vdev_id, peer_mac, type, val);
}
/**
* cdp_txrx_get_peer_param() - set pdev parameter
* @soc: opaque soc handle
* @vdev_id: id of data path vdev handle
* @peer_mac: peer mac address
* @type: param type
* @val: address of buffer
*
* Return: status
*/
static inline QDF_STATUS cdp_txrx_get_peer_param(ol_txrx_soc_handle soc,
uint8_t vdev_id,
uint8_t *peer_mac,
enum cdp_peer_param_type type,
cdp_config_param_type *val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_get_peer_param)
return QDF_STATUS_E_FAILURE;
return soc->ops->ctrl_ops->txrx_get_peer_param
(soc, vdev_id, peer_mac, type, val);
}
#ifdef QCA_MULTIPASS_SUPPORT
@@ -489,32 +394,32 @@ cdp_peer_set_vlan_id(ol_txrx_soc_handle soc, uint8_t vdev_id,
#endif
/**
* cdp_txrx_set_pdev_param() - set pdev parameter
* cdp_txrx_get_pdev_param() - get pdev parameter
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @pdev_id: id of data path pdev handle
* @type: param type
* @val: value of pdev_tx_capture
* @value: address of value buffer
*
* Return: status: 0 - Success, non-zero: Failure
* Return: status
*/
static inline QDF_STATUS cdp_txrx_set_pdev_param(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev,
static inline QDF_STATUS cdp_txrx_get_pdev_param(ol_txrx_soc_handle soc,
uint8_t pdev_id,
enum cdp_pdev_param_type type,
uint32_t val)
cdp_config_param_type *value)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance:", __func__);
QDF_BUG(0);
return QDF_STATUS_SUCCESS;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->ctrl_ops ||
!soc->ops->ctrl_ops->txrx_set_pdev_param)
return QDF_STATUS_SUCCESS;
!soc->ops->ctrl_ops->txrx_get_pdev_param)
return QDF_STATUS_E_FAILURE;
return soc->ops->ctrl_ops->txrx_set_pdev_param
(pdev, type, val);
return soc->ops->ctrl_ops->txrx_get_pdev_param
(soc, pdev_id, type, value);
}
/**

25
dp/inc/cdp_txrx_host_stats.h
View File

@@ -705,29 +705,4 @@ cdp_host_get_radio_stats(ol_txrx_soc_handle soc,
return soc->ops->host_stats_ops->txrx_get_radio_stats(soc, pdev_id,
buf);
}
/**
* @brief confgure rate stats at soc
*
* @param soc - opaque soc handle
* @param val - capabilities
* @return - QDF_STATUS
*/
static inline QDF_STATUS
cdp_soc_configure_rate_stats(ol_txrx_soc_handle soc, uint8_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->host_stats_ops ||
!soc->ops->host_stats_ops->configure_rate_stats)
return QDF_STATUS_E_FAILURE;
return soc->ops->host_stats_ops->configure_rate_stats(soc, val);
}
#endif /* _CDP_TXRX_HOST_STATS_H_ */

102
dp/inc/cdp_txrx_me.h
View File

@@ -28,67 +28,8 @@
/* TODO: adf need to be replaced with qdf */
#include "cdp_txrx_handle.h"
static inline u_int16_t
cdp_tx_desc_alloc_and_mark_for_mcast_clone(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, u_int16_t buf_count)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->me_ops ||
!soc->ops->me_ops->tx_desc_alloc_and_mark_for_mcast_clone)
return 0;
return soc->ops->me_ops->
tx_desc_alloc_and_mark_for_mcast_clone
(pdev, buf_count);
}
static inline u_int16_t
cdp_tx_desc_free_and_unmark_for_mcast_clone(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, u_int16_t buf_count)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->me_ops ||
!soc->ops->me_ops->tx_desc_free_and_unmark_for_mcast_clone)
return 0;
return soc->ops->me_ops->
tx_desc_free_and_unmark_for_mcast_clone
(pdev, buf_count);
}
static inline u_int16_t
cdp_tx_get_mcast_buf_allocated_marked(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->me_ops ||
!soc->ops->me_ops->tx_get_mcast_buf_allocated_marked)
return 0;
return soc->ops->me_ops->tx_get_mcast_buf_allocated_marked
(pdev);
}
static inline void
cdp_tx_me_alloc_descriptor(ol_txrx_soc_handle soc, struct cdp_pdev *pdev)
cdp_tx_me_alloc_descriptor(ol_txrx_soc_handle soc, uint8_t pdev_id)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -101,11 +42,11 @@ cdp_tx_me_alloc_descriptor(ol_txrx_soc_handle soc, struct cdp_pdev *pdev)
!soc->ops->me_ops->tx_me_alloc_descriptor)
return;
soc->ops->me_ops->tx_me_alloc_descriptor(pdev);
soc->ops->me_ops->tx_me_alloc_descriptor(soc, pdev_id);
}
static inline void
cdp_tx_me_free_descriptor(ol_txrx_soc_handle soc, struct cdp_pdev *pdev)
cdp_tx_me_free_descriptor(ol_txrx_soc_handle soc, uint8_t pdev_id)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -118,12 +59,13 @@ cdp_tx_me_free_descriptor(ol_txrx_soc_handle soc, struct cdp_pdev *pdev)
!soc->ops->me_ops->tx_me_free_descriptor)
return;
soc->ops->me_ops->tx_me_free_descriptor(pdev);
soc->ops->me_ops->tx_me_free_descriptor(soc, pdev_id);
}
static inline uint16_t cdp_tx_me_convert_ucast(
ol_txrx_soc_handle soc, uint8_t vdev_id,
qdf_nbuf_t wbuf, u_int8_t newmac[][6], uint8_t newmaccnt)
static inline uint16_t
cdp_tx_me_convert_ucast(ol_txrx_soc_handle soc, uint8_t vdev_id,
qdf_nbuf_t wbuf, u_int8_t newmac[][6],
uint8_t newmaccnt)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -140,32 +82,4 @@ static inline uint16_t cdp_tx_me_convert_ucast(
(soc, vdev_id, wbuf, newmac, newmaccnt);
}
/* Should be a function pointer in ol_txrx_osif_ops{} */
/**
* @brief notify mcast frame indication from FW.
* @details
* This notification will be used to convert
* multicast frame to unicast.
*
* @param pdev - handle to the ctrl SW's physical device object
* @param vdev_id - ID of the virtual device received the special data
* @param msdu - the multicast msdu returned by FW for host inspect
*/
static inline int cdp_mcast_notify(ol_txrx_soc_handle soc,
struct cdp_pdev *pdev, u_int8_t vdev_id, qdf_nbuf_t msdu)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->me_ops ||
!soc->ops->me_ops->mcast_notify)
return 0;
return soc->ops->me_ops->mcast_notify(pdev, vdev_id, msdu);
}
#endif

179
dp/inc/cdp_txrx_mon.h
View File

@@ -25,116 +25,9 @@
#ifndef _CDP_TXRX_MON_H_
#define _CDP_TXRX_MON_H_
#include "cdp_txrx_handle.h"
static inline void cdp_monitor_set_filter_ucast_data
(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, u_int8_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_set_filter_ucast_data)
return;
soc->ops->mon_ops->txrx_monitor_set_filter_ucast_data
(pdev, val);
}
static inline void cdp_monitor_set_filter_mcast_data
(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, u_int8_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_set_filter_mcast_data)
return;
soc->ops->mon_ops->txrx_monitor_set_filter_mcast_data
(pdev, val);
}
static inline void cdp_monitor_set_filter_non_data
(ol_txrx_soc_handle soc, struct cdp_pdev *pdev, u_int8_t val)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_set_filter_non_data)
return;
soc->ops->mon_ops->txrx_monitor_set_filter_non_data
(pdev, val);
}
static inline bool cdp_monitor_get_filter_ucast_data
(ol_txrx_soc_handle soc, struct cdp_vdev *vdev_txrx_handle)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_get_filter_ucast_data)
return 0;
return soc->ops->mon_ops->txrx_monitor_get_filter_ucast_data
(vdev_txrx_handle);
}
static inline bool cdp_monitor_get_filter_mcast_data
(ol_txrx_soc_handle soc, struct cdp_vdev *vdev_txrx_handle)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_get_filter_mcast_data)
return 0;
return soc->ops->mon_ops->txrx_monitor_get_filter_mcast_data
(vdev_txrx_handle);
}
static inline bool cdp_monitor_get_filter_non_data
(ol_txrx_soc_handle soc, struct cdp_vdev *vdev_txrx_handle)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return 0;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_get_filter_non_data)
return 0;
return soc->ops->mon_ops->txrx_monitor_get_filter_non_data
(vdev_txrx_handle);
}
static inline QDF_STATUS cdp_reset_monitor_mode
(ol_txrx_soc_handle soc, struct cdp_pdev *pdev)
static inline QDF_STATUS cdp_reset_monitor_mode(ol_txrx_soc_handle soc,
uint8_t pdev_id)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
@@ -147,85 +40,31 @@ static inline QDF_STATUS cdp_reset_monitor_mode
!soc->ops->mon_ops->txrx_reset_monitor_mode)
return 0;
return soc->ops->mon_ops->txrx_reset_monitor_mode(pdev);
}
static inline void
cdp_record_monitor_chan_num(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
int chan_num)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_record_channel)
return;
soc->ops->mon_ops->txrx_monitor_record_channel(pdev, chan_num);
}
static inline void
cdp_record_monitor_chan_freq(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
qdf_freq_t chan_freq)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_monitor_record_frequency)
return;
soc->ops->mon_ops->txrx_monitor_record_frequency(pdev, chan_freq);
return soc->ops->mon_ops->txrx_reset_monitor_mode(soc, pdev_id);
}
/**
* cdp_deliver_tx_mgmt() - Deliver mgmt frame for tx capture
* @soc: Datapath SOC handle
* @pdev: Datapath PDEV handle
* @pdev_id: id of datapath PDEV handle
* @nbuf: Management frame buffer
*/
static inline void
cdp_deliver_tx_mgmt(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
static inline QDF_STATUS
cdp_deliver_tx_mgmt(ol_txrx_soc_handle soc, uint8_t pdev_id,
qdf_nbuf_t nbuf)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
return QDF_STATUS_E_FAILURE;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_deliver_tx_mgmt)
return;
return QDF_STATUS_E_FAILURE;
soc->ops->mon_ops->txrx_deliver_tx_mgmt(pdev, nbuf);
}
static inline void
cdp_set_bsscolor(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
uint8_t bsscolor)
{
if (!soc || !soc->ops) {
QDF_TRACE(QDF_MODULE_ID_CDP, QDF_TRACE_LEVEL_DEBUG,
"%s: Invalid Instance", __func__);
QDF_BUG(0);
return;
}
if (!soc->ops->mon_ops ||
!soc->ops->mon_ops->txrx_set_bsscolor)
return;
soc->ops->mon_ops->txrx_set_bsscolor(pdev, bsscolor);
return soc->ops->mon_ops->txrx_deliver_tx_mgmt(soc, pdev_id, nbuf);
}
#ifdef WLAN_FEATURE_PKT_CAPTURE

256
dp/inc/cdp_txrx_ops.h
View File

@@ -171,26 +171,6 @@ struct cdp_cmn_ops {
ol_txrx_peer_unmap_sync_cb
peer_unmap_sync);
uint8_t (*txrx_get_pdev_id_frm_pdev)(struct cdp_pdev *pdev);
bool (*txrx_get_vow_config_frm_pdev)(struct cdp_pdev *pdev);
void (*txrx_pdev_set_chan_noise_floor)(struct cdp_pdev *pdev,
int16_t chan_noise_floor);
void
(*txrx_set_nac)(ol_txrx_soc_handle soc, uint8_t vdev_id,
uint8_t *peer_mac);
/**
* txrx_set_pdev_tx_capture() - callback to set pdev tx_capture
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @val: value of pdev_tx_capture
*
* Return: status: 0 - Success, non-zero: Failure
*/
QDF_STATUS (*txrx_set_pdev_tx_capture)(struct cdp_pdev *pdev, int val);
QDF_STATUS
(*txrx_get_peer_mac_from_peer_id)
(struct cdp_soc_t *cdp_soc,
@@ -257,8 +237,6 @@ struct cdp_cmn_ops {
ol_txrx_mgmt_tx_cb ota_ack_cb,
void *ctxt);
int (*txrx_get_tx_pending)(struct cdp_pdev *pdev);
/**
* ol_txrx_data_tx_cb - Function registered with the data path
* that is called when tx frames marked as "no free" are
@@ -420,18 +398,12 @@ struct cdp_cmn_ops {
uint8_t map_id,
uint8_t tos, uint8_t tid);
void (*hmmc_tid_override_en)(struct cdp_pdev *pdev, bool val);
void (*set_hmmc_tid_val)(struct cdp_pdev *pdev, uint8_t tid);
QDF_STATUS (*txrx_stats_request)(struct cdp_soc_t *soc_handle,
uint8_t vdev_id,
struct cdp_txrx_stats_req *req);
QDF_STATUS (*display_stats)(struct cdp_soc_t *psoc, uint16_t value,
enum qdf_stats_verbosity_level level);
void (*txrx_soc_set_nss_cfg)(ol_txrx_soc_handle soc, int config);
int(*txrx_soc_get_nss_cfg)(ol_txrx_soc_handle soc);
QDF_STATUS (*txrx_intr_attach)(struct cdp_soc_t *soc_handle);
void (*txrx_intr_detach)(struct cdp_soc_t *soc_handle);
@@ -494,13 +466,16 @@ struct cdp_cmn_ops {
uint8_t vdev_id,
ol_txrx_rx_fp *stack_fn,
ol_osif_vdev_handle *osif_vdev);
void (*set_rate_stats_ctx)(struct cdp_soc_t *soc,
void *ctx);
int (*txrx_classify_update)
(struct cdp_soc_t *soc, uint8_t vdev_id, qdf_nbuf_t skb,
enum txrx_direction, struct ol_txrx_nbuf_classify *nbuf_class);
bool (*get_dp_capabilities)(struct cdp_soc_t *soc,
enum cdp_capabilities dp_caps);
void (*set_rate_stats_ctx)(struct cdp_soc_t *soc, void *ctx);
void* (*get_rate_stats_ctx)(struct cdp_soc_t *soc);
QDF_STATUS (*txrx_peer_flush_rate_stats)(struct cdp_soc_t *soc,
uint8_t pdev_id,
@@ -511,13 +486,9 @@ struct cdp_cmn_ops {
QDF_STATUS (*set_pdev_pcp_tid_map)(struct cdp_soc_t *soc,
uint8_t pdev_id,
uint8_t pcp, uint8_t tid);
QDF_STATUS (*set_pdev_tidmap_prty)(struct cdp_pdev *pdev, uint8_t prty);
QDF_STATUS (*set_vdev_pcp_tid_map)(struct cdp_soc_t *soc,
uint8_t vdev_id,
uint8_t pcp, uint8_t tid);
QDF_STATUS (*set_vdev_tidmap_prty)(struct cdp_vdev *vdev, uint8_t prty);
QDF_STATUS (*set_vdev_tidmap_tbl_id)(struct cdp_vdev *vdev,
uint8_t mapid);
#ifdef QCA_MULTIPASS_SUPPORT
QDF_STATUS (*set_vlan_groupkey)(struct cdp_soc_t *soc, uint8_t vdev_id,
uint16_t vlan_id, uint16_t group_key);
@@ -531,85 +502,11 @@ struct cdp_cmn_ops {
struct cdp_ctrl_ops {
int
(*txrx_mempools_attach)(void *ctrl_pdev);
int
(*txrx_set_filter_neighbour_peers)(
struct cdp_pdev *pdev,
uint32_t val);
(*txrx_mempools_attach)(ol_txrx_soc_handle dp_soc);
int
(*txrx_update_filter_neighbour_peers)(
struct cdp_soc_t *soc, uint8_t vdev_id,
uint32_t cmd, uint8_t *macaddr);
/**
* @brief set the safemode of the device
* @details
* This flag is used to bypass the encrypt and decrypt processes when
* send and receive packets. It works like open AUTH mode, HW will
* ctreate all packets as non-encrypt frames because no key installed.
* For rx fragmented frames,it bypasses all the rx defragmentaion.
*
* @param vdev - the data virtual device object
* @param val - the safemode state
* @return - void
*/
void
(*txrx_set_safemode)(
struct cdp_vdev *vdev,
u_int32_t val);
/**
* @brief configure the drop unencrypted frame flag
* @details
* Rx related. When set this flag, all the unencrypted frames
* received over a secure connection will be discarded
*
* @param vdev - the data virtual device object
* @param val - flag
* @return - void
*/
void
(*txrx_set_drop_unenc)(
struct cdp_vdev *vdev,
u_int32_t val);
/**
* @brief set the Tx encapsulation type of the VDEV
* @details
* This will be used to populate the HTT desc packet type field
* during Tx
* @param vdev - the data virtual device object
* @param val - the Tx encap type
* @return - void
*/
void
(*txrx_set_tx_encap_type)(
struct cdp_vdev *vdev,
enum htt_cmn_pkt_type val);
/**
* @brief set the Rx decapsulation type of the VDEV
* @details
* This will be used to configure into firmware and hardware
* which format to decap all Rx packets into, for all peers under
* the VDEV.
* @param vdev - the data virtual device object
* @param val - the Rx decap mode
* @return - void
*/
void
(*txrx_set_vdev_rx_decap_type)(
struct cdp_vdev *vdev,
enum htt_cmn_pkt_type val);
/**
* @brief get the Rx decapsulation type of the VDEV
*
* @param vdev - the data virtual device object
* @return - the Rx decap type
*/
enum htt_cmn_pkt_type
(*txrx_get_vdev_rx_decap_type)(struct cdp_vdev *vdev);
/* Is this similar to ol_txrx_peer_state_update() in MCL */
/**
@@ -619,36 +516,28 @@ struct cdp_ctrl_ops {
* updates the peer/node-related parameters within rate-control
* context of the peer at association.
*
* @param peer - pointer to the node's object
* @param soc_hdl - pointer to the soc object
* @param vdev_id - id of the virtual object
* @param peer_mac - mac address of the node's object
* @authorize - either to authorize or unauthorize peer
*
* @return none
* @return QDF_STATUS
*/
void
(*txrx_peer_authorize)(struct cdp_peer *peer,
QDF_STATUS
(*txrx_peer_authorize)(struct cdp_soc_t *soc_hdl,
uint8_t vdev_id,
uint8_t *peer_mac,
u_int32_t authorize);
/* Should be ol_txrx_ctrl_api.h */
void (*txrx_set_mesh_mode)(struct cdp_vdev *vdev, u_int32_t val);
/**
* @brief setting mesh rx filter
* @details
* based on the bits enabled in the filter packets has to be dropped.
*
* @param vdev - the data virtual device object
* @param val - value to set
*/
void (*txrx_set_mesh_rx_filter)(struct cdp_vdev *vdev, uint32_t val);
void (*tx_flush_buffers)(struct cdp_vdev *vdev);
void (*tx_flush_buffers)(struct cdp_soc_t *soc, uint8_t vdev_id);
int (*txrx_is_target_ar900b)(struct cdp_soc_t *soc_hdl);
void (*txrx_set_vdev_param)(struct cdp_vdev *vdev,
enum cdp_vdev_param_type param, uint32_t val);
QDF_STATUS
(*txrx_set_vdev_param)(struct cdp_soc_t *soc, uint8_t vdev_id,
enum cdp_vdev_param_type param,
cdp_config_param_type val);
void (*txrx_peer_set_nawds)(struct cdp_peer *peer, uint8_t value);
/**
* @brief Set the reo dest ring num of the radio
* @details
@@ -687,6 +576,9 @@ struct cdp_ctrl_ops {
wdi_event_subscribe *event_cb_sub,
uint32_t event);
int (*txrx_get_sec_type)(ol_txrx_soc_handle soc, uint8_t vdev_id,
uint8_t *peer_mac, uint8_t sec_idx);
QDF_STATUS
(*txrx_update_mgmt_txpow_vdev)(struct cdp_soc_t *soc,
uint8_t vdev_id,
@@ -695,14 +587,31 @@ struct cdp_ctrl_ops {
/**
* txrx_set_pdev_param() - callback to set pdev parameter
* @soc: opaque soc handle
* @pdev: data path pdev handle
* @pdev_id:id of data path pdev handle
* @val: value of pdev_tx_capture
*
* Return: status: 0 - Success, non-zero: Failure
*/
QDF_STATUS (*txrx_set_pdev_param)(struct cdp_pdev *pdev,
QDF_STATUS (*txrx_set_pdev_param)(struct cdp_soc_t *soc,
uint8_t pdev_id,
enum cdp_pdev_param_type type,
uint32_t val);
cdp_config_param_type val);
QDF_STATUS (*txrx_get_pdev_param)(struct cdp_soc_t *soc,
uint8_t pdev_id,
enum cdp_pdev_param_type type,
cdp_config_param_type *val);
QDF_STATUS (*txrx_set_peer_param)(struct cdp_soc_t *soc,
uint8_t vdev_id, uint8_t *peer_mac,
enum cdp_peer_param_type param,
cdp_config_param_type val);
QDF_STATUS (*txrx_get_peer_param)(struct cdp_soc_t *soc,
uint8_t vdev_id, uint8_t *peer_mac,
enum cdp_peer_param_type param,
cdp_config_param_type *val);
void * (*txrx_get_pldev)(struct cdp_pdev *pdev);
#ifdef ATH_SUPPORT_NAC_RSSI
@@ -722,8 +631,10 @@ struct cdp_ctrl_ops {
(*set_key)(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *mac,
bool is_unicast, uint32_t *key);
uint32_t (*txrx_get_vdev_param)(struct cdp_vdev *vdev,
enum cdp_vdev_param_type param);
QDF_STATUS (*txrx_get_vdev_param)(struct cdp_soc_t *soc,
uint8_t vdev_id,
enum cdp_vdev_param_type param,
cdp_config_param_type *val);
int (*enable_peer_based_pktlog)(struct cdp_soc_t *cdp_soc,
uint8_t pdev_id,
uint8_t *macaddr, uint8_t enb_dsb);
@@ -761,78 +672,40 @@ struct cdp_ctrl_ops {
bool is_rx_pkt_cap_enable, bool is_tx_pkt_cap_enable,
uint8_t *peer_mac);
#endif /* WLAN_TX_PKT_CAPTURE_ENH || WLAN_RX_PKT_CAPTURE_ENH */
QDF_STATUS
(*txrx_set_psoc_param)(struct cdp_soc_t *soc,
enum cdp_psoc_param_type param,
cdp_config_param_type val);
QDF_STATUS (*txrx_get_psoc_param)(ol_txrx_soc_handle soc,
enum cdp_psoc_param_type type,
cdp_config_param_type *val);
};
struct cdp_me_ops {
u_int16_t (*tx_desc_alloc_and_mark_for_mcast_clone)
(struct cdp_pdev *pdev, u_int16_t buf_count);
void (*tx_me_alloc_descriptor)(struct cdp_soc_t *soc,
uint8_t pdev_id);
u_int16_t (*tx_desc_free_and_unmark_for_mcast_clone)(
struct cdp_pdev *pdev,
u_int16_t buf_count);
void (*tx_me_free_descriptor)(struct cdp_soc_t *soc, uint8_t pdev_id);
u_int16_t
(*tx_get_mcast_buf_allocated_marked)
(struct cdp_pdev *pdev);
void
(*tx_me_alloc_descriptor)(struct cdp_pdev *pdev);
void
(*tx_me_free_descriptor)(struct cdp_pdev *pdev);
uint16_t (*tx_me_convert_ucast)(
ol_txrx_soc_handle soc, uint8_t vdev_id,
uint16_t (*tx_me_convert_ucast)(struct cdp_soc_t *soc, uint8_t vdev_id,
qdf_nbuf_t wbuf, u_int8_t newmac[][6],
uint8_t newmaccnt);
/* Should be a function pointer in ol_txrx_osif_ops{} */
/**
* @brief notify mcast frame indication from FW.
* @details
* This notification will be used to convert
* multicast frame to unicast.
*
* @param pdev - handle to the ctrl SW's physical device object
* @param vdev_id - ID of the virtual device received the special data
* @param msdu - the multicast msdu returned by FW for host inspect
*/
int (*mcast_notify)(struct cdp_pdev *pdev,
u_int8_t vdev_id, qdf_nbuf_t msdu);
};
struct cdp_mon_ops {
void (*txrx_monitor_set_filter_ucast_data)
(struct cdp_pdev *, u_int8_t val);
void (*txrx_monitor_set_filter_mcast_data)
(struct cdp_pdev *, u_int8_t val);
void (*txrx_monitor_set_filter_non_data)
(struct cdp_pdev *, u_int8_t val);
QDF_STATUS (*txrx_reset_monitor_mode)(ol_txrx_soc_handle soc,
uint8_t pdev_id);
bool (*txrx_monitor_get_filter_ucast_data)
(struct cdp_vdev *vdev_txrx_handle);
bool (*txrx_monitor_get_filter_mcast_data)
(struct cdp_vdev *vdev_txrx_handle);
bool (*txrx_monitor_get_filter_non_data)
(struct cdp_vdev *vdev_txrx_handle);
QDF_STATUS (*txrx_reset_monitor_mode)(struct cdp_pdev *pdev);
QDF_STATUS (*txrx_deliver_tx_mgmt)
(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, qdf_nbuf_t nbuf);
/* HK advance monitor filter support */
QDF_STATUS (*txrx_set_advance_monitor_filter)
(struct cdp_pdev *pdev, struct cdp_monitor_filter *filter_val);
void (*txrx_monitor_record_channel)
(struct cdp_pdev *pdev, int val);
void (*txrx_monitor_record_frequency)
(struct cdp_pdev *pdev, qdf_freq_t val);
void (*txrx_deliver_tx_mgmt)
(struct cdp_pdev *pdev, qdf_nbuf_t nbuf);
void (*txrx_set_bsscolor)
(struct cdp_pdev *pdev, uint8_t bsscolor);
(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
struct cdp_monitor_filter *filter_val);
};
#ifdef WLAN_FEATURE_PKT_CAPTURE
@@ -983,9 +856,6 @@ struct cdp_host_stats_ops {
(*txrx_get_ratekbps)(int preamb, int mcs,
int htflag, int gintval);
QDF_STATUS
(*configure_rate_stats)(struct cdp_soc_t *soc, uint8_t val);
QDF_STATUS
(*txrx_update_peer_stats)(struct cdp_soc_t *soc, uint8_t vdev_id,
uint8_t *peer_mac, void *stats,

7
dp/wifi3.0/dp_internal.h
View File

@@ -1012,6 +1012,13 @@ void dp_rx_tid_stats_cb(struct dp_soc *soc, void *cb_ctxt,
union hal_reo_status *reo_status);
void dp_rx_bar_stats_cb(struct dp_soc *soc, void *cb_ctxt,
union hal_reo_status *reo_status);
uint16_t dp_tx_me_send_convert_ucast(struct cdp_soc_t *soc, uint8_t vdev_id,
qdf_nbuf_t nbuf,
uint8_t newmac[][QDF_MAC_ADDR_SIZE],
uint8_t new_mac_cnt);
void dp_tx_me_alloc_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id);
void dp_tx_me_free_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id);
QDF_STATUS dp_h2t_ext_stats_msg_send(struct dp_pdev *pdev,
uint32_t stats_type_upload_mask, uint32_t config_param_0,
uint32_t config_param_1, uint32_t config_param_2,

905
dp/wifi3.0/dp_main.c
View File

File diff suppressed because it is too large Load Diff

33
dp/wifi3.0/dp_peer.c
View File

@@ -3427,39 +3427,6 @@ void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer)
}
#endif
/**
* dp_get_peer_mac_addr_frm_id(): get mac address of the peer
* @soc_handle: DP SOC handle
* @peer_id:peer_id of the peer
*
* return: vdev_id of the vap
*/
uint8_t dp_get_peer_mac_addr_frm_id(struct cdp_soc_t *soc_handle,
uint16_t peer_id, uint8_t *peer_mac)
{
struct dp_soc *soc = (struct dp_soc *)soc_handle;
struct dp_peer *peer;
uint8_t vdev_id;
peer = dp_peer_find_by_id(soc, peer_id);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
"soc %pK peer_id %d", soc, peer_id);
if (!peer) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"peer not found ");
return CDP_INVALID_VDEV_ID;
}
qdf_mem_copy(peer_mac, peer->mac_addr.raw, 6);
vdev_id = peer->vdev->vdev_id;
dp_peer_unref_del_find_by_id(peer);
return vdev_id;
}
/**
* dp_peer_rxtid_stats: Retried Rx TID (REO queue) stats from HW
* @peer: DP peer handle

18
dp/wifi3.0/dp_peer.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@@ -179,6 +179,7 @@ dp_peer_update_inactive_time(struct dp_pdev *pdev, uint32_t tag_type,
/**
* dp_peer_set_vlan_id: set vlan_id for this peer
* @cdp_soc: soc handle
* @vdev_id: id of vdev object
* @peer_mac: mac address
* @vlan_id: vlan id for peer
*
@@ -186,16 +187,16 @@ dp_peer_update_inactive_time(struct dp_pdev *pdev, uint32_t tag_type,
*/
static inline
void dp_peer_set_vlan_id(struct cdp_soc_t *cdp_soc,
struct cdp_vdev *vdev_handle, uint8_t *peer_mac,
uint8_t vdev_id, uint8_t *peer_mac,
uint16_t vlan_id)
{
}
/**
* dp_set_vlan_groupkey: set vlan map for vdev
* @cdp_soc: soc handle
* @vdev_id: vdev_id
* @vlan_id: vlan_id of peer
* @soc: pointer to soc
* @vdev_id: id of vdev handle
* @vlan_id: vlan_id
* @group_key: group key for vlan
*
* return: set success/failure
@@ -230,7 +231,7 @@ void dp_peer_multipass_list_remove(struct dp_peer *peer)
}
#else
void dp_peer_set_vlan_id(struct cdp_soc_t *cdp_soc,
struct cdp_vdev *vdev_handle, uint8_t *peer_mac,
uint8_t vdev_id, uint8_t *peer_mac,
uint16_t vlan_id);
QDF_STATUS dp_set_vlan_groupkey(struct cdp_soc_t *soc, uint8_t vdev_id,
uint16_t vlan_id, uint16_t group_key);
@@ -240,6 +241,8 @@ void dp_peer_multipass_list_remove(struct dp_peer *peer);
/**
* dp_peer_update_pkt_capture_params: Set Rx & Tx Capture flags for a peer
* @soc: DP SOC handle
* @pdev_id: id of DP pdev handle
* @is_rx_pkt_cap_enable: enable/disable Rx packet capture in monitor mode
* @is_tx_pkt_cap_enable: enable/disable Tx packet capture in monitor mode
* @peer_mac: MAC address for which the above need to be enabled/disabled
@@ -247,7 +250,8 @@ void dp_peer_multipass_list_remove(struct dp_peer *peer);
* Return: Success if Rx & Tx capture is enabled for peer, false otherwise
*/
QDF_STATUS
dp_peer_update_pkt_capture_params(struct cdp_pdev *pdev,
dp_peer_update_pkt_capture_params(ol_txrx_soc_handle soc,
uint8_t pdev_id,
bool is_rx_pkt_cap_enable,
bool is_tx_pkt_cap_enable,
uint8_t *peer_mac);

4
dp/wifi3.0/dp_rx.c
View File

@@ -313,7 +313,7 @@ dp_rx_deliver_raw(struct dp_vdev *vdev, qdf_nbuf_t nbuf_list,
}
vdev->osif_rsim_rx_decap(vdev->osif_vdev, &deliver_list_head,
&deliver_list_tail, (struct cdp_peer*) peer);
&deliver_list_tail, peer->mac_addr.raw);
vdev->osif_rx(vdev->osif_vdev, deliver_list_head);
}
@@ -1323,7 +1323,7 @@ static inline void dp_rx_deliver_to_stack(struct dp_vdev *vdev,
if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw) ||
(vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)) {
vdev->osif_rsim_rx_decap(vdev->osif_vdev, &nbuf_head,
&nbuf_tail, (struct cdp_peer *) peer);
&nbuf_tail, peer->mac_addr.raw);
}
vdev->osif_rx(vdev->osif_vdev, nbuf_head);

2
dp/wifi3.0/dp_rx.h
View File

@@ -1100,7 +1100,7 @@ bool dp_rx_multipass_process(struct dp_peer *peer, qdf_nbuf_t nbuf,
#ifndef WLAN_RX_PKT_CAPTURE_ENH
static inline
void dp_peer_set_rx_capture_enabled(struct cdp_peer *peer_handle, bool value)
void dp_peer_set_rx_capture_enabled(struct dp_peer *peer_handle, bool value)
{
}
#endif

4
dp/wifi3.0/dp_rx_mon.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@@ -45,7 +45,7 @@ QDF_STATUS dp_rx_pdev_mon_status_detach(struct dp_pdev *pdev, int mac_id);
*
* Return: QDF_STATUS
*/
QDF_STATUS dp_reset_monitor_mode(struct cdp_pdev *pdev_handle);
QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl, uint8_t pdev_id);
/**
* dp_pdev_configure_monitor_rings() - configure monitor rings

26
dp/wifi3.0/dp_tx.c
View File

@@ -2049,30 +2049,6 @@ static bool dp_check_exc_metadata(struct cdp_tx_exception_metadata *tx_exc)
return true;
}
/**
* __dp_tx_send_exception: Wrapper API for dp_tx_send_exception.
* @soc: DP soc handle
* @vdev_id: id of DP vdev handle
* @tx_exc_metadata: Handle that holds exception path meta data
*
* Return: NULL on success,
* nbuf when it fails to send
*/
qdf_nbuf_t
__dp_tx_send_exception(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf,
struct cdp_tx_exception_metadata *tx_exc_metadata)
{
struct dp_vdev *vdev =
dp_get_vdev_from_soc_vdev_id_wifi3((struct dp_soc *)soc,
vdev_id);
if (!vdev)
return nbuf;
return dp_tx_send_exception((struct cdp_vdev *)vdev, nbuf,
tx_exc_metadata);
}
/**
* dp_tx_send_exception() - Transmit a frame on a given VAP in exception path
* @soc: DP soc handle
@@ -2091,10 +2067,10 @@ dp_tx_send_exception(struct cdp_soc_t *soc, uint8_t vdev_id, qdf_nbuf_t nbuf,
struct cdp_tx_exception_metadata *tx_exc_metadata)
{
qdf_ether_header_t *eh = NULL;
struct dp_tx_msdu_info_s msdu_info;
struct dp_vdev *vdev =
dp_get_vdev_from_soc_vdev_id_wifi3((struct dp_soc *)soc,
vdev_id);
struct dp_tx_msdu_info_s msdu_info;
if (qdf_unlikely(!vdev))
goto fail;

9
dp/wifi3.0/dp_tx.h
View File

@@ -187,11 +187,8 @@ QDF_STATUS dp_tx_pdev_attach(struct dp_pdev *pdev);
qdf_nbuf_t dp_tx_send(struct cdp_soc_t *soc, uint8_t vdev_id, qdf_nbuf_t nbuf);
qdf_nbuf_t
__dp_tx_send_exception(ol_txrx_soc_handle soc, uint8_t vdev_id, qdf_nbuf_t nbuf,
struct cdp_tx_exception_metadata *tx_exc_metadata);
qdf_nbuf_t dp_tx_send_exception(struct cdp_vdev *data_vdev, qdf_nbuf_t nbuf,
qdf_nbuf_t dp_tx_send_exception(struct cdp_soc_t *soc, uint8_t vdev_id,
qdf_nbuf_t nbuf,
struct cdp_tx_exception_metadata *tx_exc);
qdf_nbuf_t dp_tx_send_mesh(struct cdp_soc_t *soc, uint8_t vdev_id,
qdf_nbuf_t nbuf);
@@ -360,7 +357,7 @@ static inline void dp_tx_comp_process_exception(struct dp_tx_desc_s *tx_desc)
#ifndef WLAN_TX_PKT_CAPTURE_ENH
static inline
void dp_peer_set_tx_capture_enabled(struct cdp_peer *peer_handle, bool value)
void dp_peer_set_tx_capture_enabled(struct dp_peer *peer_handle, bool value)
{
}
#endif

2
dp/wifi3.0/dp_types.h
View File

@@ -1915,7 +1915,7 @@ struct dp_vdev {
struct dp_tx_desc_pool_s *pool;
#endif
/* AP BRIDGE enabled */
uint32_t ap_bridge_enabled;
bool ap_bridge_enabled;
enum cdp_sec_type sec_type;