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

qcacmn: Add CDP_IF wrapper layer for data path

Browse Source 
Added a new layer CDP_IF inside dp which is an intermediate
between the data path functions and the upper layers. All function
calls from outside the DP layer to the DP layer goes via the CDP_IF
layer

Change-Id: I76e671c85d2d02aa0a65a90b356840d3aeede52d
CRs-Fixed: 1075597
This commit is contained in:
Nandha Kishore Easwaran
2016-10-20 13:23:23 +05:30
committed by qcabuildsw
parent 140ce9541a
commit e5444bc96d
17 changed files with 1611 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dp/inc/cdp_txrx_cfg.h
View File

@@ -66,7 +66,7 @@ void ol_set_cfg_rx_fwd_disabled(ol_pdev_handle pdev, uint8_t disable_rx_fwd);
void ol_set_cfg_packet_log_enabled(ol_pdev_handle pdev, uint8_t val); void ol_set_cfg_packet_log_enabled(ol_pdev_handle pdev, uint8_t val);
ol_pdev_handle ol_pdev_cfg_attach(qdf_device_t osdev, ol_pdev_handle ol_pdev_cfg_attach(qdf_device_t osdev,
struct txrx_pdev_cfg_param_t cfg_param); struct txrx_pdev_cfg_param_t cfg_param);
void ol_vdev_rx_set_intrabss_fwd(ol_txrx_vdev_handle vdev, bool val); void ol_vdev_rx_set_intrabss_fwd(ol_txrx_vdev_handle vdev, bool val);

585
dp/inc/cdp_txrx_cmn.h
View File

