Google Git
Sign in
coral / imx-board-wlan-src / 4d163fd6345e66b7f1c097da4d24036368c9ea59 / . / CORE / HDD / inc / wlan_hdd_main.h
blob: b761d524b03fc9651e06d2644aa81ab365aef38c [file] [log] [blame]
/*
* Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
*
* 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
#if !defined( WLAN_HDD_MAIN_H )
#define WLAN_HDD_MAIN_H
/**===========================================================================
\file WLAN_HDD_MAIN_H.h
\brief Linux HDD Adapter Type
==========================================================================*/
/*---------------------------------------------------------------------------
Include files
-------------------------------------------------------------------------*/
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/cfg80211.h>
#include <vos_list.h>
#include <vos_types.h>
#include "sirMacProtDef.h"
#include "csrApi.h"
#include <wlan_hdd_assoc.h>
#include <wlan_hdd_dp_utils.h>
#include <wlan_hdd_wmm.h>
#include <wlan_hdd_cfg.h>
#include <linux/spinlock.h>
#include <wlan_hdd_ftm.h>
#ifdef FEATURE_WLAN_TDLS
#include "wlan_hdd_tdls.h"
#endif
#include "wlan_hdd_cfg80211.h"
#include <adf_os_defer.h>
#ifdef WLAN_FEATURE_MBSSID
#include "sapApi.h"
#endif
#include "wlan_hdd_nan_datapath.h"
#include "tl_shim.h"
/*---------------------------------------------------------------------------
Preprocessor definitions and constants
-------------------------------------------------------------------------*/
/** Number of Tx Queues */
#define NUM_TX_QUEUES 4
/** HDD's internal Tx Queue Length. Needs to be a power of 2 */
#define HDD_TX_QUEUE_MAX_LEN 128
/** HDD internal Tx Queue Low Watermark. Net Device TX queue is disabled
* when HDD queue becomes full. This Low watermark is used to enable
* the Net Device queue again */
#define HDD_TX_QUEUE_LOW_WATER_MARK (HDD_TX_QUEUE_MAX_LEN*3/4)
/** Length of the TX queue for the netdev */
#define HDD_NETDEV_TX_QUEUE_LEN (3000)
/** Hdd Tx Time out value */
#ifdef LIBRA_LINUX_PC
#define HDD_TX_TIMEOUT (8000)
#else
#define HDD_TX_TIMEOUT msecs_to_jiffies(5000)
#endif
/** Hdd Default MTU */
#define HDD_DEFAULT_MTU (1500)
#ifdef QCA_CONFIG_SMP
#define NUM_CPUS NR_CPUS
#else
#define NUM_CPUS 1
#endif
/**event flags registered net device*/
#define NET_DEVICE_REGISTERED (0)
#define SME_SESSION_OPENED (1)
#define INIT_TX_RX_SUCCESS (2)
#define WMM_INIT_DONE (3)
#define SOFTAP_BSS_STARTED (4)
#define DEVICE_IFACE_OPENED (5)
#define TDLS_INIT_DONE (6)
#define ACS_PENDING (7)
#define SOFTAP_INIT_DONE (8)
/* HDD global event flags */
#define ACS_IN_PROGRESS (0)
/** Maximum time(ms)to wait for disconnect to complete **/
#define WLAN_WAIT_TIME_DISCONNECT 5000
#define WLAN_WAIT_DISCONNECT_ALREADY_IN_PROGRESS 1000
#define WLAN_WAIT_TIME_STATS 800
#define WLAN_WAIT_TIME_POWER 800
#define WLAN_WAIT_TIME_COUNTRY 1000
#define WLAN_WAIT_TIME_LINK_STATUS 800
/* Amount of time to wait for sme close session callback.
This value should be larger than the timeout used by WDI to wait for
a response from WCNSS */
#define WLAN_WAIT_TIME_SESSIONOPENCLOSE 15000
#define WLAN_WAIT_TIME_ABORTSCAN 2000
#define WLAN_WAIT_TIME_EXTSCAN 1000
#define WLAN_WAIT_TIME_LL_STATS 800
#define WLAN_WAIT_TIME_POWER_STATS 800
#define WLAN_WAIT_SMPS_FORCE_MODE 500
/** Maximum time(ms) to wait for mc thread suspend **/
#define WLAN_WAIT_TIME_MCTHREAD_SUSPEND 1200
/** Maximum time(ms) to wait for target to be ready for suspend **/
#define WLAN_WAIT_TIME_READY_TO_SUSPEND 2000
/** Maximum time(ms) to wait for tdls add sta to complete **/
#define WAIT_TIME_TDLS_ADD_STA 1500
/** Maximum time(ms) to wait for tdls del sta to complete **/
#define WAIT_TIME_TDLS_DEL_STA 1500
/** Maximum time(ms) to wait for Link Establish Req to complete **/
#define WAIT_TIME_TDLS_LINK_ESTABLISH_REQ 1500
/** Maximum time(ms) to wait for tdls mgmt to complete **/
#define WAIT_TIME_TDLS_MGMT 11000
/** Maximum time(ms) to wait for tdls initiator to start direct communication **/
#define WAIT_TIME_TDLS_INITIATOR 600
/* Scan Req Timeout */
#define WLAN_WAIT_TIME_SCAN_REQ 100
#define WLAN_WAIT_TIME_BPF 1000
#define WLAN_WAIT_TIME_CHAIN_RSSI 1000
#define WLAN_WAIT_TIME_SET_RND 100
#define MAX_NUMBER_OF_ADAPTERS 4
#define MAX_CFG_STRING_LEN 255
#define MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
/** Mac Address string **/
#define MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC_ADDRESS_STR_LEN 18 /* Including null terminator */
#define MAX_GENIE_LEN 512
#define WLAN_CHIP_VERSION "WCNSS"
#define hddLog(level, args...) VOS_TRACE( VOS_MODULE_ID_HDD, level, ## args)
#define ENTER() VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__)
#define EXIT() VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "Exit:%s", __func__)
#define WLAN_HDD_GET_PRIV_PTR(__dev__) (hdd_adapter_t*)(netdev_priv((__dev__)))
#define MAX_EXIT_ATTEMPTS_DURING_LOGP 20
#define MAX_NO_OF_2_4_CHANNELS 14
#define WLAN_HDD_PUBLIC_ACTION_FRAME 4
#define WLAN_HDD_PUBLIC_ACTION_FRAME_OFFSET 24
#define WLAN_HDD_PUBLIC_ACTION_FRAME_BODY_OFFSET 24
#define WLAN_HDD_PUBLIC_ACTION_FRAME_TYPE_OFFSET 30
#define WLAN_HDD_PUBLIC_ACTION_FRAME_CATEGORY_OFFSET 0
#define WLAN_HDD_PUBLIC_ACTION_FRAME_ACTION_OFFSET 1
#define WLAN_HDD_PUBLIC_ACTION_FRAME_OUI_OFFSET 2
#define WLAN_HDD_PUBLIC_ACTION_FRAME_OUI_TYPE_OFFSET 5
#define WLAN_HDD_VENDOR_SPECIFIC_ACTION 0x09
#define WLAN_HDD_WFA_OUI 0x506F9A
#define WLAN_HDD_WFA_P2P_OUI_TYPE 0x09
#define WLAN_HDD_P2P_SOCIAL_CHANNELS 3
#define WLAN_HDD_P2P_SINGLE_CHANNEL_SCAN 1
#define WLAN_HDD_PUBLIC_ACTION_FRAME_SUB_TYPE_OFFSET 6
#define WLAN_HDD_IS_SOCIAL_CHANNEL(center_freq) \
(((center_freq) == 2412) || ((center_freq) == 2437) || ((center_freq) == 2462))
#define WLAN_HDD_CHANNEL_IN_UNII_1_BAND(center_freq) \
(((center_freq) == 5180 ) || ((center_freq) == 5200) \
|| ((center_freq) == 5220) || ((center_freq) == 5240))
#ifdef WLAN_FEATURE_11W
#define WLAN_HDD_SA_QUERY_ACTION_FRAME 8
#endif
#define WLAN_HDD_PUBLIC_ACTION_TDLS_DISC_RESP 14
#define WLAN_HDD_TDLS_ACTION_FRAME 12
#define WLAN_HDD_QOS_ACTION_FRAME 1
#define WLAN_HDD_QOS_MAP_CONFIGURE 4
#define HDD_SAP_WAKE_LOCK_DURATION 10000 //in msecs
#if defined(CONFIG_HL_SUPPORT)
#define HDD_MOD_EXIT_SSR_MAX_RETRIES 300
#else
#define HDD_MOD_EXIT_SSR_MAX_RETRIES 75
#endif
/* Maximum number of interfaces allowed(STA, P2P Device, P2P Interfaces) */
#ifndef WLAN_OPEN_P2P_INTERFACE
#ifdef WLAN_4SAP_CONCURRENCY
#define WLAN_MAX_INTERFACES 4
#else
#define WLAN_MAX_INTERFACES 3
#endif
#else
#define WLAN_MAX_INTERFACES 4
#endif
#ifdef WLAN_FEATURE_GTK_OFFLOAD
#define GTK_OFFLOAD_ENABLE 0
#define GTK_OFFLOAD_DISABLE 1
#endif
#define MAX_USER_COMMAND_SIZE 4096
#define HDD_MAC_ADDR_LEN 6
#define HDD_SESSION_ID_ANY 50 //This should be same as CSR_SESSION_ID_ANY
/* This should be same as CSR_ROAM_SESSION_MAX */
#define HDD_SESSION_MAX 5
#define HDD_MIN_TX_POWER (-100) // minimum tx power
#define HDD_MAX_TX_POWER (+100) // maximum tx power
/* FW expects burst duration in 1020*ms */
#define SIFS_BURST_DUR_MULTIPLIER 1020
#define SIFS_BURST_DUR_MAX 12240
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0))
#ifdef CONFIG_CNSS
#define cfg80211_vendor_cmd_reply(skb) vos_vendor_cmd_reply(skb)
#endif
#endif
/*
* NET_NAME_UNKNOWN is only introduced after Kernel 3.17, to have a macro
* here if the Kernel version is less than 3.17 to avoid the interleave
* conditional compilation.
*/
#if !(LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
#define NET_NAME_UNKNOWN 0
#endif
typedef v_U8_t tWlanHddMacAddr[HDD_MAC_ADDR_LEN];
#define HDD_BW_GET_DIFF(_x, _y) (unsigned long)((ULONG_MAX - (_y)) + (_x) + 1)
#define MAX_PROBE_REQ_OUIS 16
#define SCAN_REJECT_THRESHOLD_TIME 300000 /* Time is in msec, equal to 5 mins */
#define SCAN_REJECT_THRESHOLD 15
/*
* @eHDD_SCAN_REJECT_DEFAULT: default value
* @eHDD_CONNECTION_IN_PROGRESS: connection is in progress
* @eHDD_REASSOC_IN_PROGRESS: reassociation is in progress
* @eHDD_EAPOL_IN_PROGRESS: STA/P2P-CLI is in middle of EAPOL/WPS exchange
* @eHDD_SAP_EAPOL_IN_PROGRESS: SAP/P2P-GO is in middle of EAPOL/WPS exchange
*/
typedef enum
{
eHDD_SCAN_REJECT_DEFAULT = 0,
eHDD_CONNECTION_IN_PROGRESS,
eHDD_REASSOC_IN_PROGRESS,
eHDD_EAPOL_IN_PROGRESS,
eHDD_SAP_EAPOL_IN_PROGRESS,
} scan_reject_states;
/*
* Maximum no.of random mac addresses supported by firmware
* for transmitting management action frames
*/
#define MAX_RANDOM_MAC_ADDRS 16
/*
* Generic asynchronous request/response support
*
* Many of the APIs supported by HDD require a call to SME to
* perform an action or to retrieve some data. In most cases SME
* performs the operation asynchronously, and will execute a provided
* callback function when the request has completed. In order to
* synchronize this the HDD API allocates a context which is then
* passed to SME, and which is then, in turn, passed back to the
* callback function when the operation completes. The callback
* function then sets a completion variable inside the context which
* the HDD API is waiting on. In an ideal world the HDD API would
* wait forever (or at least for a long time) for the response to be
* received and for the completion variable to be set. However in
* most cases these HDD APIs are being invoked in the context of a
* user space thread which has invoked either a cfg80211 API or a
* wireless extensions ioctl and which has taken the kernel rtnl_lock.
* Since this lock is used to synchronize many of the kernel tasks, we
* do not want to hold it for a long time. In addition we do not want
* to block user space threads (such as the wpa supplicant's main
* thread) for an extended time. Therefore we only block for a short
* time waiting for the response before we timeout. This means that
* it is possible for the HDD API to timeout, and for the callback to
* be invoked afterwards. In order for the callback function to
* determine if the HDD API is still waiting, a magic value is also
* stored in the shared context. Only if the context has a valid
* magic will the callback routine do any work. In order to further
* synchronize these activities a spinlock is used so that if any HDD
* API timeout coincides with its callback, the operations of the two
* threads will be serialized.
*/
struct statsContext
{
struct completion completion;
hdd_adapter_t *pAdapter;
unsigned int magic;
union iwreq_data *wrqu;
char *extra;
};
struct linkspeedContext
{
struct completion completion;
hdd_adapter_t *pAdapter;
unsigned int magic;
};
/**
* struct random_mac_context - Context used with hdd_random_mac_callback
* @random_mac_completion: Event on which hdd_set_random_mac will wait
* @adapter: Pointer to adapter
* @magic: For valid context this is set to ACTION_FRAME_RANDOM_CONTEXT_MAGIC
* @set_random_addr: Status of random filter set
*/
struct random_mac_context {
struct completion random_mac_completion;
hdd_adapter_t *adapter;
unsigned int magic;
bool set_random_addr;
};
extern spinlock_t hdd_context_lock;
#define STATS_CONTEXT_MAGIC 0x53544154 //STAT
#define PEER_INFO_CONTEXT_MAGIC 0x52535349 /* PEER_INFO */
#define POWER_CONTEXT_MAGIC 0x504F5752 //POWR
#define SNR_CONTEXT_MAGIC 0x534E5200 //SNR
#define LINK_CONTEXT_MAGIC 0x4C494E4B //LINKSPEED
#define LINK_STATUS_MAGIC 0x4C4B5354 //LINKSTATUS(LNST)
#define TEMP_CONTEXT_MAGIC 0x74656d70 // TEMP (temperature)
#define FW_STATUS_MAGIC 0x46575354 /* FWSTATUS(FWST) */
#define POWER_STATS_MAGIC 0x14111990
#define BPF_CONTEXT_MAGIC 0x4575354 /* BPF */
#define ACTION_FRAME_RANDOM_CONTEXT_MAGIC 0x87878787
#define ISOLATION_CONTEXT_MAGIC 0x48575354 //Antenna Isolation
#ifdef QCA_LL_TX_FLOW_CT
/* MAX OS Q block time value in msec
* Prevent from permanent stall, resume OS Q if timer expired */
#define WLAN_HDD_TX_FLOW_CONTROL_OS_Q_BLOCK_TIME 1000
#define WLAN_SAP_HDD_TX_FLOW_CONTROL_OS_Q_BLOCK_TIME 100
#define WLAN_HDD_TX_FLOW_CONTROL_MAX_24BAND_CH 14
#endif /* QCA_LL_TX_FLOW_CT */
#define NUM_TX_RX_HISTOGRAM 1024
#define NUM_TX_RX_HISTOGRAM_MASK (NUM_TX_RX_HISTOGRAM - 1)
/**
* struct hdd_tx_rx_histogram - structure to keep track of tx and rx packets
received over 100ms intervals
* @interval_rx # of rx packets received in the last 100ms interval
* @interval_tx # of tx packets received in the last 100ms interval
* @total_rx # of total rx packets received on interface
* @total_rx # of total tx packets received on interface
* @next_vote_level cnss_bus_width_type voting level (high or low) determined
on the basis of total tx and rx packets received in the
last 100ms interval
* @next_rx_level cnss_bus_width_type voting level (high or low) determined
on the basis of rx packets received in the last 100ms
interval
* @next_tx_level cnss_bus_width_type voting level (high or low) determined
on the basis of tx packets received in the last 100ms
interval
* The structure keeps track of throughput requirements of wlan driver in 100ms
* intervals for later analysis.
*/
struct hdd_tx_rx_histogram
{
uint64_t interval_rx;
uint64_t interval_tx;
uint64_t total_rx;
uint64_t total_tx;
uint32_t next_vote_level;
uint32_t next_rx_level;
uint32_t next_tx_level;
};
typedef struct hdd_tx_rx_stats_s
{
// start_xmit stats
__u32 txXmitCalled;
__u32 txXmitDropped;
__u32 txXmitClassifiedAC[NUM_TX_QUEUES];
__u32 txXmitDroppedAC[NUM_TX_QUEUES];
// complete_cbk_stats
__u32 txCompleted;
// rx stats
__u32 rxPackets[NUM_CPUS];
__u32 rxDropped[NUM_CPUS];
__u32 rxDelivered[NUM_CPUS];
__u32 rxRefused[NUM_CPUS];
bool is_txflow_paused;
__u32 txflow_pause_cnt;
__u32 txflow_unpause_cnt;
__u32 txflow_timer_cnt;
} hdd_tx_rx_stats_t;
#ifdef WLAN_FEATURE_11W
typedef struct hdd_pmf_stats_s
{
uint8 numUnprotDeauthRx;
uint8 numUnprotDisassocRx;
} hdd_pmf_stats_t;
#endif
typedef struct hdd_stats_s
{
tCsrSummaryStatsInfo summary_stat;
tCsrGlobalClassAStatsInfo ClassA_stat;
tCsrGlobalClassBStatsInfo ClassB_stat;
tCsrGlobalClassCStatsInfo ClassC_stat;
tCsrGlobalClassDStatsInfo ClassD_stat;
tCsrPerStaStatsInfo perStaStats;
struct csr_per_chain_rssi_stats_info per_chain_rssi_stats;
hdd_tx_rx_stats_t hddTxRxStats;
#ifdef WLAN_FEATURE_11W
hdd_pmf_stats_t hddPmfStats;
#endif
} hdd_stats_t;
typedef enum
{
HDD_ROAM_STATE_NONE,
// Issuing a disconnect due to transition into low power states.
HDD_ROAM_STATE_DISCONNECTING_POWER,
// move to this state when HDD sets a key with SME/CSR. Note this is
// an important state to get right because we will get calls into our SME
// callback routine for SetKey activity that we did not initiate!
HDD_ROAM_STATE_SETTING_KEY,
} HDD_ROAM_STATE;
typedef enum
{
eHDD_SUSPEND_NONE = 0,
eHDD_SUSPEND_DEEP_SLEEP,
eHDD_SUSPEND_STANDBY,
} hdd_ps_state_t;
typedef struct roaming_info_s
{
HDD_ROAM_STATE roamingState;
vos_event_t roamingEvent;
tWlanHddMacAddr bssid;
tWlanHddMacAddr peerMac;
tANI_U32 roamId;
eRoamCmdStatus roamStatus;
v_BOOL_t deferKeyComplete;
} roaming_info_t;
#ifdef FEATURE_WLAN_WAPI
/* Define WAPI macros for Length, BKID count etc*/
#define MAX_WPI_KEY_LENGTH 16
#define MAX_NUM_PN 16
#define MAC_ADDR_LEN 6
#define MAX_ADDR_INDEX 12
#define MAX_NUM_AKM_SUITES 16
#define MAX_NUM_UNI_SUITES 16
#define MAX_NUM_BKIDS 16
/** WAPI AUTH mode definition */
enum _WAPIAuthMode
{
WAPI_AUTH_MODE_OPEN = 0,
WAPI_AUTH_MODE_PSK = 1,
WAPI_AUTH_MODE_CERT
} __packed;
typedef enum _WAPIAuthMode WAPIAuthMode;
/** WAPI Work mode structure definition */
#define WZC_ORIGINAL 0
#define WAPI_EXTENTION 1
struct _WAPI_FUNCTION_MODE
{
unsigned char wapiMode;
}__packed;
typedef struct _WAPI_FUNCTION_MODE WAPI_FUNCTION_MODE;
typedef struct _WAPI_BKID
{
v_U8_t bkid[16];
}WAPI_BKID, *pWAPI_BKID;
/** WAPI Association information structure definition */
struct _WAPI_AssocInfo
{
v_U8_t elementID;
v_U8_t length;
v_U16_t version;
v_U16_t akmSuiteCount;
v_U32_t akmSuite[MAX_NUM_AKM_SUITES];
v_U16_t unicastSuiteCount;
v_U32_t unicastSuite[MAX_NUM_UNI_SUITES];
v_U32_t multicastSuite;
v_U16_t wapiCability;
v_U16_t bkidCount;
WAPI_BKID bkidList[MAX_NUM_BKIDS];
} __packed;
typedef struct _WAPI_AssocInfo WAPI_AssocInfo;
typedef struct _WAPI_AssocInfo *pWAPI_IEAssocInfo;
/** WAPI KEY Type definition */
enum _WAPIKeyType
{
PAIRWISE_KEY, //0
GROUP_KEY //1
}__packed;
typedef enum _WAPIKeyType WAPIKeyType;
/** WAPI KEY Direction definition */
enum _KEY_DIRECTION
{
None,
Rx,
Tx,
Rx_Tx
}__packed;
typedef enum _KEY_DIRECTION WAPI_KEY_DIRECTION;
/* WAPI KEY structure definition */
struct WLAN_WAPI_KEY
{
WAPIKeyType keyType;
WAPI_KEY_DIRECTION keyDirection; /*reserved for future use*/
v_U8_t keyId;
v_U8_t addrIndex[MAX_ADDR_INDEX]; /*reserved for future use*/
int wpiekLen;
v_U8_t wpiek[MAX_WPI_KEY_LENGTH];
int wpickLen;
v_U8_t wpick[MAX_WPI_KEY_LENGTH];
v_U8_t pn[MAX_NUM_PN]; /*reserved for future use*/
}__packed;
typedef struct WLAN_WAPI_KEY WLAN_WAPI_KEY;
typedef struct WLAN_WAPI_KEY *pWLAN_WAPI_KEY;
#define WPA_GET_LE16(a) ((u16) (((a)[1] << 8) | (a)[0]))
#define WPA_GET_BE24(a) ((u32) ( (a[0] << 16) | (a[1] << 8) | a[2]))
#define WLAN_EID_WAPI 68
#define WAPI_PSK_AKM_SUITE 0x02721400
#define WAPI_CERT_AKM_SUITE 0x01721400
/* WAPI BKID List structure definition */
struct _WLAN_BKID_LIST
{
v_U32_t length;
v_U32_t BKIDCount;
WAPI_BKID BKID[1];
}__packed;
typedef struct _WLAN_BKID_LIST WLAN_BKID_LIST;
typedef struct _WLAN_BKID_LIST *pWLAN_BKID_LIST;
/* WAPI Information structure definition */
struct hdd_wapi_info_s
{
v_U32_t nWapiMode;
v_BOOL_t fIsWapiSta;
v_MACADDR_t cachedMacAddr;
v_UCHAR_t wapiAuthMode;
}__packed;
typedef struct hdd_wapi_info_s hdd_wapi_info_t;
#endif /* FEATURE_WLAN_WAPI */
typedef struct beacon_data_s {
u8 *head;
u8 *tail;
u8 *proberesp_ies;
u8 *assocresp_ies;
int head_len;
int tail_len;
int proberesp_ies_len;
int assocresp_ies_len;
int dtim_period;
} beacon_data_t;
typedef enum device_mode
{ /* MAINTAIN 1 - 1 CORRESPONDENCE WITH tVOS_CON_MODE*/
WLAN_HDD_INFRA_STATION,
WLAN_HDD_SOFTAP,
WLAN_HDD_P2P_CLIENT,
WLAN_HDD_P2P_GO,
WLAN_HDD_MONITOR,
WLAN_HDD_FTM,
WLAN_HDD_IBSS,
WLAN_HDD_P2P_DEVICE,
WLAN_HDD_OCB,
WLAN_HDD_NDI
} device_mode_t;
#define WLAN_HDD_VDEV_STA_MAX 2
typedef enum rem_on_channel_request_type
{
REMAIN_ON_CHANNEL_REQUEST,
OFF_CHANNEL_ACTION_TX,
}rem_on_channel_request_type_t;
/* Thermal mitigation Level Enum Type */
typedef enum
{
WLAN_HDD_TM_LEVEL_0,
WLAN_HDD_TM_LEVEL_1,
WLAN_HDD_TM_LEVEL_2,
WLAN_HDD_TM_LEVEL_3,
WLAN_HDD_TM_LEVEL_4,
WLAN_HDD_TM_LEVEL_MAX
} WLAN_TmLevelEnumType;
/* Driver Action based on thermal mitigation level structure */
typedef struct
{
v_BOOL_t ampduEnable;
v_BOOL_t enterImps;
v_U32_t txSleepDuration;
v_U32_t txOperationDuration;
v_U32_t txBlockFrameCountThreshold;
} hdd_tmLevelAction_t;
/* Thermal Mitigation control context structure */
typedef struct
{
WLAN_TmLevelEnumType currentTmLevel;
hdd_tmLevelAction_t tmAction;
vos_timer_t txSleepTimer;
struct mutex tmOperationLock;
vos_event_t setTmDoneEvent;
v_U32_t txFrameCount;
v_TIME_t lastblockTs;
v_TIME_t lastOpenTs;
struct netdev_queue *blockedQueue;
v_BOOL_t qBlocked;
} hdd_thermal_mitigation_info_t;
typedef struct action_pkt_buffer
{
tANI_U8* frame_ptr;
tANI_U32 frame_length;
tANI_U16 freq;
}action_pkt_buffer_t;
typedef struct hdd_remain_on_chan_ctx
{
struct net_device *dev;
struct ieee80211_channel chan;
enum nl80211_channel_type chan_type;
unsigned int duration;
u64 cookie;
rem_on_channel_request_type_t rem_on_chan_request;
v_U32_t p2pRemOnChanTimeStamp;
vos_timer_t hdd_remain_on_chan_timer;
action_pkt_buffer_t action_pkt_buff;
v_BOOL_t hdd_remain_on_chan_cancel_in_progress;
}hdd_remain_on_chan_ctx_t;
/* RoC Request entry */
typedef struct hdd_roc_req
{
hdd_list_node_t node; /* MUST be first element */
hdd_adapter_t *pAdapter;
hdd_remain_on_chan_ctx_t *pRemainChanCtx;
}hdd_roc_req_t;
typedef enum{
HDD_IDLE,
HDD_PD_REQ_ACK_PENDING,
HDD_GO_NEG_REQ_ACK_PENDING,
HDD_INVALID_STATE,
}eP2PActionFrameState;
typedef enum {
WLAN_HDD_GO_NEG_REQ,
WLAN_HDD_GO_NEG_RESP,
WLAN_HDD_GO_NEG_CNF,
WLAN_HDD_INVITATION_REQ,
WLAN_HDD_INVITATION_RESP,
WLAN_HDD_DEV_DIS_REQ,
WLAN_HDD_DEV_DIS_RESP,
WLAN_HDD_PROV_DIS_REQ,
WLAN_HDD_PROV_DIS_RESP,
WLAN_HDD_ACTION_FRM_TYPE_MAX = 255,
}tActionFrmType;
typedef struct hdd_cfg80211_state_s
{
tANI_U16 current_freq;
u64 action_cookie;
tANI_U8 *buf;
size_t len;
hdd_remain_on_chan_ctx_t* remain_on_chan_ctx;
struct mutex remain_on_chan_ctx_lock;
eP2PActionFrameState actionFrmState;
/* is_go_neg_ack_received flag is set to 1 when
* the pending ack for GO negotiation req is
* received.
*/
v_BOOL_t is_go_neg_ack_received;
}hdd_cfg80211_state_t;
typedef enum{
HDD_SSR_NOT_REQUIRED,
HDD_SSR_REQUIRED,
HDD_SSR_DISABLED,
}e_hdd_ssr_required;
/**
* struct hdd_mon_set_ch_info - Holds monitor mode channel switch params
* @channel: Channel number.
* @cb_mode: Channel bonding
* @channel_width: Channel width 0/1/2 for 20/40/80MHz respectively.
* @phy_mode: PHY mode
*/
struct hdd_mon_set_ch_info {
uint8_t channel;
uint8_t cb_mode;
uint32_t channel_width;
eCsrPhyMode phy_mode;
};
/**
* struct action_frame_cookie - Action frame cookie item in cookie list
* @cookie_node: List item
* @cookie: Cookie value
*/
struct action_frame_cookie {
struct list_head cookie_node;
uint64_t cookie;
};
/**
* struct action_frame_random_mac - Action Frame random mac addr & related attrs
* @in_use: Checks whether random mac is in use
* @addr: Contains random mac addr
* @cookie_list: List of cookies tied with random mac
*/
struct action_frame_random_mac {
bool in_use;
uint8_t addr[VOS_MAC_ADDR_SIZE];
struct list_head cookie_list;
};
struct hdd_station_ctx
{
/** Handle to the Wireless Extension State */
hdd_wext_state_t WextState;
#ifdef FEATURE_WLAN_TDLS
tdlsCtx_t *pHddTdlsCtx;
#endif
/**Connection information*/
connection_info_t conn_info;
roaming_info_t roam_info;
#if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_LFR)
int ft_carrier_on;
#endif
#ifdef WLAN_FEATURE_GTK_OFFLOAD
tSirGtkOffloadParams gtkOffloadReqParams;
#endif
/*Increment whenever ibss New peer joins and departs the network */
int ibss_sta_generation;
/* Indication of wep/wpa-none keys installation */
v_BOOL_t ibss_enc_key_installed;
/*Save the wep/wpa-none keys*/
tCsrRoamSetKey ibss_enc_key;
tSirPeerInfoRspParams ibss_peer_info;
v_BOOL_t hdd_ReassocScenario;
/* STA ctx debug variables */
int staDebugState;
struct hdd_mon_set_ch_info ch_info;
#ifdef WLAN_FEATURE_NAN_DATAPATH
struct nan_datapath_ctx ndp_ctx;
#endif
uint8_t broadcast_staid;
};
#define BSS_STOP 0
#define BSS_START 1
typedef struct hdd_hostapd_state_s
{
int bssState;
vos_event_t vosEvent;
vos_event_t stop_bss_event;
vos_event_t sta_disassoc_event;
VOS_STATUS vosStatus;
v_BOOL_t bCommit;
} hdd_hostapd_state_t;
/**
* enum bss_stop_reason - reasons why a BSS is stopped.
* @BSS_STOP_REASON_INVALID: no reason specified explicitly.
* @BSS_STOP_DUE_TO_MCC_SCC_SWITCH: BSS stopped due to host
* driver is trying to switch AP role to a different channel
* to maintain SCC mode with the STA role on the same card.
* this usually happens when STA is connected to an external
* AP that runs on a different channel
*/
enum bss_stop_reason
{
BSS_STOP_REASON_INVALID = 0,
BSS_STOP_DUE_TO_MCC_SCC_SWITCH = 1,
};
/*
* Per station structure kept in HDD for multiple station support for SoftAP
*/
typedef struct {
/** The station entry is used or not */
v_BOOL_t isUsed;
/** Station ID reported back from HAL (through SAP). Broadcast
* uses station ID zero by default in both libra and volans. */
v_U8_t ucSTAId;
/** MAC address of the station */
v_MACADDR_t macAddrSTA;
/** Current Station state so HDD knows how to deal with packet
* queue. Most recent states used to change TL STA state. */
WLANTL_STAStateType tlSTAState;
/** Transmit queues for each AC (VO,VI,BE etc). */
hdd_list_t wmm_tx_queue[NUM_TX_QUEUES];
/** Might need to differentiate queue depth in contention case */
v_U16_t aTxQueueDepth[NUM_TX_QUEUES];
/**Track whether OS TX queue has been disabled.*/
v_BOOL_t txSuspended[NUM_TX_QUEUES];
/**Track whether 3/4th of resources are used */
v_BOOL_t vosLowResource;
/** Track QoS status of station */
v_BOOL_t isQosEnabled;
/** The station entry for which Deauth is in progress */
v_BOOL_t isDeauthInProgress;
/** Number of spatial streams supported */
uint8_t nss;
/** Rate Flags for this connection */
uint32_t rate_flags;
/** SUB 20 Bandwidth Flags */
uint8_t sub20_dynamic_channelwidth;
/** Extended CSA capabilities */
uint8_t ecsa_capable;
/** Max phy rate */
uint32_t max_phy_rate;
/** Tx packets */
uint32_t tx_packets;
/** Tx bytes */
uint64_t tx_bytes;
/** Rx packets */
uint32_t rx_packets;
/** Rx bytes */
uint64_t rx_bytes;
/** Last tx/rx timestamp */
adf_os_time_t last_tx_rx_ts;
/** Assoc timestamp */
adf_os_time_t assoc_ts;
/** Tx Rate */
uint32_t tx_rate;
/** Rx Rate */
uint32_t rx_rate;
/** Ampdu */
bool ampdu;
/** Short GI */
bool sgi_enable;
/** Tx stbc */
bool tx_stbc;
/** Rx stbc */
bool rx_stbc;
/** Channel Width */
uint8_t ch_width;
/** Mode */
uint8_t mode;
/** Max supported idx */
uint8_t max_supp_idx;
/** Max extended idx */
uint8_t max_ext_idx;
/** HT max mcs idx */
uint8_t max_mcs_idx;
/** VHT rx mcs map */
uint8_t rx_mcs_map;
/** VHT tx mcs map */
uint8_t tx_mcs_map;
} hdd_station_info_t;
/**
* struct hdd_rate_info - rate_info in HDD
* @rate: tx/rx rate (kbps)
* @mode: 0->11abg legacy, 1->HT, 2->VHT (refer to sir_sme_phy_mode)
* @nss: number of streams
* @mcs: mcs index for HT/VHT mode
* @rate_flags: rate flags for last tx/rx
*
* rate info in HDD
*/
struct hdd_rate_info {
uint32_t rate;
uint8_t mode;
uint8_t nss;
uint8_t mcs;
uint8_t rate_flags;
};
/**
* struct hdd_fw_txrx_stats - fw txrx status in HDD
* (refer to station_info struct in Kernel)
* @tx_packets: packets transmitted to this station
* @tx_bytes: bytes transmitted to this station
* @rx_packets: packets received from this station
* @rx_bytes: bytes received from this station
* @rx_retries: cumulative retry counts
* @tx_failed: number of failed transmissions
* @rssi: The signal strength (dbm)
* @tx_rate: last used tx rate info
* @rx_rate: last used rx rate info
*
* fw txrx status in HDD
*/
struct hdd_fw_txrx_stats {
uint32_t tx_packets;
uint64_t tx_bytes;
uint32_t rx_packets;
uint64_t rx_bytes;
uint32_t tx_retries;
uint32_t tx_failed;
int8_t rssi;
struct hdd_rate_info tx_rate;
struct hdd_rate_info rx_rate;
};
struct hdd_ap_ctx_s
{
hdd_hostapd_state_t HostapdState;
// Memory differentiation mode is enabled
//v_U16_t uMemoryDiffThreshold;
//v_U8_t uNumActiveAC;
//v_U8_t uActiveACMask;
//v_U8_t aTxQueueLimit[NUM_TX_QUEUES];
/** Packet Count to update uNumActiveAC and uActiveACMask */
//v_U16_t uUpdatePktCount;
/** Station ID assigned after BSS starts */
v_U8_t uBCStaId;
v_U8_t uPrivacy; // The privacy bits of configuration
tSirWPSPBCProbeReq WPSPBCProbeReq;
tsap_Config_t sapConfig;
struct semaphore semWpsPBCOverlapInd;
v_BOOL_t apDisableIntraBssFwd;
vos_timer_t hdd_ap_inactivity_timer;
v_U8_t operatingChannel;
v_BOOL_t uIsAuthenticated;
eCsrEncryptionType ucEncryptType;
//This will point to group key data, if it is received before start bss.
tCsrRoamSetKey groupKey;
// This will have WEP key data, if it is received before start bss
tCsrRoamSetKey wepKey[CSR_MAX_NUM_KEY];
/* WEP default key index */
uint8_t wep_def_key_idx;
beacon_data_t *beacon;
v_BOOL_t bApActive;
#ifdef WLAN_FEATURE_MBSSID
/* SAP Context */
v_PVOID_t sapContext;
#endif
v_BOOL_t dfs_cac_block_tx;
enum bss_stop_reason bss_stop_reason;
/* Fw txrx stats info */
struct hdd_fw_txrx_stats txrx_stats;
};
typedef struct hdd_scaninfo_s
{
/* The scan id */
v_U32_t scanId;
/* The scan pending */
v_U32_t mScanPending;
/* Counter for mScanPending so that the scan pending
error log is not printed for more than 5 times */
v_U32_t mScanPendingCounter;
/* Client Wait Scan Result */
v_U32_t waitScanResult;
/* Additional IE for scan */
tSirAddie scanAddIE;
/* Scan mode*/
tSirScanType scan_mode;
/* Scan Completion Event */
struct completion scan_req_completion_event;
/* completion variable for abortscan */
struct completion abortscan_event_var;
vos_event_t scan_finished_event;
hdd_scan_pending_option_e scan_pending_option;
}hdd_scaninfo_t;
#ifdef WLAN_FEATURE_PACKET_FILTERING
typedef struct multicast_addr_list
{
v_U8_t isFilterApplied;
v_U8_t mc_cnt;
v_U8_t *addr;
} t_multicast_add_list;
#endif
/*
* WLAN_HDD_ADAPTER_MAGIC is a magic number used to identify net devices
* belonging to this driver from net devices belonging to other devices.
* Therefore, the magic number must be unique relative to the numbers for
* other drivers in the system. If WLAN_HDD_ADAPTER_MAGIC is already defined
* (e.g. by compiler argument), then use that. If it's not already defined,
* then use the first 4 characters of MULTI_IF_NAME to construct the magic
* number. If MULTI_IF_NAME is not defined, then use a default magic number.
*/
#ifndef WLAN_HDD_ADAPTER_MAGIC
#ifdef MULTI_IF_NAME
#define WLAN_HDD_ADAPTER_MAGIC \
(MULTI_IF_NAME[0] == 0 ? 0x574c414e : \
(MULTI_IF_NAME[1] == 0 ? (MULTI_IF_NAME[0] << 24) : \
(MULTI_IF_NAME[2] == 0 ? (MULTI_IF_NAME[0] << 24) | \
(MULTI_IF_NAME[1] << 16) : \
(MULTI_IF_NAME[0] << 24) | (MULTI_IF_NAME[1] << 16) | \
(MULTI_IF_NAME[2] << 8) | MULTI_IF_NAME[3])))
#else
#define WLAN_HDD_ADAPTER_MAGIC 0x574c414e //ASCII "WLAN"
#endif
#endif
/**
* struct hdd_runtime_pm_context - context to prevent/allow runtime pm
* @scan: scan context to prevent/allow runtime pm
* @roc : remain on channel runtime pm context
* @dfs : Dynamic frequency selection runtime pm context
* @obss: Obss protection runtime pm context
*
* Prevent Runtime PM for scan, roc and dfs.
*/
struct hdd_runtime_pm_context {
void *scan;
void *roc;
void *dfs;
void *obss;
};
/**
* struct hdd_adapter_pm_context - Context/Adapter to prevent/allow runtime pm
* @connect : Connect context per adapter
*
* Structure to hold runtime pm contexts for each adapter
*/
struct hdd_adapter_pm_context {
void *connect;
};
#define WLAN_HDD_MAX_HISTORY_ENTRY 10
/**
* struct hdd_netif_queue_stats - netif queue operation statistics
* @pause_count - pause counter
* @unpause_count - unpause counter
*/
struct hdd_netif_queue_stats {
uint16_t pause_count;
uint16_t unpause_count;
};
/**
* struct hdd_netif_queue_history - netif queue operation history
* @time: timestamp
* @netif_action: action type
* @netif_reason: reason type
* @pause_map: pause map
*/
struct hdd_netif_queue_history {
vos_time_t time;
uint16_t netif_action;
uint16_t netif_reason;
uint32_t pause_map;
};
struct hdd_adapter_s
{
/* Magic cookie for adapter sanity verification. Note that this
* needs to be at the beginning of the private data structure so
* that it will exists at the beginning of dev->priv and hence
* will always be in mapped memory
*/
v_U32_t magic;
void *pHddCtx;
/** Handle to the network device */
struct net_device *dev;
device_mode_t device_mode;
/** IPv4 notifier callback for handling ARP offload on change in IP */
struct work_struct ipv4NotifierWorkQueue;
#ifdef WLAN_NS_OFFLOAD
/** IPv6 notifier callback for handling NS offload on change in IP */
struct work_struct ipv6NotifierWorkQueue;
#endif
//TODO Move this to sta Ctx
struct wireless_dev wdev ;
struct cfg80211_scan_request *request ;
/** ops checks if Opportunistic Power Save is Enable or Not
* ctw stores ctWindow value once we receive Opps command from
* wpa_supplicant then using ctWindow value we need to Enable
* Opportunistic Power Save
*/
tANI_U8 ops;
tANI_U32 ctw;
/** Current MAC Address for the adapter */
v_MACADDR_t macAddressCurrent;
/**Event Flags*/
unsigned long event_flags;
/**Device TX/RX statistics*/
struct net_device_stats stats;
/** HDD statistics*/
hdd_stats_t hdd_stats;
/** linkspeed statistics */
tSirLinkSpeedInfo ls_stats;
/**Mib information*/
sHddMib_t hdd_mib;
tANI_U8 sessionId;
#ifdef FEATURE_WLAN_THERMAL_SHUTDOWN
bool netif_carrier_on;
#endif
/* Completion variable for session close */
struct completion session_close_comp_var;
/* Completion variable for session open */
struct completion session_open_comp_var;
/* Completion variable for smps force mode command */
struct completion smps_force_mode_comp_var;
int8_t smps_force_mode_status;
//TODO: move these to sta ctx. These may not be used in AP
/** completion variable for disconnect callback */
struct completion disconnect_comp_var;
/** Completion of change country code */
struct completion change_country_code;
/* completion variable for Linkup Event */
struct completion linkup_event_var;
/* completion variable for cancel remain on channel Event */
struct completion cancel_rem_on_chan_var;
/* completion variable for off channel remain on channel Event */
struct completion offchannel_tx_event;
/* Completion variable for action frame */
struct completion tx_action_cnf_event;
/* Completion variable for remain on channel ready */
struct completion rem_on_chan_ready_event;
/* Completion variable for Upper Layer Authentication */
struct completion ula_complete;
#ifdef FEATURE_WLAN_TDLS
struct completion tdls_add_station_comp;
struct completion tdls_del_station_comp;
struct completion tdls_mgmt_comp;
struct completion tdls_link_establish_req_comp;
eHalStatus tdlsAddStaStatus;
#endif
struct completion ibss_peer_info_comp;
/* Track whether the linkup handling is needed */
v_BOOL_t isLinkUpSvcNeeded;
/* Mgmt Frames TX completion status code */
tANI_U32 mgmtTxCompletionStatus;
/*************************************************************
* Tx Queues
*/
/** Transmit queues for each AC (VO,VI,BE etc) */
hdd_list_t wmm_tx_queue[NUM_TX_QUEUES];
/**Track whether VOS is in a low resource state*/
v_BOOL_t isVosOutOfResource;
/**Track whether 3/4th of resources are used */
v_BOOL_t isVosLowResource;
/**Track whether OS TX queue has been disabled.*/
v_BOOL_t isTxSuspended[NUM_TX_QUEUES];
/** WMM Status */
hdd_wmm_status_t hddWmmStatus;
/*************************************************************
*/
/*************************************************************
* TODO - Remove it later
*/
/** Multiple station supports */
/** Per-station structure */
spinlock_t staInfo_lock; //To protect access to station Info
hdd_station_info_t aStaInfo[WLAN_MAX_STA_COUNT];
//v_U8_t uNumActiveStation;
v_U16_t aTxQueueLimit[NUM_TX_QUEUES];
/*************************************************************
*/
#ifdef FEATURE_WLAN_WAPI
hdd_wapi_info_t wapi_info;
#endif
v_S7_t rssi;
int8_t rssi_on_disconnect;
#ifdef WLAN_FEATURE_LPSS
v_BOOL_t rssi_send;
#endif
tANI_U8 snr;
struct work_struct monTxWorkQueue;
struct sk_buff *skb_to_tx;
union {
hdd_station_ctx_t station;
hdd_ap_ctx_t ap;
}sessionCtx;
#ifdef WLAN_FEATURE_TSF
/* tsf value get from firmware */
uint64_t cur_target_time;
vos_timer_t host_capture_req_timer;
#ifdef WLAN_FEATURE_TSF_PLUS
/* spin lock for read/write timestamps */
spinlock_t host_target_sync_lock;
vos_timer_t host_target_sync_timer;
uint64_t cur_host_time;
uint64_t last_host_time;
uint64_t last_target_time;
/* to store the count of continuous invalid tstamp-pair */
int continuous_error_count;
/* to indicate whether tsf_sync has been initialized */
adf_os_atomic_t tsf_sync_ready_flag;
#endif /* WLAN_FEATURE_TSF_PLUS */
#endif
hdd_cfg80211_state_t cfg80211State;
#ifdef WLAN_FEATURE_PACKET_FILTERING
t_multicast_add_list mc_addr_list;
#endif
uint8_t addr_filter_pattern;
/* to store the time of last bug report generated in HDD */
uint64_t last_tx_jiffies;
/* stores how many times timeout happens since last bug report generation */
uint8_t bug_report_count;
v_BOOL_t higherDtimTransition;
v_BOOL_t survey_idx;
hdd_scaninfo_t scan_info;
#if defined(FEATURE_WLAN_ESE) && defined(FEATURE_WLAN_ESE_UPLOAD)
tAniTrafStrmMetrics tsmStats;
#endif
/* Flag to ensure PSB is configured through framework */
v_U8_t psbChanged;
/* UAPSD psb value configured through framework */
v_U8_t configuredPsb;
#ifdef IPA_OFFLOAD
void *ipa_context;
#endif
#ifdef WLAN_FEATURE_MBSSID
/* this need to be adapter struct since adapter type can be dyn changed */
mbssid_sap_dyn_ini_config_t sap_dyn_ini_cfg;
#endif
struct work_struct scan_block_work;
/* Using delayed work for ACS for Primary AP Startup to complete
* since CSR Config is same for both AP */
struct delayed_work acs_pending_work;
#ifdef FEATURE_BUS_BANDWIDTH
unsigned long prev_rx_packets;
unsigned long prev_tx_packets;
unsigned long prev_fwd_tx_packets;
unsigned long prev_fwd_rx_packets;
unsigned long prev_tx_bytes;
int connection;
#endif
v_BOOL_t is_roc_inprogress;
#ifdef QCA_LL_TX_FLOW_CT
vos_timer_t tx_flow_control_timer;
v_BOOL_t tx_flow_timer_initialized;
unsigned int tx_flow_low_watermark;
unsigned int tx_flow_high_watermark_offset;
#endif /* QCA_LL_TX_FLOW_CT */
v_BOOL_t offloads_configured;
/* DSCP to UP QoS Mapping */
sme_QosWmmUpType hddWmmDscpToUpMap[WLAN_HDD_MAX_DSCP+1];
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
v_BOOL_t isLinkLayerStatsSet;
#endif
v_U8_t linkStatus;
/* variable for temperature in Celsius */
int temperature;
/* Time stamp for last completed RoC request */
v_TIME_t lastRocTs;
/* Time stamp for start RoC request */
v_TIME_t startRocTs;
/* State for synchronous OCB requests to WMI */
struct sir_ocb_set_config_response ocb_set_config_resp;
struct sir_ocb_get_tsf_timer_response ocb_get_tsf_timer_resp;
struct sir_dcc_get_stats_response *dcc_get_stats_resp;
struct sir_dcc_update_ndl_response dcc_update_ndl_resp;
struct dsrc_radio_chan_stats_ctxt dsrc_chan_stats;
#ifdef WLAN_FEATURE_DSRC
/* MAC addresses used for OCB interfaces */
tSirMacAddr ocb_mac_address[VOS_MAX_CONCURRENCY_PERSONA];
int ocb_mac_addr_count;
#endif
struct hdd_adapter_pm_context runtime_context;
struct mib_stats_metrics mib_stats;
/* BITMAP indicating pause reason */
uint32_t pause_map;
spinlock_t pause_map_lock;
adf_os_time_t start_time;
adf_os_time_t last_time;
adf_os_time_t total_pause_time;
adf_os_time_t total_unpause_time;
uint8_t history_index;
struct hdd_netif_queue_history
queue_oper_history[WLAN_HDD_MAX_HISTORY_ENTRY];
struct hdd_netif_queue_stats queue_oper_stats[WLAN_REASON_TYPE_MAX];
struct power_stats_response *chip_power_stats;
/* random address management for management action frames */
spinlock_t random_mac_lock;
struct action_frame_random_mac random_mac[MAX_RANDOM_MAC_ADDRS];
};
#define WLAN_HDD_GET_STATION_CTX_PTR(pAdapter) (&(pAdapter)->sessionCtx.station)
#define WLAN_HDD_GET_AP_CTX_PTR(pAdapter) (&(pAdapter)->sessionCtx.ap)
#define WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter) (&(pAdapter)->sessionCtx.station.WextState)
#define WLAN_HDD_GET_CTX(pAdapter) ((hdd_context_t*)pAdapter->pHddCtx)
#define WLAN_HDD_GET_HAL_CTX(pAdapter) (((hdd_context_t*)(pAdapter->pHddCtx))->hHal)
#define WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter) (&(pAdapter)->sessionCtx.ap.HostapdState)
#define WLAN_HDD_GET_CFG_STATE_PTR(pAdapter) (&(pAdapter)->cfg80211State)
#ifdef WLAN_FEATURE_MBSSID
#define WLAN_HDD_GET_SAP_CTX_PTR(pAdapter) (pAdapter->sessionCtx.ap.sapContext)
#endif
#ifdef FEATURE_WLAN_TDLS
#define WLAN_HDD_IS_TDLS_SUPPORTED_ADAPTER(pAdapter) \
(((WLAN_HDD_INFRA_STATION != pAdapter->device_mode) && \
(WLAN_HDD_P2P_CLIENT != pAdapter->device_mode)) ? 0 : 1)
#define WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter) \
((WLAN_HDD_IS_TDLS_SUPPORTED_ADAPTER(pAdapter)) ? \
(tdlsCtx_t*)(pAdapter)->sessionCtx.station.pHddTdlsCtx : NULL)
#endif
#ifdef WLAN_FEATURE_NAN_DATAPATH
#define WLAN_HDD_GET_NDP_CTX_PTR(adapter) (&(adapter)->sessionCtx.station.ndp_ctx)
#define WLAN_HDD_IS_NDP_ENABLED(hdd_ctx) ((hdd_ctx)->nan_datapath_enabled)
#else
/* WLAN_HDD_GET_NDP_CTX_PTR and WLAN_HDD_GET_NDP_WEXT_STATE_PTR are not defined
* intentionally so that all references to these must be within NDP code.
* non-NDP code can call WLAN_HDD_IS_NDP_ENABLED(), and when it is enabled,
* invoke NDP code to do all work.
*/
#define WLAN_HDD_IS_NDP_ENABLED(hdd_ctx) (false)
#endif
/* Set mac address locally administered bit */
#define WLAN_HDD_RESET_LOCALLY_ADMINISTERED_BIT(macaddr) (macaddr[0] &= 0xFD)
#define HDD_DEFAULT_MCC_P2P_QUOTA 70
#define HDD_RESET_MCC_P2P_QUOTA 50
typedef struct hdd_adapter_list_node
{
hdd_list_node_t node; // MUST be first element
hdd_adapter_t *pAdapter;
}hdd_adapter_list_node_t;
typedef struct hdd_priv_data_s
{
tANI_U8 *buf;
int used_len;
int total_len;
}hdd_priv_data_t;
#ifdef FEATURE_GREEN_AP
#define GREEN_AP_PS_ON_TIME (0)
#define GREEN_AP_PS_DELAY_TIME (20)
/*
* Green-AP power save state
*/
typedef enum
{
GREEN_AP_PS_IDLE_STATE = 1,
GREEN_AP_PS_OFF_STATE,
GREEN_AP_PS_WAIT_STATE,
GREEN_AP_PS_ON_STATE,
}hdd_green_ap_ps_state_t;
typedef enum
{
GREEN_AP_PS_START_EVENT = 1,
GREEN_AP_PS_STOP_EVENT,
GREEN_AP_ADD_STA_EVENT,
GREEN_AP_DEL_STA_EVENT,
GREEN_AP_PS_ON_EVENT,
GREEN_AP_PS_WAIT_EVENT,
}hdd_green_ap_event_t;
typedef struct
{
uint64_t ps_on_count;
v_TIME_t ps_on_prev_ticks;
v_TIME_t ps_on_ticks;
uint64_t ps_off_count;
v_TIME_t ps_off_prev_ticks;
v_TIME_t ps_off_ticks;
}hdd_green_ap_stats;
/*
* Green-AP context
*/
typedef struct
{
v_CONTEXT_t pHddContext;
v_U8_t ps_enable;
v_U32_t ps_on_time;
v_U32_t ps_delay_time;
v_U32_t num_nodes;
hdd_green_ap_ps_state_t ps_state;
hdd_green_ap_event_t ps_event;
vos_timer_t ps_timer;
hdd_green_ap_stats stats;
bool egap_support;
}hdd_green_ap_ctx_t;
#endif /* FEATURE_GREEN_AP */
#define MAX_MOD_LOGLEVEL 10
typedef struct
{
v_U8_t enable;
v_U8_t dl_type;
v_U8_t dl_report;
v_U8_t dl_loglevel;
v_U8_t index;
v_U32_t dl_mod_loglevel[MAX_MOD_LOGLEVEL];
}fw_log_info;
/**
* enum antenna_mode - number of TX/RX chains
* @HDD_ANTENNA_MODE_INVALID: Invalid mode place holder
* @HDD_ANTENNA_MODE_1X1: Number of TX/RX chains equals 1
* @HDD_ANTENNA_MODE_2X2: Number of TX/RX chains equals 2
* @HDD_ANTENNA_MODE_MAX: Place holder for max mode
*/
enum antenna_mode {
HDD_ANTENNA_MODE_INVALID,
HDD_ANTENNA_MODE_1X1,
HDD_ANTENNA_MODE_2X2,
HDD_ANTENNA_MODE_MAX
};
/**
* enum smps_mode - SM power save mode
* @HDD_SMPS_MODE_STATIC: Static power save
* @HDD_SMPS_MODE_DYNAMIC: Dynamic power save
* @HDD_SMPS_MODE_RESERVED: Reserved
* @HDD_SMPS_MODE_DISABLED: Disable power save
* @HDD_SMPS_MODE_MAX: Place holder for max mode
*/
enum smps_mode {
HDD_SMPS_MODE_STATIC,
HDD_SMPS_MODE_DYNAMIC,
HDD_SMPS_MODE_RESERVED,
HDD_SMPS_MODE_DISABLED,
HDD_SMPS_MODE_MAX
};
#ifdef FEATURE_WLAN_EXTSCAN
/**
* struct hdd_ext_scan_context - hdd ext scan context
*
* @request_id: userspace-assigned ID associated with the request
* @response_event: Ext scan wait event
* @response_status: Status returned by FW in response to a request
* @ignore_cached_results: Flag to ignore cached results or not
* @capability_response: Ext scan capability response data from target
* @buckets_scanned: bitmask of buckets scanned in extscan cycle
*/
struct hdd_ext_scan_context {
uint32_t request_id;
int response_status;
bool ignore_cached_results;
struct completion response_event;
struct ext_scan_capabilities_response capability_response;
uint32_t buckets_scanned;
};
#endif /* End of FEATURE_WLAN_EXTSCAN */
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
/**
* struct hdd_ll_stats_context - hdd link layer stats context
*
* @request_id: userspace-assigned link layer stats request id
* @request_bitmap: userspace-assigned link layer stats request bitmap
* @response_event: LL stats request wait event
*/
struct hdd_ll_stats_context {
uint32_t request_id;
uint32_t request_bitmap;
struct completion response_event;
};
#endif /* End of WLAN_FEATURE_LINK_LAYER_STATS */
/**
* struct hdd_chain_rssi_context - hdd chain rssi context
* @response_event: chain rssi request wait event
* @ignore_result: Flag to ignore the result or not
* @chain_rssi: chain rssi array
*/
struct hdd_chain_rssi_context {
struct completion response_event;
bool ignore_result;
struct chain_rssi_result result;
};
#ifdef WLAN_FEATURE_OFFLOAD_PACKETS
/**
* struct hdd_offloaded_packets - request id to pattern id mapping
* @request_id: request id
* @pattern_id: pattern id
*
*/
struct hdd_offloaded_packets {
uint32_t request_id;
uint8_t pattern_id;
};
/**
* struct hdd_offloaded_packets_ctx - offloaded packets context
* @op_table: request id to pattern id table
* @op_lock: mutex lock
*/
struct hdd_offloaded_packets_ctx {
struct hdd_offloaded_packets op_table[MAXNUM_PERIODIC_TX_PTRNS];
struct mutex op_lock;
};
#endif
/**
* struct hdd_bpf_context - hdd Context for bpf
* @magic: magic number
* @completion: Completion variable for BPF Get Capability
* @capability_response: capabilities response received from fw
*/
struct hdd_bpf_context {
unsigned int magic;
struct completion completion;
struct sir_bpf_get_offload capability_response;
};
/**
* struct acs_dfs_policy - Define ACS policies
* @acs_dfs_mode: Dfs mode enabled/disabled.
* @acs_channel: pre defined channel to avoid ACS.
*/
struct acs_dfs_policy {
enum dfs_mode acs_dfs_mode;
uint8_t acs_channel;
};
/**
* struct hdd_scan_chan_info - channel info
* @freq: radio frequence
* @cmd flag: cmd flag
* @noise_floor: noise floor
* @cycle_count: cycle count
* @rx_clear_count: rx clear count
* @tx_frame_count: TX frame count
* @delta_cycle_count: delta of cc
* @delta_rx_clear_count: delta of rcc
* @delta_tx_frame_count: delta of tfc
* @clock_freq: clock frequence MHZ
*/
struct hdd_scan_chan_info {
uint32_t freq;
uint32_t cmd_flag;
uint32_t noise_floor;
uint32_t cycle_count;
uint32_t rx_clear_count;
uint32_t tx_frame_count;
uint32_t delta_cycle_count;
uint32_t delta_rx_clear_count;
uint32_t delta_tx_frame_count;
uint32_t clock_freq;
};
#ifdef WLAN_FEATURE_SAP_TO_FOLLOW_STA_CHAN
typedef struct sap_ch_switch_with_csa_ctx
{
v_BOOL_t is_ch_sw_through_sta_csa;
u_int8_t tbtt_count;
v_U8_t csa_to_channel; //channel on which SAP will move after sending CSA
v_U8_t sap_chan_sw_pending; //SAP channel switch pending after STA disconnect
vos_timer_t hdd_ap_chan_switch_timer; //timer to init SAP chan switch
v_BOOL_t chan_sw_timer_initialized;
v_U8_t def_csa_channel_on_disc;
v_BOOL_t scan_only_dfs_channels;
struct mutex sap_ch_sw_lock; //Synchronize access to sap_chan_sw_pending
}sap_ch_switch_ctx;
#endif
/** Adapter stucture definition */
struct hdd_context_s
{
/** Global VOS context */
v_CONTEXT_t pvosContext;
/** HAL handle...*/
tHalHandle hHal;
struct wiphy *wiphy ;
//TODO Remove this from here.
hdd_list_t hddAdapters; //List of adapters
/* One per STA: 1 for BCMC_STA_ID, 1 for each SAP_SELF_STA_ID, 1 for WDS_STAID */
hdd_adapter_t *sta_to_adapter[WLAN_MAX_STA_COUNT + VOS_MAX_NO_OF_SAP_MODE + 2]; //One per sta. For quick reference.
/** Pointer for firmware image data */
const struct firmware *fw;
/** Pointer for configuration data */
const struct firmware *cfg;
/** Pointer for nv data */
const struct firmware *nv;
/** Pointer to the parent device */
struct device *parent_dev;
/** Config values read from qcom_cfg.ini file */
hdd_config_t *cfg_ini;
wlan_hdd_ftm_status_t ftm;
/** completion variable for full power callback */
struct completion full_pwr_comp_var;
/** completion variable for Request BMPS callback */
struct completion req_bmps_comp_var;
/** completion variable for standby callback */
struct completion standby_comp_var;
/* Completion variable to indicate Rx Thread Suspended */
struct completion rx_sus_event_var;
/* Completion variable to indicate Tx Thread Suspended */
struct completion tx_sus_event_var;
/* Completion variable to indicate Mc Thread Suspended */
struct completion mc_sus_event_var;
struct completion reg_init;
v_BOOL_t isWlanSuspended;
v_BOOL_t isTxThreadSuspended;
v_BOOL_t isMcThreadSuspended;
v_BOOL_t isRxThreadSuspended;
#ifdef QCA_CONFIG_SMP
v_BOOL_t isTlshimRxThreadSuspended;
#endif
volatile v_BOOL_t isLogpInProgress;
v_BOOL_t isLoadInProgress;
v_BOOL_t isUnloadInProgress;
#ifdef FEATURE_WLAN_THERMAL_SHUTDOWN
bool system_suspended;
volatile int thermal_suspend_state;
spinlock_t thermal_suspend_lock;
struct workqueue_struct *thermal_suspend_wq;
struct delayed_work thermal_suspend_work;
#endif
/**Track whether driver has been suspended.*/
hdd_ps_state_t hdd_ps_state;
/* Track whether Mcast/Bcast Filter is enabled.*/
v_BOOL_t hdd_mcastbcast_filter_set;
/* Track whether ignore DTIM is enabled*/
v_BOOL_t hdd_ignore_dtim_enabled;
v_U32_t hdd_actual_ignore_DTIM_value;
v_U32_t hdd_actual_LI_value;
v_BOOL_t hdd_wlan_suspended;
v_BOOL_t suspended;
spinlock_t filter_lock;
/* Lock to avoid race condition during start/stop bss */
struct mutex sap_lock;
/** ptt Process ID*/
v_SINT_t ptt_pid;
#ifdef WLAN_KD_READY_NOTIFIER
v_BOOL_t kd_nl_init;
#endif /* WLAN_KD_READY_NOTIFIER */
#ifdef FEATURE_OEM_DATA_SUPPORT
/* OEM App registered or not */
v_BOOL_t oem_app_registered;
/* OEM App Process ID */
v_SINT_t oem_pid;
#endif
v_U8_t change_iface;
/** Concurrency Parameters*/
tVOS_CONCURRENCY_MODE concurrency_mode;
v_U8_t no_of_open_sessions[VOS_MAX_NO_OF_MODE];
v_U8_t no_of_active_sessions[VOS_MAX_NO_OF_MODE];
/* Number of times riva restarted */
v_U32_t hddRivaResetStats;
/* Can we allow AMP connection right now*/
v_BOOL_t isAmpAllowed;
/** P2P Device MAC Address for the adapter */
v_MACADDR_t p2pDeviceAddress;
/* Thermal mitigation information */
hdd_thermal_mitigation_info_t tmInfo;
vos_wake_lock_t rx_wake_lock;
/*
* Framework initiated driver restarting
* hdd_reload_timer : Restart retry timer
* isRestartInProgress: Restart in progress
* hdd_restart_retries: Restart retries
*
*/
vos_timer_t hdd_restart_timer;
atomic_t isRestartInProgress;
u_int8_t hdd_restart_retries;
vos_wake_lock_t sap_wake_lock;
#ifdef FEATURE_WLAN_TDLS
eTDLSSupportMode tdls_mode;
eTDLSSupportMode tdls_mode_last;
tdlsConnInfo_t tdlsConnInfo[HDD_MAX_NUM_TDLS_STA];
/* maximum TDLS station number allowed upon runtime condition */
tANI_U16 max_num_tdls_sta;
/* TDLS peer connected count */
tANI_U16 connected_peer_count;
tdls_scan_context_t tdls_scan_ctxt;
/* Lock to avoid race condition during TDLS operations*/
struct mutex tdls_lock;
tANI_U8 tdls_off_channel;
tANI_U16 tdls_channel_offset;
int32_t tdls_fw_off_chan_mode;
bool tdls_nss_switch_in_progress;
bool tdls_nss_teardown_complete;
int32_t tdls_nss_transition_mode;
int32_t tdls_teardown_peers_cnt;
#endif
#ifdef IPA_OFFLOAD
void *hdd_ipa;
#ifdef IPA_UC_OFFLOAD
/* CE resources */
v_U32_t ce_sr_base_paddr;
v_U32_t ce_sr_ring_size;
v_U32_t ce_reg_paddr;
/* WLAN TX:IPA->WLAN */
v_U32_t tx_comp_ring_base_paddr;
v_U32_t tx_comp_ring_size;
v_U32_t tx_num_alloc_buffer;
/* WLAN RX:WLAN->IPA */
v_U32_t rx_rdy_ring_base_paddr;
v_U32_t rx_rdy_ring_size;
v_U32_t rx_proc_done_idx_paddr;
/* IPA UC doorbell registers paddr */
v_U32_t tx_comp_doorbell_paddr;
v_U32_t rx_ready_doorbell_paddr;
#endif /* IPA_UC_OFFLOAD */
#endif
/* MC/BC Filter state variable
* This always contains the value that is currently
* configured
* */
v_U8_t configuredMcastBcastFilter;
v_U8_t sus_res_mcastbcast_filter;
v_BOOL_t sus_res_mcastbcast_filter_valid;
/* debugfs entry */
struct dentry *debugfs_phy;
#ifdef WLAN_POWER_DEBUGFS
/* mutex lock to block concurrent access */
struct mutex power_stats_lock;
#endif
/* Use below lock to protect access to isSchedScanUpdatePending
* since it will be accessed in two different contexts.
*/
spinlock_t schedScan_lock;
// Flag keeps track of wiphy suspend/resume
v_BOOL_t isWiphySuspended;
// Indicates about pending sched_scan results
v_BOOL_t isSchedScanUpdatePending;
#ifdef FEATURE_BUS_BANDWIDTH
/* DDR bus bandwidth compute timer */
vos_timer_t bus_bw_timer;
int cur_vote_level;
spinlock_t bus_bw_lock;
int cur_rx_level;
uint64_t prev_rx;
int cur_tx_level;
uint64_t prev_tx;
#endif
/* VHT80 allowed*/
v_BOOL_t isVHT80Allowed;
struct completion ready_to_suspend;
/* defining the solution type */
v_U32_t target_type;
/* defining the firmware version */
v_U32_t target_fw_version;
v_U32_t dfs_radar_found;
/* defining the chip/rom version */
v_U32_t target_hw_version;
/* defining the chip/rom revision */
v_U32_t target_hw_revision;
/* chip/rom name */
const char *target_hw_name;
struct regulatory reg;
#ifdef FEATURE_WLAN_CH_AVOID
v_U16_t unsafe_channel_count;
v_U16_t unsafe_channel_list[NUM_20MHZ_RF_CHANNELS];
#endif /* FEATURE_WLAN_CH_AVOID */
v_U8_t max_intf_count;
v_U8_t current_intf_count;
#ifdef WLAN_FEATURE_LPSS
v_U8_t lpss_support;
#endif
uint8_t ap_arpns_support;
tSirScanType ioctl_scan_mode;
#ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
adf_os_work_t sta_ap_intf_check_work;
#endif
struct work_struct sap_start_work;
bool is_sap_restart_required;
bool is_ch_avoid_in_progress;
bool is_sta_connection_pending;
spinlock_t sap_update_info_lock;
spinlock_t sta_update_info_lock;
v_U8_t dev_dfs_cac_status;
v_BOOL_t btCoexModeSet;
#ifdef FEATURE_GREEN_AP
hdd_green_ap_ctx_t *green_ap_ctx;
#endif
fw_log_info fw_log_settings;
#ifdef FEATURE_WLAN_AP_AP_ACS_OPTIMIZE
vos_timer_t skip_acs_scan_timer;
v_U8_t skip_acs_scan_status;
uint8_t *last_acs_channel_list;
uint8_t num_of_channels;
spinlock_t acs_skip_lock;
#endif
vos_wake_lock_t sap_dfs_wakelock;
atomic_t sap_dfs_ref_cnt;
#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
v_BOOL_t is_extwow_app_type1_param_set;
v_BOOL_t is_extwow_app_type2_param_set;
v_BOOL_t ext_wow_should_suspend;
struct completion ready_to_extwow;
#endif
/* Time since boot up to extscan start (in micro seconds) */
v_U64_t ext_scan_start_since_boot;
/* RoC request queue and work */
struct delayed_work rocReqWork;
hdd_list_t hdd_roc_req_q;
bool mcc_mode;
unsigned long g_event_flags;
uint8_t miracast_value;
/* Dfs lock used to syncronize on sap channel switch during
* radar found indication and application triggered channel
* switch
*/
spinlock_t dfs_lock;
#ifdef FEATURE_WLAN_EXTSCAN
struct hdd_ext_scan_context ext_scan_context;
#endif /* FEATURE_WLAN_EXTSCAN */
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
struct hdd_ll_stats_context ll_stats_context;
#endif /* End of WLAN_FEATURE_LINK_LAYER_STATS */
struct hdd_chain_rssi_context chain_rssi_context;
struct mutex memdump_lock;
uint16_t driver_dump_size;
uint8_t *driver_dump_mem;
/* number of rf chains supported by target */
uint32_t num_rf_chains;
/* Is htTxSTBC supported by target */
uint8_t ht_tx_stbc_supported;
bool ns_offload_enable;
#ifdef WLAN_NS_OFFLOAD
/* IPv6 notifier callback for handling NS offload on change in IP */
struct notifier_block ipv6_notifier;
#endif
/* IPv4 notifier callback for handling ARP offload on change in IP */
struct notifier_block ipv4_notifier;
#ifdef WLAN_FEATURE_OFFLOAD_PACKETS
struct hdd_offloaded_packets_ctx op_ctx;
#endif
bool per_band_chainmask_supp;
uint16_t hdd_txrx_hist_idx;
struct hdd_tx_rx_histogram *hdd_txrx_hist;
struct hdd_runtime_pm_context runtime_context;
bool hbw_requested;
#ifdef IPA_OFFLOAD
struct completion ipa_ready;
#endif
uint8_t supp_2g_chain_mask;
uint8_t supp_5g_chain_mask;
/* Current number of TX X RX chains being used */
enum antenna_mode current_antenna_mode;
bool bpf_enabled;
uint16_t wmi_max_len;
/*
* place to store FTM capab of target. This allows changing of FTM capab
* at runtime and intersecting it with target capab before updating.
*/
uint32_t fine_time_meas_cap_target;
uint32_t rx_high_ind_cnt;
int radio_index;
#ifdef WLAN_FEATURE_NAN_DATAPATH
bool nan_datapath_enabled;
#endif
unsigned int last_scan_bug_report_timestamp;
bool driver_being_stopped; /* Track if DRIVER STOP cmd is sent */
uint8_t max_mc_addr_list;
struct acs_dfs_policy acs_policy;
uint8_t max_peers;
/* bit map to set/reset TDLS by different sources */
unsigned long tdls_source_bitmap;
/* tdls source timer to enable/disable TDLS on p2p listen */
vos_timer_t tdls_source_timer;
struct hdd_scan_chan_info *chan_info;
struct mutex chan_info_lock;
uint32_t no_of_probe_req_ouis;
struct vendor_oui *probe_req_voui;
v_U8_t last_scan_reject_session_id;
scan_reject_states last_scan_reject_reason;
v_TIME_t last_scan_reject_timestamp;
uint8_t scan_reject_cnt;
uint8_t hdd_dfs_regdomain;
#ifdef WLAN_FEATURE_TSF
/* indicate whether tsf has been initialized */
adf_os_atomic_t tsf_ready_flag;
/* indicate whether it's now capturing tsf(updating tstamp-pair) */
adf_os_atomic_t cap_tsf_flag;
/* the context that is capturing tsf */
hdd_adapter_t *cap_tsf_context;
#endif
/* flag to show whether moniotr mode is enabled */
bool is_mon_enable;
v_MACADDR_t hw_macaddr;
#ifdef WLAN_FEATURE_SAP_TO_FOLLOW_STA_CHAN
sap_ch_switch_ctx ch_switch_ctx;
#endif//#ifdef WLAN_FEATURE_SAP_TO_FOLLOW_CHAN
};
/*---------------------------------------------------------------------------
Function declarations and documentation
-------------------------------------------------------------------------*/
#ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *sta_pAdapter);
#endif
const char* hdd_device_mode_to_string(uint8_t device_mode);
VOS_STATUS hdd_get_front_adapter( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t** ppAdapterNode);
VOS_STATUS hdd_get_next_adapter( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t* pAdapterNode,
hdd_adapter_list_node_t** pNextAdapterNode);
VOS_STATUS hdd_remove_adapter( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t* pAdapterNode);
VOS_STATUS hdd_remove_front_adapter( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t** ppAdapterNode);
VOS_STATUS hdd_add_adapter_back( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t* pAdapterNode);
VOS_STATUS hdd_add_adapter_front( hdd_context_t *pHddCtx,
hdd_adapter_list_node_t* pAdapterNode);
/**
* hdd_get_current_vdev_sta_count() - get currnet vdev sta count
* @hdd_ctx: hdd context
*
* Traverse the adapter list to get the vdev sta count
*
* Return: vdev sta count
*/
uint32_t hdd_get_current_vdev_sta_count(hdd_context_t *hdd_ctx);
hdd_adapter_t* hdd_open_adapter( hdd_context_t *pHddCtx, tANI_U8 session_type,
const char* name, tSirMacAddr macAddr,
unsigned char name_assign_type,
tANI_U8 rtnl_held );
VOS_STATUS hdd_close_adapter( hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter, tANI_U8 rtnl_held );
VOS_STATUS hdd_close_all_adapters( hdd_context_t *pHddCtx );
VOS_STATUS hdd_stop_all_adapters( hdd_context_t *pHddCtx );
VOS_STATUS hdd_reset_all_adapters( hdd_context_t *pHddCtx );
VOS_STATUS hdd_start_all_adapters( hdd_context_t *pHddCtx );
VOS_STATUS hdd_reconnect_all_adapters( hdd_context_t *pHddCtx );
void hdd_dump_concurrency_info(hdd_context_t *pHddCtx);
hdd_adapter_t * hdd_get_adapter_by_name( hdd_context_t *pHddCtx, tANI_U8 *name );
hdd_adapter_t * hdd_get_adapter_by_vdev( hdd_context_t *pHddCtx,
tANI_U32 vdev_id );
hdd_adapter_t * hdd_get_adapter_by_macaddr( hdd_context_t *pHddCtx, tSirMacAddr macAddr );
/**
* hdd_get_adapter_by_rand_macaddr() - Get adapter using random DA of MA frms
* @hdd_ctx: Pointer to hdd context
* @mac_addr: random mac address
*
* This function is used to get adapter from randomized destination mac
* address present in management action frames
*
* Return: If randomized addr is present then return pointer to adapter
* else NULL
*/
hdd_adapter_t * hdd_get_adapter_by_rand_macaddr(hdd_context_t *hdd_ctx, tSirMacAddr mac_addr);
VOS_STATUS hdd_init_station_mode( hdd_adapter_t *pAdapter );
hdd_adapter_t * hdd_get_adapter( hdd_context_t *pHddCtx, device_mode_t mode );
void hdd_deinit_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
bool rtnl_held);
VOS_STATUS hdd_stop_adapter( hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
const v_BOOL_t bCloseSession);
void hdd_set_station_ops( struct net_device *pWlanDev );
tANI_U8* wlan_hdd_get_intf_addr(hdd_context_t* pHddCtx);
void wlan_hdd_release_intf_addr(hdd_context_t* pHddCtx, tANI_U8* releaseAddr);
v_U8_t hdd_get_operating_channel( hdd_context_t *pHddCtx, device_mode_t mode );
void hdd_set_conparam ( v_UINT_t newParam );
tVOS_CON_MODE hdd_get_conparam( void );
void wlan_hdd_enable_deepsleep(v_VOID_t * pVosContext);
v_BOOL_t hdd_is_suspend_notify_allowed(hdd_context_t* pHddCtx);
void hdd_abort_mac_scan(hdd_context_t* pHddCtx, tANI_U8 sessionId,
eCsrAbortReason reason);
void hdd_cleanup_actionframe( hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter );
void crda_regulatory_entry_default(v_U8_t *countryCode, int domain_id);
void wlan_hdd_set_concurrency_mode(hdd_context_t *pHddCtx,
tVOS_CON_MODE mode);
void wlan_hdd_clear_concurrency_mode(hdd_context_t *pHddCtx,
tVOS_CON_MODE mode);
void wlan_hdd_incr_active_session(hdd_context_t *pHddCtx,
tVOS_CON_MODE mode);
void wlan_hdd_decr_active_session(hdd_context_t *pHddCtx,
tVOS_CON_MODE mode);
uint8_t wlan_hdd_get_active_session_count(hdd_context_t *pHddCtx);
void wlan_hdd_reset_prob_rspies(hdd_adapter_t* pHostapdAdapter);
void hdd_prevent_suspend(uint32_t reason);
void hdd_allow_suspend(uint32_t reason);
void hdd_prevent_suspend_timeout(v_U32_t timeout, uint32_t reason);
void hdd_wlan_wakelock_create (void);
void hdd_wlan_wakelock_destroy(void);
void wlan_hdd_wakelocks_destroy(hdd_context_t *hdd_ctx);
void wlan_hdd_netdev_notifiers_cleanup(hdd_context_t * hdd_ctx);
bool hdd_is_ssr_required(void);
void hdd_set_ssr_required(e_hdd_ssr_required value);
VOS_STATUS hdd_enable_bmps_imps(hdd_context_t *pHddCtx);
VOS_STATUS hdd_disable_bmps_imps(hdd_context_t *pHddCtx, tANI_U8 session_type);
/**
* hdd_thermal_suspend_queue_work() - Queue a thermal suspend work
* @hdd_ctx: Pointer to hdd_context_t
* @ms: Delay time in milliseconds to execute the work
*
* Queue thermal suspend work on the workqueue after delay
*
* Return: false if work was already on a queue, true otherwise.
*/
bool hdd_thermal_suspend_queue_work(hdd_context_t *hdd_ctx, unsigned long ms);
void wlan_hdd_cfg80211_update_wiphy_caps(struct wiphy *wiphy);
VOS_STATUS hdd_setIbssPowerSaveParams(hdd_adapter_t *pAdapter);
VOS_STATUS wlan_hdd_restart_driver(hdd_context_t *pHddCtx);
void hdd_exchange_version_and_caps(hdd_context_t *pHddCtx);
void hdd_set_pwrparams(hdd_context_t *pHddCtx);
void hdd_reset_pwrparams(hdd_context_t *pHddCtx);
int wlan_hdd_validate_context(hdd_context_t *pHddCtx);
v_BOOL_t hdd_is_valid_mac_address(const tANI_U8* pMacAddr);
VOS_STATUS hdd_issta_p2p_clientconnected(hdd_context_t *pHddCtx);
void hdd_ipv4_notifier_work_queue(struct work_struct *work);
bool hdd_isConnectionInProgress(hdd_context_t *pHddCtx, v_U8_t *session_id,
scan_reject_states *reason);
#ifdef WLAN_FEATURE_PACKET_FILTERING
int wlan_hdd_setIPv6Filter(hdd_context_t *pHddCtx, tANI_U8 filterType, tANI_U8 sessionId);
#endif
#ifdef WLAN_NS_OFFLOAD
void hdd_ipv6_notifier_work_queue(struct work_struct *work);
#endif
v_MACADDR_t* hdd_wlan_get_ibss_mac_addr_from_staid(hdd_adapter_t *pAdapter, v_U8_t staIdx);
void hdd_checkandupdate_phymode( hdd_context_t *pHddCtx);
int hdd_wmmps_helper(hdd_adapter_t *pAdapter, tANI_U8 *ptr);
int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate);
#ifdef FEATURE_BUS_BANDWIDTH
void hdd_start_bus_bw_compute_timer(hdd_adapter_t *pAdapter);
void hdd_stop_bus_bw_compute_timer(hdd_adapter_t *pAdapter);
#else
static inline void hdd_start_bus_bw_compute_timer(hdd_adapter_t *pAdapter)
{
return;
}
static inline void hdd_stop_bus_bw_computer_timer(hdd_adapter_t *pAdapter)
{
return;
}
#endif
int hdd_wlan_startup(struct device *dev, void *hif_sc);
void __hdd_wlan_exit(void);
int hdd_wlan_notify_modem_power_state(int state);
#ifdef QCA_HT_2040_COEX
int hdd_wlan_set_ht2040_mode(hdd_adapter_t *pAdapter, v_U16_t staId,
v_MACADDR_t macAddrSTA, int width);
#endif
VOS_STATUS hdd_abort_mac_scan_all_adapters(hdd_context_t *pHddCtx);
#ifdef WLAN_FEATURE_LPSS
void wlan_hdd_send_status_pkg(hdd_adapter_t *pAdapter,
hdd_station_ctx_t *pHddStaCtx,
v_U8_t is_on,
v_U8_t is_connected);
void wlan_hdd_send_version_pkg(v_U32_t fw_version,
v_U32_t chip_id,
const char *chip_name);
void wlan_hdd_send_all_scan_intf_info(hdd_context_t *pHddCtx);
#endif
void wlan_hdd_send_svc_nlink_msg(int radio, int type, void *data, int len);
#ifdef FEATURE_WLAN_AUTO_SHUTDOWN
void wlan_hdd_auto_shutdown_enable(hdd_context_t *hdd_ctx, v_U8_t enable);
#endif
hdd_adapter_t *hdd_get_con_sap_adapter(hdd_adapter_t *this_sap_adapter,
bool check_start_bss);
boolean hdd_is_5g_supported(hdd_context_t * pHddCtx);
int wlan_hdd_scan_abort(hdd_adapter_t *pAdapter);
#ifdef FEATURE_GREEN_AP
void hdd_wlan_green_ap_mc(hdd_context_t *pHddCtx,
hdd_green_ap_event_t event);
void hdd_wlan_green_ap_init(struct hdd_context_s *hdd_ctx);
void hdd_wlan_green_ap_deinit(struct hdd_context_s *hdd_ctx);
void hdd_wlan_green_ap_start_bss(hdd_context_t *hdd_ctx);
void hdd_wlan_green_ap_stop_bss(struct hdd_context_s *hdd_ctx);
void hdd_wlan_green_ap_add_sta(struct hdd_context_s *hdd_ctx);
void hdd_wlan_green_ap_del_sta(struct hdd_context_s *hdd_ctx);
int hdd_wlan_enable_egap(struct hdd_context_s *hdd_ctx);
#else
static inline void hdd_wlan_green_ap_init(struct hdd_context_s *hdd_ctx) {}
static inline void hdd_wlan_green_ap_deinit(struct hdd_context_s *hdd_ctx) {}
static inline void hdd_wlan_green_ap_start_bss(hdd_context_t *hdd_ctx) {}
static inline void hdd_wlan_green_ap_stop_bss(struct hdd_context_s *hdd_ctx) {}
static inline void hdd_wlan_green_ap_add_sta(struct hdd_context_s *hdd_ctx) {}
static inline void hdd_wlan_green_ap_del_sta(struct hdd_context_s *hdd_ctx) {}
static inline int hdd_wlan_enable_egap(struct hdd_context_s *hdd_ctx) {
return -EINVAL;
}
#endif
#ifdef WLAN_FEATURE_STATS_EXT
void wlan_hdd_cfg80211_stats_ext_init(hdd_context_t *pHddCtx);
#endif
void hdd_update_macaddr(hdd_config_t *cfg_ini, v_MACADDR_t hw_macaddr);
#if defined(FEATURE_WLAN_LFR) && defined(WLAN_FEATURE_ROAM_SCAN_OFFLOAD)
void wlan_hdd_disable_roaming(hdd_adapter_t *pAdapter);
void wlan_hdd_enable_roaming(hdd_adapter_t *pAdapter);
#endif
int hdd_set_miracast_mode(hdd_adapter_t *pAdapter, tANI_U8 *command);
VOS_STATUS wlan_hdd_check_custom_con_channel_rules(hdd_adapter_t *sta_adapter,
hdd_adapter_t *ap_adapter,
tCsrRoamProfile *roam_profile,
tScanResultHandle *scan_cache,
bool *concurrent_chnl_same);
#ifdef WLAN_FEATURE_MBSSID
void wlan_hdd_stop_sap(hdd_adapter_t *ap_adapter);
void wlan_hdd_start_sap(hdd_adapter_t *ap_adapter, bool reinit);
#else
static inline void wlan_hdd_stop_sap(hdd_adapter_t *ap_adapter) {}
static inline void wlan_hdd_start_sap(hdd_adapter_t *ap_adapter, bool reinit) {}
#endif
int wlan_hdd_get_link_speed(hdd_adapter_t *sta_adapter, uint32_t *link_speed);
int hdd_wlan_go_set_mcc_p2p_quota(hdd_adapter_t *hostapd_adapter,
uint32_t set_value);
int hdd_wlan_set_mcc_p2p_quota(hdd_adapter_t *hostapd_adapter,
uint32_t set_value);
int hdd_set_mas(hdd_adapter_t *hostapd_adapter, uint8_t filter_type);
uint8_t hdd_is_mcc_in_24G(hdd_context_t *hdd_ctx);
bool wlan_hdd_get_fw_state(hdd_adapter_t *adapter);
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
static inline bool hdd_link_layer_stats_supported(void)
{
return true;
}
/**
* hdd_init_ll_stats_ctx() - initialize link layer stats context
* @hdd_ctx: Pointer to hdd context
*
* Return: none
*/
static inline void hdd_init_ll_stats_ctx(hdd_context_t *hdd_ctx)
{
init_completion(&hdd_ctx->ll_stats_context.response_event);
hdd_ctx->ll_stats_context.request_bitmap = 0;
return;
}
/**
* wlan_hdd_cfg80211_link_layer_stats_init() - Initialize llstats callbacks
* @pHddCtx: HDD context
*
* Return: none
*/
void wlan_hdd_cfg80211_link_layer_stats_init(hdd_context_t *pHddCtx);
#else
static inline bool hdd_link_layer_stats_supported(void)
{
return false;
}
static inline void hdd_init_ll_stats_ctx(hdd_context_t *hdd_ctx)
{
return;
}
void wlan_hdd_cfg80211_link_layer_stats_init(hdd_context_t *pHddCtx)
{
return;
}
#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
#ifdef FEATURE_WLAN_LFR
static inline bool hdd_driver_roaming_supported(hdd_context_t *hdd_ctx)
{
return hdd_ctx->cfg_ini->isFastRoamIniFeatureEnabled;
}
#else
static inline bool hdd_driver_roaming_supported(hdd_context_t *hdd_ctx)
{
return false;
}
#endif
#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
static inline bool hdd_firmware_roaming_supported(hdd_context_t *hdd_ctx)
{
return hdd_ctx->cfg_ini->isRoamOffloadScanEnabled;
}
#else
static inline bool hdd_firmware_roaming_supported(hdd_context_t *hdd_ctx)
{
return false;
}
#endif
static inline bool hdd_roaming_supported(hdd_context_t *hdd_ctx)
{
bool val;
val = hdd_driver_roaming_supported(hdd_ctx) ||
hdd_firmware_roaming_supported(hdd_ctx);
return val;
}
#ifdef CFG80211_SCAN_RANDOM_MAC_ADDR
static inline bool hdd_scan_random_mac_addr_supported(void)
{
return true;
}
#else
static inline bool hdd_scan_random_mac_addr_supported(void)
{
return false;
}
#endif
void hdd_get_fw_version(hdd_context_t *hdd_ctx,
uint32_t *major_spid, uint32_t *minor_spid,
uint32_t *siid, uint32_t *crmid);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
static inline void
hdd_set_needed_headroom(struct net_device *wlan_dev, uint16_t len)
{
wlan_dev->needed_headroom = len;
}
#else
static inline void
hdd_set_needed_headroom(struct net_device *wlan_dev, uint16_t len)
{
/* no-op */
}
#endif /* LINUX_VERSION_CODE */
#ifdef QCA_CONFIG_SMP
int wlan_hdd_get_cpu(void);
#else
static inline int wlan_hdd_get_cpu(void)
{
return 0;
}
#endif
const char *hdd_get_fwpath(void);
uint8_t wlan_hdd_find_opclass(tHalHandle hal, uint8_t channel,
uint8_t bw_offset);
#ifdef QCA_LL_TX_FLOW_CT
void wlan_hdd_clean_tx_flow_control_timer(hdd_context_t *hddctx,
hdd_adapter_t *adapter);
#else
static inline void
wlan_hdd_clean_tx_flow_control_timer(hdd_context_t *hddctx,
hdd_adapter_t *adapter)
{
}
#endif
struct cfg80211_bss *hdd_cfg80211_get_bss(struct wiphy *wiphy,
struct ieee80211_channel *channel,
const u8 *bssid,
const u8 *ssid, size_t ssid_len);
void hdd_connect_result(struct net_device *dev, const u8 *bssid,
tCsrRoamInfo *roam_info, const u8 *req_ie,
size_t req_ie_len, const u8 * resp_ie,
size_t resp_ie_len, u16 status, gfp_t gfp,
bool connect_timeout,
tSirResultCodes timeout_reason);
int wlan_hdd_init_tx_rx_histogram(hdd_context_t *pHddCtx);
void wlan_hdd_deinit_tx_rx_histogram(hdd_context_t *pHddCtx);
void wlan_hdd_display_tx_rx_histogram(hdd_context_t *pHddCtx);
void wlan_hdd_clear_tx_rx_histogram(hdd_context_t *pHddCtx);
void wlan_hdd_display_netif_queue_history(hdd_context_t *hdd_ctx);
void wlan_hdd_clear_netif_queue_history(hdd_context_t *hdd_ctx);
void hdd_runtime_suspend_init(hdd_context_t *);
void hdd_runtime_suspend_deinit(hdd_context_t *);
void hdd_indicate_mgmt_frame(tSirSmeMgmtFrameInd *frame_ind);
hdd_adapter_t *hdd_get_adapter_by_sme_session_id(hdd_context_t *hdd_ctx,
uint32_t sme_session_id);
#ifdef FEATURE_GREEN_AP
void wlan_hdd_set_egap_support(hdd_context_t *hdd_ctx, struct hdd_tgt_cfg *cfg);
#else
static inline void wlan_hdd_set_egap_support(hdd_context_t *hdd_ctx,
struct hdd_tgt_cfg *cfg) {}
#endif
int wlan_hdd_update_txrx_chain_mask(hdd_context_t *hdd_ctx,
uint8_t chain_mask);
void
hdd_get_ibss_peer_info_cb(v_VOID_t *pUserData,
tSirPeerInfoRspParams *pPeerInfo);
eHalStatus hdd_smeCloseSessionCallback(void *pContext);
int hdd_enable_disable_ca_event(hdd_context_t *hddctx,
tANI_U8 set_value);
void wlan_hdd_undo_acs(hdd_adapter_t *adapter);
void hdd_decide_dynamic_chain_mask(hdd_context_t *hdd_ctx,
enum antenna_mode forced);
#ifdef CONFIG_CNSS_LOGGER
/**
* wlan_hdd_nl_init() - wrapper function to CNSS_LOGGER case
* @hdd_ctx: the hdd context pointer
*
* The nl_srv_init() will call to cnss_logger_device_register() and
* expect to get a radio_index from cnss_logger module and assign to
* hdd_ctx->radio_index, then to maintain the consistency to original
* design, adding the radio_index check here, then return the error
* code if radio_index is not assigned correctly, which means the nl_init
* from cnss_logger is failed.
*
* Return: 0 if successfully, otherwise error code
*/
static inline int wlan_hdd_nl_init(hdd_context_t *hdd_ctx)
{
hdd_ctx->radio_index = nl_srv_init(hdd_ctx->wiphy);
/* radio_index is assigned from 0, so only >=0 will be valid index */
if (hdd_ctx->radio_index >= 0)
return 0;
else
return -EINVAL;
}
#else
/**
* wlan_hdd_nl_init() - wrapper function to non CNSS_LOGGER case
* @hdd_ctx: the hdd context pointer
*
* In case of non CNSS_LOGGER case, the nl_srv_init() will initialize
* the netlink socket and return the success or not.
*
* Return: the return value from nl_srv_init()
*/
static inline int wlan_hdd_nl_init(hdd_context_t *hdd_ctx)
{
return nl_srv_init(hdd_ctx->wiphy);
}
#endif
#ifdef WLAN_FEATURE_PACKET_FILTERING
int hdd_init_packet_filtering(hdd_context_t *hdd_ctx,
hdd_adapter_t *adapter);
void hdd_deinit_packet_filtering(hdd_adapter_t *adapter);
#else
static inline int hdd_init_packet_filtering(hdd_context_t *hdd_ctx,
hdd_adapter_t *adapter)
{
return 0;
}
static inline void hdd_deinit_packet_filtering(hdd_adapter_t *adapter)
{
}
#endif
enum sap_acs_dfs_mode wlan_hdd_get_dfs_mode(enum dfs_mode mode);
void hdd_ch_avoid_cb(void *hdd_context, void *indi_param);
uint8_t hdd_find_prefd_safe_chnl(hdd_context_t *hdd_ctxt,
hdd_adapter_t *ap_adapter);
void hdd_unsafe_channel_restart_sap(hdd_context_t *hdd_ctx);
#if defined (FEATURE_WLAN_MCC_TO_SCC_SWITCH) || \
defined (FEATURE_WLAN_STA_AP_MODE_DFS_DISABLE)
void wlan_hdd_restart_sap(hdd_adapter_t *ap_adapter);
#else
static inline void wlan_hdd_restart_sap(hdd_adapter_t *ap_adapter)
{
}
#endif
#ifdef QCA_SUPPORT_TXRX_DRIVER_TCP_DEL_ACK
static inline
void hdd_set_driver_del_ack_enable(uint16_t session_id, hdd_context_t *hdd_ctx,
uint64_t rx_packets)
{
tlshim_set_driver_del_ack_enable(session_id, rx_packets,
hdd_ctx->cfg_ini->busBandwidthComputeInterval,
hdd_ctx->cfg_ini->del_ack_threshold_high,
hdd_ctx->cfg_ini->del_ack_threshold_low);
}
#else
static inline
void hdd_set_driver_del_ack_enable(uint16_t session_id, hdd_context_t *hdd_ctx,
uint64_t rx_packets)
{
}
#endif
int hdd_reassoc(hdd_adapter_t *pAdapter, const tANI_U8 *bssid,
const tANI_U8 channel, const handoff_src src);
void hdd_sap_restart_handle(struct work_struct *work);
void hdd_set_rps_cpu_mask(hdd_context_t *hdd_ctx);
void hdd_initialize_adapter_common(hdd_adapter_t *adapter);
void hdd_svc_fw_shutdown_ind(struct device *dev);
void wlan_hdd_stop_enter_lowpower(hdd_context_t *hdd_ctx);
void wlan_hdd_init_chan_info(hdd_context_t *hdd_ctx);
void wlan_hdd_deinit_chan_info(hdd_context_t *hdd_ctx);
void hdd_chip_pwr_save_fail_detected_cb(void *hddctx,
struct chip_pwr_save_fail_detected_params
*data);
/**
* hdd_drv_cmd_validate() - Validates for space in hdd driver command
* @command: pointer to input data (its a NULL terminated string)
* @len: length of command name
*
* This function checks for space after command name and if no space
* is found returns error.
*
* Return: 0 for success non-zero for failure
*/
int hdd_drv_cmd_validate(tANI_U8 *command, int len);
/**
* wlan_hdd_monitor_mode_enable() - function to enable/disable monitor mode
* @hdd_ctx: pointer to HDD context
* @enable: 0 - disable, 1 - enable
*
* Return: 0 for success and error number for failure
*/
int wlan_hdd_monitor_mode_enable(hdd_context_t *hdd_ctx, bool enable);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0))
static inline int
hdd_wlan_nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
{
return nla_put_u64(skb, attrtype, value);
}
#else
static inline int
hdd_wlan_nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
{
return nla_put_u64_64bit(skb, attrtype, value,
QCA_WLAN_VENDOR_ATTR_LL_STATS_PAD);
}
#endif
#endif // end #if !defined( WLAN_HDD_MAIN_H )