From db6358c42f927ee0dfdcd2194934bbf4c76533ed Mon Sep 17 00:00:00 2001 From: Leo Chang Date: Tue, 27 Sep 2016 17:00:52 -0700 Subject: [PATCH] qcacmn: add cdp wrapper for mobile device compile add cdp wrapper for mobile device data path compile Change-Id: I05a6c58056f8884915580c074efa81a5a28f71be CRs-fixed: 1075597 --- dp/inc/cdp_txrx_bus.h | 43 +- dp/inc/cdp_txrx_cfg.h | 255 +++++++++-- dp/inc/cdp_txrx_cmn.h | 12 +- dp/inc/cdp_txrx_cmn_reg.h | 29 +- dp/inc/cdp_txrx_cmn_struct.h | 27 +- dp/inc/cdp_txrx_flow_ctrl_legacy.h | 260 +++++++---- dp/inc/cdp_txrx_flow_ctrl_v2.h | 84 +++- dp/inc/cdp_txrx_ipa.h | 236 +++++++--- dp/inc/cdp_txrx_lro.h | 49 +- dp/inc/cdp_txrx_misc.h | 450 +++++++++++++++--- dp/inc/cdp_txrx_mob_def.h | 394 ++++++++++++++++ dp/inc/cdp_txrx_ocb.h | 51 ++- dp/inc/cdp_txrx_ops.h | 309 ++++++++++++- dp/inc/cdp_txrx_peer_ops.h | 712 ++++++++++++++++++++++++----- dp/inc/cdp_txrx_pmf.h | 22 +- dp/inc/cdp_txrx_stats.h | 28 +- dp/inc/cdp_txrx_tx_delay.h | 104 ++++- dp/inc/cdp_txrx_tx_throttle.h | 57 ++- dp/inc/cdp_txrx_wds.h | 6 + 19 files changed, 2666 insertions(+), 462 deletions(-) create mode 100644 dp/inc/cdp_txrx_mob_def.h diff --git a/dp/inc/cdp_txrx_bus.h b/dp/inc/cdp_txrx_bus.h index 575d6c4147..d20e7ce7a1 100644 --- a/dp/inc/cdp_txrx_bus.h +++ b/dp/inc/cdp_txrx_bus.h @@ -31,7 +31,46 @@ #ifndef _CDP_TXRX_BUS_H_ #define _CDP_TXRX_BUS_H_ -QDF_STATUS ol_txrx_bus_suspend(void); -QDF_STATUS ol_txrx_bus_resume(void); +/** + * cdp_bus_suspend() - suspend bus + * @soc - data path soc handle + * + * suspend bus + * + * return QDF_STATUS_SUCCESS suspend is not implemented or suspend done + */ +static inline QDF_STATUS cdp_bus_suspend(ol_txrx_soc_handle soc) +{ + if (!soc || !soc->ops || !soc->ops->bus_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->bus_ops->bus_suspend) + return soc->ops->bus_ops->bus_suspend(); + return QDF_STATUS_E_NOSUPPORT; +} + +/** + * cdp_bus_resume() - resume bus + * @soc - data path soc handle + * + * resume bus + * + * return QDF_STATUS_SUCCESS resume is not implemented or suspend done + */ +static inline QDF_STATUS cdp_bus_resume(ol_txrx_soc_handle soc) +{ + if (!soc || !soc->ops || !soc->ops->bus_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->bus_ops->bus_resume) + return soc->ops->bus_ops->bus_resume(); + return QDF_STATUS_E_NOSUPPORT; +} #endif /* _CDP_TXRX_BUS_H_ */ diff --git a/dp/inc/cdp_txrx_cfg.h b/dp/inc/cdp_txrx_cfg.h index 50e26e303f..d982bf2eeb 100644 --- a/dp/inc/cdp_txrx_cfg.h +++ b/dp/inc/cdp_txrx_cfg.h @@ -32,58 +32,225 @@ #define _CDP_TXRX_CFG_H_ /** - * struct txrx_pdev_cfg_param_t - configuration information - * passed to the data path + * cdp_cfg_set_rx_fwd_disabled() - enable/disable rx forwarding + * @soc - data path soc handle + * @pdev - data path device instance + * @disable_rx_fwd - enable or disable rx forwarding + * + * enable/disable rx forwarding + * + * return NONE */ -struct txrx_pdev_cfg_param_t { - uint8_t is_full_reorder_offload; - /* IPA Micro controller data path offload enable flag */ - uint8_t is_uc_offload_enabled; - /* IPA Micro controller data path offload TX buffer count */ - uint32_t uc_tx_buffer_count; - /* IPA Micro controller data path offload TX buffer size */ - uint32_t uc_tx_buffer_size; - /* IPA Micro controller data path offload RX indication ring count */ - uint32_t uc_rx_indication_ring_count; - /* IPA Micro controller data path offload TX partition base */ - uint32_t uc_tx_partition_base; - /* IP, TCP and UDP checksum offload */ - bool ip_tcp_udp_checksum_offload; - /* Rx processing in thread from TXRX */ - bool enable_rxthread; - /* CE classification enabled through INI */ - bool ce_classify_enabled; -#ifdef QCA_LL_TX_FLOW_CONTROL_V2 - /* Threshold to stop queue in percentage */ - uint32_t tx_flow_stop_queue_th; - /* Start queue offset in percentage */ - uint32_t tx_flow_start_queue_offset; -#endif -}; +static inline void +cdp_cfg_set_rx_fwd_disabled(ol_txrx_soc_handle soc, void *pdev, + uint8_t disable_rx_fwd) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } -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); - -ol_pdev_handle ol_pdev_cfg_attach(qdf_device_t osdev, - struct txrx_pdev_cfg_param_t cfg_param); - -void ol_vdev_rx_set_intrabss_fwd(ol_txrx_vdev_handle vdev, bool val); + if (soc->ops->cfg_ops->set_cfg_rx_fwd_disabled) + return soc->ops->cfg_ops->set_cfg_rx_fwd_disabled(pdev, + disable_rx_fwd); +} /** - * ol_txrx_get_opmode() - Return operation mode of vdev - * @vdev: vdev handle + * cdp_cfg_set_packet_log_enabled() - enable/disable packet log + * @soc - data path soc handle + * @pdev - data path device instance + * @val - enable or disable packet log * - * Return: operation mode. + * packet log enable or disable + * + * return NONE */ -int ol_txrx_get_opmode(ol_txrx_vdev_handle vdev); +static inline void +cdp_cfg_set_packet_log_enabled(ol_txrx_soc_handle soc, + void *pdev, uint8_t val) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->cfg_ops->set_cfg_packet_log_enabled) + return soc->ops->cfg_ops->set_cfg_packet_log_enabled(pdev, + val); +} /** - * ol_txrx_is_rx_fwd_disabled() - returns the rx_fwd_disabled status on vdev - * @vdev: vdev handle + * cdp_cfg_attach() - attach config module + * @soc - data path soc handle + * @osdev - os instance + * @cfg_param - configuration parameter should be propagated * - * Return: Rx Fwd disabled status + * Allocate configuration module instance, and propagate configuration values + * + * return soc configuration module instance */ -uint8_t -ol_txrx_is_rx_fwd_disabled(ol_txrx_vdev_handle vdev); +static inline void +*cdp_cfg_attach(ol_txrx_soc_handle soc, + qdf_device_t osdev, void *cfg_param) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->cfg_ops->cfg_attach) + return soc->ops->cfg_ops->cfg_attach(osdev, cfg_param); + + return NULL; +} + +/** + * cdp_cfg_vdev_rx_set_intrabss_fwd() - enable/disable intra bass forwarding + * @soc - data path soc handle + * @vdev - virtual interface instance + * @val - enable or disable intra bss forwarding + * + * ap isolate, do not forward intra bss traffic + * + * return NONE + */ +static inline void +cdp_cfg_vdev_rx_set_intrabss_fwd(ol_txrx_soc_handle soc, void *vdev, bool val) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->cfg_ops->vdev_rx_set_intrabss_fwd) + return soc->ops->cfg_ops->vdev_rx_set_intrabss_fwd(vdev, val); +} + +/** + * cdp_cfg_is_rx_fwd_disabled() - get vdev rx forward + * @soc - data path soc handle + * @vdev - virtual interface instance + * + * Return rx forward feature enable status + * + * return 1 enabled + * 0 disabled + */ +static inline uint8_t +cdp_cfg_is_rx_fwd_disabled(ol_txrx_soc_handle soc, void *vdev) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->cfg_ops->is_rx_fwd_disabled) + return soc->ops->cfg_ops->is_rx_fwd_disabled(vdev); + return 0; +} + +/** + * cdp_cfg_tx_set_is_mgmt_over_wmi_enabled() - mgmt tx over wmi enable/disable + * @soc - data path soc handle + * @value - feature enable or disable + * + * Enable or disable management packet TX over WMI feature + * + * return None + */ +static inline void +cdp_cfg_tx_set_is_mgmt_over_wmi_enabled(ol_txrx_soc_handle soc, + uint8_t value) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->cfg_ops->tx_set_is_mgmt_over_wmi_enabled) + return soc->ops->cfg_ops->tx_set_is_mgmt_over_wmi_enabled( + value); +} + +/** + * cdp_cfg_is_high_latency() - query data path is in high or low latency + * @soc - data path soc handle + * @pdev - data path device instance + * + * query data path is in high or low latency + * + * return 1 high latency data path, usb or sdio + * 0 low latency data path + */ +static inline int +cdp_cfg_is_high_latency(ol_txrx_soc_handle soc, void *pdev) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->cfg_ops->is_high_latency) + return soc->ops->cfg_ops->is_high_latency(pdev); + + return 0; +} + +/** + * cdp_cfg_set_flow_control_parameters() - set flow control params + * @soc - data path soc handle + * @cfg - dp config module instance + * @param - parameters should set + * + * set flow control params + * + * return None + */ +static inline void +cdp_cfg_set_flow_control_parameters(ol_txrx_soc_handle soc, + void *cfg, void *param) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->cfg_ops->set_flow_control_parameters) + return soc->ops->cfg_ops->set_flow_control_parameters(cfg, + param); + + return; +} + +/** + * cdp_cfg_set_flow_steering - Set Rx flow steering config based on CFG ini + * config. + * + * @pdev - handle to the physical device + * @val - 0 - disable, 1 - enable + * + * Return: None + */ +static inline void cdp_cfg_set_flow_steering(ol_txrx_soc_handle soc, + void *pdev, uint8_t val) +{ + if (!soc || !soc->ops || !soc->ops->cfg_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->cfg_ops->set_flow_steering) + return soc->ops->cfg_ops->set_flow_steering(pdev, val); + + return; +} #endif /* _CDP_TXRX_CFG_H_ */ diff --git a/dp/inc/cdp_txrx_cmn.h b/dp/inc/cdp_txrx_cmn.h index e27b0cbe37..9869798b30 100644 --- a/dp/inc/cdp_txrx_cmn.h +++ b/dp/inc/cdp_txrx_cmn.h @@ -87,6 +87,13 @@ static inline void *cdp_pdev_attach return NULL; } +static inline int cdp_pdev_post_attach(ol_txrx_soc_handle soc, void *pdev) +{ + if (soc->ops->cmn_drv_ops->txrx_pdev_post_attach) + return soc->ops->cmn_drv_ops->txrx_pdev_post_attach(pdev); + return 0; +} + static inline void cdp_pdev_detach(ol_txrx_soc_handle soc, void *pdev, int force) { @@ -310,11 +317,12 @@ cdp_get_ctrl_pdev_from_vdev(ol_txrx_soc_handle soc, void *vdev) } static inline void * -cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, uint8_t vdev_id) +cdp_get_vdev_from_vdev_id(ol_txrx_soc_handle soc, void *pdev, + 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); + (pdev, vdev_id); return NULL; } diff --git a/dp/inc/cdp_txrx_cmn_reg.h b/dp/inc/cdp_txrx_cmn_reg.h index bcfa7e7128..ea597cce5e 100644 --- a/dp/inc/cdp_txrx_cmn_reg.h +++ b/dp/inc/cdp_txrx_cmn_reg.h @@ -34,13 +34,36 @@ ol_txrx_soc_handle ol_txrx_soc_attach(struct ol_if_ops *dp_ol_if_ops); +#ifdef QCA_WIFI_QCA8074 +void *dp_soc_attach_wifi3(void *osif_soc, void *hif_handle, + HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, + struct ol_if_ops *ol_ops); +#else +/* + * dp_soc_attach_wifi3() - Attach txrx SOC + * @osif_soc: Opaque SOC handle from OSIF/HDD + * @htc_handle: Opaque HTC handle + * @hif_handle: Opaque HIF handle + * @qdf_osdev: QDF device + * + * Return: DP SOC handle on success, NULL on failure + */ +static inline void *dp_soc_attach_wifi3(void *osif_soc, void *hif_handle, + HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, + struct ol_if_ops *ol_ops) +{ + return NULL; +} +#endif /* QCA_WIFI_QCA8074 */ + 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) + 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; + return dp_soc_attach_wifi3(scn, hif_handle, htc_handle, + qdf_dev, dp_ol_if_ops); break; default: return ol_txrx_soc_attach(dp_ol_if_ops); diff --git a/dp/inc/cdp_txrx_cmn_struct.h b/dp/inc/cdp_txrx_cmn_struct.h index d6090e5384..358118e653 100644 --- a/dp/inc/cdp_txrx_cmn_struct.h +++ b/dp/inc/cdp_txrx_cmn_struct.h @@ -24,10 +24,24 @@ #ifndef _CDP_TXRX_CMN_STRUCT_H_ #define _CDP_TXRX_CMN_STRUCT_H_ +/** + * For WIN legacy header compilation + * Temporary add dummy definitions + * should be removed properly WIN legacy code handle + */ + #include "htc_api.h" #include "qdf_types.h" #include "qdf_nbuf.h" +#ifndef CONFIG_WIN +#include +#endif /* CONFIG_WIN */ +#ifndef OL_TXRX_NUM_LOCAL_PEER_IDS +#define OL_TXRX_NUM_LOCAL_PEER_IDS 33 /* default */ +#endif + +#define OL_TXRX_INVALID_LOCAL_PEER_ID 0xffff /* * htt_dbg_stats_type - @@ -104,6 +118,16 @@ enum htt_cmn_t2h_en_stats_status { HTT_CMN_T2H_EN_STATS_STATUS_SERIES_DONE = 7, }; +/** + * struct ol_txrx_peer_state - Peer state information + */ +enum ol_txrx_peer_state { + OL_TXRX_PEER_STATE_INVALID, + OL_TXRX_PEER_STATE_DISC, /* initial state */ + OL_TXRX_PEER_STATE_CONN, /* authentication in progress */ + OL_TXRX_PEER_STATE_AUTH, /* authentication successful */ +}; + typedef struct cdp_soc_t *ol_txrx_soc_handle; /** @@ -135,6 +159,7 @@ enum wlan_op_mode { wlan_op_mode_sta, wlan_op_mode_monitor, wlan_op_mode_ocb, + wlan_op_mode_ndi, }; /** @@ -310,7 +335,7 @@ struct ol_txrx_stats_req { /* DP soc struct definition */ struct cdp_soc_t { struct cdp_ops *ops; - struct ol_if_ops *ol_ops; + struct ol_if_ops *ol_ops; }; diff --git a/dp/inc/cdp_txrx_flow_ctrl_legacy.h b/dp/inc/cdp_txrx_flow_ctrl_legacy.h index b53a397ff9..47b3c7dd7a 100644 --- a/dp/inc/cdp_txrx_flow_ctrl_legacy.h +++ b/dp/inc/cdp_txrx_flow_ctrl_legacy.h @@ -31,100 +31,190 @@ */ #ifndef _CDP_TXRX_FC_LEG_H_ #define _CDP_TXRX_FC_LEG_H_ +#include /** - * enum netif_action_type - Type of actions on netif queues - * @WLAN_STOP_ALL_NETIF_QUEUE: stop all netif queues - * @WLAN_START_ALL_NETIF_QUEUE: start all netif queues - * @WLAN_WAKE_ALL_NETIF_QUEUE: wake all netif queues - * @WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER: stop all queues and off carrier - * @WLAN_START_ALL_NETIF_QUEUE_N_CARRIER: start all queues and on carrier - * @WLAN_NETIF_TX_DISABLE: disable tx - * @WLAN_NETIF_TX_DISABLE_N_CARRIER: disable tx and off carrier - * @WLAN_NETIF_CARRIER_ON: on carrier - * @WLAN_NETIF_CARRIER_OFF: off carrier + * cdp_fc_register() - Register flow control callback function pointer + * @soc - data path soc handle + * @vdev_id - virtual interface id to register flow control + * @flowControl - callback function pointer + * @osif_fc_ctx - client context pointer + * + * Register flow control callback function pointer and client context pointer + * + * return 0 success */ -enum netif_action_type { - WLAN_STOP_ALL_NETIF_QUEUE = 1, - WLAN_START_ALL_NETIF_QUEUE, - WLAN_WAKE_ALL_NETIF_QUEUE, - WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, - WLAN_START_ALL_NETIF_QUEUE_N_CARRIER, - WLAN_NETIF_TX_DISABLE, - WLAN_NETIF_TX_DISABLE_N_CARRIER, - WLAN_NETIF_CARRIER_ON, - WLAN_NETIF_CARRIER_OFF, - WLAN_NETIF_ACTION_TYPE_MAX, -}; - -/** - * enum netif_reason_type - reason for netif queue action - * @WLAN_CONTROL_PATH: action from control path - * @WLAN_DATA_FLOW_CONTROL: because of flow control - * @WLAN_FW_PAUSE: because of firmware pause - * @WLAN_TX_ABORT: because of tx abort - * @WLAN_VDEV_STOP: because of vdev stop - * @WLAN_PEER_UNAUTHORISED: because of peer is unauthorised - * @WLAN_THERMAL_MITIGATION: because of thermal mitigation - */ -enum netif_reason_type { - WLAN_CONTROL_PATH = 1, - WLAN_DATA_FLOW_CONTROL, - WLAN_FW_PAUSE, - WLAN_TX_ABORT, - WLAN_VDEV_STOP, - WLAN_PEER_UNAUTHORISED, - WLAN_THERMAL_MITIGATION, - WLAN_REASON_TYPE_MAX, -}; - -#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL -/** - * 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); - -int ol_txrx_register_tx_flow_control(uint8_t vdev_id, - ol_txrx_tx_flow_control_fp flowControl, - void *osif_fc_ctx); - -int ol_txrx_deregister_tx_flow_control_cb(uint8_t vdev_id); - -void ol_txrx_flow_control_cb(ol_txrx_vdev_handle vdev, - bool tx_resume); -bool -ol_txrx_get_tx_resource(uint8_t sta_id, - unsigned int low_watermark, - unsigned int high_watermark_offset); - -int -ol_txrx_ll_set_tx_pause_q_depth(uint8_t vdev_id, int pause_q_depth); - -#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */ - -void ol_txrx_vdev_flush(ol_txrx_vdev_handle data_vdev); - -#ifdef CONFIG_ICNSS -static inline void ol_txrx_vdev_pause(ol_txrx_vdev_handle vdev, uint32_t reason) +static inline int +cdp_fc_register(ol_txrx_soc_handle soc, uint8_t vdev_id, + ol_txrx_tx_flow_control_fp flowControl, void *osif_fc_ctx) { + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->l_flowctl_ops->register_tx_flow_control) + return soc->ops->l_flowctl_ops->register_tx_flow_control( + vdev_id, flowControl, osif_fc_ctx); + + return 0; +} + +/** + * cdp_fc_deregister() - remove flow control instance + * @soc - data path soc handle + * @vdev_id - virtual interface id to register flow control + * + * remove flow control instance + * + * return 0 success + */ +static inline int +cdp_fc_deregister(ol_txrx_soc_handle soc, uint8_t vdev_id) +{ + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->l_flowctl_ops->deregister_tx_flow_control_cb) + return soc->ops->l_flowctl_ops->deregister_tx_flow_control_cb( + vdev_id); + + return 0; +} + +/** + * cdp_fc_get_tx_resource() - get data path resource count + * @soc - data path soc handle + * @sta_id - local peer id + * @low_watermark - low resource threshold + * @high_watermark_offset - high resource threshold + * + * get data path resource count + * + * return true enough data path resource available + * false resource is not avaialbe + */ +static inline bool +cdp_fc_get_tx_resource(ol_txrx_soc_handle soc, uint8_t sta_id, + unsigned int low_watermark, unsigned int high_watermark_offset) +{ + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return false; + } + + if (soc->ops->l_flowctl_ops->get_tx_resource) + return soc->ops->l_flowctl_ops->get_tx_resource(sta_id, + low_watermark, high_watermark_offset); + + return false; +} + +/** + * cdp_fc_ll_set_tx_pause_q_depth() - set pause queue depth + * @soc - data path soc handle + * @vdev_id - virtual interface id to register flow control + * @pause_q_depth - pending tx queue delth + * + * set pause queue depth + * + * return 0 success + */ +static inline int +cdp_fc_ll_set_tx_pause_q_depth(ol_txrx_soc_handle soc, + uint8_t vdev_id, int pause_q_depth) +{ + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->l_flowctl_ops->ll_set_tx_pause_q_depth) + return soc->ops->l_flowctl_ops->ll_set_tx_pause_q_depth(vdev_id, + pause_q_depth); + + return 0; +} + +/** + * cdp_fc_vdev_flush() - flush tx queue + * @soc - data path soc handle + * @vdev - virtual interface context pointer + * + * flush tx queue + * + * return None + */ +static inline void +cdp_fc_vdev_flush(ol_txrx_soc_handle soc, void *vdev) +{ + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->l_flowctl_ops->vdev_flush) + return soc->ops->l_flowctl_ops->vdev_flush(vdev); + return; } -#else -void ol_txrx_vdev_pause(ol_txrx_vdev_handle vdev, uint32_t reason); -#endif -#ifdef CONFIG_ICNSS -static inline void ol_txrx_vdev_unpause(ol_txrx_vdev_handle data_vdev, - uint32_t reason) +/** + * cdp_fc_vdev_pause() - pause tx scheduler on vdev + * @soc - data path soc handle + * @vdev - virtual interface context pointer + * @reason - pause reason + * + * pause tx scheduler on vdev + * + * return None + */ +static inline void +cdp_fc_vdev_pause(ol_txrx_soc_handle soc, void *vdev, + uint32_t reason) { + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->l_flowctl_ops->vdev_pause) + return soc->ops->l_flowctl_ops->vdev_pause(vdev, reason); + return; } -#else -void ol_txrx_vdev_unpause(ol_txrx_vdev_handle data_vdev, uint32_t reason); -#endif +/** + * cdp_fc_vdev_unpause() - resume tx scheduler on vdev + * @soc - data path soc handle + * @vdev - virtual interface context pointer + * @reason - pause reason + * + * resume tx scheduler on vdev + * + * return None + */ +static inline void +cdp_fc_vdev_unpause(ol_txrx_soc_handle soc, void *vdev, + uint32_t reason) +{ + if (!soc || !soc->ops || !soc->ops->l_flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->l_flowctl_ops->vdev_unpause) + return soc->ops->l_flowctl_ops->vdev_unpause(vdev, reason); + + return; +} #endif /* _CDP_TXRX_FC_LEG_H_ */ diff --git a/dp/inc/cdp_txrx_flow_ctrl_v2.h b/dp/inc/cdp_txrx_flow_ctrl_v2.h index 53948c39c5..39d0455e2a 100644 --- a/dp/inc/cdp_txrx_flow_ctrl_v2.h +++ b/dp/inc/cdp_txrx_flow_ctrl_v2.h @@ -31,33 +31,81 @@ */ #ifndef _CDP_TXRX_FC_V2_H_ #define _CDP_TXRX_FC_V2_H_ - -#include "cdp_txrx_flow_ctrl_legacy.h" +#include /** - * @typedef ol_tx_pause_callback_fp - * @brief OSIF function registered with the data path + * cdp_register_pause_cb() - Register flow control callback function pointer + * @soc - data path soc handle + * @pause_cb - callback function pointer + * + * Register flow control callback function pointer and client context pointer + * + * return QDF_STATUS_SUCCESS success */ -typedef void (*ol_tx_pause_callback_fp)(uint8_t vdev_id, - enum netif_action_type action, - enum netif_reason_type reason); - -#ifdef QCA_LL_TX_FLOW_CONTROL_V2 -QDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb); - -void ol_tx_set_desc_global_pool_size(uint32_t num_msdu_desc); -#else -static inline -QDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb) +static inline QDF_STATUS +cdp_register_pause_cb(ol_txrx_soc_handle soc, + ol_tx_pause_callback_fp pause_cb) { - return QDF_STATUS_SUCCESS; + if (!soc || !soc->ops || !soc->ops->flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + if (soc->ops->flowctl_ops->register_pause_cb) + return soc->ops->flowctl_ops->register_pause_cb(pause_cb); + + return QDF_STATUS_SUCCESS; } -static inline void ol_tx_set_desc_global_pool_size(uint32_t num_msdu_desc) +/** + * cdp_set_desc_global_pool_size() - set global device pool size + * @soc - data path soc handle + * @num_msdu_desc - descriptor pool size + * + * set global device pool size + * + * return none + */ +static inline void +cdp_set_desc_global_pool_size(ol_txrx_soc_handle soc, + uint32_t num_msdu_desc) { + if (!soc || !soc->ops || !soc->ops->flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->flowctl_ops->set_desc_global_pool_size) + return soc->ops->flowctl_ops->set_desc_global_pool_size( + num_msdu_desc); + return; } -#endif + +/** + * cdp_dump_flow_pool_info() - dump flow pool information + * @soc - data path soc handle + * + * dump flow pool information + * + * return none + */ +static inline void +cdp_dump_flow_pool_info(ol_txrx_soc_handle soc) +{ + if (!soc || !soc->ops || !soc->ops->flowctl_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->flowctl_ops->dump_flow_pool_info) + return soc->ops->flowctl_ops->dump_flow_pool_info(); + + return; +} + #endif /* _CDP_TXRX_FC_V2_H_ */ diff --git a/dp/inc/cdp_txrx_ipa.h b/dp/inc/cdp_txrx_ipa.h index 67f2478f40..f6fe67eb78 100644 --- a/dp/inc/cdp_txrx_ipa.h +++ b/dp/inc/cdp_txrx_ipa.h @@ -30,100 +30,212 @@ */ #ifndef _CDP_TXRX_IPA_H_ #define _CDP_TXRX_IPA_H_ - +#include /** - * ol_txrx_ipa_resources - Resources needed for IPA + * cdp_ipa_get_resource() - Get allocated wlan resources for ipa data path + * @soc - data path soc handle + * @pdev - device instance pointer + * @ipa_res - ipa resources pointer + * + * Get allocated wlan resources for ipa data path + * + * return none */ -struct ol_txrx_ipa_resources { - qdf_dma_addr_t ce_sr_base_paddr; - uint32_t ce_sr_ring_size; - qdf_dma_addr_t ce_reg_paddr; - - qdf_dma_addr_t tx_comp_ring_base_paddr; - uint32_t tx_comp_ring_size; - uint32_t tx_num_alloc_buffer; - - qdf_dma_addr_t rx_rdy_ring_base_paddr; - uint32_t rx_rdy_ring_size; - qdf_dma_addr_t rx_proc_done_idx_paddr; - void *rx_proc_done_idx_vaddr; - - qdf_dma_addr_t rx2_rdy_ring_base_paddr; - uint32_t rx2_rdy_ring_size; - qdf_dma_addr_t rx2_proc_done_idx_paddr; - void *rx2_proc_done_idx_vaddr; -}; - -#ifdef IPA_OFFLOAD - -void -ol_txrx_ipa_uc_get_resource(ol_txrx_pdev_handle pdev, - struct ol_txrx_ipa_resources *ipa_res); - -void -ol_txrx_ipa_uc_set_doorbell_paddr(ol_txrx_pdev_handle pdev, - qdf_dma_addr_t ipa_tx_uc_doorbell_paddr, - qdf_dma_addr_t ipa_rx_uc_doorbell_paddr); - -void -ol_txrx_ipa_uc_set_active(ol_txrx_pdev_handle pdev, - bool uc_active, bool is_tx); - -void ol_txrx_ipa_uc_op_response(ol_txrx_pdev_handle pdev, uint8_t *op_msg); - -void ol_txrx_ipa_uc_register_op_cb(ol_txrx_pdev_handle pdev, - void (*ipa_uc_op_cb_type)(uint8_t *op_msg, - void *osif_ctxt), - void *osif_dev); - -void ol_txrx_ipa_uc_get_stat(ol_txrx_pdev_handle pdev); - -qdf_nbuf_t ol_tx_send_ipa_data_frame(void *vdev, qdf_nbuf_t skb); -#else - static inline void -ol_txrx_ipa_uc_get_resource(ol_txrx_pdev_handle pdev, +cdp_ipa_get_resource(ol_txrx_soc_handle soc, void *pdev, struct ol_txrx_ipa_resources *ipa_res) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_get_resource) + return soc->ops->ipa_ops->ipa_get_resource(pdev, ipa_res); + return; } +/** + * cdp_ipa_set_doorbell_paddr() - give IPA db paddr to fw + * @soc - data path soc handle + * @pdev - device instance pointer + * @ipa_tx_uc_doorbell_paddr - tx db paddr + * @ipa_rx_uc_doorbell_paddr - rx db paddr + * + * give IPA db paddr to fw + * + * return none + */ static inline void -ol_txrx_ipa_uc_set_doorbell_paddr(ol_txrx_pdev_handle pdev, - qdf_dma_addr_t ipa_tx_uc_doorbell_paddr, - qdf_dma_addr_t ipa_rx_uc_doorbell_paddr) +cdp_ipa_set_doorbell_paddr(ol_txrx_soc_handle soc, void *pdev, + qdf_dma_addr_t ipa_tx_uc_doorbell_paddr, + qdf_dma_addr_t ipa_rx_uc_doorbell_paddr) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_set_doorbell_paddr) + return soc->ops->ipa_ops->ipa_set_doorbell_paddr(pdev, + ipa_tx_uc_doorbell_paddr, ipa_rx_uc_doorbell_paddr); + return; } +/** + * cdp_ipa_set_active() - activate/de-ctivate wlan fw ipa data path + * @soc - data path soc handle + * @pdev - device instance pointer + * @uc_active - activate or de-activate + * @is_tx - toggle tx or rx data path + * + * activate/de-ctivate wlan fw ipa data path + * + * return none + */ static inline void -ol_txrx_ipa_uc_set_active(ol_txrx_pdev_handle pdev, - bool uc_active, bool is_tx) +cdp_ipa_set_active(ol_txrx_soc_handle soc, void *pdev, + bool uc_active, bool is_tx) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_set_active) + return soc->ops->ipa_ops->ipa_set_active(pdev, uc_active, + is_tx); + return; } +/** + * cdp_ipa_op_response() - event handler from fw + * @soc - data path soc handle + * @pdev - device instance pointer + * @op_msg - event contents from firmware + * + * event handler from fw + * + * return none + */ static inline void -ol_txrx_ipa_uc_op_response(ol_txrx_pdev_handle pdev, uint8_t *op_msg) +cdp_ipa_op_response(ol_txrx_soc_handle soc, void *pdev, + uint8_t *op_msg) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_op_response) + return soc->ops->ipa_ops->ipa_op_response(pdev, op_msg); + return; } +/** + * cdp_ipa_register_op_cb() - register event handler function pointer + * @soc - data path soc handle + * @pdev - device instance pointer + * @op_cb - event handler callback function pointer + * @osif_dev - osif instance pointer + * + * register event handler function pointer + * + * return none + */ static inline void -ol_txrx_ipa_uc_register_op_cb(ol_txrx_pdev_handle pdev, - void (*ipa_uc_op_cb_type)(uint8_t *op_msg, - void *osif_ctxt), - void *osif_dev) +cdp_ipa_register_op_cb(ol_txrx_soc_handle soc, void *pdev, + ipa_op_cb_type op_cb, void *osif_dev) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_register_op_cb) + return soc->ops->ipa_ops->ipa_register_op_cb(pdev, op_cb, + osif_dev); + return; } -static inline void ol_txrx_ipa_uc_get_stat(ol_txrx_pdev_handle pdev) +/** + * cdp_ipa_get_stat() - get ipa data path stats from fw + * @soc - data path soc handle + * @pdev - device instance pointer + * + * get ipa data path stats from fw async + * + * return none + */ +static inline void +cdp_ipa_get_stat(ol_txrx_soc_handle soc, void *pdev) { + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_get_stat) + return soc->ops->ipa_ops->ipa_get_stat(pdev); + return; } -#endif /* IPA_OFFLOAD */ +/** + * cdp_tx_send_ipa_data_frame() - send IPA data frame + * @vdev: vdev + * @skb: skb + * + * Return: skb/ NULL is for success + */ +static inline qdf_nbuf_t cdp_ipa_tx_send_data_frame(ol_txrx_soc_handle soc, + void *vdev, qdf_nbuf_t skb) +{ + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return skb; + } + + if (soc->ops->ipa_ops->ipa_tx_data_frame) + return soc->ops->ipa_ops->ipa_tx_data_frame(vdev, skb); + + return skb; +} + +/** + * cdp_ipa_set_uc_tx_partition_base() - set tx packet partition base + * @pdev: physical device instance + * @value: partition base value + * + * Return: none + */ +static inline void cdp_ipa_set_uc_tx_partition_base(ol_txrx_soc_handle soc, + void *pdev, uint32_t value) +{ + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ipa_ops->ipa_set_uc_tx_partition_base) + return soc->ops->ipa_ops->ipa_set_uc_tx_partition_base(pdev, + value); + + return; +} #endif /* _CDP_TXRX_IPA_H_ */ diff --git a/dp/inc/cdp_txrx_lro.h b/dp/inc/cdp_txrx_lro.h index 46ca71961f..e95eaf5e20 100644 --- a/dp/inc/cdp_txrx_lro.h +++ b/dp/inc/cdp_txrx_lro.h @@ -31,9 +31,52 @@ */ #ifndef _CDP_TXRX_LRO_H_ #define _CDP_TXRX_LRO_H_ +/** + * cdp_register_lro_flush_cb() - register lro flsu cb function pointer + * @soc - data path soc handle + * @pdev - device instance pointer + * + * register lro flush callback function pointer + * + * return none + */ +static inline void cdp_register_lro_flush_cb(ol_txrx_soc_handle soc, + void (lro_flush_cb)(void *), void *(lro_init_cb)(void)) +{ + if (!soc || !soc->ops || !soc->ops->lro_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } -void ol_register_lro_flush_cb(void (lro_flush_cb)(void *), - void *(lro_init_cb)(void)); -void ol_deregister_lro_flush_cb(void (lro_deinit_cb)(void *)); + if (soc->ops->lro_ops->register_lro_flush_cb) + return soc->ops->lro_ops->register_lro_flush_cb(lro_flush_cb, + lro_init_cb); + + return; +} +/** + * cdp_deregister_lro_flush_cb() - deregister lro flsu cb function pointer + * @soc - data path soc handle + * + * deregister lro flush callback function pointer + * + * return none + */ +static inline void cdp_deregister_lro_flush_cb(ol_txrx_soc_handle soc + void (lro_deinit_cb)(void *)) +{ + if (!soc || !soc->ops || !soc->ops->lro_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->lro_ops->deregister_lro_flush_cb) + return soc->ops->lro_ops->deregister_lro_flush_cb( + lro_deinit_cb); + + return; +} #endif /* _CDP_TXRX_LRO_H_ */ diff --git a/dp/inc/cdp_txrx_misc.h b/dp/inc/cdp_txrx_misc.h index e7461a3f40..c0ce80e324 100644 --- a/dp/inc/cdp_txrx_misc.h +++ b/dp/inc/cdp_txrx_misc.h @@ -33,37 +33,9 @@ #define _CDP_TXRX_MISC_H_ /** - * @enum ol_tx_spec - * @brief indicate what non-standard transmission actions to apply - * @details - * Indicate one or more of the following: - * - The tx frame already has a complete 802.11 header. - * Thus, skip 802.3/native-WiFi to 802.11 header encapsulation and - * A-MSDU aggregation. - * - The tx frame should not be aggregated (A-MPDU or A-MSDU) - * - The tx frame is already encrypted - don't attempt encryption. - * - The tx frame is a segment of a TCP jumbo frame. - * - This tx frame should not be unmapped and freed by the txrx layer - * after transmission, but instead given to a registered tx completion - * callback. - * More than one of these specification can apply, though typically - * only a single specification is applied to a tx frame. - * A compound specification can be created, as a bit-OR of these - * specifications. - */ -enum ol_tx_spec { - OL_TX_SPEC_STD = 0x0, /* do regular processing */ - OL_TX_SPEC_RAW = 0x1, /* skip encap + A-MSDU aggr */ - OL_TX_SPEC_NO_AGGR = 0x2, /* skip encap + all aggr */ - OL_TX_SPEC_NO_ENCRYPT = 0x4, /* skip encap + encrypt */ - OL_TX_SPEC_TSO = 0x8, /* TCP segmented */ - OL_TX_SPEC_NWIFI_NO_ENCRYPT = 0x10, /* skip encrypt for nwifi */ - OL_TX_SPEC_NO_FREE = 0x20, /* give to cb rather than free */ -}; - -/** - * ol_tx_non_std() - Allow the control-path SW to send data frames + * cdp_tx_non_std() - Allow the control-path SW to send data frames * + * @soc - data path soc handle * @data_vdev - which vdev should transmit the tx data frames * @tx_spec - what non-standard handling to apply to the tx data frames * @msdu_list - NULL-terminated list of tx MSDUs @@ -83,32 +55,408 @@ enum ol_tx_spec { * * Return: null - success, skb - failure */ -qdf_nbuf_t ol_tx_non_std(ol_txrx_vdev_handle vdev, - enum ol_tx_spec tx_spec, qdf_nbuf_t msdu_list); +static inline qdf_nbuf_t +cdp_tx_non_std(ol_txrx_soc_handle soc, void *vdev, + enum ol_tx_spec tx_spec, qdf_nbuf_t msdu_list) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->misc_ops->tx_non_std) + return soc->ops->misc_ops->tx_non_std( + vdev, tx_spec, msdu_list); + return NULL; +} /** - * ol_txrx_update_ibss_vdev_heart_beat_timer_of_vdev() - Update ibss vdev heart + * cdp_set_ibss_vdev_heart_beat_timer() - Update ibss vdev heart * beat timer - * @vdev: vdev handle - * @timer_value_sec: new heart beat timer value + * @soc - data path soc handle + * @vdev - vdev handle + * @timer_value_sec - new heart beat timer value * * Return: Old timer value set in vdev. */ -uint16_t ol_txrx_set_ibss_vdev_heart_beat_timer(ol_txrx_vdev_handle vdev, - uint16_t timer_value_sec); +static inline uint16_t +cdp_set_ibss_vdev_heart_beat_timer(ol_txrx_soc_handle soc, void *vdev, + uint16_t timer_value_sec) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->misc_ops->set_ibss_vdev_heart_beat_timer) + return soc->ops->misc_ops->set_ibss_vdev_heart_beat_timer( + vdev, timer_value_sec); + + return 0; +} + +/** + * cdp_set_wisa_mode() - set wisa mode + * @soc - data path soc handle + * @vdev - vdev handle + * @enable - enable or disable + * + * Return: QDF_STATUS_SUCCESS mode enable success + */ +static inline QDF_STATUS +cdp_set_wisa_mode(ol_txrx_soc_handle soc, void *vdev, bool enable) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->misc_ops->set_wisa_mode) + return soc->ops->misc_ops->set_wisa_mode(vdev, enable); + return QDF_STATUS_SUCCESS; +} + +/** + * cdp_set_wmm_param() - set wmm parameter + * @soc - data path soc handle + * @pdev - device instance pointer + * @wmm_param - wmm parameter + * + * Return: none + */ +static inline void +cdp_set_wmm_param(ol_txrx_soc_handle soc, void *pdev, + struct ol_tx_wmm_param_t wmm_param) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->set_wmm_param) + return soc->ops->misc_ops->set_wmm_param( + pdev, wmm_param); + + return; +} + +/** + * cdp_runtime_suspend() - suspend + * @soc - data path soc handle + * @pdev - device instance pointer + * + * Return: QDF_STATUS_SUCCESS suspend success + */ +static inline QDF_STATUS cdp_runtime_suspend(ol_txrx_soc_handle soc, + void *pdev) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->misc_ops->runtime_suspend) + return soc->ops->misc_ops->runtime_suspend(pdev); + + return QDF_STATUS_SUCCESS; +} + +/** + * cdp_runtime_resume() - resume + * @soc - data path soc handle + * @pdev - device instance pointer + * + * Return: QDF_STATUS_SUCCESS suspend success + */ +static inline QDF_STATUS cdp_runtime_resume(ol_txrx_soc_handle soc, + void *pdev) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->misc_ops->runtime_resume) + return soc->ops->misc_ops->runtime_resume(pdev); + + return QDF_STATUS_SUCCESS; +} + +/** + * cdp_hl_tdls_flag_reset() - tdls flag reset + * @soc - data path soc handle + * @vdev - virtual interface handle pointer + * @flag + * + * Return: none + */ +static inline void +cdp_hl_tdls_flag_reset(ol_txrx_soc_handle soc, void *vdev, bool flag) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->hl_tdls_flag_reset) + return soc->ops->misc_ops->hl_tdls_flag_reset(vdev, flag); + + return; +} + +/** + * cdp_get_opmode() - get vdev operation mode + * @soc - data path soc handle + * @vdev - virtual interface instance + * + * Return virtual device operational mode + * op_mode_ap, + * op_mode_ibss, + * op_mode_sta, + * op_mode_monitor, + * op_mode_ocb, + * + * return interface id + * 0 unknown interface + */ +static inline int +cdp_get_opmode(ol_txrx_soc_handle soc, void *vdev) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->misc_ops->get_opmode) + return soc->ops->misc_ops->get_opmode(vdev); + return 0; +} + +/** + * cdp_get_vdev_id() - get vdev id + * @soc - data path soc handle + * @vdev - virtual interface instance + * + * get virtual interface id + * + * return interface id + * 0 unknown interface + */ +static inline uint16_t +cdp_get_vdev_id(ol_txrx_soc_handle soc, void *vdev) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->misc_ops->get_vdev_id) + return soc->ops->misc_ops->get_vdev_id(vdev); + return 0; +} + +/** + * cdp_bad_peer_txctl_set_setting() - TBD + * @soc - data path soc handle + * @pdev - data path device instance + * @enable - + * @period - + * @txq_limit - + * + * TBD + * + * Return: none + */ +static inline void +cdp_bad_peer_txctl_set_setting(ol_txrx_soc_handle soc, void *pdev, + int enable, int period, int txq_limit) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->bad_peer_txctl_set_setting) + return soc->ops->misc_ops->bad_peer_txctl_set_setting(pdev, + enable, period, txq_limit); + return; +} + +/** + * cdp_bad_peer_txctl_update_threshold() - TBD + * @soc - data path soc handle + * @pdev - data path device instance + * @level - + * @tput_thresh - + * @tx_limit - + * + * TBD + * + * Return: none + */ +static inline void +cdp_bad_peer_txctl_update_threshold(ol_txrx_soc_handle soc, void *pdev, + int level, int tput_thresh, int tx_limit) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->bad_peer_txctl_update_threshold) + return soc->ops->misc_ops->bad_peer_txctl_update_threshold( + pdev, level, tput_thresh, tx_limit); + return; +} + +/** + * cdp_mark_first_wakeup_packet() - set flag to indicate that + * fw is compatible for marking first packet after wow wakeup + * @soc - data path soc handle + * @value: 1 for enabled/ 0 for disabled + * + * Return: None + */ +static inline void cdp_mark_first_wakeup_packet(ol_txrx_soc_handle soc, + uint8_t value) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->mark_first_wakeup_packet) + return soc->ops->misc_ops->mark_first_wakeup_packet(value); + return; +} + + +/** + * cds_update_mac_id() - update mac_id for vdev + * @soc - data path soc handle + * @vdev_id: vdev id + * @mac_id: mac id + * + * Return: none + */ +static inline void cdp_update_mac_id(void *psoc, uint8_t vdev_id, + uint8_t mac_id) +{ + ol_txrx_soc_handle soc = psoc; + + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->update_mac_id) + return soc->ops->misc_ops->update_mac_id(vdev_id, mac_id); + return; +} + +/** + * cdp_flush_rx_frames() - flush cached rx frames + * @soc - data path soc handle + * @peer: peer + * @drop: set flag to drop frames + * + * Return: None + */ +static inline void cdp_flush_rx_frames(ol_txrx_soc_handle soc, void *peer, + bool drop) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->flush_rx_frames) + return soc->ops->misc_ops->flush_rx_frames(peer, drop); + return; +} + +/* + * cdp_get_intra_bss_fwd_pkts_count() - to get the total tx and rx packets + * that has been forwarded from txrx layer without going to upper layers. + * @vdev_id: vdev id + * @fwd_tx_packets: pointer to forwarded tx packets count parameter + * @fwd_rx_packets: pointer to forwarded rx packets count parameter + * + * Return: status -> A_OK - success, A_ERROR - failure + */ +static inline A_STATUS cdp_get_intra_bss_fwd_pkts_count( + ol_txrx_soc_handle soc, uint8_t vdev_id, + uint64_t *fwd_tx_packets, uint64_t *fwd_rx_packets) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->misc_ops->get_intra_bss_fwd_pkts_count) + return soc->ops->misc_ops->get_intra_bss_fwd_pkts_count( + vdev_id, fwd_tx_packets, fwd_rx_packets); + + return 0; +} + +/** + * cdp_pkt_log_init() - API to initialize packet log + * @handle: pdev handle + * @scn: HIF context + * + * Return: void + */ +static inline void cdp_pkt_log_init(ol_txrx_soc_handle soc, void *pdev, + void *scn) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->pkt_log_init) + return soc->ops->misc_ops->pkt_log_init(pdev, scn); + + return; +} + +/** + * cdp_pkt_log_con_service() - API to connect packet log service + * @handle: pdev handle + * @scn: HIF context + * + * Return: void + */ +static inline void cdp_pkt_log_con_service(ol_txrx_soc_handle soc, + void *pdev, void *scn) +{ + if (!soc || !soc->ops || !soc->ops->misc_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->misc_ops->pkt_log_con_service) + return soc->ops->misc_ops->pkt_log_con_service(pdev, scn); + + return; +} #endif /* _CDP_TXRX_MISC_H_ */ - - - - - - - - - - - - - - diff --git a/dp/inc/cdp_txrx_mob_def.h b/dp/inc/cdp_txrx_mob_def.h new file mode 100644 index 0000000000..3c6254ad40 --- /dev/null +++ b/dp/inc/cdp_txrx_mob_def.h @@ -0,0 +1,394 @@ +/* + * Copyright (c) 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. + */ + +#ifndef __CDP_TXRX_MOB_DEF_H +#define __CDP_TXRX_MOB_DEF_H +#include +#include + +#define OL_TXQ_PAUSE_REASON_FW (1 << 0) +#define OL_TXQ_PAUSE_REASON_PEER_UNAUTHORIZED (1 << 1) +#define OL_TXQ_PAUSE_REASON_TX_ABORT (1 << 2) +#define OL_TXQ_PAUSE_REASON_VDEV_STOP (1 << 3) +#define OL_TXQ_PAUSE_REASON_THERMAL_MITIGATION (1 << 4) + +/* command options for dumpStats*/ +#define WLAN_HDD_STATS 0 +#define WLAN_TXRX_STATS 1 +#define WLAN_TXRX_HIST_STATS 2 +#define WLAN_TXRX_TSO_STATS 3 +#define WLAN_HDD_NETIF_OPER_HISTORY 4 +#define WLAN_DUMP_TX_FLOW_POOL_INFO 5 +#define WLAN_TXRX_DESC_STATS 6 +#define WLAN_HIF_STATS 7 +#define WLAN_LRO_STATS 8 +#define WLAN_SCHEDULER_STATS 21 +#define WLAN_TX_QUEUE_STATS 22 +#define WLAN_BUNDLE_STATS 23 +#define WLAN_CREDIT_STATS 24 + +#define OL_TXRX_INVALID_NUM_PEERS (-1) + +#define OL_TXRX_MAC_ADDR_LEN 6 + + +/* Maximum number of station supported by data path, including BC. */ +#define WLAN_MAX_STA_COUNT (HAL_NUM_STA) + +/* The symbolic station ID return to HDD to specify the packet is bc/mc */ +#define WLAN_RX_BCMC_STA_ID (WLAN_MAX_STA_COUNT + 1) + +/* The symbolic station ID return to HDD to specify the packet is + to soft-AP itself */ +#define WLAN_RX_SAP_SELF_STA_ID (WLAN_MAX_STA_COUNT + 2) + +/* is 802.11 address multicast/broadcast? */ +#define IEEE80211_IS_MULTICAST(_a) (*(_a) & 0x01) + +#define MAX_PEERS 32 + +/* + * Bins used for reporting delay histogram: + * bin 0: 0 - 10 ms delay + * bin 1: 10 - 20 ms delay + * bin 2: 20 - 40 ms delay + * bin 3: 40 - 80 ms delay + * bin 4: 80 - 160 ms delay + * bin 5: > 160 ms delay + */ +#define QCA_TX_DELAY_HIST_REPORT_BINS 6 + +/* BA actions */ +#define IEEE80211_ACTION_BA_ADDBA_REQUEST 0 /* ADDBA request */ +#define IEEE80211_ACTION_BA_ADDBA_RESPONSE 1 /* ADDBA response */ +#define IEEE80211_ACTION_BA_DELBA 2 /* DELBA */ + +#define IEEE80211_BA_POLICY_DELAYED 0 +#define IEEE80211_BA_POLICY_IMMEDIATE 1 +#define IEEE80211_BA_AMSDU_SUPPORTED 1 + +/** + * enum netif_action_type - Type of actions on netif queues + * @WLAN_STOP_ALL_NETIF_QUEUE: stop all netif queues + * @WLAN_START_ALL_NETIF_QUEUE: start all netif queues + * @WLAN_WAKE_ALL_NETIF_QUEUE: wake all netif queues + * @WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER: stop all queues and off carrier + * @WLAN_START_ALL_NETIF_QUEUE_N_CARRIER: start all queues and on carrier + * @WLAN_NETIF_TX_DISABLE: disable tx + * @WLAN_NETIF_TX_DISABLE_N_CARRIER: disable tx and off carrier + * @WLAN_NETIF_CARRIER_ON: on carrier + * @WLAN_NETIF_CARRIER_OFF: off carrier + */ +enum netif_action_type { + WLAN_STOP_ALL_NETIF_QUEUE = 1, + WLAN_START_ALL_NETIF_QUEUE, + WLAN_WAKE_ALL_NETIF_QUEUE, + WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, + WLAN_START_ALL_NETIF_QUEUE_N_CARRIER, + WLAN_NETIF_TX_DISABLE, + WLAN_NETIF_TX_DISABLE_N_CARRIER, + WLAN_NETIF_CARRIER_ON, + WLAN_NETIF_CARRIER_OFF, + WLAN_NETIF_ACTION_TYPE_MAX, +}; + +/** + * enum netif_reason_type - reason for netif queue action + * @WLAN_CONTROL_PATH: action from control path + * @WLAN_DATA_FLOW_CONTROL: because of flow control + * @WLAN_FW_PAUSE: because of firmware pause + * @WLAN_TX_ABORT: because of tx abort + * @WLAN_VDEV_STOP: because of vdev stop + * @WLAN_PEER_UNAUTHORISED: because of peer is unauthorised + * @WLAN_THERMAL_MITIGATION: because of thermal mitigation + */ +enum netif_reason_type { + WLAN_CONTROL_PATH = 1, + WLAN_DATA_FLOW_CONTROL, + WLAN_FW_PAUSE, + WLAN_TX_ABORT, + WLAN_VDEV_STOP, + WLAN_PEER_UNAUTHORISED, + WLAN_THERMAL_MITIGATION, + WLAN_REASON_TYPE_MAX, +}; + +enum ol_rx_err_type { + OL_RX_ERR_DEFRAG_MIC, + OL_RX_ERR_PN, + OL_RX_ERR_UNKNOWN_PEER, + OL_RX_ERR_MALFORMED, + OL_RX_ERR_TKIP_MIC, + OL_RX_ERR_DECRYPT, + OL_RX_ERR_MPDU_LENGTH, + OL_RX_ERR_ENCRYPT_REQUIRED, + OL_RX_ERR_DUP, + OL_RX_ERR_UNKNOWN, + OL_RX_ERR_FCS, + OL_RX_ERR_PRIVACY, + OL_RX_ERR_NONE_FRAG, + OL_RX_ERR_NONE = 0xFF +}; + +enum throttle_level { + THROTTLE_LEVEL_0, + THROTTLE_LEVEL_1, + THROTTLE_LEVEL_2, + THROTTLE_LEVEL_3, + /* Invalid */ + THROTTLE_LEVEL_MAX, +}; + +enum { + OL_TX_WMM_AC_BE, + OL_TX_WMM_AC_BK, + OL_TX_WMM_AC_VI, + OL_TX_WMM_AC_VO, + OL_TX_NUM_WMM_AC +}; + +/** + * @enum ol_tx_spec + * @brief indicate what non-standard transmission actions to apply + * @details + * Indicate one or more of the following: + * - The tx frame already has a complete 802.11 header. + * Thus, skip 802.3/native-WiFi to 802.11 header encapsulation and + * A-MSDU aggregation. + * - The tx frame should not be aggregated (A-MPDU or A-MSDU) + * - The tx frame is already encrypted - don't attempt encryption. + * - The tx frame is a segment of a TCP jumbo frame. + * - This tx frame should not be unmapped and freed by the txrx layer + * after transmission, but instead given to a registered tx completion + * callback. + * More than one of these specification can apply, though typically + * only a single specification is applied to a tx frame. + * A compound specification can be created, as a bit-OR of these + * specifications. + */ +enum ol_tx_spec { + OL_TX_SPEC_STD = 0x0, /* do regular processing */ + OL_TX_SPEC_RAW = 0x1, /* skip encap + A-MSDU aggr */ + OL_TX_SPEC_NO_AGGR = 0x2, /* skip encap + all aggr */ + OL_TX_SPEC_NO_ENCRYPT = 0x4, /* skip encap + encrypt */ + OL_TX_SPEC_TSO = 0x8, /* TCP segmented */ + OL_TX_SPEC_NWIFI_NO_ENCRYPT = 0x10, /* skip encrypt for nwifi */ + OL_TX_SPEC_NO_FREE = 0x20, /* give to cb rather than free */ +}; + +/** + * struct ol_txrx_desc_type - txrx descriptor type + * @sta_id: sta id + * @is_qos_enabled: is station qos enabled + * @is_wapi_supported: is station wapi supported + */ +struct ol_txrx_desc_type { + uint8_t sta_id; + uint8_t is_qos_enabled; + uint8_t is_wapi_supported; +}; + +/** + * struct txrx_pdev_cfg_param_t - configuration information + * passed to the data path + */ +struct txrx_pdev_cfg_param_t { + uint8_t is_full_reorder_offload; + /* IPA Micro controller data path offload enable flag */ + uint8_t is_uc_offload_enabled; + /* IPA Micro controller data path offload TX buffer count */ + uint32_t uc_tx_buffer_count; + /* IPA Micro controller data path offload TX buffer size */ + uint32_t uc_tx_buffer_size; + /* IPA Micro controller data path offload RX indication ring count */ + uint32_t uc_rx_indication_ring_count; + /* IPA Micro controller data path offload TX partition base */ + uint32_t uc_tx_partition_base; + /* IP, TCP and UDP checksum offload */ + bool ip_tcp_udp_checksum_offload; + /* Rx processing in thread from TXRX */ + bool enable_rxthread; + /* CE classification enabled through INI */ + bool ce_classify_enabled; +#ifdef QCA_LL_TX_FLOW_CONTROL_V2 + /* Threshold to stop queue in percentage */ + uint32_t tx_flow_stop_queue_th; + /* Start queue offset in percentage */ + uint32_t tx_flow_start_queue_offset; +#endif +}; + +/** + * ol_txrx_ipa_resources - Resources needed for IPA + */ +struct ol_txrx_ipa_resources { + qdf_dma_addr_t ce_sr_base_paddr; + uint32_t ce_sr_ring_size; + qdf_dma_addr_t ce_reg_paddr; + + qdf_dma_addr_t tx_comp_ring_base_paddr; + uint32_t tx_comp_ring_size; + uint32_t tx_num_alloc_buffer; + + qdf_dma_addr_t rx_rdy_ring_base_paddr; + uint32_t rx_rdy_ring_size; + qdf_dma_addr_t rx_proc_done_idx_paddr; + void *rx_proc_done_idx_vaddr; + + qdf_dma_addr_t rx2_rdy_ring_base_paddr; + uint32_t rx2_rdy_ring_size; + qdf_dma_addr_t rx2_proc_done_idx_paddr; + void *rx2_proc_done_idx_vaddr; +}; + +struct ol_txrx_ocb_chan_info { + uint32_t chan_freq; + uint16_t disable_rx_stats_hdr:1; +}; + +/** + * ol_mic_error_info - carries the information associated with + * a MIC error + * @vdev_id: virtual device ID + * @key_id: Key ID + * @pn: packet number + * @sa: source address + * @da: destination address + * @ta: transmitter address + */ +struct ol_mic_error_info { + uint8_t vdev_id; + uint32_t key_id; + uint64_t pn; + uint8_t sa[OL_TXRX_MAC_ADDR_LEN]; + uint8_t da[OL_TXRX_MAC_ADDR_LEN]; + uint8_t ta[OL_TXRX_MAC_ADDR_LEN]; +}; + +/** + * ol_error_info - carries the information associated with an + * error indicated by the firmware + * @mic_err: MIC error information + */ +struct ol_error_info { + union { + struct ol_mic_error_info mic_err; + } u; +}; + + +/** + * struct ol_txrx_ocb_set_chan - txrx OCB channel info + * @ocb_channel_count: Channel count + * @ocb_channel_info: OCB channel info + */ +struct ol_txrx_ocb_set_chan { + uint32_t ocb_channel_count; + struct ol_txrx_ocb_chan_info *ocb_channel_info; +}; + +/** + * @brief Parameter type to pass WMM setting to ol_txrx_set_wmm_param + * @details + * The struct is used to specify informaiton to update TX WMM scheduler. + */ +struct ol_tx_ac_param_t { + uint32_t aifs; + uint32_t cwmin; + uint32_t cwmax; +}; + +struct ol_tx_wmm_param_t { + struct ol_tx_ac_param_t ac[OL_TX_NUM_WMM_AC]; +}; + +struct ieee80211_ba_parameterset { +#if _BYTE_ORDER == _BIG_ENDIAN + uint16_t buffersize:10, /* B6-15 buffer size */ + tid:4, /* B2-5 TID */ + bapolicy:1, /* B1 block ack policy */ + amsdusupported:1; /* B0 amsdu supported */ +#else + uint16_t amsdusupported:1, /* B0 amsdu supported */ + bapolicy:1, /* B1 block ack policy */ + tid:4, /* B2-5 TID */ + buffersize:10; /* B6-15 buffer size */ +#endif +} __packed; + +struct ieee80211_ba_seqctrl { +#if _BYTE_ORDER == _BIG_ENDIAN + uint16_t startseqnum:12, /* B4-15 starting sequence number */ + fragnum:4; /* B0-3 fragment number */ +#else + uint16_t fragnum:4, /* B0-3 fragment number */ + startseqnum:12; /* B4-15 starting sequence number */ +#endif +} __packed; + +struct ieee80211_delba_parameterset { +#if _BYTE_ORDER == _BIG_ENDIAN + uint16_t tid:4, /* B12-15 tid */ + initiator:1, /* B11 initiator */ + reserved0:11; /* B0-10 reserved */ +#else + uint16_t reserved0:11, /* B0-10 reserved */ + initiator:1, /* B11 initiator */ + tid:4; /* B12-15 tid */ +#endif +} __packed; + +typedef QDF_STATUS(*rx_callback_fp)(void *p_cds_gctx, + qdf_nbuf_t pDataBuff, + uint8_t ucSTAId); + +/** + * ol_txrx_vdev_peer_remove_cb - wma_remove_peer callback + */ +typedef void (*ol_txrx_vdev_peer_remove_cb)(void *handle, uint8_t *bssid, + uint8_t vdev_id, void *peer, bool roam_synch_in_progress); + +/** + * 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_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 (*tx_flow_control_fp)(void *osif_dev, + bool tx_resume); + +/** + * @typedef ol_tx_pause_callback_fp + * @brief OSIF function registered with the data path + */ +typedef void (*ol_tx_pause_callback_fp)(uint8_t vdev_id, + enum netif_action_type action, + enum netif_reason_type reason); + +typedef void (*ipa_op_cb_type)(uint8_t *op_msg, + void *osif_ctxt); + +#endif /* __CDP_TXRX_MOB_DEF_H */ diff --git a/dp/inc/cdp_txrx_ocb.h b/dp/inc/cdp_txrx_ocb.h index 074637a263..79ef796fb1 100644 --- a/dp/inc/cdp_txrx_ocb.h +++ b/dp/inc/cdp_txrx_ocb.h @@ -27,32 +27,51 @@ #ifndef _CDP_TXRX_OCB_H_ #define _CDP_TXRX_OCB_H_ +#include /** - * struct ol_txrx_ocb_set_chan - txrx OCB channel info - * @ocb_channel_count: Channel count - * @ocb_channel_info: OCB channel info - */ -struct ol_txrx_ocb_set_chan { - uint32_t ocb_channel_count; - struct ol_txrx_ocb_chan_info *ocb_channel_info; -}; - -/** - * ol_txrx_set_ocb_chan_info() - set OCB channel info to vdev. + * cdp_set_ocb_chan_info() - set OCB channel info to vdev. + * @soc - data path soc handle * @vdev: vdev handle * @ocb_set_chan: OCB channel information to be set in vdev. * * Return: NONE */ -void ol_txrx_set_ocb_chan_info(ol_txrx_vdev_handle vdev, - struct ol_txrx_ocb_set_chan ocb_set_chan); +static inline void +cdp_set_ocb_chan_info(ol_txrx_soc_handle soc, void *vdev, + struct ol_txrx_ocb_set_chan ocb_set_chan) +{ + if (!soc || !soc->ops || !soc->ops->ocb_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->ocb_ops->set_ocb_chan_info) + return soc->ops->ocb_ops->set_ocb_chan_info(vdev, + ocb_set_chan); + + return; +} /** - * ol_txrx_get_ocb_chan_info() - return handle to vdev ocb_channel_info + * cdp_get_ocb_chan_info() - return handle to vdev ocb_channel_info + * @soc - data path soc handle * @vdev: vdev handle * * Return: handle to struct ol_txrx_ocb_chan_info */ -struct ol_txrx_ocb_chan_info * -ol_txrx_get_ocb_chan_info(ol_txrx_vdev_handle vdev); +static inline struct ol_txrx_ocb_chan_info * +cdp_get_ocb_chan_info(ol_txrx_soc_handle soc, void *vdev) +{ + if (!soc || !soc->ops || !soc->ops->ocb_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->ocb_ops->get_ocb_chan_info) + return soc->ops->ocb_ops->get_ocb_chan_info(vdev); + + return NULL; +} #endif /* _CDP_TXRX_OCB_H_ */ diff --git a/dp/inc/cdp_txrx_ops.h b/dp/inc/cdp_txrx_ops.h index 87814dc315..795f12415e 100644 --- a/dp/inc/cdp_txrx_ops.h +++ b/dp/inc/cdp_txrx_ops.h @@ -52,6 +52,8 @@ struct cdp_cmn_ops { (ol_txrx_soc_handle soc, void *ctrl_pdev, HTC_HANDLE htc_pdev, qdf_device_t osdev, uint8_t pdev_id); + int (*txrx_pdev_post_attach)(void *pdev); + void(*txrx_pdev_detach)(void *pdev, int force); void *(*txrx_peer_attach) @@ -108,8 +110,8 @@ struct cdp_cmn_ops { 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 per_vdev, bool response_expected); + A_STATUS(*txrx_fw_stats_get)(void *vdev, struct ol_txrx_stats_req *req, + bool per_vdev, bool response_expected); int(*txrx_debug)(void *vdev, int debug_specs); @@ -155,7 +157,7 @@ struct cdp_cmn_ops { (*txrx_get_ctrl_pdev_from_vdev)(void *vdev); void * - (*txrx_get_vdev_from_vdev_id)(uint8_t vdev_id); + (*txrx_get_vdev_from_vdev_id)(void *pdev, uint8_t vdev_id); void (*txrx_soc_detach)(void *soc); @@ -377,7 +379,7 @@ struct cdp_host_stats_ops { void (*txrx_host_ce_stats)(void *vdev); int (*txrx_stats_publish)(void *pdev, - struct ol_txrx_stats *buf); + void *buf); /** * @brief Enable enhanced stats functionality. * @@ -451,15 +453,12 @@ struct cdp_raw_ops { (*rsim_tx_encap)(void *vdev, qdf_nbuf_t *pnbuf); }; +#ifdef CONFIG_WIN struct cdp_pflow_ops { uint32_t(*pflow_update_pdev_params)(void *, ol_ath_param_t, uint32_t, void *); }; - -struct cdp_mob_drv_ops { - /* FIXME to be fixed */ -}; - +#endif /* CONFIG_WIN */ struct ol_if_ops { void (*peer_set_default_routing)(void *scn_handle, @@ -474,7 +473,283 @@ struct ol_if_ops { /* TODO: Add any other control path calls required to OL_IF/WMA layer */ }; +#ifndef CONFIG_WIN +/* From here MCL specific OPs */ +/** + * struct cdp_misc_ops - mcl ops not classified + * @set_ibss_vdev_heart_beat_timer: + * @bad_peer_txctl_set_setting: + * @bad_peer_txctl_update_threshold: + * @hl_tdls_flag_reset: + * @tx_non_std: + * @get_vdev_id: + * @set_wisa_mode: + * @runtime_suspend: + * @runtime_resume: + */ +struct cdp_misc_ops { + uint16_t (*set_ibss_vdev_heart_beat_timer)(void *vdev, + uint16_t timer_value_sec); + void (*set_wmm_param)(void *cfg_pdev, + struct ol_tx_wmm_param_t wmm_param); + void (*bad_peer_txctl_set_setting)(void *pdev, int enable, + int period, int txq_limit); + void (*bad_peer_txctl_update_threshold)(void *pdev, + int level, int tput_thresh, int tx_limit); + void (*hl_tdls_flag_reset)(void *vdev, bool flag); + qdf_nbuf_t (*tx_non_std)(void *vdev, + enum ol_tx_spec tx_spec, qdf_nbuf_t msdu_list); + uint16_t (*get_vdev_id)(void *vdev); + QDF_STATUS (*set_wisa_mode)(void *vdev, bool enable); + QDF_STATUS (*runtime_suspend)(void *pdev); + QDF_STATUS (*runtime_resume)(void *pdev); + int (*get_opmode)(void *vdev); + void (*mark_first_wakeup_packet)(uint8_t value); + void (*update_mac_id)(uint8_t vdev_id, uint8_t mac_id); + void (*flush_rx_frames)(void *peer, bool drop); + A_STATUS (*get_intra_bss_fwd_pkts_count)(uint8_t vdev_id, + uint64_t *fwd_tx_packets, uint64_t *fwd_rx_packets); + void (*pkt_log_init)(void *handle, void *scn); + void (*pkt_log_con_service)(void *pdev, void *scn); +}; +/** + * struct cdp_tx_delay_ops - mcl tx delay ops + * @tx_delay: + * @tx_delay_hist: + * @tx_packet_count: + * @tx_set_compute_interval: + */ +struct cdp_tx_delay_ops { + void (*tx_delay)(void *pdev, uint32_t *queue_delay_microsec, + uint32_t *tx_delay_microsec, int category); + void (*tx_delay_hist)(void *pdev, + uint16_t *bin_values, int category); + void (*tx_packet_count)(void *pdev, uint16_t *out_packet_count, + uint16_t *out_packet_loss_count, int category); + void (*tx_set_compute_interval)(void *pdev, uint32_t interval); +}; + +/** + * struct cdp_pmf_ops - mcl protected management frame ops + * @get_pn_info: + */ +struct cdp_pmf_ops { + void (*get_pn_info)(void *peer, uint8_t **last_pn_valid, + uint64_t **last_pn, uint32_t **rmf_pn_replays); +}; + +/** + * struct cdp_cfg_ops - mcl configuration ops + * @set_cfg_rx_fwd_disabled: + * @set_cfg_packet_log_enabled: + * @cfg_attach: + * @vdev_rx_set_intrabss_fwd: + * @get_opmode: + * @is_rx_fwd_disabled: + * @tx_set_is_mgmt_over_wmi_enabled: + * @is_high_latency: + * @set_flow_control_parameters: + */ +struct cdp_cfg_ops { + void (*set_cfg_rx_fwd_disabled)(void *pdev, uint8_t disable_rx_fwd); + void (*set_cfg_packet_log_enabled)(void *pdev, uint8_t val); + void * (*cfg_attach)(qdf_device_t osdev, void *cfg_param); + void (*vdev_rx_set_intrabss_fwd)(void *vdev, bool val); + uint8_t (*is_rx_fwd_disabled)(void *vdev); + void (*tx_set_is_mgmt_over_wmi_enabled)(uint8_t value); + int (*is_high_latency)(void *pdev); + void (*set_flow_control_parameters)(void *cfg, void *param); + void (*set_flow_steering)(void *pdev, uint8_t val); +}; + +/** + * struct cdp_flowctl_ops - mcl flow control + * @register_pause_cb: + * @set_desc_global_pool_size: + * @dump_flow_pool_info: + */ +struct cdp_flowctl_ops { + QDF_STATUS (*register_pause_cb)(ol_tx_pause_callback_fp); + + void (*set_desc_global_pool_size)(uint32_t num_msdu_desc); + void (*dump_flow_pool_info)(void); +}; + +/** + * struct cdp_lflowctl_ops - mcl legacy flow control ops + * @register_tx_flow_control: + * @deregister_tx_flow_control_cb: + * @flow_control_cb: + * @get_tx_resource: + * @ll_set_tx_pause_q_depth: + * @vdev_flush: + * @vdev_pause: + * @vdev_unpause: + */ +struct cdp_lflowctl_ops { + int (*register_tx_flow_control)(uint8_t vdev_id, + ol_txrx_tx_flow_control_fp flowControl, void *osif_fc_ctx); + int (*deregister_tx_flow_control_cb)(uint8_t vdev_id); + void (*flow_control_cb)(void *vdev, bool tx_resume); + bool (*get_tx_resource)(uint8_t sta_id, + unsigned int low_watermark, + unsigned int high_watermark_offset); + int (*ll_set_tx_pause_q_depth)(uint8_t vdev_id, int pause_q_depth); + void (*vdev_flush)(void *vdev); + void (*vdev_pause)(void *vdev, uint32_t reason); + void (*vdev_unpause)(void *vdev, uint32_t reason); +}; + +/** + * struct cdp_ipa_ops - mcl ipa data path ops + * @ipa_get_resource: + * @ipa_set_doorbell_paddr: + * @ipa_set_active: + * @ipa_op_response: + * @ipa_register_op_cb: + * @ipa_get_stat: + * @ipa_tx_data_frame: + */ +struct cdp_ipa_ops { + void (*ipa_get_resource)(void *pdev, + struct ol_txrx_ipa_resources *ipa_res); + void (*ipa_set_doorbell_paddr)(void *pdev, + qdf_dma_addr_t ipa_tx_uc_doorbell_paddr, + qdf_dma_addr_t ipa_rx_uc_doorbell_paddr); + void (*ipa_set_active)(void *pdev, bool uc_active, bool is_tx); + void (*ipa_op_response)(void *pdev, uint8_t *op_msg); + void (*ipa_register_op_cb)(void *pdev, + void (*ipa_uc_op_cb_type)(uint8_t *op_msg, void *osif_ctxt), + void *osif_dev); + void (*ipa_get_stat)(void *pdev); + qdf_nbuf_t (*ipa_tx_data_frame)(void *vdev, qdf_nbuf_t skb); + void (*ipa_set_uc_tx_partition_base)(void *pdev, uint32_t value); +}; + +/** + * struct cdp_lro_ops - mcl large receive offload ops + * @register_lro_flush_cb: + * @deregister_lro_flush_cb: + */ +struct cdp_lro_ops { + void (*register_lro_flush_cb)(void (lro_flush_cb)(void *), + void *(lro_init_cb)(void)); + void (*deregister_lro_flush_cb)(void (lro_deinit_cb)(void *)); +}; + +/** + * struct cdp_bus_ops - mcl bus suspend/resume ops + * @bus_suspend: + * @bus_resume: + */ +struct cdp_bus_ops { + QDF_STATUS (*bus_suspend)(void); + QDF_STATUS (*bus_resume)(void); +}; + +/** + * struct cdp_ocb_ops - mcl ocb ops + * @set_ocb_chan_info: + * @get_ocb_chan_info: + */ +struct cdp_ocb_ops { + void (*set_ocb_chan_info)(void *vdev, + struct ol_txrx_ocb_set_chan ocb_set_chan); + struct ol_txrx_ocb_chan_info * (*get_ocb_chan_info)(void *vdev); +}; + +/** + * struct cdp_peer_ops - mcl peer related ops + * @register_peer: + * @clear_peer: + * @cfg_attach: + * @find_peer_by_addr: + * @find_peer_by_addr_and_vdev: + * @local_peer_id: + * @peer_find_by_local_id: + * @peer_state_update: + * @get_vdevid: + * @get_vdev_by_sta_id: + * @register_ocb_peer: + * @peer_get_peer_mac_addr: + * @get_peer_state: + * @get_vdev_for_peer: + * @update_ibss_add_peer_num_of_vdev: + * @remove_peers_for_vdev: + * @remove_peers_for_vdev_no_lock: + * @copy_mac_addr_raw: + * @add_last_real_peer: + * @last_assoc_received: + * @last_disassoc_received: + * @last_deauth_received: + * @is_vdev_restore_last_peer: + * @update_last_real_peer: + */ +struct cdp_peer_ops { + QDF_STATUS (*register_peer)(void *pdev, + struct ol_txrx_desc_type *sta_desc); + QDF_STATUS (*clear_peer)(void *pdev, uint8_t sta_id); + QDF_STATUS (*change_peer_state)(uint8_t sta_id, + enum ol_txrx_peer_state sta_state, + bool roam_synch_in_progress); + void * (*find_peer_by_addr)(void *pdev, + uint8_t *peer_addr, uint8_t *peer_id); + void * (*find_peer_by_addr_and_vdev)(void *pdev, void *vdev, + uint8_t *peer_addr, uint8_t *peer_id); + uint16_t (*local_peer_id)(void *peer); + void * (*peer_find_by_local_id)(void *pdev, uint8_t local_peer_id); + QDF_STATUS (*peer_state_update)(void *pdev, uint8_t *peer_addr, + enum ol_txrx_peer_state state); + QDF_STATUS (*get_vdevid)(void *peer, uint8_t *vdev_id); + void * (*get_vdev_by_sta_id)(uint8_t sta_id); + QDF_STATUS (*register_ocb_peer)(void *cds_ctx, uint8_t *mac_addr, + uint8_t *peer_id); + uint8_t * (*peer_get_peer_mac_addr)(void *peer); + int (*get_peer_state)(void *peer); + void * (*get_vdev_for_peer)(void *peer); + int16_t (*update_ibss_add_peer_num_of_vdev)(void *vdev, + int16_t peer_num_delta); + void (*remove_peers_for_vdev)(void *vdev, + ol_txrx_vdev_peer_remove_cb callback, + void *callback_context, bool remove_last_peer); + void (*remove_peers_for_vdev_no_lock)(void *vdev, + ol_txrx_vdev_peer_remove_cb callback, + void *callback_context); + void (*copy_mac_addr_raw)(void *vdev, uint8_t *bss_addr); + void (*add_last_real_peer)(void *pdev, void *vdev, uint8_t *peer_id); + qdf_time_t * (*last_assoc_received)(void *peer); + qdf_time_t * (*last_disassoc_received)(void *peer); + qdf_time_t * (*last_deauth_received)(void *peer); + bool (*is_vdev_restore_last_peer)(void *peer); + void (*update_last_real_peer)(void *pdev, void *peer, + uint8_t *peer_id, bool restore_last_peer); + void (*peer_detach_force_delete)(void *peer); +}; + +/** + * struct cdp_ocb_ops - mcl ocb ops + * @throttle_init_period: + * @throttle_set_level: + */ +struct cdp_throttle_ops { + void (*throttle_init_period)(void *pdev, int period, + uint8_t *dutycycle_level); + void (*throttle_set_level)(void *pdev, int level); +}; + +/** + * struct cdp_ocb_ops - mcl ocb ops + * @display_stats: + * @clear_stats: + * @stats: + */ +struct cdp_mob_stats_ops { + void (*display_stats)(uint16_t bitmap); + void (*clear_stats)(uint16_t bitmap); + int (*stats)(uint8_t vdev_id, char *buffer, unsigned buf_len); +}; +#endif /* CONFIG_WIN */ struct cdp_ops { struct cdp_cmn_ops *cmn_drv_ops; @@ -485,7 +760,21 @@ struct cdp_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; +#ifndef CONFIG_WIN + struct cdp_misc_ops *misc_ops; + struct cdp_cfg_ops *cfg_ops; + struct cdp_flowctl_ops *flowctl_ops; + struct cdp_lflowctl_ops *l_flowctl_ops; + struct cdp_ipa_ops *ipa_ops; + struct cdp_lro_ops *lro_ops; + struct cdp_bus_ops *bus_ops; + struct cdp_ocb_ops *ocb_ops; + struct cdp_peer_ops *peer_ops; + struct cdp_throttle_ops *throttle_ops; + struct cdp_mob_stats_ops *mob_stats_ops; + struct cdp_tx_delay_ops *delay_ops; + struct cdp_pmf_ops *pmf_ops; +#endif /* CONFIG_WIN */ }; #endif diff --git a/dp/inc/cdp_txrx_peer_ops.h b/dp/inc/cdp_txrx_peer_ops.h index 893c77fd85..e34ec825d6 100644 --- a/dp/inc/cdp_txrx_peer_ops.h +++ b/dp/inc/cdp_txrx_peer_ops.h @@ -31,148 +31,616 @@ */ #ifndef _CDP_TXRX_PEER_H_ #define _CDP_TXRX_PEER_H_ - -typedef QDF_STATUS(*ol_rx_callback_fp)(void *p_cds_gctx, - qdf_nbuf_t pDataBuff, - uint8_t ucSTAId); +#include /** - * struct ol_txrx_peer_state - Peer state information - */ -enum ol_txrx_peer_state { - OL_TXRX_PEER_STATE_INVALID, - OL_TXRX_PEER_STATE_DISC, /* initial state */ - OL_TXRX_PEER_STATE_CONN, /* authentication in progress */ - OL_TXRX_PEER_STATE_AUTH, /* authentication successful */ -}; - -/** - * struct ol_txrx_desc_type - txrx descriptor type - * @sta_id: sta id - * @is_qos_enabled: is station qos enabled - * @is_wapi_supported: is station wapi supported - */ -struct ol_txrx_desc_type { - uint8_t sta_id; - uint8_t is_qos_enabled; - uint8_t is_wapi_supported; -}; - -QDF_STATUS ol_txrx_register_peer(struct ol_txrx_desc_type *sta_desc); - -/** - * ol_txrx_vdev_peer_remove_cb - wma_remove_peer callback - */ -typedef void (*ol_txrx_vdev_peer_remove_cb)(void *handle, uint8_t *bssid, - uint8_t vdev_id, - ol_txrx_peer_handle peer, - bool roam_synch_in_progress); - -QDF_STATUS ol_txrx_clear_peer(uint8_t sta_id); - -QDF_STATUS ol_txrx_change_peer_state(uint8_t sta_id, - enum ol_txrx_peer_state sta_state, - bool roam_synch_in_progress); - -ol_txrx_peer_handle ol_txrx_find_peer_by_addr(ol_txrx_pdev_handle pdev, - uint8_t *peer_addr, - uint8_t *peer_id); - -ol_txrx_peer_handle -ol_txrx_find_peer_by_addr_and_vdev(ol_txrx_pdev_handle pdev, - ol_txrx_vdev_handle vdev, - uint8_t *peer_addr, uint8_t *peer_id); - -#ifdef QCA_SUPPORT_TXRX_LOCAL_PEER_ID -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, - uint8_t *peer_addr, - uint8_t *peer_id); -ol_txrx_peer_handle -ol_txrx_find_peer_by_addr_and_vdev(ol_txrx_pdev_handle pdev, - ol_txrx_vdev_handle vdev, - uint8_t *peer_addr, uint8_t *peer_id); -ol_txrx_peer_handle -ol_txrx_peer_find_by_local_id(ol_txrx_pdev_handle pdev, uint8_t local_peer_id); -#else -#define ol_txrx_local_peer_id(peer) OL_TXRX_INVALID_LOCAL_PEER_ID -#define ol_txrx_find_peer_by_addr(pdev, peer_addr, peer_id) NULL -#define ol_txrx_find_peer_by_addr_and_vdev(pdev, vdev, peer_addr, peer_id) NULL -#define ol_txrx_peer_find_by_local_id(pdev, local_peer_id) NULL -#endif /* QCA_SUPPORT_TXRX_LOCAL_PEER_ID */ - -QDF_STATUS -ol_txrx_peer_state_update(ol_txrx_pdev_handle pdev, uint8_t *peer_addr, - enum ol_txrx_peer_state state); - -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); - -QDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr, - uint8_t *peer_id); - -/** - * ol_txrx_peer_get_peer_mac_addr() - return mac_addr from peer handle. - * @peer: handle to peer + * cdp_peer_register() - Register peer into physical device + * @soc - data path soc handle + * @pdev - data path device instance + * @sta_desc - peer description * - * returns mac addrs for module which do not know peer type + * Register peer into physical device * - * Return: the mac_addr from peer + * Return: QDF_STATUS_SUCCESS registration success + * QDF_STATUS_E_NOSUPPORT not support this feature */ -uint8_t *ol_txrx_peer_get_peer_mac_addr(ol_txrx_peer_handle peer); +static inline QDF_STATUS +cdp_peer_register(ol_txrx_soc_handle soc, void *pdev, + struct ol_txrx_desc_type *sta_desc) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->peer_ops->register_peer) + return soc->ops->peer_ops->register_peer(pdev, sta_desc); + + return QDF_STATUS_E_NOSUPPORT; +} /** - * ol_txrx_get_peer_state() - Return peer state of peer - * @peer: peer handle + * cdp_peer_clear() - remove peer from physical device + * @soc - data path soc handle + * @pdev - data path device instance + * @sta_id - local peer id * - * Return: return peer state + * remove peer from physical device + * + * Return: QDF_STATUS_SUCCESS registration success + * QDF_STATUS_E_NOSUPPORT not support this feature */ -int ol_txrx_get_peer_state(ol_txrx_peer_handle peer); +static inline QDF_STATUS +cdp_peer_clear(ol_txrx_soc_handle soc, void *pdev, uint8_t sta_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + return QDF_STATUS_E_NOSUPPORT; +} /** - * ol_txrx_get_vdev_for_peer() - Return vdev from peer handle - * @peer: peer handle + * cdp_peer_register_ocb_peer() - register ocb peer from physical device + * @soc - data path soc handle + * @cds_ctx - cds void context + * @mac_addr - mac address for ocb self peer + * @peer_id - local peer id * - * Return: vdev handle from peer + * register ocb peer from physical device + * + * Return: QDF_STATUS_SUCCESS registration success + * QDF_STATUS_E_NOSUPPORT not support this feature */ -ol_txrx_vdev_handle -ol_txrx_get_vdev_for_peer(ol_txrx_peer_handle peer); +static inline QDF_STATUS +cdp_peer_register_ocb_peer(ol_txrx_soc_handle soc, void *cds_ctx, + uint8_t *mac_addr, uint8_t *peer_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->peer_ops->register_ocb_peer) + return soc->ops->peer_ops->register_ocb_peer(cds_ctx, + mac_addr, peer_id); + + return QDF_STATUS_E_NOSUPPORT; +} /** - * ol_txrx_update_ibss_add_peer_num_of_vdev() - update and return peer num - * @vdev: vdev handle - * @peer_num_delta: peer nums to be adjusted + * cdp_peer_remove_for_vdev() - remove peer instance from virtual interface + * @soc - data path soc handle + * @vdev - virtual interface instance + * @callback - remove done notification callback function pointer + * @callback_context - callback caller context + * @remove_last_peer - removed peer is last peer or not * - * Return: -1 for failure or total peer nums after adjustment. - */ -int16_t -ol_txrx_update_ibss_add_peer_num_of_vdev(ol_txrx_vdev_handle vdev, - int16_t peer_num_delta); -/** - * ol_txrx_remove_peers_for_vdev() - remove all vdev peers with lock held - * @vdev: vdev handle - * @callback: callback function to remove the peer. - * @callback_context: handle for callback function - * @remove_last_peer: Does it required to last peer. + * remove peer instance from virtual interface * * Return: NONE */ -void -ol_txrx_remove_peers_for_vdev(ol_txrx_vdev_handle vdev, - ol_txrx_vdev_peer_remove_cb callback, - void *callback_context, bool remove_last_peer); +static inline void +cdp_peer_remove_for_vdev(ol_txrx_soc_handle soc, + void *vdev, ol_txrx_vdev_peer_remove_cb callback, + void *callback_context, bool remove_last_peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->peer_ops->remove_peers_for_vdev) + return soc->ops->peer_ops->remove_peers_for_vdev( + vdev, callback, callback_context, remove_last_peer); + + return; +} + /** - * ol_txrx_remove_peers_for_vdev_no_lock() - remove vdev peers with no lock. - * @vdev: vdev handle - * @callback: callback function to remove the peer. - * @callback_context: handle for callback function + * cdp_peer_find_by_addr() - Find peer by peer mac address + * @soc - data path soc handle + * @pdev - data path device instance + * @peer_addr - peer mac address + * @peer_id - local peer id with target mac address * - * Return: NONE + * Find peer and local peer id by peer mac address + * + * Return: peer instance void pointer + * NULL cannot find target peer */ -void -ol_txrx_remove_peers_for_vdev_no_lock(ol_txrx_vdev_handle vdev, - ol_txrx_vdev_peer_remove_cb callback, - void *callback_context); +static inline void +*cdp_peer_find_by_addr(ol_txrx_soc_handle soc, void *pdev, + uint8_t *peer_addr, uint8_t *peer_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->find_peer_by_addr) + return soc->ops->peer_ops->find_peer_by_addr( + pdev, peer_addr, peer_id); + + return NULL; +} + +/** + * cdp_peer_find_by_addr_and_vdev() - Find peer by peer mac address within vdev + * @soc - data path soc handle + * @pdev - data path device instance + * @vdev - virtual interface instance + * @peer_addr - peer mac address + * @peer_id - local peer id with target mac address + * + * Find peer by peer mac address within vdev + * + * Return: peer instance void pointer + * NULL cannot find target peer + */ +static inline void +*cdp_peer_find_by_addr_and_vdev(ol_txrx_soc_handle soc, void *pdev, + void *vdev, uint8_t *peer_addr, uint8_t *peer_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->find_peer_by_addr_and_vdev) + return soc->ops->peer_ops->find_peer_by_addr_and_vdev( + pdev, vdev, peer_addr, peer_id); + + return NULL; +} + +/** + * cdp_peer_find_by_local_id() - Find peer by local peer id + * @soc - data path soc handle + * @pdev - data path device instance + * @local_peer_id - local peer id want to find + * + * Find peer by local peer id within physical device + * + * Return: peer instance void pointer + * NULL cannot find target peer + */ +static inline void +*cdp_peer_find_by_local_id(ol_txrx_soc_handle soc, void *pdev, + uint8_t local_peer_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->peer_find_by_local_id) + return soc->ops->peer_ops->peer_find_by_local_id( + pdev, local_peer_id); + + return NULL; +} + +/** + * cdp_peer_state_update() - update peer local state + * @soc - data path soc handle + * @pdev - data path device instance + * @peer_addr - peer mac address + * @state - new peer local state + * + * update peer local state + * + * Return: QDF_STATUS_SUCCESS registration success + * QDF_STATUS_E_NOSUPPORT not support this feature + */ +static inline QDF_STATUS +cdp_peer_state_update(ol_txrx_soc_handle soc, void *pdev, + uint8_t *peer_addr, enum ol_txrx_peer_state state) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->peer_ops->peer_state_update) + return soc->ops->peer_ops->peer_state_update( + pdev, peer_addr, state); + + return QDF_STATUS_E_NOSUPPORT; +} + +/** + * cdp_peer_state_get() - Get local peer state + * @soc - data path soc handle + * @peer - peer instance + * + * Get local peer state + * + * Return: peer status + */ +static inline int +cdp_peer_state_get(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->peer_ops->get_peer_state) + return soc->ops->peer_ops->get_peer_state(peer); + + return 0; +} + +/** + * cdp_peer_get_local_peer_id() - Find local peer id within peer instance + * @soc - data path soc handle + * @peer - peer instance + * + * Find local peer id within peer instance + * + * Return: local peer id + * HTT_INVALID_PEER Invalid peer + */ +static inline uint16_t +cdp_peer_get_local_peer_id(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return HTT_INVALID_PEER; + } + + if (soc->ops->peer_ops->local_peer_id) + return soc->ops->peer_ops->local_peer_id(peer); + + return HTT_INVALID_PEER; +} + +/** + * cdp_peer_get_vdevid() - Get virtaul interface id which peer registered + * @soc - data path soc handle + * @peer - peer instance + * @vdev_id - virtaul interface id which peer registered + * + * Get virtaul interface id which peer registered + * + * Return: QDF_STATUS_SUCCESS registration success + * QDF_STATUS_E_NOSUPPORT not support this feature + */ +static inline QDF_STATUS +cdp_peer_get_vdevid(ol_txrx_soc_handle soc, void *peer, uint8_t *vdev_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_INVAL; + } + + if (soc->ops->peer_ops->get_vdevid) + return soc->ops->peer_ops->get_vdevid(peer, vdev_id); + + return QDF_STATUS_E_NOSUPPORT; +} + +/** + * cdp_peer_get_vdev_by_sta_id() - Get vdev instance by local peer id + * @soc - data path soc handle + * @sta_id - local peer id + * + * Get virtaul interface id by local peer id + * + * Return: Virtual interface instance + * NULL in case cannot find + */ +static inline void +*cdp_peer_get_vdev_by_sta_id(ol_txrx_soc_handle soc, uint8_t sta_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->get_vdev_by_sta_id) + return soc->ops->peer_ops->get_vdev_by_sta_id(sta_id); + + return NULL; +} + +/** + * cdp_peer_get_peer_mac_addr() - Get peer mac address + * @soc - data path soc handle + * @peer - peer instance + * + * Get peer mac address + * + * Return: peer mac address pointer + * NULL in case cannot find + */ +static inline uint8_t +*cdp_peer_get_peer_mac_addr(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->peer_get_peer_mac_addr) + return soc->ops->peer_ops->peer_get_peer_mac_addr(peer); + + return NULL; +} + +/** + * cdp_peer_get_vdev() - Get virtual interface instance which peer belongs + * @soc - data path soc handle + * @peer - peer instance + * + * Get virtual interface instance which peer belongs + * + * Return: virtual interface instance pointer + * NULL in case cannot find + */ +static inline void +*cdp_peer_get_vdev(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->get_vdev_for_peer) + return soc->ops->peer_ops->get_vdev_for_peer(peer); + + return NULL; +} + +/** + * cdp_peer_update_ibss_add_peer_num_of_vdev() - update number of peer + * @soc - data path soc handle + * @vdev - virtual interface instance + * @peer_num_delta - number of peer should be updated + * + * update number of peer + * + * Return: updated number of peer + * 0 fail + */ +static inline int16_t +cdp_peer_update_ibss_add_peer_num_of_vdev(ol_txrx_soc_handle soc, + void *vdev, int16_t peer_num_delta) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return 0; + } + + if (soc->ops->peer_ops->update_ibss_add_peer_num_of_vdev) + return soc->ops->peer_ops->update_ibss_add_peer_num_of_vdev( + vdev, peer_num_delta); + + return 0; +} + +/** + * cdp_peer_copy_mac_addr_raw() - copy peer mac address + * @soc - data path soc handle + * @vdev - virtual interface instance + * @bss_addr - mac address should be copied + * + * copy peer mac address + * + * Return: none + */ +static inline void +cdp_peer_copy_mac_addr_raw(ol_txrx_soc_handle soc, + void *vdev, uint8_t *bss_addr) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->peer_ops->copy_mac_addr_raw) + return soc->ops->peer_ops->copy_mac_addr_raw(vdev, bss_addr); + + return; +} + +/** + * cdp_peer_add_last_real_peer() - Add peer with last peer marking + * @soc - data path soc handle + * @pdev - data path device instance + * @vdev - virtual interface instance + * @peer_id - local peer id + * + * copy peer mac address + * + * Return: none + */ +static inline void +cdp_peer_add_last_real_peer(ol_txrx_soc_handle soc, + void *pdev, void *vdev, uint8_t *peer_id) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->peer_ops->add_last_real_peer) + return soc->ops->peer_ops->add_last_real_peer( + pdev, vdev, peer_id); + return; +} + +/** + * cdp_peer_last_assoc_received() - last assoc received peer + * @soc - data path soc handle + * @peer - peer instance pointer + * + * !!! This should be implemented on legacy also + * last assoc received peer + * + * Return: pointer + */ +static inline qdf_time_t * +cdp_peer_last_assoc_received(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->last_assoc_received) + return soc->ops->peer_ops->last_assoc_received(peer); + + return NULL; +} + +/** + * cdp_peer_last_disassoc_received() - last disassoc received peer + * @soc - data path soc handle + * @peer - peer instance pointer + * + * !!! This should be implemented on legacy also + * last disassoc received peer + * + * Return: pointer + */ +static inline qdf_time_t * +cdp_peer_last_disassoc_received(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->last_disassoc_received) + return soc->ops->peer_ops->last_disassoc_received(peer); + + return NULL; +} + +/** + * cdp_peer_last_deauth_received() - last deauth received peer + * @soc - data path soc handle + * @peer - peer instance pointer + * + * !!! This should be implemented on legacy also + * last deauth received peer + * + * Return: pointer + */ +static inline qdf_time_t * +cdp_peer_last_deauth_received(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return NULL; + } + + if (soc->ops->peer_ops->last_deauth_received) + return soc->ops->peer_ops->last_deauth_received(peer); + + return NULL; +} + +/** + * cdp_peer_is_vdev_restore_last_peer() - restore last peer + * @soc - data path soc handle + * @peer - peer instance pointer + * + * restore last peer + * + * Return: true, restore success + * fasle, restore fail + */ +static inline bool +cdp_peer_is_vdev_restore_last_peer(ol_txrx_soc_handle soc, void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return false; + } + + if (soc->ops->peer_ops->is_vdev_restore_last_peer) + return soc->ops->peer_ops->is_vdev_restore_last_peer(peer); + + return false; +} + +/** + * cdp_peer_update_last_real_peer() - update last real peer + * @soc - data path soc handle + * @pdev - data path device instance + * @peer - peer instance pointer + * @peer_id - local peer id + * @restore_last_peer - restore last peer or not + * + * update last real peer + * + * Return: none + */ +static inline void +cdp_peer_update_last_real_peer(ol_txrx_soc_handle soc, void *pdev, + void *peer, uint8_t *peer_id, bool restore_last_peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->peer_ops->update_last_real_peer) + return soc->ops->peer_ops->update_last_real_peer(pdev, peer, + peer_id, restore_last_peer); + + return; +} + +/** + * ol_txrx_peer_detach_force_delete() - Detach and delete a peer's data object + * @peer - the object to detach + * + * Detach a peer and force the peer object to be removed. It is called during + * roaming scenario when the firmware has already deleted a peer. + * Peer object is freed immediately to avoid duplicate peers during roam sync + * indication processing. + * + * Return: None + */ +static inline void cdp_peer_detach_force_delete(ol_txrx_soc_handle soc, + void *peer) +{ + if (!soc || !soc->ops || !soc->ops->peer_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->peer_ops->peer_detach_force_delete) + return soc->ops->peer_ops->peer_detach_force_delete(peer); + + return; +} #endif /* _CDP_TXRX_PEER_H_ */ diff --git a/dp/inc/cdp_txrx_pmf.h b/dp/inc/cdp_txrx_pmf.h index 42218c77cf..f787a8f26c 100644 --- a/dp/inc/cdp_txrx_pmf.h +++ b/dp/inc/cdp_txrx_pmf.h @@ -28,7 +28,8 @@ #define _CDP_TXRX_PMF_H_ /** - * ol_txrx_get_pn_info() - Returns pn info from peer + * cdp_get_pn_info() - Returns pn info from peer + * @soc - data path soc handle * @peer: handle to peer * @last_pn_valid: return last_rmf_pn_valid value from peer. * @last_pn: return last_rmf_pn value from peer. @@ -36,7 +37,20 @@ * * Return: NONE */ -void -ol_txrx_get_pn_info(ol_txrx_peer_handle peer, uint8_t **last_pn_valid, - uint64_t **last_pn, uint32_t **rmf_pn_replays); +static inline void +cdp_get_pn_info(ol_txrx_soc_handle soc, void *peer, uint8_t **last_pn_valid, + uint64_t **last_pn, uint32_t **rmf_pn_replays) +{ + if (!soc || !soc->ops || !soc->ops->pmf_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->pmf_ops->get_pn_info) + return soc->ops->pmf_ops->get_pn_info( + peer, last_pn_valid, last_pn, rmf_pn_replays); + + return; +} #endif /* _CDP_TXRX_PMF_H_ */ diff --git a/dp/inc/cdp_txrx_stats.h b/dp/inc/cdp_txrx_stats.h index 419282008f..142fb73d74 100644 --- a/dp/inc/cdp_txrx_stats.h +++ b/dp/inc/cdp_txrx_stats.h @@ -31,9 +31,31 @@ */ #ifndef _CDP_TXRX_STATS_H_ #define _CDP_TXRX_STATS_H_ +#include -void ol_txrx_display_stats(uint16_t bitmap); -void ol_txrx_clear_stats(uint16_t bitmap); -int ol_txrx_stats(uint8_t vdev_id, char *buffer, unsigned buf_len); +static inline void +cdp_display_stats(ol_txrx_soc_handle soc, uint16_t bitmap) +{ + if (soc->ops->mob_stats_ops->display_stats) + return soc->ops->mob_stats_ops->display_stats(bitmap); + return; +} + +static inline void +cdp_clear_stats(ol_txrx_soc_handle soc, uint16_t bitmap) +{ + if (soc->ops->mob_stats_ops->clear_stats) + return soc->ops->mob_stats_ops->clear_stats(bitmap); + return; +} + +static inline int +cdp_stats(ol_txrx_soc_handle soc, uint8_t vdev_id, char *buffer, + unsigned buf_len) +{ + if (soc->ops->mob_stats_ops->stats) + return soc->ops->mob_stats_ops->stats(vdev_id, buffer, buf_len); + return 0; +} #endif /* _CDP_TXRX_STATS_H_ */ diff --git a/dp/inc/cdp_txrx_tx_delay.h b/dp/inc/cdp_txrx_tx_delay.h index c1b3ce7a46..4d410ed243 100644 --- a/dp/inc/cdp_txrx_tx_delay.h +++ b/dp/inc/cdp_txrx_tx_delay.h @@ -32,45 +32,105 @@ #ifndef _CDP_TXRX_COMPUTE_TX_DELAY_H_ #define _CDP_TXRX_COMPUTE_TX_DELAY_H_ -#ifdef QCA_COMPUTE_TX_DELAY -void -ol_tx_delay(ol_txrx_pdev_handle pdev, uint32_t *queue_delay_microsec, - uint32_t *tx_delay_microsec, int category); -void -ol_tx_delay_hist(ol_txrx_pdev_handle pdev, - uint16_t *bin_values, int category); -void -ol_tx_packet_count(ol_txrx_pdev_handle pdev, uint16_t *out_packet_count, - uint16_t *out_packet_loss_count, int category); -void ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev, - uint32_t interval); -#else +/** + * cdp_tx_delay() - get tx packet delay + * @soc: data path soc handle + * @pdev: physical device instance + * @queue_delay_microsec: tx packet delay within queue, usec + * @tx_delay_microsec: tx packet delay, usec + * @category: packet catagory + * + * Return: NONE + */ static inline void -ol_tx_delay(ol_txrx_pdev_handle pdev, uint32_t *queue_delay_microsec, - uint32_t *tx_delay_microsec, int category) +cdp_tx_delay(ol_txrx_soc_handle soc, void *pdev, + uint32_t *queue_delay_microsec, uint32_t *tx_delay_microsec, + int category) { + if (!soc || !soc->ops || !soc->ops->delay_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->delay_ops->tx_delay) + return soc->ops->delay_ops->tx_delay(pdev, + queue_delay_microsec, tx_delay_microsec, category); return; } +/** + * cdp_tx_delay_hist() - get tx packet delay histogram + * @soc: data path soc handle + * @pdev: physical device instance + * @bin_values: bin + * @category: packet catagory + * + * Return: NONE + */ static inline void -ol_tx_delay_hist(ol_txrx_pdev_handle pdev, - uint16_t *bin_values, int category) +cdp_tx_delay_hist(ol_txrx_soc_handle soc, void *pdev, + uint16_t *bin_values, int category) { + if (!soc || !soc->ops || !soc->ops->delay_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->delay_ops->tx_delay_hist) + return soc->ops->delay_ops->tx_delay_hist(pdev, + bin_values, category); return; } +/** + * cdp_tx_packet_count() - get tx packet count + * @soc: data path soc handle + * @pdev: physical device instance + * @out_packet_loss_count: packet loss count + * @category: packet catagory + * + * Return: NONE + */ static inline void -ol_tx_packet_count(ol_txrx_pdev_handle pdev, uint16_t *out_packet_count, - uint16_t *out_packet_loss_count, int category) +cdp_tx_packet_count(ol_txrx_soc_handle soc, void *pdev, + uint16_t *out_packet_count, uint16_t *out_packet_loss_count, + int category) { + if (!soc || !soc->ops || !soc->ops->delay_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->delay_ops->tx_packet_count) + return soc->ops->delay_ops->tx_packet_count(pdev, + out_packet_count, out_packet_loss_count, category); return; } +/** + * cdp_tx_set_compute_interval() - set tx packet stat compute interval + * @soc: data path soc handle + * @pdev: physical device instance + * @interval: compute interval + * + * Return: NONE + */ static inline void -ol_tx_set_compute_interval(ol_txrx_pdev_handle pdev, uint32_t interval) +cdp_tx_set_compute_interval(ol_txrx_soc_handle soc, void *pdev, + uint32_t interval) { + if (!soc || !soc->ops || !soc->ops->delay_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->delay_ops->tx_set_compute_interval) + return soc->ops->delay_ops->tx_set_compute_interval(pdev, + interval); return; } -#endif - #endif /* _CDP_TXRX_COMPUTE_TX_DELAY_H_ */ diff --git a/dp/inc/cdp_txrx_tx_throttle.h b/dp/inc/cdp_txrx_tx_throttle.h index b48f31dafe..0ef3a13eb2 100644 --- a/dp/inc/cdp_txrx_tx_throttle.h +++ b/dp/inc/cdp_txrx_tx_throttle.h @@ -32,24 +32,53 @@ */ #ifndef _CDP_TXRX_TX_THROTTLE_H_ #define _CDP_TXRX_TX_THROTTLE_H_ +#include -#if defined(QCA_SUPPORT_TX_THROTTLE) -void ol_tx_throttle_init_period(struct ol_txrx_pdev_t *pdev, int period, - uint8_t *dutycycle_level); - -void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev, int level); -#else -static inline void ol_tx_throttle_set_level(struct ol_txrx_pdev_t *pdev, - int level) +/** + * cdp_throttle_init_period() - init tx throttle period + * @soc: data path soc handle + * @pdev: physical device instance + * @period: throttle period + * @dutycycle_level: duty cycle level + * + * Return: NONE + */ +static inline void +cdp_throttle_init_period(ol_txrx_soc_handle soc, void *pdev, int period, + uint8_t *dutycycle_level) { - /* no-op */ + if (!soc || !soc->ops || !soc->ops->throttle_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->throttle_ops->throttle_init_period) + return soc->ops->throttle_ops->throttle_init_period(pdev, + period, dutycycle_level); + return; } -static inline void ol_tx_throttle_init_period(struct ol_txrx_pdev_t *pdev, - int period, - uint8_t *dutycycle_level) +/** + * cdp_throttle_init_period() - init tx throttle period + * @soc: data path soc handle + * @pdev: physical device instance + * @level: throttle level + * + * Return: NONE + */ +static inline void +cdp_throttle_set_level(ol_txrx_soc_handle soc, void *pdev, int level) { - /* no-op */ + if (!soc || !soc->ops || !soc->ops->throttle_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + + if (soc->ops->throttle_ops->throttle_set_level) + return soc->ops->throttle_ops->throttle_set_level(pdev, level); + return; } -#endif + #endif /* _CDP_TXRX_TX_THROTTLE_H_ */ diff --git a/dp/inc/cdp_txrx_wds.h b/dp/inc/cdp_txrx_wds.h index 6e74c5e0d4..80d78b9f92 100644 --- a/dp/inc/cdp_txrx_wds.h +++ b/dp/inc/cdp_txrx_wds.h @@ -47,6 +47,12 @@ cdp_set_wds_rx_policy(ol_txrx_soc_handle soc, void *vdev, u_int32_t val) { + if (!soc || !soc->ops || !soc->ops->wds_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return; + } + if (soc->ops->wds_ops->txrx_set_wds_rx_policy) return soc->ops->wds_ops->txrx_set_wds_rx_policy(vdev, val); return;