@@ -25,422 +25,305 @@
* to the Linux Foundation. * to the Linux Foundation.
*/ */
/** /**
* @file cdp_txrx_api_common.h * @file cdp_txrx_cmn.h
* @brief Define the host data path converged API functions * @brief Define the host data path converged API functions
* called by the host control SW and the OS interface module * called by the host control SW and the OS interface module
*/ */
#ifndef _CDP_TXRX_CMN_H_ #ifndef _CDP_TXRX_CMN_H_
#define _CDP_TXRX_CMN_H_ #define _CDP_TXRX_CMN_H_
#include "htc_api.h"
#include "qdf_types.h" #include "qdf_types.h"
#include "qdf_nbuf.h" #include "qdf_nbuf.h"
#include "cdp_txrx_ops.h"
/****************************************************************************** /******************************************************************************
* *
* Common Data Path Header File * Common Data Path Header File
* *
*****************************************************************************/ *****************************************************************************/
/****************************************************************************** static inline int
* cdp_soc_attach_target(ol_txrx_soc_handle soc)
* Structure definitions {
* if (soc->ops->cmn_drv_ops->txrx_soc_attach_target)
*****************************************************************************/ return soc->ops->cmn_drv_ops->txrx_soc_attach_target(soc);
return 0;
}
/** static inline void *
* ol_txrx_pdev_handle - opaque handle for txrx physical device cdp_vdev_attach(ol_txrx_soc_handle soc, void *pdev,
* object uint8_t *vdev_mac_addr, uint8_t vdev_id, enum wlan_op_mode op_mode)
*/ {
struct ol_txrx_pdev_t; if (soc->ops->cmn_drv_ops->txrx_vdev_attach)
typedef struct ol_txrx_pdev_t *ol_txrx_pdev_handle; return soc->ops->cmn_drv_ops->txrx_vdev_attach(pdev,
vdev_mac_addr, vdev_id, op_mode);
return NULL;
}
/** static inline void
* ol_txrx_vdev_handle - opaque handle for txrx virtual device cdp_vdev_detach(ol_txrx_soc_handle soc, void *vdev,
* object ol_txrx_vdev_delete_cb callback, void *cb_context)
*/ {
struct ol_txrx_vdev_t; if (soc->ops->cmn_drv_ops->txrx_vdev_detach)
typedef struct ol_txrx_vdev_t *ol_txrx_vdev_handle; return soc->ops->cmn_drv_ops->txrx_vdev_detach(vdev,
callback, cb_context);
return;
}
/** static inline int
* ol_pdev_handle - opaque handle for the configuration cdp_pdev_attach_target(ol_txrx_soc_handle soc, void *pdev)
* associated with the physical device {
*/ if (soc->ops->cmn_drv_ops->txrx_pdev_attach_target)
struct ol_pdev_t; return soc->ops->cmn_drv_ops->txrx_pdev_attach_target(pdev);
typedef struct ol_pdev_t *ol_pdev_handle; return 0;
}
/** static inline void *cdp_pdev_attach
* ol_txrx_peer_handle - opaque handle for txrx peer object (ol_txrx_soc_handle soc, void *ctrl_pdev,
*/ HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id)
struct ol_txrx_peer_t; {
typedef struct ol_txrx_peer_t *ol_txrx_peer_handle; if (soc->ops->cmn_drv_ops->txrx_pdev_attach)
return soc->ops->cmn_drv_ops->txrx_pdev_attach(soc, ctrl_pdev,
htc_pdev, osdev, pdev_id);
return NULL;
}
/** static inline void
* ol_txrx_vdev_delete_cb - callback registered during vdev cdp_pdev_detach(ol_txrx_soc_handle soc, void *pdev, int force)
* detach {
*/ if (soc->ops->cmn_drv_ops->txrx_pdev_detach)
typedef void (*ol_txrx_vdev_delete_cb)(void *context); return soc->ops->cmn_drv_ops->txrx_pdev_detach(pdev, force);
return;
}
/** static inline void *cdp_peer_attach
* ol_osif_vdev_handle - paque handle for OS shim virtual device (ol_txrx_soc_handle soc, void *vdev,
* object uint8_t *peer_mac_addr)
*/ {
struct ol_osif_vdev_t; if (soc->ops->cmn_drv_ops->txrx_peer_attach)
typedef struct ol_osif_vdev_t *ol_osif_vdev_handle; return soc->ops->cmn_drv_ops->txrx_peer_attach(vdev,
peer_mac_addr);
return NULL;
}
/** static inline void
* wlan_op_mode - Virtual device operation mode cdp_peer_detach(ol_txrx_soc_handle soc, void *peer)
* @wlan_op_mode_unknown: Unknown mode {
* @wlan_op_mode_ap: AP mode if (soc->ops->cmn_drv_ops->txrx_peer_detach)
* @wlan_op_mode_ibss: IBSS mode return soc->ops->cmn_drv_ops->txrx_peer_detach(peer);
* @wlan_op_mode_sta: STA (client) mode return;
* @wlan_op_mode_monitor: Monitor mode }
* @wlan_op_mode_ocb: OCB mode
* @wlan_op_mode_ndi: NAN datapath mode
*/
enum wlan_op_mode {
wlan_op_mode_unknown,
wlan_op_mode_ap,
wlan_op_mode_ibss,
wlan_op_mode_sta,
wlan_op_mode_monitor,
wlan_op_mode_ocb,
wlan_op_mode_ndi,
};
/** static inline int
* ol_txrx_tx_fp - top-level transmit function cdp_set_monitor_mode(ol_txrx_soc_handle soc, void *vdev)
* @data_vdev - handle to the virtual device object {
* @msdu_list - list of network buffers if (soc->ops->cmn_drv_ops->txrx_set_monitor_mode)
*/ return soc->ops->cmn_drv_ops->txrx_set_monitor_mode(vdev);
typedef qdf_nbuf_t (*ol_txrx_tx_fp)(ol_txrx_vdev_handle data_vdev, return 0;
qdf_nbuf_t msdu_list); }
/**
* ol_txrx_tx_flow_control_fp - tx flow control notification
* function from txrx to OS shim
* @osif_dev - the virtual device's OS shim object
* @tx_resume - tx os q should be resumed or not
*/
typedef void (*ol_txrx_tx_flow_control_fp)(void *osif_dev,
bool tx_resume);
/** static inline void
* ol_txrx_rx_fp - receive function to hand batches of data cdp_set_curchan(ol_txrx_soc_handle soc,
* frames from txrx to OS shim void *pdev,
* @data_vdev - handle to the OSIF virtual device object uint32_t chan_mhz)
* @msdu_list - list of network buffers {
*/ if (soc->ops->cmn_drv_ops->txrx_set_curchan)
typedef QDF_STATUS (*ol_txrx_rx_fp)(void *osif_dev, qdf_nbuf_t msdu_list); return soc->ops->cmn_drv_ops->txrx_set_curchan(pdev, chan_mhz);
return;
}
/** static inline void
* ol_txrx_rx_check_wai_fp - OSIF WAPI receive function cdp_set_privacy_filters(ol_txrx_soc_handle soc, void *vdev,
*/ void *filter, uint32_t num)
typedef bool (*ol_txrx_rx_check_wai_fp)(ol_osif_vdev_handle vdev, {
qdf_nbuf_t mpdu_head, if (soc->ops->cmn_drv_ops->txrx_set_privacy_filters)
qdf_nbuf_t mpdu_tail); return soc->ops->cmn_drv_ops->txrx_set_privacy_filters(vdev,
/** filter, num);
* ol_txrx_rx_mon_fp - OSIF monitor mode receive function for single return;
* MPDU (802.11 format) }
*/
typedef void (*ol_txrx_rx_mon_fp)(ol_osif_vdev_handle vdev,
qdf_nbuf_t mpdu,
void *rx_status);
/**
* ol_txrx_proxy_arp_fp - proxy arp function pointer
*/
typedef int (*ol_txrx_proxy_arp_fp)(ol_osif_vdev_handle vdev,
qdf_nbuf_t netbuf);
/**
* ol_txrx_stats_callback - statistics notify callback
*/
typedef void (*ol_txrx_stats_callback)(void *ctxt,
uint32_t type,
uint8_t *buf, int bytes);
/**
* ol_txrx_ops - (pointers to) the functions used for tx and rx
* data xfer
*
* There are two portions of these txrx operations.
* The rx portion is filled in by OSIF SW before calling
* ol_txrx_osif_vdev_register; inside the ol_txrx_osif_vdev_register
* the txrx SW stores a copy of these rx function pointers, to use
* as it delivers rx data frames to the OSIF SW.
* The tx portion is filled in by the txrx SW inside
* ol_txrx_osif_vdev_register; when the function call returns,
* the OSIF SW stores a copy of these tx functions to use as it
* delivers tx data frames to the txrx SW.
*
* @tx.std - the tx function pointer for standard data
* frames This function pointer is set by the txrx SW
* perform host-side transmit operations based on
* whether a HL or LL host/target interface is in use.
* @tx.flow_control_cb - the transmit flow control
* function that is registered by the
* OSIF which is called from txrx to
* indicate whether the transmit OS
* queues should be paused/resumed
* @rx.std - the OS shim rx function to deliver rx data
* frames to. This can have different values for
* different virtual devices, e.g. so one virtual
* device's OS shim directly hands rx frames to the OS,
* but another virtual device's OS shim filters out P2P
* messages before sending the rx frames to the OS. The
* netbufs delivered to the osif_rx function are in the
* format specified by the OS to use for tx and rx
* frames (either 802.3 or native WiFi)
* @rx.wai_check - the tx function pointer for WAPI frames
* @rx.mon - the OS shim rx monitor function to deliver
* monitor data to Though in practice, it is probable
* that the same function will be used for delivering
* rx monitor data for all virtual devices, in theory
* each different virtual device can have a different
* OS shim function for accepting rx monitor data. The
* netbufs delivered to the osif_rx_mon function are in
* 802.11 format. Each netbuf holds a 802.11 MPDU, not
* an 802.11 MSDU. Depending on compile-time
* configuration, each netbuf may also have a
* monitor-mode encapsulation header such as a radiotap
* header added before the MPDU contents.
* @proxy_arp - proxy arp function pointer - specified by
* OS shim, stored by txrx
*/
struct ol_txrx_ops {
/* tx function pointers - specified by txrx, stored by OS shim */
struct {
ol_txrx_tx_fp tx;
} tx;
/* rx function pointers - specified by OS shim, stored by txrx */
struct {
ol_txrx_rx_fp rx;
ol_txrx_rx_check_wai_fp wai_check;
ol_txrx_rx_mon_fp mon;
} rx;
/* proxy arp function pointer - specified by OS shim, stored by txrx */
ol_txrx_proxy_arp_fp proxy_arp;
};
/**
* ol_txrx_stats_req - specifications of the requested
* statistics
*/
struct ol_txrx_stats_req {
uint32_t stats_type_upload_mask; /* which stats to upload */
uint32_t stats_type_reset_mask; /* which stats to reset */
/* stats will be printed if either print element is set */
struct {
int verbose; /* verbose stats printout */
int concise; /* concise stats printout (takes precedence) */
} print; /* print uploaded stats */
/* stats notify callback will be invoked if fp is non-NULL */
struct {
ol_txrx_stats_callback fp;
void *ctxt;
} callback;
/* stats will be copied into the specified buffer if buf is non-NULL */
struct {
uint8_t *buf;
int byte_limit; /* don't copy more than this */
} copy;
/*
* If blocking is true, the caller will take the specified semaphore
* to wait for the stats to be uploaded, and the driver will release
* the semaphore when the stats are done being uploaded.
*/
struct {
int blocking;
/*Note: this needs to change to some qdf_* type */
qdf_semaphore_t *sem_ptr;
} wait;
};
/******************************************************************************
*
* Control Interface (A Interface)
*
*****************************************************************************/
int
ol_txrx_pdev_attach_target(ol_txrx_pdev_handle pdev);
ol_txrx_vdev_handle
ol_txrx_vdev_attach(ol_txrx_pdev_handle pdev, uint8_t *vdev_mac_addr,
uint8_t vdev_id, enum wlan_op_mode op_mode);
void
ol_txrx_vdev_detach(ol_txrx_vdev_handle vdev,
ol_txrx_vdev_delete_cb callback, void *cb_context);
ol_txrx_pdev_handle
ol_txrx_pdev_attach(
ol_pdev_handle ctrl_pdev,
HTC_HANDLE htc_pdev,
qdf_device_t osdev);
void
ol_txrx_pdev_detach(ol_txrx_pdev_handle pdev, int force);
ol_txrx_peer_handle
ol_txrx_peer_attach(ol_txrx_vdev_handle vdev, uint8_t *peer_mac_addr);
void
ol_txrx_peer_detach(ol_txrx_peer_handle peer);
int
ol_txrx_set_monitor_mode(ol_txrx_vdev_handle vdev);
void
ol_txrx_set_curchan(
ol_txrx_pdev_handle pdev,
uint32_t chan_mhz);
void
ol_txrx_set_privacy_filters(ol_txrx_vdev_handle vdev,
void *filter, uint32_t num);
/****************************************************************************** /******************************************************************************
* Data Interface (B Interface) * Data Interface (B Interface)
*****************************************************************************/ *****************************************************************************/
void static inline void
ol_txrx_vdev_register(ol_txrx_vdev_handle vdev, cdp_vdev_register(ol_txrx_soc_handle soc, void *vdev,
void *osif_vdev, struct ol_txrx_ops *txrx_ops); void *osif_vdev, struct ol_txrx_ops *txrx_ops)
{
if (soc->ops->cmn_drv_ops->txrx_vdev_register)
return soc->ops->cmn_drv_ops->txrx_vdev_register(vdev,
osif_vdev, txrx_ops);
return;
}
int static inline int
ol_txrx_mgmt_send( cdp_mgmt_send(ol_txrx_soc_handle soc, void *vdev,
ol_txrx_vdev_handle vdev, qdf_nbuf_t tx_mgmt_frm, uint8_t type)
qdf_nbuf_t tx_mgmt_frm, {
uint8_t type); if (soc->ops->cmn_drv_ops->txrx_mgmt_send)
return soc->ops->cmn_drv_ops->txrx_mgmt_send(vdev,
tx_mgmt_frm, type);
return 0;
}
int static inline int
ol_txrx_mgmt_send_ext(ol_txrx_vdev_handle vdev, cdp_mgmt_send_ext(ol_txrx_soc_handle soc, void *vdev,
qdf_nbuf_t tx_mgmt_frm, qdf_nbuf_t tx_mgmt_frm, uint8_t type,
uint8_t type, uint8_t use_6mbps, uint16_t chanfreq); uint8_t use_6mbps, uint16_t chanfreq)
{
if (soc->ops->cmn_drv_ops->txrx_mgmt_send_ext)
return soc->ops->cmn_drv_ops->txrx_mgmt_send_ext
(vdev, tx_mgmt_frm, type, use_6mbps, chanfreq);
return 0;
}
/**
* ol_txrx_mgmt_tx_cb - tx management delivery notification
* callback function
*/
typedef void
(*ol_txrx_mgmt_tx_cb)(void *ctxt, qdf_nbuf_t tx_mgmt_frm, int had_error);
void static inline void
ol_txrx_mgmt_tx_cb_set(ol_txrx_pdev_handle pdev, cdp_mgmt_tx_cb_set(ol_txrx_soc_handle soc, void *pdev,
uint8_t type, uint8_t type,
ol_txrx_mgmt_tx_cb download_cb, ol_txrx_mgmt_tx_cb download_cb,
ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt); ol_txrx_mgmt_tx_cb ota_ack_cb, void *ctxt)
{
if (soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set)
return soc->ops->cmn_drv_ops->txrx_mgmt_tx_cb_set
(pdev, type, download_cb, ota_ack_cb, ctxt);
return;
}
int ol_txrx_get_tx_pending(ol_txrx_pdev_handle pdev); static inline int cdp_get_tx_pending(ol_txrx_soc_handle soc,
void *pdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_tx_pending)
return soc->ops->cmn_drv_ops->txrx_get_tx_pending(pdev);
return 0;
}
/** static inline void
* ol_txrx_data_tx_cb - Function registered with the data path cdp_data_tx_cb_set(ol_txrx_soc_handle soc, void *data_vdev,
* that is called when tx frames marked as "no free" are ol_txrx_data_tx_cb callback, void *ctxt)
* done being transmitted {
*/ if (soc->ops->cmn_drv_ops->txrx_data_tx_cb_set)
typedef void return soc->ops->cmn_drv_ops->txrx_data_tx_cb_set(data_vdev,
(*ol_txrx_data_tx_cb)(void *ctxt, qdf_nbuf_t tx_frm, int had_error); callback, ctxt);
return;
void }
ol_txrx_data_tx_cb_set(ol_txrx_vdev_handle data_vdev,
ol_txrx_data_tx_cb callback, void *ctxt);
/****************************************************************************** /******************************************************************************
* Statistics and Debugging Interface (C Inteface) * Statistics and Debugging Interface (C Inteface)
*****************************************************************************/ *****************************************************************************/
int static inline int
ol_txrx_aggr_cfg(ol_txrx_vdev_handle vdev, cdp_aggr_cfg(ol_txrx_soc_handle soc, void *vdev,
int max_subfrms_ampdu, int max_subfrms_ampdu,
int max_subfrms_amsdu); int max_subfrms_amsdu)
{
if (soc->ops->cmn_drv_ops->txrx_aggr_cfg)
return soc->ops->cmn_drv_ops->txrx_aggr_cfg(vdev,
max_subfrms_ampdu, max_subfrms_amsdu);
return 0;
}
int static inline int
ol_txrx_fw_stats_get( cdp_fw_stats_get(ol_txrx_soc_handle soc, void *vdev,
ol_txrx_vdev_handle vdev, struct ol_txrx_stats_req *req, bool per_vdev,
struct ol_txrx_stats_req *req, bool response_expected)
bool per_vdev, {
bool response_expected); if (soc->ops->cmn_drv_ops->txrx_fw_stats_get)
return soc->ops->cmn_drv_ops->txrx_fw_stats_get(vdev, req,
per_vdev, response_expected);
return 0;
}
int static inline int
ol_txrx_debug(ol_txrx_vdev_handle vdev, int debug_specs); cdp_debug(ol_txrx_soc_handle soc, void *vdev, int debug_specs)
{
if (soc->ops->cmn_drv_ops->txrx_debug)
return soc->ops->cmn_drv_ops->txrx_debug(vdev, debug_specs);
return 0;
}
void ol_txrx_fw_stats_cfg( static inline void cdp_fw_stats_cfg(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev, uint8_t cfg_stats_type, uint32_t cfg_val)
uint8_t cfg_stats_type, {
uint32_t cfg_val); if (soc->ops->cmn_drv_ops->txrx_fw_stats_cfg)
return soc->ops->cmn_drv_ops->txrx_fw_stats_cfg(vdev,
cfg_stats_type, cfg_val);
return;
}
void ol_txrx_print_level_set(unsigned level); static inline void cdp_print_level_set(ol_txrx_soc_handle soc, unsigned level)
{
if (soc->ops->cmn_drv_ops->txrx_print_level_set)
return soc->ops->cmn_drv_ops->txrx_print_level_set(level);
return;
}
#define TXRX_FW_STATS_TXSTATS 1 static inline uint8_t *
#define TXRX_FW_STATS_RXSTATS 2 cdp_get_vdev_mac_addr(ol_txrx_soc_handle soc, void *vdev)
#define TXRX_FW_STATS_RX_RATE_INFO 3 {
#define TXRX_FW_STATS_PHYSTATS 4 if (soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr)
#define TXRX_FW_STATS_PHYSTATS_CONCISE 5 return soc->ops->cmn_drv_ops->txrx_get_vdev_mac_addr(vdev);
#define TXRX_FW_STATS_TX_RATE_INFO 6 return NULL;
#define TXRX_FW_STATS_TID_STATE 7 }
#define TXRX_FW_STATS_HOST_STATS 8
#define TXRX_FW_STATS_CLEAR_HOST_STATS 9
#define TXRX_FW_STATS_CE_STATS 10
#define TXRX_FW_STATS_VOW_UMAC_COUNTER 11
#define TXRX_FW_STATS_ME_STATS 12
#define TXRX_FW_STATS_TXBF_INFO 13
#define TXRX_FW_STATS_SND_INFO 14
#define TXRX_FW_STATS_ERROR_INFO 15
#define TXRX_FW_STATS_TX_SELFGEN_INFO 16
#define TXRX_FW_STATS_TX_MU_INFO 17
#define TXRX_FW_SIFS_RESP_INFO 18
#define TXRX_FW_RESET_STATS 19
#define TXRX_FW_MAC_WDOG_STATS 20
#define TXRX_FW_MAC_DESC_STATS 21
#define TXRX_FW_MAC_FETCH_MGR_STATS 22
#define TXRX_FW_MAC_PREFETCH_MGR_STATS 23
#define TXRX_FW_STATS_DURATION_INFO 24
#define TXRX_FW_STATS_DURATION_INFO_RESET 25
#define PER_RADIO_FW_STATS_REQUEST 0
#define PER_VDEV_FW_STATS_REQUEST 1
/**
* ol_txrx_get_vdev_mac_addr() - Return mac addr of vdev
* @vdev: vdev handle
*
* Return: vdev mac address
*/
uint8_t *
ol_txrx_get_vdev_mac_addr(ol_txrx_vdev_handle vdev);
/** /**
* ol_txrx_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of * cdp_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of
* vdev * vdev
* @vdev: vdev handle * @vdev: vdev handle
* *
* Return: Handle to struct qdf_mac_addr * Return: Handle to struct qdf_mac_addr
*/ */
struct qdf_mac_addr * static inline struct qdf_mac_addr *cdp_get_vdev_struct_mac_addr
ol_txrx_get_vdev_struct_mac_addr(ol_txrx_vdev_handle vdev); (ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr)
return soc->ops->cmn_drv_ops->txrx_get_vdev_struct_mac_addr
(vdev);
return NULL;
}
/** /**
* ol_txrx_get_pdev_from_vdev() - Return handle to pdev of vdev * cdp_get_pdev_from_vdev() - Return handle to pdev of vdev
* @vdev: vdev handle * @vdev: vdev handle
* *
* Return: Handle to pdev * Return: Handle to pdev
*/ */
ol_txrx_pdev_handle ol_txrx_get_pdev_from_vdev(ol_txrx_vdev_handle vdev); static inline void *cdp_get_pdev_from_vdev
(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev)
return soc->ops->cmn_drv_ops->txrx_get_pdev_from_vdev(vdev);
return NULL;
}
/** /**
* ol_txrx_get_ctrl_pdev_from_vdev() - Return control pdev of vdev * cdp_get_ctrl_pdev_from_vdev() - Return control pdev of vdev
* @vdev: vdev handle * @vdev: vdev handle
* *
* Return: Handle to control pdev * Return: Handle to control pdev
*/ */
ol_pdev_handle static inline void *
ol_txrx_get_ctrl_pdev_from_vdev(ol_txrx_vdev_handle vdev); cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev)
return soc->ops->cmn_drv_ops->txrx_get_ctrl_pdev_from_vdev
(vdev);
return NULL;
}
static inline void *
cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, uint8_t vdev_id)
{
if (soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id)
return soc->ops->cmn_drv_ops->txrx_get_vdev_from_vdev_id
(vdev_id);
return NULL;
}
static inline void
cdp_soc_detach(ol_txrx_soc_handle soc)
{
if (soc->ops->cmn_drv_ops->txrx_soc_detach)
return soc->ops->cmn_drv_ops->txrx_soc_detach((void *)soc);
return;
}
#endif /* _CDP_TXRX_CMN_H_ */ #endif /* _CDP_TXRX_CMN_H_ */

51
dp/inc/cdp_txrx_cmn_reg.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright (c) 2011-2016 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file cdp_txrx_cmn.h
* @brief Define the host data path converged API functions
* called by the host control SW and the OS interface module
*/
#ifndef _CDP_TXRX_CMN_REG_H_
#define _CDP_TXRX_CMN_REG_H_
#define IPQ4019_DEVICE_ID 0x12ef
#define AR900B_DEVICE_ID 0x0040
#define QCA9984_DEVICE_ID 0x0046
#define QCA9888_DEVICE_ID 0x0056
#define MOB_DRV_LEGACY_DP 0xffff/*FIXME Add MCL device IDs */
#define LITHIUM_DP 0xfffe/*FIXME Add Litium device ID */
/* Use these device IDs for attach in future */
ol_txrx_soc_handle ol_txrx_soc_attach(struct ol_if_ops *dp_ol_if_ops);
static inline ol_txrx_soc_handle cdp_soc_attach(u_int16_t devid,
void *hif_handle, void *scn, void *htc_handle, qdf_device_t *qdf_dev,
struct ol_if_ops *dp_ol_if_ops)
{
switch (devid) {
case LITHIUM_DP: /*FIXME Add lithium devide IDs */
return NULL;
break;
default:
return ol_txrx_soc_attach(dp_ol_if_ops);
}
return NULL;
}
#endif /*_CDP_TXRX_CMN_REG_H_ */

266
dp/inc/cdp_txrx_cmn_struct.h Normal file
View File

@@ -0,0 +1,266 @@
/*
* Copyright (c) 2011-2016 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file cdp_txrx_cmn_struct.h
* @brief Define the host data path converged API functions
* called by the host control SW and the OS interface module
*/
#ifndef _CDP_TXRX_CMN_STRUCT_H_
#define _CDP_TXRX_CMN_STRUCT_H_
#include "htc_api.h"
#include "htt.h"
#include "qdf_types.h"
#include "qdf_nbuf.h"
typedef struct cdp_soc_t *ol_txrx_soc_handle;
/**
* ol_txrx_vdev_delete_cb - callback registered during vdev
* detach
*/
typedef void (*ol_txrx_vdev_delete_cb)(void *context);
/**
* ol_osif_vdev_handle - paque handle for OS shim virtual device
* object
*/
struct ol_osif_vdev_t;
typedef struct ol_osif_vdev_t *ol_osif_vdev_handle;
/**
* wlan_op_mode - Virtual device operation mode
* @wlan_op_mode_unknown: Unknown mode
* @wlan_op_mode_ap: AP mode
* @wlan_op_mode_ibss: IBSS mode
* @wlan_op_mode_sta: STA (client) mode
* @wlan_op_mode_monitor: Monitor mode
* @wlan_op_mode_ocb: OCB mode
*/
enum wlan_op_mode {
wlan_op_mode_unknown,
wlan_op_mode_ap,
wlan_op_mode_ibss,
wlan_op_mode_sta,
wlan_op_mode_monitor,
wlan_op_mode_ocb,
};
/**
* cdp_mgmt_tx_cb - tx management delivery notification
* callback function
*/
typedef void
(*ol_txrx_mgmt_tx_cb)(void *ctxt, qdf_nbuf_t tx_mgmt_frm, int had_error);
/**
* ol_rxrx_data_tx_cb - Function registered with the data path
* that is called when tx frames marked as "no free" are
* done being transmitted
*/
typedef void
(*ol_txrx_data_tx_cb)(void *ctxt, qdf_nbuf_t tx_frm, int had_error);
/**
* ol_txrx_tx_fp - top-level transmit function
* @data_vdev - handle to the virtual device object
* @msdu_list - list of network buffers
*/
typedef qdf_nbuf_t (*ol_txrx_tx_fp)(void *data_vdev,
qdf_nbuf_t msdu_list);
/**
* ol_txrx_tx_flow_control_fp - tx flow control notification
* function from txrx to OS shim
* @osif_dev - the virtual device's OS shim object
* @tx_resume - tx os q should be resumed or not
*/
typedef void (*ol_txrx_tx_flow_control_fp)(void *osif_dev,
bool tx_resume);
/**
* ol_txrx_rx_fp - receive function to hand batches of data
* frames from txrx to OS shim
* @data_vdev - handle to the OSIF virtual device object
* @msdu_list - list of network buffers
*/
typedef QDF_STATUS(*ol_txrx_rx_fp)(void *osif_dev, qdf_nbuf_t msdu_list);
/**
* ol_txrx_rx_check_wai_fp - OSIF WAPI receive function
*/
typedef bool (*ol_txrx_rx_check_wai_fp)(ol_osif_vdev_handle vdev,
qdf_nbuf_t mpdu_head,
qdf_nbuf_t mpdu_tail);
/**
* ol_txrx_rx_mon_fp - OSIF monitor mode receive function for single
* MPDU (802.11 format)
*/
typedef void (*ol_txrx_rx_mon_fp)(ol_osif_vdev_handle vdev,
qdf_nbuf_t mpdu,
void *rx_status);
/**
* ol_txrx_proxy_arp_fp - proxy arp function pointer
*/
typedef int (*ol_txrx_proxy_arp_fp)(ol_osif_vdev_handle vdev,
qdf_nbuf_t netbuf);
/**
* ol_txrx_stats_callback - statistics notify callback
*/
typedef void (*ol_txrx_stats_callback)(void *ctxt,
enum htt_dbg_stats_type type,
uint8_t *buf, int bytes);
/**
* ol_txrx_ops - (pointers to) the functions used for tx and rx
* data xfer
*
* There are two portions of these txrx operations.
* The rx portion is filled in by OSIF SW before calling
* ol_txrx_osif_vdev_register; inside the ol_txrx_osif_vdev_register
* the txrx SW stores a copy of these rx function pointers, to use
* as it delivers rx data frames to the OSIF SW.
* The tx portion is filled in by the txrx SW inside
* ol_txrx_osif_vdev_register; when the function call returns,
* the OSIF SW stores a copy of these tx functions to use as it
* delivers tx data frames to the txrx SW.
*
* @tx.std - the tx function pointer for standard data
* frames This function pointer is set by the txrx SW
* perform host-side transmit operations based on
* whether a HL or LL host/target interface is in use.
* @tx.flow_control_cb - the transmit flow control
* function that is registered by the
* OSIF which is called from txrx to
* indicate whether the transmit OS
* queues should be paused/resumed
* @rx.std - the OS shim rx function to deliver rx data
* frames to. This can have different values for
* different virtual devices, e.g. so one virtual
* device's OS shim directly hands rx frames to the OS,
* but another virtual device's OS shim filters out P2P
* messages before sending the rx frames to the OS. The
* netbufs delivered to the osif_rx function are in the
* format specified by the OS to use for tx and rx
* frames (either 802.3 or native WiFi)
* @rx.wai_check - the tx function pointer for WAPI frames
* @rx.mon - the OS shim rx monitor function to deliver
* monitor data to Though in practice, it is probable
* that the same function will be used for delivering
* rx monitor data for all virtual devices, in theory
* each different virtual device can have a different
* OS shim function for accepting rx monitor data. The
* netbufs delivered to the osif_rx_mon function are in
* 802.11 format. Each netbuf holds a 802.11 MPDU, not
* an 802.11 MSDU. Depending on compile-time
* configuration, each netbuf may also have a
* monitor-mode encapsulation header such as a radiotap
* header added before the MPDU contents.
* @proxy_arp - proxy arp function pointer - specified by
* OS shim, stored by txrx
*/
struct ol_txrx_ops {
/* tx function pointers - specified by txrx, stored by OS shim */
struct {
ol_txrx_tx_fp tx;
} tx;
/* rx function pointers - specified by OS shim, stored by txrx */
struct {
ol_txrx_rx_fp rx;
ol_txrx_rx_check_wai_fp wai_check;
ol_txrx_rx_mon_fp mon;
} rx;
/* proxy arp function pointer - specified by OS shim, stored by txrx */
ol_txrx_proxy_arp_fp proxy_arp;
};
/**
* ol_txrx_stats_req - specifications of the requested
* statistics
*/
struct ol_txrx_stats_req {
uint32_t stats_type_upload_mask; /* which stats to upload */
uint32_t stats_type_reset_mask; /* which stats to reset */
/* stats will be printed if either print element is set */
struct {
int verbose; /* verbose stats printout */
int concise; /* concise stats printout (takes precedence) */
} print; /* print uploaded stats */
/* stats notify callback will be invoked if fp is non-NULL */
struct {
ol_txrx_stats_callback fp;
void *ctxt;
} callback;
/* stats will be copied into the specified buffer if buf is non-NULL */
struct {
uint8_t *buf;
int byte_limit; /* don't copy more than this */
} copy;
/*
* If blocking is true, the caller will take the specified semaphore
* to wait for the stats to be uploaded, and the driver will release
* the semaphore when the stats are done being uploaded.
*/
struct {
int blocking;
/*Note: this needs to change to some qdf_* type */
qdf_semaphore_t *sem_ptr;
} wait;
};
/* DP soc struct definition */
struct cdp_soc_t {
struct cdp_ops *ops;
struct ol_if_ops *ol_ops;
};
#define TXRX_FW_STATS_TXSTATS 1
#define TXRX_FW_STATS_RXSTATS 2
#define TXRX_FW_STATS_RX_RATE_INFO 3
#define TXRX_FW_STATS_PHYSTATS 4
#define TXRX_FW_STATS_PHYSTATS_CONCISE 5
#define TXRX_FW_STATS_TX_RATE_INFO 6
#define TXRX_FW_STATS_TID_STATE 7
#define TXRX_FW_STATS_HOST_STATS 8
#define TXRX_FW_STATS_CLEAR_HOST_STATS 9
#define TXRX_FW_STATS_CE_STATS 10
#define TXRX_FW_STATS_VOW_UMAC_COUNTER 11
#define TXRX_FW_STATS_ME_STATS 12
#define TXRX_FW_STATS_TXBF_INFO 13
#define TXRX_FW_STATS_SND_INFO 14
#define TXRX_FW_STATS_ERROR_INFO 15
#define TXRX_FW_STATS_TX_SELFGEN_INFO 16
#define TXRX_FW_STATS_TX_MU_INFO 17
#define TXRX_FW_SIFS_RESP_INFO 18
#define TXRX_FW_RESET_STATS 19
#define TXRX_FW_MAC_WDOG_STATS 20
#define TXRX_FW_MAC_DESC_STATS 21
#define TXRX_FW_MAC_FETCH_MGR_STATS 22
#define TXRX_FW_MAC_PREFETCH_MGR_STATS 23
#endif

245
dp/inc/cdp_txrx_ctrl.h
View File

@@ -32,83 +32,34 @@
#ifndef _CDP_TXRX_CTRL_H_ #ifndef _CDP_TXRX_CTRL_H_
#define _CDP_TXRX_CTRL_H_ #define _CDP_TXRX_CTRL_H_
/* TODO: adf need to be replaced with qdf */
/*
* Cleanups -- Might need cleanup
*/
#if !QCA_OL_TX_PDEV_LOCK && QCA_NSS_PLATFORM || \
(defined QCA_PARTNER_PLATFORM && QCA_PARTNER_SUPPORT_FAST_TX)
#define VAP_TX_SPIN_LOCK(_x) spin_lock(_x)
#define VAP_TX_SPIN_UNLOCK(_x) spin_unlock(_x)
#else /* QCA_OL_TX_PDEV_LOCK */
#define VAP_TX_SPIN_LOCK(_x)
#define VAP_TX_SPIN_UNLOCK(_x)
#endif /* QCA_OL_TX_PDEV_LOCK */
#if QCA_OL_TX_PDEV_LOCK static inline int cdp_is_target_ar900b
void ol_ll_pdev_tx_lock(void *); (ol_txrx_soc_handle soc, void *vdev)
void ol_ll_pdev_tx_unlock(void *); {
#define OL_TX_LOCK(_x) ol_ll_pdev_tx_lock(_x) if (soc->ops->ctrl_ops->txrx_is_target_ar900b)
#define OL_TX_UNLOCK(_x) ol_ll_pdev_tx_unlock(_x) return soc->ops->ctrl_ops->txrx_is_target_ar900b(vdev);
return 0;
#define OL_TX_PDEV_LOCK(_x) qdf_spin_lock_bh(_x) }
#define OL_TX_PDEV_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#else
#define OL_TX_PDEV_LOCK(_x)
#define OL_TX_PDEV_UNLOCK(_x)
#define OL_TX_LOCK(_x)
#define OL_TX_UNLOCK(_x)
#endif /* QCA_OL_TX_PDEV_LOCK */
#if !QCA_OL_TX_PDEV_LOCK
#define OL_TX_FLOW_CTRL_LOCK(_x) qdf_spin_lock_bh(_x)
#define OL_TX_FLOW_CTRL_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#define OL_TX_DESC_LOCK(_x) qdf_spin_lock_bh(_x)
#define OL_TX_DESC_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#define OSIF_VAP_TX_LOCK(_x) spin_lock(&((_x)->tx_lock))
#define OSIF_VAP_TX_UNLOCK(_x) spin_unlock(&((_x)->tx_lock))
#define OL_TX_PEER_LOCK(_x, _id) qdf_spin_lock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UNLOCK(_x, _id) qdf_spin_unlock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UPDATE_LOCK(_x, _id) \
qdf_spin_lock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UPDATE_UNLOCK(_x, _id) \
qdf_spin_unlock_bh(&((_x)->peer_lock[_id]))
#else
#define OSIF_VAP_TX_LOCK(_x) ol_ll_pdev_tx_lock((_x)->iv_txrx_handle)
#define OSIF_VAP_TX_UNLOCK(_x) ol_ll_pdev_tx_unlock((_x)->iv_txrx_handle)
#define OL_TX_FLOW_CTRL_LOCK(_x)
#define OL_TX_FLOW_CTRL_UNLOCK(_x)
#define OL_TX_DESC_LOCK(_x)
#define OL_TX_DESC_UNLOCK(_x)
#define OL_TX_PEER_LOCK(_x, _id)
#define OL_TX_PEER_UNLOCK(_x, _id)
#define OL_TX_PEER_UPDATE_LOCK(_x, _id) qdf_spin_lock_bh(&((_x)->tx_lock))
#define OL_TX_PEER_UPDATE_UNLOCK(_x, _id) qdf_spin_unlock_bh(&((_x)->tx_lock))
#endif /* !QCA_OL_TX_PDEV_LOCK */
extern int ol_txrx_is_target_ar900b(ol_txrx_vdev_handle vdev);
#define OL_TXRX_IS_TARGET_AR900B(vdev) ol_txrx_is_target_ar900b(vdev)
/* WIN */ /* WIN */
int static inline int
ol_txrx_mempools_attach(ol_pdev_handle ctrl_pdev); cdp_mempools_attach(ol_txrx_soc_handle soc, void *ctrl_pdev)
int {
ol_txrx_set_filter_neighbour_peers( if (soc->ops->ctrl_ops->txrx_mempools_attach)
ol_txrx_pdev_handle pdev, return soc->ops->ctrl_ops->txrx_mempools_attach(ctrl_pdev);
u_int32_t val); return 0;
}
static inline int
cdp_set_filter_neighbour_peers(ol_txrx_soc_handle soc,
void *pdev, u_int32_t val)
{
if (soc->ops->ctrl_ops->txrx_set_filter_neighbour_peers)
return soc->ops->ctrl_ops->txrx_set_filter_neighbour_peers
(pdev, val);
return 0;
}
/** /**
* @brief set the safemode of the device * @brief set the safemode of the device
* @details * @details
@@ -122,10 +73,14 @@ ol_txrx_set_filter_neighbour_peers(
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_set_safemode( cdp_set_safemode(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev, u_int32_t val)
u_int32_t val); {
if (soc->ops->ctrl_ops->txrx_set_safemode)
return soc->ops->ctrl_ops->txrx_set_safemode(vdev, val);
return;
}
/** /**
* @brief configure the drop unencrypted frame flag * @brief configure the drop unencrypted frame flag
* @details * @details
@@ -136,10 +91,14 @@ ol_txrx_set_safemode(
* @param val - flag * @param val - flag
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_set_drop_unenc( cdp_set_drop_unenc(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev, u_int32_t val)
u_int32_t val); {
if (soc->ops->ctrl_ops->txrx_set_drop_unenc)
return soc->ops->ctrl_ops->txrx_set_drop_unenc(vdev, val);
return;
}
/** /**
@@ -151,10 +110,14 @@ ol_txrx_set_drop_unenc(
* @param val - the Tx encap type (htt_pkt_type) * @param val - the Tx encap type (htt_pkt_type)
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_set_tx_encap_type( cdp_set_tx_encap_type(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev, enum htt_pkt_type val)
uint32_t val); {
if (soc->ops->ctrl_ops->txrx_set_tx_encap_type)
return soc->ops->ctrl_ops->txrx_set_tx_encap_type(vdev, val);
return;
}
/** /**
* @brief set the Rx decapsulation type of the VDEV * @brief set the Rx decapsulation type of the VDEV
@@ -166,10 +129,15 @@ ol_txrx_set_tx_encap_type(
* @param val - the Rx decap mode (htt_pkt_type) * @param val - the Rx decap mode (htt_pkt_type)
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_set_vdev_rx_decap_type( cdp_set_vdev_rx_decap_type(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev, enum htt_pkt_type val)
uint32_t val); {
if (soc->ops->ctrl_ops->txrx_set_vdev_rx_decap_type)
return soc->ops->ctrl_ops->txrx_set_vdev_rx_decap_type
(vdev, val);
return;
}
/** /**
* @brief get the Rx decapsulation type of the VDEV * @brief get the Rx decapsulation type of the VDEV
@@ -177,8 +145,13 @@ ol_txrx_set_vdev_rx_decap_type(
* @param vdev - the data virtual device object * @param vdev - the data virtual device object
* @return - the Rx decap type (htt_pkt_type) * @return - the Rx decap type (htt_pkt_type)
*/ */
uint32_t static inline enum htt_pkt_type
ol_txrx_get_vdev_rx_decap_type(ol_txrx_vdev_handle vdev); cdp_get_vdev_rx_decap_type(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->ctrl_ops->txrx_get_vdev_rx_decap_type)
return soc->ops->ctrl_ops->txrx_get_vdev_rx_decap_type(vdev);
return 0;
}
/* Is this similar to ol_txrx_peer_state_update() in MCL */ /* Is this similar to ol_txrx_peer_state_update() in MCL */
/** /**
@@ -193,18 +166,38 @@ ol_txrx_get_vdev_rx_decap_type(ol_txrx_vdev_handle vdev);
* *
* @return none * @return none
*/ */
void static inline void
ol_txrx_peer_authorize(struct ol_txrx_peer_t *peer, u_int32_t authorize); cdp_peer_authorize(ol_txrx_soc_handle soc,
struct ol_txrx_peer_t *peer, u_int32_t authorize)
{
if (soc->ops->ctrl_ops->txrx_peer_authorize)
return soc->ops->ctrl_ops->txrx_peer_authorize
(peer, authorize);
return;
}
bool static inline bool
ol_txrx_set_inact_params(ol_txrx_pdev_handle pdev, cdp_set_inact_params(ol_txrx_soc_handle soc, void *pdev,
u_int16_t inact_check_interval, u_int16_t inact_check_interval,
u_int16_t inact_normal, u_int16_t inact_normal,
u_int16_t inact_overload); u_int16_t inact_overload)
bool {
ol_txrx_start_inact_timer( if (soc->ops->ctrl_ops->txrx_set_inact_params)
ol_txrx_pdev_handle pdev, return soc->ops->ctrl_ops->txrx_set_inact_params
bool enable); (pdev, inact_check_interval, inact_normal,
inact_overload);
return false;
}
static inline bool
cdp_start_inact_timer(ol_txrx_soc_handle soc,
void *pdev,
bool enable)
{
if (soc->ops->ctrl_ops->txrx_start_inact_timer)
return soc->ops->ctrl_ops->txrx_start_inact_timer
(pdev, enable);
return false;
}
/** /**
* @brief Set the overload status of the radio * @brief Set the overload status of the radio
@@ -215,18 +208,28 @@ ol_txrx_start_inact_timer(
* @param pdev - the data physical device object * @param pdev - the data physical device object
* @param overload - whether the radio is overloaded or not * @param overload - whether the radio is overloaded or not
*/ */
void static inline void
ol_txrx_set_overload( cdp_set_overload(ol_txrx_soc_handle soc, void *pdev,
ol_txrx_pdev_handle pdev, bool overload)
bool overload); {
if (soc->ops->ctrl_ops->txrx_set_overload)
return soc->ops->ctrl_ops->txrx_set_overload(pdev, overload);
return;
}
/** /**
* @brief Check the inactivity status of the peer/node * @brief Check the inactivity status of the peer/node
* *
* @param peer - pointer to the node's object * @param peer - pointer to the node's object
* @return true if the node is inactive; otherwise return false * @return true if the node is inactive; otherwise return false
*/ */
bool static inline bool
ol_txrx_peer_is_inact(ol_txrx_peer_handle peer); cdp_peer_is_inact(ol_txrx_soc_handle soc, void *peer)
{
if (soc->ops->ctrl_ops->txrx_peer_is_inact)
return soc->ops->ctrl_ops->txrx_peer_is_inact(peer);
return false;
}
/** /**
* @brief Mark inactivity status of the peer/node * @brief Mark inactivity status of the peer/node
@@ -237,15 +240,33 @@ ol_txrx_peer_is_inact(ol_txrx_peer_handle peer);
* @param peer - pointer to the node's object * @param peer - pointer to the node's object
* @param inactive - whether the node is inactive or not * @param inactive - whether the node is inactive or not
*/ */
void static inline void
ol_txrx_mark_peer_inact( cdp_mark_peer_inact(ol_txrx_soc_handle soc,
ol_txrx_peer_handle peer, void *peer,
bool inactive); bool inactive)
{
if (soc->ops->ctrl_ops->txrx_mark_peer_inact)
return soc->ops->ctrl_ops->txrx_mark_peer_inact
(peer, inactive);
return;
}
/* Should be ol_txrx_ctrl_api.h */ /* Should be ol_txrx_ctrl_api.h */
void ol_txrx_set_mesh_mode(ol_txrx_vdev_handle vdev, u_int32_t val); static inline void cdp_set_mesh_mode
(ol_txrx_soc_handle soc, void *vdev, u_int32_t val)
{
if (soc->ops->ctrl_ops->txrx_set_mesh_mode)
return soc->ops->ctrl_ops->txrx_set_mesh_mode(vdev, val);
return;
}
void ol_tx_flush_buffers(struct ol_txrx_vdev_t *vdev); static inline void cdp_tx_flush_buffers
(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->ctrl_ops->tx_flush_buffers)
return soc->ops->ctrl_ops->tx_flush_buffers(vdev);
return;
}
#endif #endif

92
dp/inc/cdp_txrx_ctrl_def.h Normal file
View File

@@ -0,0 +1,92 @@
/*
* Copyright (c) 2011-2016 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file cdp_txrx_ctrl.h
* @brief Define the host data path control API functions
* called by the host control SW and the OS interface module
*/
#ifndef _CDP_TXRX_CTRL_DEF_H_
#define _CDP_TXRX_CTRL_DEF_H_
/* TODO: adf need to be replaced with qdf */
/*
* Cleanups -- Might need cleanup
*/
#if !QCA_OL_TX_PDEV_LOCK && QCA_NSS_PLATFORM || \
(defined QCA_PARTNER_PLATFORM && QCA_PARTNER_SUPPORT_FAST_TX)
#define VAP_TX_SPIN_LOCK(_x) spin_lock(_x)
#define VAP_TX_SPIN_UNLOCK(_x) spin_unlock(_x)
#else /* QCA_OL_TX_PDEV_LOCK */
#define VAP_TX_SPIN_LOCK(_x)
#define VAP_TX_SPIN_UNLOCK(_x)
#endif /* QCA_OL_TX_PDEV_LOCK */
#if QCA_OL_TX_PDEV_LOCK
void ol_ll_pdev_tx_lock(void *);
void ol_ll_pdev_tx_unlock(void *);
#define OL_TX_LOCK(_x) ol_ll_pdev_tx_lock(_x)
#define OL_TX_UNLOCK(_x) ol_ll_pdev_tx_unlock(_x)
#define OL_TX_PDEV_LOCK(_x) qdf_spin_lock_bh(_x)
#define OL_TX_PDEV_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#else
#define OL_TX_PDEV_LOCK(_x)
#define OL_TX_PDEV_UNLOCK(_x)
#define OL_TX_LOCK(_x)
#define OL_TX_UNLOCK(_x)
#endif /* QCA_OL_TX_PDEV_LOCK */
#if !QCA_OL_TX_PDEV_LOCK
#define OL_TX_FLOW_CTRL_LOCK(_x) qdf_spin_lock_bh(_x)
#define OL_TX_FLOW_CTRL_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#define OL_TX_DESC_LOCK(_x) qdf_spin_lock_bh(_x)
#define OL_TX_DESC_UNLOCK(_x) qdf_spin_unlock_bh(_x)
#define OSIF_VAP_TX_LOCK(_x) spin_lock(&((_x)->tx_lock))
#define OSIF_VAP_TX_UNLOCK(_x) spin_unlock(&((_x)->tx_lock))
#define OL_TX_PEER_LOCK(_x, _id) qdf_spin_lock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UNLOCK(_x, _id) qdf_spin_unlock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UPDATE_LOCK(_x, _id) \
qdf_spin_lock_bh(&((_x)->peer_lock[_id]))
#define OL_TX_PEER_UPDATE_UNLOCK(_x, _id) \
qdf_spin_unlock_bh(&((_x)->peer_lock[_id]))
#else
#define OSIF_VAP_TX_LOCK(_x) ol_ll_pdev_tx_lock((_x)->iv_txrx_handle)
#define OSIF_VAP_TX_UNLOCK(_x) ol_ll_pdev_tx_unlock((_x)->iv_txrx_handle)
#define OL_TX_FLOW_CTRL_LOCK(_x)
#define OL_TX_FLOW_CTRL_UNLOCK(_x)
#define OL_TX_DESC_LOCK(_x)
#define OL_TX_DESC_UNLOCK(_x)
#define OL_TX_PEER_LOCK(_x, _id)
#define OL_TX_PEER_UNLOCK(_x, _id)
#define OL_TX_PEER_UPDATE_LOCK(_x, _id) qdf_spin_lock_bh(&((_x)->tx_lock))
#define OL_TX_PEER_UPDATE_UNLOCK(_x, _id) qdf_spin_unlock_bh(&((_x)->tx_lock))
#endif /* !QCA_OL_TX_PDEV_LOCK */
#endif

187
dp/inc/cdp_txrx_host_stats.h
View File

@@ -31,35 +31,60 @@
*/ */
#ifndef _CDP_TXRX_HOST_STATS_H_ #ifndef _CDP_TXRX_HOST_STATS_H_
#define _CDP_TXRX_HOST_STATS_H_ #define _CDP_TXRX_HOST_STATS_H_
#include <cdp_txrx_stats_struct.h>
/* WIN */ /* WIN */
/* Need to remove the "req" parameter */ /* Need to remove the "req" parameter */
/* Need to rename the function to reflect the functionality "show" / "display" /* Need to rename the function to reflect the functionality "show" / "display"
* WIN -- to figure out whether to change OSIF to converge (not an immediate AI) * WIN -- to figure out whether to change OSIF to converge (not an immediate AI)
* */ * */
#if WLAN_FEATURE_FASTPATH #if WLAN_FEATURE_FASTPATH
int ol_txrx_host_stats_get( static inline int cdp_host_stats_get(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev,
struct ol_txrx_stats_req *req); struct ol_txrx_stats_req *req)
{
if (soc->ops->host_stats_ops->txrx_host_stats_get)
return soc->ops->host_stats_ops->txrx_host_stats_get(vdev, req);
return 0;
}
void static inline void
ol_txrx_host_stats_clr(ol_txrx_vdev_handle vdev); cdp_host_stats_clr(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->txrx_host_stats_clr)
return soc->ops->host_stats_ops->txrx_host_stats_clr(vdev);
return;
}
void static inline void
ol_txrx_host_ce_stats(ol_txrx_vdev_handle vdev); cdp_host_ce_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->txrx_host_ce_stats)
return soc->ops->host_stats_ops->txrx_host_ce_stats(vdev);
return;
}
int static inline int cdp_stats_publish
ol_txrx_stats_publish(ol_txrx_pdev_handle pdev, struct ol_txrx_stats *buf); (ol_txrx_soc_handle soc, void *pdev,
struct ol_txrx_stats *buf)
{
if (soc->ops->host_stats_ops->txrx_stats_publish)
return soc->ops->host_stats_ops->txrx_stats_publish(pdev, buf);
return 0;
}
/** /**
* @brief Enable enhanced stats functionality. * @brief Enable enhanced stats functionality.
* *
* @param pdev - the physical device object * @param pdev - the physical device object
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_enable_enhanced_stats(ol_txrx_pdev_handle pdev); cdp_enable_enhanced_stats(ol_txrx_soc_handle soc, void *pdev)
{
if (soc->ops->host_stats_ops->txrx_enable_enhanced_stats)
return soc->ops->host_stats_ops->txrx_enable_enhanced_stats
(pdev);
return;
}
/** /**
* @brief Disable enhanced stats functionality. * @brief Disable enhanced stats functionality.
@@ -67,8 +92,14 @@ ol_txrx_enable_enhanced_stats(ol_txrx_pdev_handle pdev);
* @param pdev - the physical device object * @param pdev - the physical device object
* @return - void * @return - void
*/ */
void static inline void
ol_txrx_disable_enhanced_stats(ol_txrx_pdev_handle pdev); cdp_disable_enhanced_stats(ol_txrx_soc_handle soc, void *pdev)
{
if (soc->ops->host_stats_ops->txrx_disable_enhanced_stats)
return soc->ops->host_stats_ops->txrx_disable_enhanced_stats
(pdev);
return;
}
#if ENHANCED_STATS #if ENHANCED_STATS
/** /**
@@ -79,64 +110,124 @@ ol_txrx_disable_enhanced_stats(ol_txrx_pdev_handle pdev);
* @param type - stats type. * @param type - stats type.
* @return - pointer to requested stat identified by type * @return - pointer to requested stat identified by type
*/ */
uint32_t *ol_txrx_get_stats_base(ol_txrx_pdev_handle pdev, static inline uint32_t *cdp_get_stats_base
uint32_t *stats_base, uint32_t msg_len, uint8_t type); (ol_txrx_soc_handle soc, void *pdev,
uint32_t *stats_base, uint32_t msg_len, uint8_t type)
{
if (soc->ops->host_stats_ops->txrx_get_stats_base)
return (uint32_t *)soc->ops->host_stats_ops->txrx_get_stats_base
(pdev, stats_base, msg_len, type);
return 0;
}
#endif #endif
#endif /* WLAN_FEATURE_FASTPATH*/ #endif /* WLAN_FEATURE_FASTPATH*/
#if (HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE) #if (HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE)
void static inline void
ol_tx_print_tso_stats( cdp_tx_print_tso_stats(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev); void *vdev)
{
if (soc->ops->host_stats_ops->tx_print_tso_stats)
return soc->ops->host_stats_ops->tx_print_tso_stats(vdev);
return;
}
void static inline void
ol_tx_rst_tso_stats(ol_txrx_vdev_handle vdev); cdp_tx_rst_tso_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->tx_rst_tso_stats)
return soc->ops->host_stats_ops->tx_rst_tso_stats(vdev);
return;
}
#endif /* HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE */ #endif /* HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE */
#if HOST_SW_SG_ENABLE #if HOST_SW_SG_ENABLE
void static inline void
ol_tx_print_sg_stats( cdp_tx_print_sg_stats(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev); void *vdev)
{
if (soc->ops->host_stats_ops->tx_print_sg_stats)
return soc->ops->host_stats_ops->tx_print_sg_stats(vdev);
return;
}
void static inline void
ol_tx_rst_sg_stats(ol_txrx_vdev_handle vdev); cdp_tx_rst_sg_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->tx_rst_sg_stats)
return soc->ops->host_stats_ops->tx_rst_sg_stats(vdev);
return;
}
#endif /* HOST_SW_SG_ENABLE */ #endif /* HOST_SW_SG_ENABLE */
#if RX_CHECKSUM_OFFLOAD #if RX_CHECKSUM_OFFLOAD
void static inline void
ol_print_rx_cksum_stats( cdp_print_rx_cksum_stats(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev); void *vdev)
{
if (soc->ops->host_stats_ops->print_rx_cksum_stats)
return soc->ops->host_stats_ops->print_rx_cksum_stats(vdev);
return;
}
void static inline void
ol_rst_rx_cksum_stats(ol_txrx_vdev_handle vdev); cdp_rst_rx_cksum_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->rst_rx_cksum_stats)
return soc->ops->host_stats_ops->rst_rx_cksum_stats(vdev);
return;
}
#endif /* RX_CHECKSUM_OFFLOAD */ #endif /* RX_CHECKSUM_OFFLOAD */
#if (ATH_SUPPORT_IQUE && WLAN_FEATURE_FASTPATH) #if (ATH_SUPPORT_IQUE && WLAN_FEATURE_FASTPATH)
A_STATUS static inline A_STATUS
ol_txrx_host_me_stats(ol_txrx_vdev_handle vdev); cdp_host_me_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->txrx_host_me_stats)
return soc->ops->host_stats_ops->txrx_host_me_stats(vdev);
return 0;
}
#endif /* WLAN_FEATURE_FASTPATH */ #endif /* WLAN_FEATURE_FASTPATH */
#if PEER_FLOW_CONTROL #if PEER_FLOW_CONTROL
extern void static inline void cdp_per_peer_stats
ol_txrx_per_peer_stats(struct ol_txrx_pdev_t *pdev, char *addr); (ol_txrx_soc_handle soc, void *pdev, char *addr)
{
if (soc->ops->host_stats_ops->txrx_per_peer_stats)
return soc->ops->host_stats_ops->txrx_per_peer_stats
(pdev, addr);
return;
}
#endif #endif
#if WLAN_FEATURE_FASTPATH && PEER_FLOW_CONTROL #if WLAN_FEATURE_FASTPATH && PEER_FLOW_CONTROL
int ol_txrx_host_msdu_ttl_stats( static inline int cdp_host_msdu_ttl_stats(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev,
struct ol_txrx_stats_req *req); struct ol_txrx_stats_req *req)
{
if (soc->ops->host_stats_ops->txrx_host_msdu_ttl_stats)
return soc->ops->host_stats_ops->txrx_host_msdu_ttl_stats
(vdev, req);
return 0;
}
#endif #endif
#define BSS_CHAN_INFO_READ 1
#define BSS_CHAN_INFO_READ_AND_CLEAR 2
#define TX_FRAME_TYPE_DATA 0
#define TX_FRAME_TYPE_MGMT 1
#define TX_FRAME_TYPE_BEACON 2
#if HOST_SW_LRO_ENABLE #if HOST_SW_LRO_ENABLE
void static inline void
ol_print_lro_stats(ol_txrx_vdev_handle vdev); cdp_print_lro_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->print_lro_stats)
return soc->ops->host_stats_ops->print_lro_stats(vdev);
return;
}
void static inline void
ol_reset_lro_stats(ol_txrx_vdev_handle vdev); cdp_reset_lro_stats(ol_txrx_soc_handle soc, void *vdev)
{
if (soc->ops->host_stats_ops->reset_lro_stats)
return soc->ops->host_stats_ops->reset_lro_stats(vdev);
return;
}
#endif /* HOST_SW_LRO_ENABLE */ #endif /* HOST_SW_LRO_ENABLE */

83
dp/inc/cdp_txrx_me.h
View File

@@ -32,30 +32,68 @@
#ifndef _CDP_TXRX_ME_H_ #ifndef _CDP_TXRX_ME_H_
#define _CDP_TXRX_ME_H_ #define _CDP_TXRX_ME_H_
#include <cdp_txrx_ops.h>
/* TODO: adf need to be replaced with qdf */ /* TODO: adf need to be replaced with qdf */
#if ATH_SUPPORT_ME_FW_BASED #if ATH_SUPPORT_ME_FW_BASED
extern u_int16_t static inline u_int16_t
ol_tx_desc_alloc_and_mark_for_mcast_clone(struct ol_txrx_pdev_t *pdev, u_int16_t cdp_tx_desc_alloc_and_mark_for_mcast_clone(ol_txrx_soc_handle soc,
buf_count) void *pdev, u_int16_t buf_count)
{
if (soc->ops->me_ops->tx_desc_alloc_and_mark_for_mcast_clone)
return soc->ops->me_ops->
tx_desc_alloc_and_mark_for_mcast_clone
(pdev, buf_count);
return 0;
}
extern u_int16_t static inline u_int16_t
ol_tx_desc_free_and_unmark_for_mcast_clone(struct ol_txrx_pdev_t *pdev, cdp_tx_desc_free_and_unmark_for_mcast_clone(ol_txrx_soc_handle soc,
u_int16_t buf_count); void *pdev, u_int16_t buf_count)
{
if (soc->ops->me_ops->tx_desc_free_and_unmark_for_mcast_clone)
return soc->ops->me_ops->
tx_desc_free_and_unmark_for_mcast_clone
(pdev, buf_count);
return 0;
}
extern u_int16_t static inline u_int16_t
ol_tx_get_mcast_buf_allocated_marked(struct ol_txrx_pdev_t *pdev); cdp_tx_get_mcast_buf_allocated_marked(ol_txrx_soc_handle soc,
void *pdev)
{
if (soc->ops->me_ops->tx_get_mcast_buf_allocated_marked)
return soc->ops->me_ops->tx_get_mcast_buf_allocated_marked
(pdev);
return 0;
}
#else #else
extern void
ol_tx_me_alloc_descriptor(struct ol_txrx_pdev_t *pdev);
extern void static inline void
ol_tx_me_free_descriptor(struct ol_txrx_pdev_t *pdev); cdp_tx_me_alloc_descriptor(ol_txrx_soc_handle soc, void *pdev)
{
if (soc->ops->me_ops->tx_me_alloc_descriptor)
return soc->ops->me_ops->tx_me_alloc_descriptor(pdev);
return;
}
extern uint16_t static inline void
ol_tx_me_convert_ucast(ol_txrx_vdev_handle vdev, qdf_nbuf_t wbuf, cdp_tx_me_free_descriptor(ol_txrx_soc_handle soc, void *pdev)
u_int8_t newmac[][6], uint8_t newmaccnt); {
if (soc->ops->me_ops->tx_me_free_descriptor)
return soc->ops->me_ops->tx_me_free_descriptor(pdev);
return;
}
static inline uint16_t
cdp_tx_me_convert_ucast(ol_txrx_soc_handle soc, void *vdev,
qdf_nbuf_t wbuf, u_int8_t newmac[][6], uint8_t newmaccnt)
{
if (soc->ops->me_ops->tx_me_convert_ucast)
return soc->ops->me_ops->tx_me_convert_ucast
(vdev, wbuf, newmac, newmaccnt);
return 0;
}
#endif #endif
/* Should be a function pointer in ol_txrx_osif_ops{} */ /* Should be a function pointer in ol_txrx_osif_ops{} */
#if ATH_MCAST_HOST_INSPECT #if ATH_MCAST_HOST_INSPECT
@@ -70,11 +108,12 @@ ol_tx_me_convert_ucast(ol_txrx_vdev_handle vdev, qdf_nbuf_t wbuf,
* @param msdu - the multicast msdu returned by FW for host inspect * @param msdu - the multicast msdu returned by FW for host inspect
*/ */
int ol_mcast_notify(ol_pdev_handle pdev, static inline int cdp_mcast_notify(ol_txrx_soc_handle soc, void *pdev,
u_int8_t vdev_id, qdf_nbuf_t msdu); u_int8_t vdev_id, qdf_nbuf_t msdu)
{
if (soc->ops->me_ops->mcast_notify)
return soc->ops->me_ops->mcast_notify(pdev, vdev_id, msdu);
return 0;
}
#endif #endif
#endif #endif

67
dp/inc/cdp_txrx_mon.h
View File

@@ -32,18 +32,61 @@
#ifndef _CDP_TXRX_MON_H_ #ifndef _CDP_TXRX_MON_H_
#define _CDP_TXRX_MON_H_ #define _CDP_TXRX_MON_H_
void ol_txrx_monitor_set_filter_ucast_data(ol_txrx_pdev_handle, u_int8_t val);
void ol_txrx_monitor_set_filter_mcast_data(ol_txrx_pdev_handle, u_int8_t val);
void ol_txrx_monitor_set_filter_non_data(ol_txrx_pdev_handle, u_int8_t val);
u_int8_t ol_txrx_monitor_get_filter_ucast_data( static inline void cdp_monitor_set_filter_ucast_data
ol_txrx_vdev_handle vdev_txrx_handle); (ol_txrx_soc_handle soc, void *pdev, u_int8_t val)
u_int8_t ol_txrx_monitor_get_filter_mcast_data( {
ol_txrx_vdev_handle vdev_txrx_handle); if (soc->ops->mon_ops->txrx_monitor_set_filter_ucast_data)
u_int8_t ol_txrx_monitor_get_filter_non_data( return soc->ops->mon_ops->txrx_monitor_set_filter_ucast_data
ol_txrx_vdev_handle vdev_txrx_handle); (pdev, val);
return;
}
int ol_txrx_reset_monitor_mode(ol_txrx_pdev_handle pdev); static inline void cdp_monitor_set_filter_mcast_data
(ol_txrx_soc_handle soc, void *pdev, u_int8_t val)
{
if (soc->ops->mon_ops->txrx_monitor_set_filter_mcast_data)
return soc->ops->mon_ops->txrx_monitor_set_filter_mcast_data
(pdev, val);
return;
}
static inline void cdp_monitor_set_filter_non_data
(ol_txrx_soc_handle soc, void *pdev, u_int8_t val)
{
if (soc->ops->mon_ops->txrx_monitor_set_filter_non_data)
return soc->ops->mon_ops->txrx_monitor_set_filter_non_data
(pdev, val);
return;
}
static inline u_int8_t cdp_monitor_get_filter_ucast_data(ol_txrx_soc_handle soc,
void *vdev_txrx_handle)
{
if (soc->ops->mon_ops->txrx_monitor_get_filter_ucast_data)
return soc->ops->mon_ops->txrx_monitor_get_filter_ucast_data
(vdev_txrx_handle);
return 0;
}
static inline u_int8_t cdp_monitor_get_filter_mcast_data(ol_txrx_soc_handle soc,
void *vdev_txrx_handle)
{
if (soc->ops->mon_ops->txrx_monitor_get_filter_mcast_data)
return soc->ops->mon_ops->txrx_monitor_get_filter_mcast_data
(vdev_txrx_handle);
return 0;
}
static inline u_int8_t cdp_monitor_get_filter_non_data(ol_txrx_soc_handle soc,
void *vdev_txrx_handle)
{
if (soc->ops->mon_ops->txrx_monitor_get_filter_non_data)
return soc->ops->mon_ops->txrx_monitor_get_filter_non_data
(vdev_txrx_handle);
return 0;
}
static inline int cdp_reset_monitor_mode
(ol_txrx_soc_handle soc, void *pdev)
{
if (soc->ops->mon_ops->txrx_reset_monitor_mode)
return soc->ops->mon_ops->txrx_reset_monitor_mode(pdev);
return 0;
}
#endif #endif

518
dp/inc/cdp_txrx_ops.h Normal file
View File

@@ -0,0 +1,518 @@
/*
* Copyright (c) 2011-2016 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
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file cdp_txrx_ops.h
* @brief Define the host data path converged API functions
* called by the host control SW and the OS interface module
*/
#ifndef _CDP_TXRX_CMN_OPS_H_
#define _CDP_TXRX_CMN_OPS_H_
#include <cdp_txrx_cmn_struct.h>
/******************************************************************************
*
* Control Interface (A Interface)
*
*****************************************************************************/
struct cdp_cmn_ops {
int(*txrx_soc_attach_target)(ol_txrx_soc_handle soc);
int(*txrx_pdev_attach_target)(void *pdev);
void *(*txrx_vdev_attach)
(void *pdev, uint8_t *vdev_mac_addr,
uint8_t vdev_id, enum wlan_op_mode op_mode);
void(*txrx_vdev_detach)
(void *vdev, ol_txrx_vdev_delete_cb callback,
void *cb_context);
void *(*txrx_pdev_attach)
(ol_txrx_soc_handle soc, void *ctrl_pdev,
HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id);
void(*txrx_pdev_detach)(void *pdev, int force);
void *(*txrx_peer_attach)
(void *vdev, uint8_t *peer_mac_addr);
void(*txrx_peer_detach)(void *peer);
int(*txrx_set_monitor_mode)(void *vdev);
void(*txrx_set_curchan)(void *pdev, uint32_t chan_mhz);
void (*txrx_set_privacy_filters)
(void *vdev, void *filter, uint32_t num);
/********************************************************************
* Data Interface (B Interface)
********************************************************************/
void(*txrx_vdev_register)(void *vdev,
void *osif_vdev, struct ol_txrx_ops *txrx_ops);
int(*txrx_mgmt_send)(void *vdev,
qdf_nbuf_t tx_mgmt_frm, uint8_t type);
int(*txrx_mgmt_send_ext)(void *vdev,
qdf_nbuf_t tx_mgmt_frm, uint8_t type, uint8_t use_6mbps,
uint16_t chanfreq);
/**
* ol_txrx_mgmt_tx_cb - tx management delivery notification
* callback function
*/
void(*txrx_mgmt_tx_cb_set)
(void *pdev, uint8_t type,
ol_txrx_mgmt_tx_cb download_cb, ol_txrx_mgmt_tx_cb ota_ack_cb,
void *ctxt);
int (*txrx_get_tx_pending)(void *pdev);
/**
* ol_txrx_data_tx_cb - Function registered with the data path
* that is called when tx frames marked as "no free" are
* done being transmitted
*/
void(*txrx_data_tx_cb_set)(void *data_vdev,
ol_txrx_data_tx_cb callback, void *ctxt);
/*******************************************************************
* Statistics and Debugging Interface (C Inteface)
********************************************************************/
int(*txrx_aggr_cfg)(void *vdev, int max_subfrms_ampdu,
int max_subfrms_amsdu);
int(*txrx_fw_stats_get)(void *vdev,
struct ol_txrx_stats_req *req, bool response_expected);
int(*txrx_debug)(void *vdev, int debug_specs);
void(*txrx_fw_stats_cfg)(void *vdev,
uint8_t cfg_stats_type, uint32_t cfg_val);
void(*txrx_print_level_set)(unsigned level);
/**
* ol_txrx_get_vdev_mac_addr() - Return mac addr of vdev
* @vdev: vdev handle
*
* Return: vdev mac address
*/
uint8_t *(*txrx_get_vdev_mac_addr)(void *vdev);
/**
* ol_txrx_get_vdev_struct_mac_addr() - Return handle to struct qdf_mac_addr of
* vdev
* @vdev: vdev handle
*
* Return: Handle to struct qdf_mac_addr
*/
struct qdf_mac_addr *
(*txrx_get_vdev_struct_mac_addr)(void *vdev);
/**
* ol_txrx_get_pdev_from_vdev() - Return handle to pdev of vdev
* @vdev: vdev handle
*
* Return: Handle to pdev
*/
void *(*txrx_get_pdev_from_vdev)
(void *vdev);
/**
* ol_txrx_get_ctrl_pdev_from_vdev() - Return control pdev of vdev
* @vdev: vdev handle
*
* Return: Handle to control pdev
*/
void *
(*txrx_get_ctrl_pdev_from_vdev)(void *vdev);
void *
(*txrx_get_vdev_from_vdev_id)(uint8_t vdev_id);
void (*txrx_soc_detach)(void *soc);
};
struct cdp_ctrl_ops {
int
(*txrx_mempools_attach)(void *ctrl_pdev);
int
(*txrx_set_filter_neighbour_peers)(
void *pdev,
u_int32_t val);
/**
* @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)(
void *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)(
void *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)(
void *vdev,
enum htt_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)(
void *vdev,
enum htt_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_pkt_type
(*txrx_get_vdev_rx_decap_type)(void *vdev);
/* Is this similar to ol_txrx_peer_state_update() in MCL */
/**
* @brief Update the authorize peer object at association time
* @details
* For the host-based implementation of rate-control, it
* updates the peer/node-related parameters within rate-control
* context of the peer at association.
*
* @param peer - pointer to the node's object
* @authorize - either to authorize or unauthorize peer
*
* @return none
*/
void
(*txrx_peer_authorize)(void *peer,
u_int32_t authorize);
bool
(*txrx_set_inact_params)(void *pdev,
u_int16_t inact_check_interval,
u_int16_t inact_normal,
u_int16_t inact_overload);
bool
(*txrx_start_inact_timer)(
void *pdev,
bool enable);
/**
* @brief Set the overload status of the radio
* @details
* Set the overload status of the radio, updating the inactivity
* threshold and inactivity count for each node.
*
* @param pdev - the data physical device object
* @param overload - whether the radio is overloaded or not
*/
void (*txrx_set_overload)(
void *pdev,
bool overload);
/**
* @brief Check the inactivity status of the peer/node
*
* @param peer - pointer to the node's object
* @return true if the node is inactive; otherwise return false
*/
bool
(*txrx_peer_is_inact)(void *peer);
/**
* @brief Mark inactivity status of the peer/node
* @details
* If it becomes active, reset inactivity count to reload value;
* if the inactivity status changed, notify umac band steering.
*
* @param peer - pointer to the node's object
* @param inactive - whether the node is inactive or not
*/
void (*txrx_mark_peer_inact)(
void *peer,
bool inactive);
/* Should be ol_txrx_ctrl_api.h */
void (*txrx_set_mesh_mode)(void *vdev, u_int32_t val);
void (*tx_flush_buffers)(void *vdev);
int (*txrx_is_target_ar900b)(void *vdev);
};
struct cdp_me_ops {
#if ATH_SUPPORT_ME_FW_BASED
u_int16_t (*tx_desc_alloc_and_mark_for_mcast_clone)
(void *pdev, u_int16_t buf_count)
u_int16_t (*tx_desc_free_and_unmark_for_mcast_clone)(
void *pdev,
u_int16_t buf_count);
u_int16_t
(*tx_get_mcast_buf_allocated_marked)
(void *pdev);
#else
void
(*tx_me_alloc_descriptor)(void *pdev);
void
(*tx_me_free_descriptor)(void *pdev);
uint16_t
(*tx_me_convert_ucast)(void *vdev,
qdf_nbuf_t wbuf, u_int8_t newmac[][6],
uint8_t newmaccnt);
#endif
/* Should be a function pointer in ol_txrx_osif_ops{} */
#if ATH_MCAST_HOST_INSPECT
/**
* @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)(void *pdev,
u_int8_t vdev_id, qdf_nbuf_t msdu);
#endif
};
struct cdp_mon_ops {
void (*txrx_monitor_set_filter_ucast_data)
(void *, u_int8_t val);
void (*txrx_monitor_set_filter_mcast_data)
(void *, u_int8_t val);
void (*txrx_monitor_set_filter_non_data)
(void *, u_int8_t val);
u_int8_t (*txrx_monitor_get_filter_ucast_data)
(void *vdev_txrx_handle);
u_int8_t (*txrx_monitor_get_filter_mcast_data)
(void *vdev_txrx_handle);
u_int8_t (*txrx_monitor_get_filter_non_data)
(void *vdev_txrx_handle);
int (*txrx_reset_monitor_mode)(void *pdev);
};
struct cdp_host_stats_ops {
#if WLAN_FEATURE_FASTPATH
int (*txrx_host_stats_get)(void *vdev,
struct ol_txrx_stats_req *req);
void (*txrx_host_stats_clr)(void *vdev);
void (*txrx_host_ce_stats)(void *vdev);
int (*txrx_stats_publish)(void *pdev,
struct ol_txrx_stats *buf);
/**
* @brief Enable enhanced stats functionality.
*
* @param pdev - the physical device object
* @return - void
*/
void (*txrx_enable_enhanced_stats)(void *pdev);
/**
* @brief Disable enhanced stats functionality.
*
* @param pdev - the physical device object
* @return - void
*/
void (*txrx_disable_enhanced_stats)(void *pdev);
#if ENHANCED_STATS
/**
* @brief Get the desired stats from the message.
*
* @param pdev - the physical device object
* @param stats_base - stats buffer recieved from FW
* @param type - stats type.
* @return - pointer to requested stat identified by type
*/
uint32_t*(*txrx_get_stats_base)(void *pdev,
uint32_t *stats_base, uint32_t msg_len, uint8_t type);
#endif
#endif /* WLAN_FEATURE_FASTPATH*/
#if (HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE)
void
(*tx_print_tso_stats)(void *vdev);
void
(*tx_rst_tso_stats)(void *vdev);
#endif /* HOST_SW_TSO_ENABLE || HOST_SW_TSO_SG_ENABLE */
#if HOST_SW_SG_ENABLE
void
(*tx_print_sg_stats)(void *vdev);
void
(*tx_rst_sg_stats)(void *vdev);
#endif /* HOST_SW_SG_ENABLE */
#if RX_CHECKSUM_OFFLOAD
void
(*print_rx_cksum_stats)(void *vdev);
void
(*rst_rx_cksum_stats)(void *vdev);
#endif /* RX_CHECKSUM_OFFLOAD */
#if (ATH_SUPPORT_IQUE && WLAN_FEATURE_FASTPATH)
A_STATUS
(*txrx_host_me_stats)(void *vdev);
#endif /* WLAN_FEATURE_FASTPATH */
#if PEER_FLOW_CONTROL
void
(*txrx_per_peer_stats)(void *pdev, char *addr);
#endif
#if WLAN_FEATURE_FASTPATH && PEER_FLOW_CONTROL
int (*txrx_host_msdu_ttl_stats)(void *vdev,
struct ol_txrx_stats_req *req);
#endif
#if HOST_SW_LRO_ENABLE
void
(*print_lro_stats)(void *vdev);
void
(*reset_lro_stats)(void *vdev);
#endif /* HOST_SW_LRO_ENABLE */
};
struct cdp_wds_ops {
#if WDS_VENDOR_EXTENSION
void
(*txrx_set_wds_rx_policy)(void *vdev,
u_int32_t val);
#endif
};
struct cdp_raw_ops {
int (*txrx_get_nwifi_mode)(void *vdev);
int
(*rsim_tx_encap)(void *vdev, qdf_nbuf_t *pnbuf);
};
struct cdp_pflow_ops {
#if PEER_FLOW_CONTROL
uint32_t(*pflow_update_pdev_params)(void *,
ol_ath_param_t, uint32_t, void *);
#endif
};
struct cdp_mob_drv_ops {
/* FIXME to be fixed */
};
struct ol_if_ops {
void (*peer_set_default_routing)(void *scn_handle,
uint8_t *peer_macaddr, uint8_t vdev_id,
bool hash_based, uint8_t ring_num);
int (*peer_rx_reorder_queue_setup)(void *ol_soc_handle,
uint8_t vdev_id, uint8_t *peer_mac,
qdf_dma_addr_t hw_qdesc, int tid, uint16_t queue_num);
int (*peer_rx_reorder_queue_remove)(void *ol_soc_handle,
uint8_t vdev_id, uint8_t *peer_macaddr,
uint32_t tid_mask);
/* TODO: Add any other control path calls required to OL_IF/WMA layer */
};
struct cdp_ops {
struct cdp_cmn_ops *cmn_drv_ops;
struct cdp_ctrl_ops *ctrl_ops;
struct cdp_me_ops *me_ops;
struct cdp_mon_ops *mon_ops;
struct cdp_host_stats_ops *host_stats_ops;
struct cdp_wds_ops *wds_ops;
struct cdp_raw_ops *raw_ops;
struct cdp_pflow_ops *pflow_ops;
struct cdp_mob_ops *mob_drv_ops;
};
#endif

4
dp/inc/cdp_txrx_peer_ops.h
View File

@@ -32,7 +32,7 @@
#ifndef _CDP_TXRX_PEER_H_ #ifndef _CDP_TXRX_PEER_H_
#define _CDP_TXRX_PEER_H_ #define _CDP_TXRX_PEER_H_
typedef QDF_STATUS (*ol_rx_callback_fp)(void *p_cds_gctx, typedef QDF_STATUS(*ol_rx_callback_fp)(void *p_cds_gctx,
qdf_nbuf_t pDataBuff, qdf_nbuf_t pDataBuff,
uint8_t ucSTAId); uint8_t ucSTAId);
@@ -85,6 +85,7 @@ ol_txrx_find_peer_by_addr_and_vdev(ol_txrx_pdev_handle pdev,
#ifdef QCA_SUPPORT_TXRX_LOCAL_PEER_ID #ifdef QCA_SUPPORT_TXRX_LOCAL_PEER_ID
uint16_t ol_txrx_local_peer_id(ol_txrx_peer_handle peer); uint16_t ol_txrx_local_peer_id(ol_txrx_peer_handle peer);
ol_txrx_peer_handle ol_txrx_find_peer_by_addr(ol_txrx_pdev_handle pdev, ol_txrx_peer_handle ol_txrx_find_peer_by_addr(ol_txrx_pdev_handle pdev,
uint8_t *peer_addr, uint8_t *peer_addr,
uint8_t *peer_id); uint8_t *peer_id);
@@ -106,6 +107,7 @@ ol_txrx_peer_state_update(ol_txrx_pdev_handle pdev, uint8_t *peer_addr,
enum ol_txrx_peer_state state); enum ol_txrx_peer_state state);
QDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id); QDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id);
void *ol_txrx_get_vdev_by_sta_id(uint8_t sta_id); void *ol_txrx_get_vdev_by_sta_id(uint8_t sta_id);
QDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr, QDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,

18
dp/inc/cdp_txrx_pflow.h
View File

@@ -33,9 +33,17 @@
#define _CDP_TXRX_PFLOW_H_ #define _CDP_TXRX_PFLOW_H_
#include <cdp_txrx_stats_struct.h> #include <cdp_txrx_stats_struct.h>
#if PEER_FLOW_CONTROL #include "cdp_txrx_ops.h"
extern uint32_t ol_pflow_update_pdev_params(struct ol_txrx_pdev_t *,
ol_ath_param_t, uint32_t, void *);
#endif
#endif
#if PEER_FLOW_CONTROL
static inline uint32_t cdp_pflow_update_pdev_params
(ol_txrx_soc_handle soc, void *pdev,
ol_ath_param_t param, uint32_t val, void *ctx)
{
if (soc->ops->pflow_ops->pflow_update_pdev_params)
return soc->ops->pflow_ops->pflow_update_pdev_params
(pdev, param, val, ctx);
return 0;
}
#endif
#endif

21
dp/inc/cdp_txrx_raw.h
View File

@@ -33,9 +33,15 @@
#define _CDP_TXRX_RAW_H_ #define _CDP_TXRX_RAW_H_
#include "cdp_txrx_ops.h"
/* TODO: adf need to be replaced with qdf */ /* TODO: adf need to be replaced with qdf */
extern int ol_txrx_get_nwifi_mode(ol_txrx_vdev_handle vdev); static inline int cdp_get_nwifi_mode(ol_txrx_soc_handle soc,
#define OL_TXRX_GET_NWIFI_MODE(vdev) ol_txrx_get_nwifi_mode(vdev) void *vdev)
{
if (soc->ops->raw_ops->txrx_get_nwifi_mode)
return soc->ops->raw_ops->txrx_get_nwifi_mode(vdev);
return 0;
}
/* Questionable -- should this be in OL AND/OR is this used? */ /* Questionable -- should this be in OL AND/OR is this used? */
/* Called by ol_tx_ll_umac_raw_process() */ /* Called by ol_tx_ll_umac_raw_process() */
/** /**
@@ -57,6 +63,13 @@ extern int ol_txrx_get_nwifi_mode(ol_txrx_vdev_handle vdev);
* @return - 0 on success, -1 on error, 1 if more nbufs need to be consumed. * @return - 0 on success, -1 on error, 1 if more nbufs need to be consumed.
*/ */
int static inline int
ol_rsim_tx_encap(ol_txrx_vdev_handle vdev, qdf_nbuf_t *pnbuf); cdp_rsim_tx_encap(ol_txrx_soc_handle soc,
void *vdev, qdf_nbuf_t *pnbuf)
{
if (soc->ops->raw_ops->rsim_tx_encap)
return soc->ops->raw_ops->rsim_tx_encap(vdev, pnbuf);
return 0;
}
#endif #endif

7
dp/inc/cdp_txrx_stats_struct.h
View File

@@ -37,6 +37,13 @@
#define TXRX_STATS_LEVEL_BASIC 1 #define TXRX_STATS_LEVEL_BASIC 1
#define TXRX_STATS_LEVEL_FULL 2 #define TXRX_STATS_LEVEL_FULL 2
#define BSS_CHAN_INFO_READ 1
#define BSS_CHAN_INFO_READ_AND_CLEAR 2
#define TX_FRAME_TYPE_DATA 0
#define TX_FRAME_TYPE_MGMT 1
#define TX_FRAME_TYPE_BEACON 2
#ifndef TXRX_STATS_LEVEL #ifndef TXRX_STATS_LEVEL
#define TXRX_STATS_LEVEL TXRX_STATS_LEVEL_BASIC #define TXRX_STATS_LEVEL TXRX_STATS_LEVEL_BASIC
#endif #endif

25
dp/inc/cdp_txrx_tx_delay.h
View File

@@ -34,23 +34,20 @@
#ifdef QCA_COMPUTE_TX_DELAY #ifdef QCA_COMPUTE_TX_DELAY
void void
ol_tx_delay(ol_txrx_pdev_handle pdev, ol_tx_delay(ol_txrx_pdev_handle pdev, uint32_t *queue_delay_microsec,
uint32_t *queue_delay_microsec, uint32_t *tx_delay_microsec, int category);
uint32_t *tx_delay_microsec, int category);
void void
ol_tx_delay_hist(ol_txrx_pdev_handle pdev, ol_tx_delay_hist(ol_txrx_pdev_handle pdev,
uint16_t *bin_values, int category); uint16_t *bin_values, int category);
void void
ol_tx_packet_count(ol_txrx_pdev_handle pdev, ol_tx_packet_count(ol_txrx_pdev_handle pdev, uint16_t *out_packet_count,
uint16_t *out_packet_count, uint16_t *out_packet_loss_count, int category);
uint16_t *out_packet_loss_count, int category);
void ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev, void ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev,
uint32_t interval); uint32_t interval);
#else #else
static inline void static inline void
ol_tx_delay(ol_txrx_pdev_handle pdev, ol_tx_delay(ol_txrx_pdev_handle pdev, uint32_t *queue_delay_microsec,
uint32_t *queue_delay_microsec, uint32_t *tx_delay_microsec, int category)
uint32_t *tx_delay_microsec, int category)
{ {
return; return;
} }
@@ -63,16 +60,14 @@ ol_tx_delay_hist(ol_txrx_pdev_handle pdev,
} }
static inline void static inline void
ol_tx_packet_count(ol_txrx_pdev_handle pdev, ol_tx_packet_count(ol_txrx_pdev_handle pdev, uint16_t *out_packet_count,
uint16_t *out_packet_count, uint16_t *out_packet_loss_count, int category)
uint16_t *out_packet_loss_count, int category)
{ {
return; return;
} }
static inline void static inline void
ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev, ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev, uint32_t interval)
uint32_t interval)
{ {
return; return;
} }

2
dp/inc/cdp_txrx_tx_throttle.h
View File

@@ -40,7 +40,7 @@ void ol_tx_throttle_init_period(struct ol_txrx_pdev_t *pdev, int period,
void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev, int level); void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev, int level);
#else #else
static inline void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev, static inline void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev,
int level) int level)
{ {
/* no-op */ /* no-op */
} }

14
dp/inc/cdp_txrx_wds.h
View File

@@ -43,9 +43,15 @@
* @return - void * @return - void
*/ */
#if WDS_VENDOR_EXTENSION #if WDS_VENDOR_EXTENSION
void static inline void
ol_txrx_set_wds_rx_policy( cdp_set_wds_rx_policy(ol_txrx_soc_handle soc,
ol_txrx_vdev_handle vdev, void *vdev,
u_int32_t val); u_int32_t val)
{
if (soc->ops->wds_ops->txrx_set_wds_rx_policy)
return soc->ops->wds_ops->txrx_set_wds_rx_policy(vdev, val);
return;
}
#endif #endif
#endif #endif