xref: /wlan-driver/qcacld-3.0/core/hdd/inc/wlan_hdd_main.h (revision 5113495b16420b49004c444715d2daae2066e7dc) !
1 /*
2  * Copyright (c) 2012-2021 The Linux Foundation. All rights reserved.
3  * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for
6  * any purpose with or without fee is hereby granted, provided that the
7  * above copyright notice and this permission notice appear in all
8  * copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17  * PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #if !defined(WLAN_HDD_MAIN_H)
21 #define WLAN_HDD_MAIN_H
22 /**
23  * DOC: wlan_hdd_main.h
24  *
25  * Linux HDD Adapter Type
26  */
27 
28 /*
29  * The following terms were in use in prior versions of the driver but
30  * have now been replaced with terms that are aligned with the Linux
31  * Coding style. Macros are defined to hopefully prevent new instances
32  * from being introduced, primarily by code propagation.
33  */
34 #define pHddCtx
35 #define pAdapter
36 #define pHostapdAdapter
37 #define pHddApCtx
38 #define pHddStaCtx
39 #define pHostapdState
40 #define pRoamInfo
41 #define pScanInfo
42 #define pBeaconIes
43 
44 /*
45  * Include files
46  */
47 
48 #include <linux/netdevice.h>
49 #include <linux/skbuff.h>
50 #include <net/cfg80211.h>
51 #include <linux/ieee80211.h>
52 #include <qdf_delayed_work.h>
53 #include <qdf_list.h>
54 #include <qdf_types.h>
55 #include "sir_mac_prot_def.h"
56 #include "csr_api.h"
57 #include "wlan_dsc.h"
58 #include <wlan_hdd_assoc.h>
59 #include <wlan_hdd_wmm.h>
60 #include <wlan_hdd_cfg.h>
61 #include <linux/spinlock.h>
62 #include <ani_system_defs.h>
63 #if defined(CONFIG_HAS_WAKELOCK)
64 #include <linux/wakelock.h>
65 #endif
66 #ifdef WLAN_FEATURE_TSF_PTP
67 #include <linux/ptp_classify.h>
68 #include <linux/ptp_clock_kernel.h>
69 #endif
70 #include <wlan_hdd_ftm.h>
71 #include "wlan_hdd_tdls.h"
72 #include "wlan_hdd_tsf.h"
73 #include "wlan_hdd_cfg80211.h"
74 #include "wlan_hdd_debugfs.h"
75 #include <qdf_defer.h>
76 #include "sap_api.h"
77 #include "cdp_txrx_flow_ctrl_legacy.h"
78 #include <cdp_txrx_peer_ops.h>
79 #include <cdp_txrx_misc.h>
80 #include "wlan_hdd_nan_datapath.h"
81 #if defined(CONFIG_HL_SUPPORT)
82 #include "wlan_tgt_def_config_hl.h"
83 #else
84 #include "wlan_tgt_def_config.h"
85 #endif
86 #include <wlan_objmgr_cmn.h>
87 #include <wlan_objmgr_global_obj.h>
88 #include <wlan_objmgr_psoc_obj.h>
89 #include <wlan_objmgr_pdev_obj.h>
90 #include <wlan_objmgr_vdev_obj.h>
91 #include <wlan_objmgr_peer_obj.h>
92 #include "wlan_pmo_ucfg_api.h"
93 #ifdef WIFI_POS_CONVERGED
94 #include "os_if_wifi_pos.h"
95 #include "wifi_pos_api.h"
96 #else
97 #include "wlan_hdd_oemdata.h"
98 #endif
99 #include "wlan_hdd_he.h"
100 
101 #include <net/neighbour.h>
102 #include <net/netevent.h>
103 #include "wlan_hdd_twt.h"
104 #include "wma_sar_public_structs.h"
105 #include "wlan_mlme_ucfg_api.h"
106 #include "pld_common.h"
107 #include "wlan_cm_roam_public_struct.h"
108 
109 #ifdef WLAN_FEATURE_DP_BUS_BANDWIDTH
110 #include "qdf_periodic_work.h"
111 #endif
112 
113 #if defined(CLD_PM_QOS) || defined(FEATURE_RUNTIME_PM)
114 #include <linux/pm_qos.h>
115 #endif
116 
117 #include "wlan_hdd_sta_info.h"
118 #include <wlan_hdd_cm_api.h>
119 #include "wlan_hdd_mlo.h"
120 #include "wlan_osif_features.h"
121 #include "wlan_dp_public_struct.h"
122 
123 /*
124  * Preprocessor definitions and constants
125  */
126 
127 /* Milli seconds to delay SSR thread when an packet is getting processed */
128 #define SSR_WAIT_SLEEP_TIME 200
129 /* MAX iteration count to wait for dp tx to complete */
130 #define MAX_SSR_WAIT_ITERATIONS 100
131 #define MAX_SSR_PROTECT_LOG (16)
132 
133 #define HDD_MAX_OEM_DATA_LEN 1024
134 #define HDD_MAX_FILE_NAME_LEN 64
135 #ifdef FEATURE_WLAN_APF
136 /**
137  * struct hdd_apf_context - hdd Context for apf
138  * @magic: magic number
139  * @qdf_apf_event: Completion variable for APF get operations
140  * @capability_response: capabilities response received from fw
141  * @apf_enabled: True: APF Interpreter enabled, False: Disabled
142  * @cmd_in_progress: Flag that indicates an APF command is in progress
143  * @buf: Buffer to accumulate read memory chunks
144  * @buf_len: Length of the read memory requested
145  * @offset: APF work memory offset to fetch from
146  * @lock: APF Context lock
147  */
148 struct hdd_apf_context {
149 	unsigned int magic;
150 	qdf_event_t qdf_apf_event;
151 	bool apf_enabled;
152 	bool cmd_in_progress;
153 	uint8_t *buf;
154 	uint32_t buf_len;
155 	uint32_t offset;
156 	qdf_spinlock_t lock;
157 };
158 #endif /* FEATURE_WLAN_APF */
159 
160 #ifdef TX_MULTIQ_PER_AC
161 #define TX_GET_QUEUE_IDX(ac, off) (((ac) * TX_QUEUES_PER_AC) + (off))
162 #define TX_QUEUES_PER_AC 4
163 #else
164 #define TX_GET_QUEUE_IDX(ac, off) (ac)
165 #define TX_QUEUES_PER_AC 1
166 #endif
167 
168 /** Number of Tx Queues */
169 #if defined(QCA_LL_TX_FLOW_CONTROL_V2) || \
170 	defined(QCA_HL_NETDEV_FLOW_CONTROL) || \
171 	defined(QCA_LL_PDEV_TX_FLOW_CONTROL)
172 /* Only one HI_PRIO queue */
173 #define NUM_TX_QUEUES (4 * TX_QUEUES_PER_AC + 1)
174 #else
175 #define NUM_TX_QUEUES (4 * TX_QUEUES_PER_AC)
176 #endif
177 
178 #define NUM_RX_QUEUES 5
179 
180 /*
181  * Number of DPTRACE records to dump when a cfg80211 disconnect with reason
182  * WLAN_REASON_DEAUTH_LEAVING DEAUTH is received from user-space.
183  */
184 #define WLAN_DEAUTH_DPTRACE_DUMP_COUNT 100
185 
186 /* HDD_IS_RATE_LIMIT_REQ: Macro helper to implement rate limiting
187  * @flag: The flag to determine if limiting is required or not
188  * @rate: The number of seconds within which if multiple commands come, the
189  *	  flag will be set to true
190  *
191  * If the function in which this macro is used is called multiple times within
192  * "rate" number of seconds, the "flag" will be set to true which can be used
193  * to reject/take appropriate action.
194  */
195 #define HDD_IS_RATE_LIMIT_REQ(flag, rate)\
196 	do {\
197 		static ulong __last_ticks;\
198 		ulong __ticks = jiffies;\
199 		flag = false; \
200 		if (!time_after(__ticks,\
201 		    __last_ticks + rate * HZ)) {\
202 			flag = true; \
203 		} \
204 		else { \
205 			__last_ticks = __ticks;\
206 		} \
207 	} while (0)
208 
209 /*
210  * API in_compat_syscall() is introduced in 4.6 kernel to check whether we're
211  * in a compat syscall or not. It is a new way to query the syscall type, which
212  * works properly on all architectures.
213  *
214  */
215 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0))
in_compat_syscall(void)216 static inline bool in_compat_syscall(void) { return is_compat_task(); }
217 #endif
218 
219 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0)) || \
220 	defined(CFG80211_REMOVE_IEEE80211_BACKPORT)
221 #define HDD_NL80211_BAND_2GHZ   NL80211_BAND_2GHZ
222 #define HDD_NL80211_BAND_5GHZ   NL80211_BAND_5GHZ
223 #define HDD_NUM_NL80211_BANDS   NUM_NL80211_BANDS
224 #else
225 #define HDD_NL80211_BAND_2GHZ   IEEE80211_BAND_2GHZ
226 #define HDD_NL80211_BAND_5GHZ   IEEE80211_BAND_5GHZ
227 #define HDD_NUM_NL80211_BANDS   ((enum nl80211_band)IEEE80211_NUM_BANDS)
228 #endif
229 
230 #if defined(CONFIG_BAND_6GHZ) && (defined(CFG80211_6GHZ_BAND_SUPPORTED) || \
231 	(KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE))
232 #define HDD_NL80211_BAND_6GHZ   NL80211_BAND_6GHZ
233 #endif
234 
235 #define TSF_GPIO_PIN_INVALID 255
236 
237 /** Length of the TX queue for the netdev */
238 #define HDD_NETDEV_TX_QUEUE_LEN (3000)
239 
240 /** Hdd Tx Time out value */
241 #define HDD_TX_TIMEOUT          msecs_to_jiffies(5000)
242 
243 #define HDD_TX_STALL_THRESHOLD 4
244 
245 /** Hdd Default MTU */
246 #define HDD_DEFAULT_MTU         (1500)
247 
248 #ifdef QCA_CONFIG_SMP
249 #define NUM_CPUS NR_CPUS
250 #else
251 #define NUM_CPUS 1
252 #endif
253 
254 #define ACS_COMPLETE_TIMEOUT 3000
255 
256 #define HDD_PSOC_IDLE_SHUTDOWN_SUSPEND_DELAY (1000)
257 /**
258  * enum hdd_adapter_flags - event bitmap flags registered net device
259  * @NET_DEVICE_REGISTERED: Adapter is registered with the kernel
260  * @WMM_INIT_DONE: Adapter is initialized
261  * @DEVICE_IFACE_OPENED: Adapter has been "opened" via the kernel
262  * @WDEV_ONLY_REGISTERED: Only WDEV is registered
263  */
264 enum hdd_adapter_flags {
265 	NET_DEVICE_REGISTERED,
266 	WMM_INIT_DONE,
267 	DEVICE_IFACE_OPENED,
268 	WDEV_ONLY_REGISTERED,
269 };
270 
271 /**
272  * enum hdd_link_flags - Event bitmap flags specific to per link
273  * @SME_SESSION_OPENED: Firmware vdev has been created
274  * @SOFTAP_BSS_STARTED: Software Access Point (SAP) is running
275  * @SOFTAP_INIT_DONE: Software Access Point (SAP) is initialized
276  * @VENDOR_ACS_RESPONSE_PENDING: Waiting for event for vendor acs
277  */
278 enum hdd_link_flags {
279 	SME_SESSION_OPENED,
280 	SOFTAP_BSS_STARTED,
281 	SOFTAP_INIT_DONE,
282 	VENDOR_ACS_RESPONSE_PENDING,
283 };
284 
285 /**
286  * enum hdd_nb_cmd_id - North bound command IDs received during SSR
287  * @NO_COMMAND: No NB command received during SSR
288  * @INTERFACE_DOWN: Received interface down during SSR
289  */
290 enum hdd_nb_cmd_id {
291 	NO_COMMAND,
292 	INTERFACE_DOWN
293 };
294 
295 #define WLAN_WAIT_TIME_STATS       800
296 #define WLAN_WAIT_TIME_LINK_STATUS 800
297 
298 /** Maximum time(ms) to wait for mc thread suspend **/
299 #define WLAN_WAIT_TIME_MCTHREAD_SUSPEND  1200
300 
301 /** Maximum time(ms) to wait for target to be ready for suspend **/
302 #define WLAN_WAIT_TIME_READY_TO_SUSPEND  2000
303 
304 /* Scan Req Timeout */
305 #define WLAN_WAIT_TIME_SCAN_REQ 100
306 
307 #define WLAN_WAIT_TIME_APF     1000
308 
309 #define WLAN_WAIT_TIME_FW_ROAM_STATS 1000
310 
311 #define WLAN_WAIT_TIME_ANTENNA_ISOLATION 8000
312 
313 /* Maximum time(ms) to wait for RSO CMD status event */
314 #define WAIT_TIME_RSO_CMD_STATUS 2000
315 
316 /* rcpi request timeout in milli seconds */
317 #define WLAN_WAIT_TIME_RCPI 500
318 
319 #define WLAN_WAIT_PEER_CLEANUP 5000
320 
321 #define MAX_CFG_STRING_LEN  255
322 
323 /* Maximum time(ms) to wait for external acs response */
324 #define WLAN_VENDOR_ACS_WAIT_TIME 1000
325 
326 /* Maximum time(ms) to wait for monitor mode vdev up event completion*/
327 #define WLAN_MONITOR_MODE_VDEV_UP_EVT      SME_CMD_VDEV_START_BSS_TIMEOUT
328 
329 /* Mac Address string length */
330 #define MAC_ADDRESS_STR_LEN 18  /* Including null terminator */
331 /* Max and min IEs length in bytes */
332 #define MAX_GENIE_LEN (512)
333 #define MIN_GENIE_LEN (2)
334 
335 #define WPS_OUI_TYPE   "\x00\x50\xf2\x04"
336 #define WPS_OUI_TYPE_SIZE  4
337 
338 #define P2P_OUI_TYPE   "\x50\x6f\x9a\x09"
339 #define P2P_OUI_TYPE_SIZE  4
340 
341 #define OSEN_OUI_TYPE   "\x50\x6f\x9a\x12"
342 #define OSEN_OUI_TYPE_SIZE  4
343 
344 #ifdef WLAN_FEATURE_WFD
345 #define WFD_OUI_TYPE   "\x50\x6f\x9a\x0a"
346 #define WFD_OUI_TYPE_SIZE  4
347 #endif
348 
349 #define MBO_OUI_TYPE   "\x50\x6f\x9a\x16"
350 #define MBO_OUI_TYPE_SIZE  4
351 
352 #define QCN_OUI_TYPE   "\x8c\xfd\xf0\x01"
353 #define QCN_OUI_TYPE_SIZE  4
354 
355 #define wlan_hdd_get_wps_ie_ptr(ie, ie_len) \
356 	wlan_get_vendor_ie_ptr_from_oui(WPS_OUI_TYPE, WPS_OUI_TYPE_SIZE, \
357 	ie, ie_len)
358 
359 #define hdd_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_HDD, params)
360 #define hdd_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_HDD, params)
361 #define hdd_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_HDD, params)
362 #define hdd_info(params...) QDF_TRACE_INFO(QDF_MODULE_ID_HDD, params)
363 #define hdd_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_HDD, params)
364 
365 #define hdd_nofl_alert(params...) \
366 	QDF_TRACE_FATAL_NO_FL(QDF_MODULE_ID_HDD, params)
367 #define hdd_nofl_err(params...) \
368 	QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_HDD, params)
369 #define hdd_nofl_warn(params...) \
370 	QDF_TRACE_WARN_NO_FL(QDF_MODULE_ID_HDD, params)
371 #define hdd_nofl_info(params...) \
372 	QDF_TRACE_INFO_NO_FL(QDF_MODULE_ID_HDD, params)
373 #define hdd_nofl_debug(params...) \
374 	QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_HDD, params)
375 
376 #define hdd_alert_rl(params...) QDF_TRACE_FATAL_RL(QDF_MODULE_ID_HDD, params)
377 #define hdd_err_rl(params...) QDF_TRACE_ERROR_RL(QDF_MODULE_ID_HDD, params)
378 #define hdd_warn_rl(params...) QDF_TRACE_WARN_RL(QDF_MODULE_ID_HDD, params)
379 #define hdd_info_rl(params...) QDF_TRACE_INFO_RL(QDF_MODULE_ID_HDD, params)
380 #define hdd_debug_rl(params...) QDF_TRACE_DEBUG_RL(QDF_MODULE_ID_HDD, params)
381 
382 #define hdd_enter() QDF_TRACE_ENTER(QDF_MODULE_ID_HDD, "enter")
383 #define hdd_enter_dev(dev) \
384 	QDF_TRACE_ENTER(QDF_MODULE_ID_HDD, "enter(%s)", (dev)->name)
385 #define hdd_exit() QDF_TRACE_EXIT(QDF_MODULE_ID_HDD, "exit")
386 
387 #define WLAN_HDD_GET_PRIV_PTR(__dev__) \
388 		(struct hdd_adapter *)(netdev_priv((__dev__)))
389 
390 #define MAX_NO_OF_2_4_CHANNELS 14
391 
392 #define WLAN_HDD_PUBLIC_ACTION_FRAME_OFFSET 24
393 
394 #define WLAN_HDD_IS_SOCIAL_CHANNEL(center_freq)	\
395 	(((center_freq) == 2412) || ((center_freq) == 2437) || \
396 	((center_freq) == 2462))
397 
398 #define WLAN_HDD_QOS_ACTION_FRAME 1
399 #define WLAN_HDD_QOS_MAP_CONFIGURE 4
400 #define HDD_SAP_WAKE_LOCK_DURATION WAKELOCK_DURATION_RECOMMENDED
401 
402 /* SAP client disconnect wake lock duration in milli seconds */
403 #define HDD_SAP_CLIENT_DISCONNECT_WAKE_LOCK_DURATION \
404 	WAKELOCK_DURATION_RECOMMENDED
405 
406 #define HDD_CFG_REQUEST_FIRMWARE_RETRIES (3)
407 #define HDD_CFG_REQUEST_FIRMWARE_DELAY (20)
408 
409 #define MAX_USER_COMMAND_SIZE 4096
410 #define DNS_DOMAIN_NAME_MAX_LEN 255
411 #define ICMPv6_ADDR_LEN 16
412 
413 
414 #define HDD_MIN_TX_POWER (-100) /* minimum tx power */
415 #define HDD_MAX_TX_POWER (+100) /* maximum tx power */
416 
417 /* If IPA UC data path is enabled, target should reserve extra tx descriptors
418  * for IPA data path.
419  * Then host data path should allow less TX packet pumping in case
420  * IPA data path enabled
421  */
422 #define WLAN_TFC_IPAUC_TX_DESC_RESERVE   100
423 
424 /*
425  * NET_NAME_UNKNOWN is only introduced after Kernel 3.17, to have a macro
426  * here if the Kernel version is less than 3.17 to avoid the interleave
427  * conditional compilation.
428  */
429 #if !((LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0)) ||\
430 	defined(WITH_BACKPORTS))
431 #define NET_NAME_UNKNOWN	0
432 #endif
433 
434 #define PRE_CAC_SSID "pre_cac_ssid"
435 
436 #define SCAN_REJECT_THRESHOLD_TIME 300000 /* Time is in msec, equal to 5 mins */
437 #define SCAN_REJECT_THRESHOLD 15
438 
439 /* Default Psoc id */
440 #define DEFAULT_PSOC_ID 1
441 
442 /* wait time for nud stats in milliseconds */
443 #define WLAN_WAIT_TIME_NUD_STATS 800
444 /* nud stats skb max length */
445 #define WLAN_NUD_STATS_LEN 800
446 /* ARP packet type for NUD debug stats */
447 #define WLAN_NUD_STATS_ARP_PKT_TYPE 1
448 /* Assigned size of driver memory dump is 4096 bytes */
449 #define DRIVER_MEM_DUMP_SIZE    4096
450 
451 /* MAX OS Q block time value in msec
452  * Prevent from permanent stall, resume OS Q if timer expired
453  */
454 #define WLAN_HDD_TX_FLOW_CONTROL_OS_Q_BLOCK_TIME 1000
455 #define WLAN_SAP_HDD_TX_FLOW_CONTROL_OS_Q_BLOCK_TIME 100
456 #define WLAN_HDD_TX_FLOW_CONTROL_MAX_24BAND_CH   14
457 
458 #ifndef NUM_TX_RX_HISTOGRAM
459 #define NUM_TX_RX_HISTOGRAM 128
460 #endif
461 
462 #define NUM_TX_RX_HISTOGRAM_MASK (NUM_TX_RX_HISTOGRAM - 1)
463 
464 #define HDD_NOISE_FLOOR_DBM (-96)
465 
466 #define INTF_MACADDR_MASK       0x7
467 
468 /**
469  * typedef wlan_net_dev_ref_dbgid - Debug IDs to detect net device reference
470  *                                  leaks.
471  * NOTE: New values added to the enum must also be reflected in function
472  * net_dev_ref_debug_string_from_id()
473  */
474 typedef enum {
475 	NET_DEV_HOLD_ID_RESERVED = 0,
476 	NET_DEV_HOLD_GET_STA_CONNECTION_IN_PROGRESS = 1,
477 	NET_DEV_HOLD_CHECK_DFS_CHANNEL_FOR_ADAPTER = 2,
478 	NET_DEV_HOLD_GET_SAP_OPERATING_BAND = 3,
479 	NET_DEV_HOLD_RECOVERY_NOTIFIER_CALL = 4,
480 	NET_DEV_HOLD_IS_ANY_STA_CONNECTING = 5,
481 	NET_DEV_HOLD_SAP_DESTROY_CTX_ALL = 6,
482 	NET_DEV_HOLD_DRV_CMD_MAX_TX_POWER = 7,
483 	NET_DEV_HOLD_IPA_SET_TX_FLOW_INFO = 8,
484 	NET_DEV_HOLD_SET_RPS_CPU_MASK = 9,
485 	NET_DEV_HOLD_DFS_INDICATE_RADAR = 10,
486 	NET_DEV_HOLD_MAX_STA_INTERFACE_UP_COUNT_REACHED = 11,
487 	NET_DEV_HOLD_IS_CHAN_SWITCH_IN_PROGRESS = 12,
488 	NET_DEV_HOLD_STA_DESTROY_CTX_ALL = 13,
489 	NET_DEV_HOLD_CHECK_FOR_EXISTING_MACADDR = 14,
490 	NET_DEV_HOLD_DEINIT_ALL_ADAPTERS = 15,
491 	NET_DEV_HOLD_STOP_ALL_ADAPTERS = 16,
492 	NET_DEV_HOLD_RESET_ALL_ADAPTERS = 17,
493 	NET_DEV_HOLD_IS_ANY_INTERFACE_OPEN = 18,
494 	NET_DEV_HOLD_START_ALL_ADAPTERS = 19,
495 	NET_DEV_HOLD_GET_ADAPTER_BY_RAND_MACADDR = 20,
496 	NET_DEV_HOLD_GET_ADAPTER_BY_MACADDR = 21,
497 	NET_DEV_HOLD_GET_ADAPTER_BY_VDEV = 22,
498 	NET_DEV_HOLD_ADAPTER_GET_BY_REFERENCE = 23,
499 	NET_DEV_HOLD_GET_ADAPTER_BY_IFACE_NAME = 24,
500 	NET_DEV_HOLD_GET_ADAPTER = 25,
501 	NET_DEV_HOLD_GET_OPERATING_CHAN_FREQ = 26,
502 	NET_DEV_HOLD_UNREGISTER_WEXT_ALL_ADAPTERS = 27,
503 	NET_DEV_HOLD_ABORT_MAC_SCAN_ALL_ADAPTERS = 28,
504 	NET_DEV_HOLD_ABORT_SCHED_SCAN_ALL_ADAPTERS = 29,
505 	NET_DEV_HOLD_GET_FIRST_VALID_ADAPTER = 30,
506 	NET_DEV_HOLD_CLEAR_RPS_CPU_MASK = 31,
507 	NET_DEV_HOLD_BUS_BW_WORK_HANDLER = 32,
508 	NET_DEV_HOLD_DISPLAY_NETIF_QUEUE_HISTORY_COMPACT = 33,
509 	NET_DEV_HOLD_DISPLAY_NETIF_QUEUE_HISTORY = 34,
510 	NET_DEV_HOLD_CLEAR_NETIF_QUEUE_HISTORY = 35,
511 	NET_DEV_HOLD_UNSAFE_CHANNEL_RESTART_SAP = 36,
512 	NET_DEV_HOLD_INDICATE_MGMT_FRAME = 37,
513 	NET_DEV_HOLD_STATE_INFO_DUMP = 38,
514 	NET_DEV_HOLD_DISABLE_ROAMING = 39,
515 	NET_DEV_HOLD_ENABLE_ROAMING = 40,
516 	NET_DEV_HOLD_AUTO_SHUTDOWN_ENABLE = 41,
517 	NET_DEV_HOLD_GET_CON_SAP_ADAPTER = 42,
518 	NET_DEV_HOLD_IS_ANY_ADAPTER_CONNECTED = 43,
519 	NET_DEV_HOLD_IS_ROAMING_IN_PROGRESS = 44,
520 	NET_DEV_HOLD_DEL_P2P_INTERFACE = 45,
521 	NET_DEV_HOLD_IS_NDP_ALLOWED = 46,
522 	NET_DEV_HOLD_NDI_OPEN = 47,
523 	NET_DEV_HOLD_SEND_OEM_REG_RSP_NLINK_MSG = 48,
524 	NET_DEV_HOLD_PERIODIC_STA_STATS_DISPLAY = 49,
525 	NET_DEV_HOLD_SUSPEND_WLAN = 50,
526 	NET_DEV_HOLD_RESUME_WLAN = 51,
527 	NET_DEV_HOLD_SSR_RESTART_SAP = 52,
528 	NET_DEV_HOLD_SEND_DEFAULT_SCAN_IES = 53,
529 	NET_DEV_HOLD_CFG80211_SUSPEND_WLAN = 54,
530 	NET_DEV_HOLD_COUNTRY_CHANGE_UPDATE_STA = 55,
531 	NET_DEV_HOLD_COUNTRY_CHANGE_UPDATE_SAP = 56,
532 	NET_DEV_HOLD_CACHE_STATION_STATS_CB = 57,
533 	NET_DEV_HOLD_DISPLAY_TXRX_STATS = 58,
534 	NET_DEV_HOLD_BUS_BW_MGR = 59,
535 	NET_DEV_HOLD_START_PRE_CAC_TRANS = 60,
536 	NET_DEV_HOLD_IS_ANY_STA_CONNECTED = 61,
537 	NET_DEV_HOLD_GET_ADAPTER_BY_BSSID = 62,
538 	NET_DEV_HOLD_ALLOW_NEW_INTF = 63,
539 
540 	/* Keep it at the end */
541 	NET_DEV_HOLD_ID_MAX
542 } wlan_net_dev_ref_dbgid;
543 
544 struct hdd_tx_rx_stats {
545 	struct {
546 		/* start_xmit stats */
547 		__u32    tx_classified_ac[WLAN_MAX_AC];
548 		__u32    tx_dropped_ac[WLAN_MAX_AC];
549 #ifdef TX_MULTIQ_PER_AC
550 		/* Neither valid socket nor skb->hash */
551 		uint32_t inv_sk_and_skb_hash;
552 		/* skb->hash already calculated */
553 		uint32_t qselect_existing_skb_hash;
554 		/* valid tx queue id in socket */
555 		uint32_t qselect_sk_tx_map;
556 		/* skb->hash calculated in select queue */
557 		uint32_t qselect_skb_hash_calc;
558 #endif
559 	} per_cpu[NUM_CPUS];
560 
561 	/* txflow stats */
562 	bool     is_txflow_paused;
563 	__u32    txflow_pause_cnt;
564 	__u32    txflow_unpause_cnt;
565 	__u32    txflow_timer_cnt;
566 
567 };
568 
569 /**
570  * struct hdd_pmf_stats - Protected Management Frame statistics
571  * @num_unprot_deauth_rx: Number of unprotected deauth frames received
572  * @num_unprot_disassoc_rx: Number of unprotected disassoc frames received
573  */
574 struct hdd_pmf_stats {
575 	uint8_t num_unprot_deauth_rx;
576 	uint8_t num_unprot_disassoc_rx;
577 };
578 
579 /**
580  * struct hdd_peer_stats - Peer stats at HDD level
581  * @rx_count: RX count
582  * @rx_bytes: RX bytes
583  * @fcs_count: FCS err count
584  */
585 struct hdd_peer_stats {
586 	uint32_t rx_count;
587 	uint64_t rx_bytes;
588 	uint32_t fcs_count;
589 };
590 
591 #define HDD_MAX_PER_PEER_RATES 16
592 #if defined(WLAN_FEATURE_11BE_MLO)
593 /**
594  * struct wlan_hdd_station_stats_info - Station stats info
595  * @signal: Signal strength of last received PPDU
596  * @signal_avg: Average signal strength
597  * @chain_signal_avg: Per-chain signal strength average
598  * @rxrate: Last unicast data frame rx rate
599  * @txrate: Current unicasr tx rate
600  * @rx_bytes: Total received bytes (MPDU length)
601  * @tx_bytes: Total transmitted bytes (MPDU length)
602  * @rx_packets: Total received packets (MSDUs and MMPDUs)
603  * @tx_packets: Total transmitted packets (MSDUs and MMPDUs)
604  * @tx_retries: Cumulative retry count (MPDU)
605  * @tx_failed: Number of failed transmissions (MPDUs)
606  * @rx_mpdu_count: Number of MPDUs received from this station
607  * @fcs_err_count: Number of MPDUs received from this station with an FCS error
608  */
609 struct wlan_hdd_station_stats_info {
610 	int8_t signal;
611 	int8_t signal_avg;
612 	int8_t chain_signal_avg[IEEE80211_MAX_CHAINS];
613 	struct rate_info txrate;
614 	struct rate_info rxrate;
615 	uint64_t rx_bytes;
616 	uint64_t tx_bytes;
617 	uint32_t rx_packets;
618 	uint32_t tx_packets;
619 	uint32_t tx_retries;
620 	uint32_t tx_failed;
621 	uint32_t rx_mpdu_count;
622 	uint32_t fcs_err_count;
623 };
624 
625 /**
626  * struct wlan_hdd_mlo_iface_stats_info - mlo iface stats info
627  * @link_id: mlo link_id
628  * @freq: frequency of the mlo link
629  * @radio_id: radio id of the mlo link
630  */
631 struct wlan_hdd_mlo_iface_stats_info {
632 	uint8_t link_id;
633 	uint32_t freq;
634 	uint32_t radio_id;
635 };
636 
637 /**
638  * struct wlan_hdd_peer_info - hdd per peer info
639  * @type: peer type (AP, TDLS, GO etc.)
640  * @peer_mac: peer mac address
641  * @capabilities: peer WIFI_CAPABILITY_XXX
642  * @power_saving: peer power saving mode
643  * @num_rate: number of rates
644  * @rate_stats: per rate statistics, num entries = HDD_MAX_PER_PEER_RATES
645  * @stats_cached: whether peer stats cached into link_info struct
646  * @link_id: IEEE link id for the link
647  */
648 struct wlan_hdd_peer_info {
649 	enum wmi_peer_type type;
650 	struct qdf_mac_addr peer_mac;
651 	uint32_t capabilities;
652 	union {
653 		uint32_t power_saving;
654 		uint32_t num_rate;
655 	};
656 	struct wifi_rate_stat rate_stats[HDD_MAX_PER_PEER_RATES];
657 	bool stats_cached;
658 	uint32_t link_id;
659 };
660 #endif
661 
662 #define MAX_SUBTYPES_TRACKED	4
663 
664 struct hdd_stats {
665 	tCsrSummaryStatsInfo summary_stat;
666 	tCsrGlobalClassAStatsInfo class_a_stat;
667 	tCsrGlobalClassDStatsInfo class_d_stat;
668 	struct csr_per_chain_rssi_stats_info  per_chain_rssi_stats;
669 	struct hdd_tx_rx_stats tx_rx_stats;
670 	struct hdd_peer_stats peer_stats;
671 	struct hdd_pmf_stats hdd_pmf_stats;
672 	struct pmf_bcn_protect_stats bcn_protect_stats;
673 };
674 
675 /**
676  * struct hdd_roaming_info - HDD Internal Roaming Information
677  * @bssid: BSSID to which we are connected
678  * @peer_mac: Peer MAC address for IBSS connection
679  * @roam_id: Unique identifier for a roaming instance
680  * @roam_status: Current roam command status
681  */
682 struct hdd_roaming_info {
683 	tSirMacAddr bssid;
684 	tSirMacAddr peer_mac;
685 	uint32_t roam_id;
686 	eRoamCmdStatus roam_status;
687 };
688 
689 #ifdef FEATURE_WLAN_WAPI
690 /* Define WAPI macros for Length, BKID count etc*/
691 #define MAX_NUM_AKM_SUITES    16
692 
693 /** WAPI AUTH mode definition */
694 enum wapi_auth_mode {
695 	WAPI_AUTH_MODE_OPEN = 0,
696 	WAPI_AUTH_MODE_PSK = 1,
697 	WAPI_AUTH_MODE_CERT
698 } __packed;
699 
700 #define WPA_GET_LE16(a) ((u16) (((a)[1] << 8) | (a)[0]))
701 #define WPA_GET_BE24(a) ((u32) ((a[0] << 16) | (a[1] << 8) | a[2]))
702 #define WAPI_PSK_AKM_SUITE  0x02721400
703 #define WAPI_CERT_AKM_SUITE 0x01721400
704 
705 /**
706  * struct hdd_wapi_info - WAPI Information structure definition
707  * @wapi_mode: Is WAPI enabled on this adapter?
708  * @is_wapi_sta: Is the STA associated with WAPI?
709  * @wapi_auth_mode: WAPI authentication mode used by this adapter
710  */
711 struct hdd_wapi_info {
712 	bool wapi_mode;
713 	bool is_wapi_sta;
714 	enum wapi_auth_mode wapi_auth_mode;
715 };
716 #endif /* FEATURE_WLAN_WAPI */
717 
718 struct hdd_beacon_data {
719 	u8 *head;
720 	u8 *tail;
721 	u8 *proberesp_ies;
722 	u8 *assocresp_ies;
723 	int head_len;
724 	int tail_len;
725 	int proberesp_ies_len;
726 	int assocresp_ies_len;
727 	int dtim_period;
728 };
729 
730 /**
731  * struct hdd_mon_set_ch_info - Holds monitor mode channel switch params
732  * @freq: Channel frequency.
733  * @cb_mode: Channel bonding
734  * @channel_width: Channel width 0/1/2 for 20/40/80MHz respectively.
735  * @phy_mode: PHY mode
736  */
737 struct hdd_mon_set_ch_info {
738 	uint32_t freq;
739 	uint8_t cb_mode;
740 	uint32_t channel_width;
741 	eCsrPhyMode phy_mode;
742 };
743 
744 /**
745  * struct hdd_station_ctx -- STA-specific information
746  * @roam_profile: current roaming profile
747  * @conn_info: current connection information
748  * @cache_conn_info: prev connection info
749  * @reg_phymode: reg phymode
750  * @ch_info: monitor mode channel information
751  * @ap_supports_immediate_power_save: Does the current AP allow our STA
752  *    to immediately go into power save?
753  * @user_cfg_chn_width: max channel bandwidth set by user space
754  */
755 struct hdd_station_ctx {
756 	uint32_t reg_phymode;
757 	struct csr_roam_profile roam_profile;
758 	struct hdd_connection_info conn_info;
759 	struct hdd_connection_info cache_conn_info;
760 	struct hdd_mon_set_ch_info ch_info;
761 	bool ap_supports_immediate_power_save;
762 	uint8_t user_cfg_chn_width;
763 };
764 
765 /**
766  * enum bss_state - current state of the BSS
767  * @BSS_STOP: BSS is stopped
768  * @BSS_START: BSS is started
769  */
770 enum bss_state {
771 	BSS_STOP,
772 	BSS_START,
773 };
774 
775 /**
776  * struct hdd_hostapd_state - hostapd-related state information
777  * @bss_state: Current state of the BSS
778  * @qdf_event: Event to synchronize actions between hostapd thread and
779  *    internal callback threads
780  * @qdf_stop_bss_event: Event to synchronize Stop BSS. When Stop BSS
781  *    is issued userspace thread can wait on this event. The event will
782  *    be set when the Stop BSS processing in UMAC has completed.
783  * @qdf_sta_disassoc_event: Event to synchronize STA Disassociation.
784  *    When a STA is disassociated userspace thread can wait on this
785  *    event. The event will be set when the STA Disassociation
786  *    processing in UMAC has completed.
787  * @qdf_sta_eap_frm_done_event: Event to synchronize P2P GO disassoc
788  *    frame and EAP frame.
789  * @qdf_status: Used to communicate state from other threads to the
790  *    userspace thread.
791  */
792 struct hdd_hostapd_state {
793 	enum bss_state bss_state;
794 	qdf_event_t qdf_event;
795 	qdf_event_t qdf_stop_bss_event;
796 	qdf_event_t qdf_sta_disassoc_event;
797 	qdf_event_t qdf_sta_eap_frm_done_event;
798 	QDF_STATUS qdf_status;
799 };
800 
801 /**
802  * enum bss_stop_reason - reasons why a BSS is stopped.
803  * @BSS_STOP_REASON_INVALID: no reason specified explicitly.
804  * @BSS_STOP_DUE_TO_MCC_SCC_SWITCH: BSS stopped due to host
805  *  driver is trying to switch AP role to a different channel
806  *  to maintain SCC mode with the STA role on the same card.
807  *  this usually happens when STA is connected to an external
808  *  AP that runs on a different channel
809  * @BSS_STOP_DUE_TO_VENDOR_CONFIG_CHAN: BSS stopped due to
810  *  vendor subcmd set sap config channel
811  */
812 enum bss_stop_reason {
813 	BSS_STOP_REASON_INVALID = 0,
814 	BSS_STOP_DUE_TO_MCC_SCC_SWITCH = 1,
815 	BSS_STOP_DUE_TO_VENDOR_CONFIG_CHAN = 2,
816 };
817 
818 /**
819  * struct hdd_rate_info - rate_info in HDD
820  * @rate: tx/rx rate (kbps)
821  * @mode: 0->11abg legacy, 1->HT, 2->VHT (refer to sir_sme_phy_mode)
822  * @nss: number of streams
823  * @mcs: mcs index for HT/VHT mode
824  * @rate_flags: rate flags for last tx/rx
825  *
826  * rate info in HDD
827  */
828 struct hdd_rate_info {
829 	uint32_t rate;
830 	uint8_t mode;
831 	uint8_t nss;
832 	uint8_t mcs;
833 	enum tx_rate_info rate_flags;
834 };
835 
836 enum hdd_work_status {
837 	HDD_WORK_UNINITIALIZED,
838 	HDD_WORK_INITIALIZED,
839 };
840 
841 /**
842  * struct hdd_fw_txrx_stats - fw txrx status in HDD
843  *                            (refer to station_info struct in Kernel)
844  * @tx_packets: packets transmitted to this station
845  * @tx_bytes: bytes transmitted to this station
846  * @rx_packets: packets received from this station
847  * @rx_bytes: bytes received from this station
848  * @tx_retries: cumulative retry counts
849  * @tx_failed: the number of failed frames
850  * @tx_succeed: the number of succeed frames
851  * @rssi: The signal strength (dbm)
852  * @tx_rate: last used tx rate info
853  * @rx_rate: last used rx rate info
854  *
855  * fw txrx status in HDD
856  */
857 struct hdd_fw_txrx_stats {
858 	uint32_t tx_packets;
859 	uint64_t tx_bytes;
860 	uint32_t rx_packets;
861 	uint64_t rx_bytes;
862 	uint32_t tx_retries;
863 	uint32_t tx_failed;
864 	uint32_t tx_succeed;
865 	int8_t rssi;
866 	struct hdd_rate_info tx_rate;
867 	struct hdd_rate_info rx_rate;
868 };
869 
870 /**
871  * struct hdd_ap_ctx - SAP/P2PGO specific information
872  * @hostapd_state: state control information
873  * @dfs_cac_block_tx: Is data tramsmission blocked due to DFS CAC?
874  * @ap_active: Are any stations active?
875  * @disable_intrabss_fwd: Prevent forwarding between stations
876  * @broadcast_sta_id: Station ID assigned after BSS starts
877  * @privacy: The privacy bits of configuration
878  * @encryption_type: The encryption being used
879  * @group_key: Group Encryption Key
880  * @wep_key: WEP key array
881  * @wep_def_key_idx: WEP default key index
882  * @sap_context: Pointer to context maintained by SAP (opaque to HDD)
883  * @sap_config: SAP configuration
884  * @operating_chan_freq: channel upon which the SAP is operating
885  * @beacon: Beacon information
886  * @vendor_acs_timer: Timer for ACS
887  * @vendor_acs_timer_initialized: Is @vendor_acs_timer initialized?
888  * @bss_stop_reason: Reason why the BSS was stopped
889  * @acs_in_progress: In progress acs flag for an adapter
890  * @ch_switch_in_progress: channel change in progress or not
891  * @client_count: client count per dot11_mode
892  * @country_ie_updated: country ie is updated or not by hdd hostapd
893  * @during_auth_offload: auth mgmt frame is offloading to hostapd
894  * @reg_punc_bitmap: puncturing bitmap
895  */
896 struct hdd_ap_ctx {
897 	struct hdd_hostapd_state hostapd_state;
898 	bool dfs_cac_block_tx;
899 	bool ap_active;
900 	bool disable_intrabss_fwd;
901 	uint8_t broadcast_sta_id;
902 	uint8_t privacy;
903 	eCsrEncryptionType encryption_type;
904 	uint8_t wep_def_key_idx;
905 	struct sap_context *sap_context;
906 	struct sap_config sap_config;
907 	uint32_t operating_chan_freq;
908 	struct hdd_beacon_data *beacon;
909 	qdf_mc_timer_t vendor_acs_timer;
910 	bool vendor_acs_timer_initialized;
911 	enum bss_stop_reason bss_stop_reason;
912 	qdf_atomic_t acs_in_progress;
913 	qdf_atomic_t ch_switch_in_progress;
914 	uint16_t client_count[QCA_WLAN_802_11_MODE_INVALID];
915 	bool country_ie_updated;
916 	bool during_auth_offload;
917 #ifdef WLAN_FEATURE_11BE
918 	uint16_t reg_punc_bitmap;
919 #endif
920 };
921 
922 /**
923  * struct hdd_scan_info - Per-adapter scan information
924  * @scan_add_ie: Additional IE for scan
925  * @default_scan_ies: Default scan IEs
926  * @default_scan_ies_len: Length of @default_scan_ies
927  * @scan_mode: Scan mode
928  */
929 struct hdd_scan_info {
930 	tSirAddie scan_add_ie;
931 	uint8_t *default_scan_ies;
932 	uint16_t default_scan_ies_len;
933 	tSirScanType scan_mode;
934 };
935 
936 #define WLAN_HDD_MAX_MC_ADDR_LIST CFG_TGT_MAX_MULTICAST_FILTER_ENTRIES
937 
938 struct hdd_multicast_addr_list {
939 	uint8_t mc_cnt;
940 	uint8_t addr[WLAN_HDD_MAX_MC_ADDR_LIST][ETH_ALEN];
941 };
942 
943 #define WLAN_HDD_MAX_HISTORY_ENTRY 25
944 
945 /**
946  * struct hdd_netif_queue_stats - netif queue operation statistics
947  * @pause_count: pause counter
948  * @unpause_count: unpause counter
949  * @total_pause_time: amount of time in paused state
950  */
951 struct hdd_netif_queue_stats {
952 	u32 pause_count;
953 	u32 unpause_count;
954 	qdf_time_t total_pause_time;
955 };
956 
957 /**
958  * struct hdd_netif_queue_history - netif queue operation history
959  * @time: timestamp
960  * @netif_action: action type
961  * @netif_reason: reason type
962  * @pause_map: pause map
963  * @tx_q_state: state of the netdev TX queues
964  */
965 struct hdd_netif_queue_history {
966 	qdf_time_t time;
967 	uint16_t netif_action;
968 	uint16_t netif_reason;
969 	uint32_t pause_map;
970 	unsigned long tx_q_state[NUM_TX_QUEUES];
971 };
972 
973 /**
974  * struct hdd_chan_change_params - channel related information
975  * @chan_freq: operating channel frequency
976  * @chan_params: channel parameters
977  */
978 struct hdd_chan_change_params {
979 	uint32_t chan_freq;
980 	struct ch_params chan_params;
981 };
982 
983 /**
984  * struct hdd_runtime_pm_context - context to prevent/allow runtime pm
985  * @dfs: dfs context to prevent/allow runtime pm
986  * @connect: connect context to prevent/allow runtime pm
987  * @user: user context to prevent/allow runtime pm
988  * @is_user_wakelock_acquired: boolean to check if user wakelock status
989  * @monitor_mode: monitor mode context to prevent/allow runtime pm
990  * @wow_unit_test: wow unit test mode context to prevent/allow runtime pm
991  * @system_suspend: system suspend context to prevent/allow runtime pm
992  * @dyn_mac_addr_update: update mac addr context to prevent/allow runtime pm
993  * @vdev_destroy: vdev destroy context to prevent/allow runtime pm
994  * @oem_data_cmd: OEM data context to prevent/allow runtime pm
995  *
996  * Runtime PM control for underlying activities
997  */
998 struct hdd_runtime_pm_context {
999 	qdf_runtime_lock_t dfs;
1000 	qdf_runtime_lock_t connect;
1001 	qdf_runtime_lock_t user;
1002 	bool is_user_wakelock_acquired;
1003 	qdf_runtime_lock_t monitor_mode;
1004 	qdf_runtime_lock_t wow_unit_test;
1005 	qdf_runtime_lock_t system_suspend;
1006 	qdf_runtime_lock_t dyn_mac_addr_update;
1007 	qdf_runtime_lock_t vdev_destroy;
1008 	qdf_runtime_lock_t oem_data_cmd;
1009 };
1010 
1011 /*
1012  * WLAN_HDD_ADAPTER_MAGIC is a magic number used to identify net devices
1013  * belonging to this driver from net devices belonging to other devices.
1014  * Therefore, the magic number must be unique relative to the numbers for
1015  * other drivers in the system. If WLAN_HDD_ADAPTER_MAGIC is already defined
1016  * (e.g. by compiler argument), then use that. If it's not already defined,
1017  * then use the first 4 characters of MULTI_IF_NAME to construct the magic
1018  * number. If MULTI_IF_NAME is not defined, then use a default magic number.
1019  */
1020 #ifndef WLAN_HDD_ADAPTER_MAGIC
1021 #ifdef MULTI_IF_NAME
1022 #define WLAN_HDD_ADAPTER_MAGIC                                          \
1023 	(MULTI_IF_NAME[0] == 0 ? 0x574c414e :                           \
1024 	(MULTI_IF_NAME[1] == 0 ? (MULTI_IF_NAME[0] << 24) :             \
1025 	(MULTI_IF_NAME[2] == 0 ? (MULTI_IF_NAME[0] << 24) |             \
1026 		(MULTI_IF_NAME[1] << 16) :                              \
1027 	(MULTI_IF_NAME[0] << 24) | (MULTI_IF_NAME[1] << 16) |           \
1028 	(MULTI_IF_NAME[2] << 8) | MULTI_IF_NAME[3])))
1029 #else
1030 #define WLAN_HDD_ADAPTER_MAGIC 0x574c414e       /* ASCII "WLAN" */
1031 #endif
1032 #endif
1033 
1034 /**
1035  * struct rcpi_info - rcpi info
1036  * @rcpi: computed value in dB
1037  * @mac_addr: peer mac addr for which rcpi is computed
1038  */
1039 struct rcpi_info {
1040 	int32_t rcpi;
1041 	struct qdf_mac_addr mac_addr;
1042 };
1043 
1044 struct hdd_context;
1045 
1046 #ifdef MULTI_CLIENT_LL_SUPPORT
1047 /* Max host clients which can request the FW arbiter with the latency level */
1048 #define WLM_MAX_HOST_CLIENT 5
1049 
1050 /**
1051  * struct wlm_multi_client_info_table - To store multi client id information
1052  * @client_id: host id for a client
1053  * @port_id: client id coming from upper layer
1054  * @in_use: set true for a client when host receives vendor cmd for that client
1055  */
1056 struct wlm_multi_client_info_table {
1057 	uint32_t client_id;
1058 	uint32_t port_id;
1059 	bool in_use;
1060 };
1061 #endif
1062 
1063 /**
1064  * enum udp_qos_upgrade - Enumeration of the various User priority (UP) types
1065  *			  UDP QoS upgrade request
1066  * @UDP_QOS_UPGRADE_NONE: Do not upgrade UDP QoS AC
1067  * @UDP_QOS_UPGRADE_BK_BE: Upgrade UDP QoS for BK/BE only
1068  * @UDP_QOS_UPGRADE_ALL: Upgrade UDP QoS for all packets
1069  * @UDP_QOS_UPGRADE_MAX: Max enum limit, not to add new beyond this
1070  */
1071 enum udp_qos_upgrade {
1072 	UDP_QOS_UPGRADE_NONE,
1073 	UDP_QOS_UPGRADE_BK_BE,
1074 	UDP_QOS_UPGRADE_ALL,
1075 	UDP_QOS_UPGRADE_MAX
1076 };
1077 
1078 #define WLAN_HDD_DEFLINK_IDX	0
1079 
1080 /**
1081  * struct wlan_hdd_link_info - Data structure to store the link specific info
1082  * @adapter: Reverse pointer to HDD adapter
1083  * @vdev_id: Unique value to identify VDEV. Equal to WLAN_UMAC_VDEV_ID_MAX
1084  *           for invalid VDEVs.
1085  * @vdev_lock: Lock to protect VDEV pointer access.
1086  * @vdev: Pointer to VDEV objmgr.
1087  * @vdev_destroy_event: vdev_destroy_event is moved from the qdf_event
1088  *                      to linux event consciously, Lets take example
1089  *                      when sap interface is waiting on the
1090  *                      session_close event and then there is a SSR
1091  *                      the wait event is completed the interface down
1092  *                      is returned and the next command to the driver
1093  *                      will be hdd_hostapd_uinit-->
1094  *                      hdd_deinit_ap_mode-->
1095  *                      hdd_hostapd_deinit_sap_session where in the
1096  *                      sap_ctx would be freed.  During the SSR if the
1097  *                      same sap context is used it would result in
1098  *                      null pointer de-reference.
1099  * @link_addr: Link MAC address
1100  * @session: union of @ap and @station specific structs
1101  * @session.station: station mode information
1102  * @session.ap: ap mode specific information
1103  * @acs_complete_event: acs complete event
1104  * @rssi: The signal strength (dBm)
1105  * @snr: SNR measured from @rssi
1106  * @rssi_on_disconnect: Rssi at disconnection time in STA mode
1107  * @rssi_send: Notify RSSI over lpass
1108  * @is_mlo_vdev_active: is the mlo vdev currently active
1109  * @estimated_linkspeed: estimated link speed
1110  * @hdd_stats: HDD statistics
1111  * @big_data_stats: Big data stats
1112  * @ll_iface_stats: Link Layer interface stats
1113  * @hdd_sinfo: hdd vdev station stats that will be sent to userspace
1114  * @mlo_peer_info: mlo peer stats info
1115  * @mscs_prev_tx_vo_pkts: count of prev VO AC packets transmitted
1116  * @mscs_counter: Counter on MSCS action frames sent
1117  * @link_flags: a bitmap of hdd_link_flags
1118  * @chan_change_notify_work: Channel change notify work
1119  */
1120 struct wlan_hdd_link_info {
1121 	struct hdd_adapter *adapter;
1122 	uint8_t vdev_id;
1123 	qdf_spinlock_t vdev_lock;
1124 	struct wlan_objmgr_vdev *vdev;
1125 	struct completion vdev_destroy_event;
1126 	struct qdf_mac_addr link_addr;
1127 
1128 	union {
1129 		struct hdd_station_ctx station;
1130 		struct hdd_ap_ctx ap;
1131 	} session;
1132 
1133 	qdf_event_t acs_complete_event;
1134 
1135 	int8_t rssi;
1136 	uint8_t snr;
1137 	int32_t rssi_on_disconnect;
1138 #ifdef WLAN_FEATURE_LPSS
1139 	bool rssi_send;
1140 #endif
1141 	bool is_mlo_vdev_active;
1142 	uint32_t estimated_linkspeed;
1143 	struct hdd_stats hdd_stats;
1144 #ifdef WLAN_FEATURE_BIG_DATA_STATS
1145 	struct big_data_stats_event big_data_stats;
1146 #endif
1147 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC)
1148 	struct wifi_interface_stats ll_iface_stats;
1149 	struct wlan_hdd_station_stats_info hdd_sinfo;
1150 	struct wlan_hdd_peer_info mlo_peer_info;
1151 #endif
1152 
1153 #ifdef WLAN_FEATURE_MSCS
1154 	unsigned long mscs_prev_tx_vo_pkts;
1155 	uint32_t mscs_counter;
1156 #endif /* WLAN_FEATURE_MSCS */
1157 
1158 	unsigned long link_flags;
1159 	qdf_work_t chan_change_notify_work;
1160 };
1161 
1162 /**
1163  * struct wlan_hdd_tx_power - Structure to store connection tx power info
1164  * @tx_pwr: connection tx power sent by firmware
1165  * @tx_pwr_cached_timestamp: timestamp when tx_pwr is cached into adapter
1166  */
1167 struct wlan_hdd_tx_power {
1168 	int tx_pwr;
1169 	uint32_t tx_pwr_cached_timestamp;
1170 };
1171 
1172 /**
1173  * struct hdd_adapter - hdd vdev/net_device context
1174  * @magic: Magic cookie for adapter sanity verification.  Note that this
1175  *         needs to be at the beginning of the private data structure so
1176  *         that it will exist at the beginning of dev->priv and hence
1177  *         will always be in mapped memory
1178  * @node: list node for membership in the adapter list
1179  * @hdd_ctx:
1180  * @dev: Handle to the network device
1181  * @device_mode:
1182  * @ipv4_notifier_work: IPv4 notifier callback for handling ARP offload on
1183  *                      change in IP
1184  * @ipv6_notifier_work: IPv6 notifier callback for handling NS offload on
1185  *                      change in IP
1186  * @wdev: TODO Move this to sta Ctx
1187  * @ops: ops checks if Opportunistic Power Save is Enable or Not
1188  * @ctw: stores CT Window value once we receive Opps command from
1189  *       wpa_supplicant then using CT Window value we need to Enable
1190  *       Opportunistic Power Save
1191  * @allow_power_save: STA/CLI powersave enable/disable from userspace
1192  * @mac_addr: Current MAC Address for the adapter
1193  * @mld_addr: MLD address for adapter
1194  * @event_flags: a bitmap of hdd_adapter_flags
1195  * @curr_link_info_map: Current mapping of link info in adapter array
1196  * @active_links: a bitmap of active links in @link_info array
1197  * @num_links_on_create: No of active links set on initial hdd_open_adapter().
1198  * @is_ll_stats_req_pending: atomic variable to check active stats req
1199  * @sta_stats_cached_timestamp: last updated stats timestamp
1200  * @qdf_monitor_mode_vdev_up_event: QDF event for monitor mode vdev up
1201  * @disconnect_comp_var: completion variable for disconnect callback
1202  * @linkup_event_var: completion variable for Linkup Event
1203  * @is_link_up_service_needed: Track whether the linkup handling is needed
1204  * @hdd_wmm_status: WMM Status
1205  * @sta_info:
1206  * @cache_sta_info:
1207  * @sta_info_list:
1208  * @cache_sta_info_list:
1209  * @cache_sta_count: number of currently cached stations
1210  * @wapi_info:
1211  * @sap_stop_bss_work:
1212  * @tsf: structure containing tsf related information
1213  * @mc_addr_list: multicast address list
1214  * @mc_list_lock: spin lock for multicast list
1215  * @addr_filter_pattern:
1216  * @scan_info:
1217  * @psb_changed: Flag to ensure PSB is configured through framework
1218  * @configured_psb: UAPSD psb value configured through framework
1219  * @scan_block_work:
1220  * @blocked_scan_request_q:
1221  * @blocked_scan_request_q_lock:
1222  * @tx_flow_control_timer:
1223  * @tx_flow_timer_initialized:
1224  * @tx_flow_low_watermark:
1225  * @tx_flow_hi_watermark_offset:
1226  * @dscp_to_up_map: DSCP to UP QoS Mapping
1227  * @is_link_layer_stats_set:
1228  * @ll_stats_failure_count:
1229  * @link_status:
1230  * @upgrade_udp_qos_threshold: The threshold for user priority upgrade for
1231  *			       any UDP packet.
1232  * @udp_qos_upgrade_type: UDP QoS packet upgrade request type
1233  * @temperature: variable for temperature in Celsius
1234  * @ocb_mac_address: MAC addresses used for OCB interfaces
1235  * @ocb_mac_addr_count:
1236  * @pause_map: BITMAP indicating pause reason
1237  * @subqueue_pause_map:
1238  * @pause_map_lock:
1239  * @start_time:
1240  * @last_time:
1241  * @total_pause_time:
1242  * @total_unpause_time:
1243  * @history_index:
1244  * @queue_oper_history:
1245  * @queue_oper_stats:
1246  * @debugfs_phy: debugfs entry
1247  * @lfr_fw_status:
1248  * @active_ac:
1249  * @mon_chan_freq:
1250  * @mon_bandwidth:
1251  * @latency_level: 0 - normal, 1 - xr, 2 - low, 3 - ultralow
1252  * @multi_client_ll_support: to check multi client ll support in driver
1253  * @client_info: To store multi client id information
1254  * @multi_ll_response_cookie: cookie for multi client ll command
1255  * @multi_ll_req_in_progress: to check multi client ll request in progress
1256  * @multi_ll_resp_expected: to decide whether host will wait for multi client
1257  *                          event or not
1258  * @monitor_mode_vdev_up_in_progress:
1259  * @rcpi: rcpi information
1260  * @send_mode_change:
1261  * @apf_context:
1262  * @csr_file:
1263  * @motion_detection_mode:
1264  * @motion_det_cfg:
1265  * @motion_det_in_progress:
1266  * @motion_det_baseline_value:
1267  * @last_disconnect_reason: Last disconnected internal reason code
1268  * as per enum qca_disconnect_reason_codes
1269  * @connect_req_status: Last disconnected internal status code
1270  *                          as per enum qca_sta_connect_fail_reason_codes
1271  * @peer_cleanup_done:
1272  * @oem_data_in_progress:
1273  * @cookie:
1274  * @response_expected:
1275  * @handle_feature_update: Handle feature update only if it is triggered
1276  *			   by hdd_netdev_feature_update
1277  * @tso_csum_feature_enabled: Indicate if TSO and checksum offload features
1278  *                            are enabled or not
1279  * @netdev_features_update_work: work for handling the netdev features update
1280  * for the adapter.
1281  * @netdev_features_update_work_status: status for netdev_features_update_work
1282  * @net_dev_hold_ref_count:
1283  * @delete_in_progress: Flag to indicate that the adapter delete is in
1284  * progress, and any operation using rtnl lock inside
1285  * the driver can be avoided/skipped.
1286  * @is_virtual_iface: Indicates that netdev is called from virtual interface
1287  * @mon_adapter: hdd_adapter of monitor mode.
1288  * @mlo_adapter_info:
1289  * @set_mac_addr_req_ctx: Set MAC address command request context
1290  * @delta_qtime: delta between host qtime and monotonic time
1291  * @traffic_end_ind_en: traffic end indication feature enable/disable
1292  * @is_dbam_configured:
1293  * @user_phy_mode: phy mode is set per vdev
1294  * @deflink: Default link pointing to the 0th index of the linkinfo array
1295  * @link_info: Data structure to hold link specific information
1296  * @tx_power: Structure to hold connection tx Power info
1297  * @tx_latency_cfg: configuration for per-link transmit latency statistics
1298  * @link_state_cached_timestamp: link state cached timestamp
1299  * @keep_alive_interval: user configured STA keep alive interval
1300  */
1301 struct hdd_adapter {
1302 	uint32_t magic;
1303 	qdf_list_node_t node;
1304 
1305 	struct hdd_context *hdd_ctx;
1306 
1307 	struct net_device *dev;
1308 
1309 	enum QDF_OPMODE device_mode;
1310 
1311 	struct work_struct ipv4_notifier_work;
1312 #ifdef WLAN_NS_OFFLOAD
1313 	/* IPv6 notifier callback for handling NS offload on change in IP */
1314 	struct work_struct ipv6_notifier_work;
1315 #endif
1316 
1317 	/* TODO Move this to sta Ctx */
1318 	struct wireless_dev wdev;
1319 
1320 	uint8_t ops;
1321 	uint32_t ctw;
1322 	bool allow_power_save;
1323 
1324 	struct qdf_mac_addr mac_addr;
1325 #ifndef WLAN_HDD_MULTI_VDEV_SINGLE_NDEV
1326 	struct qdf_mac_addr mld_addr;
1327 #endif
1328 	unsigned long event_flags;
1329 	uint8_t curr_link_info_map[WLAN_MAX_ML_BSS_LINKS];
1330 	unsigned long active_links;
1331 	uint8_t num_links_on_create;
1332 
1333 	qdf_atomic_t is_ll_stats_req_pending;
1334 
1335 #ifdef FEATURE_CLUB_LL_STATS_AND_GET_STATION
1336 	uint32_t sta_stats_cached_timestamp;
1337 #endif
1338 
1339 #ifdef FEATURE_MONITOR_MODE_SUPPORT
1340 	qdf_event_t qdf_monitor_mode_vdev_up_event;
1341 #endif
1342 
1343 	/* TODO: move these to sta ctx. These may not be used in AP */
1344 	struct completion disconnect_comp_var;
1345 	struct completion linkup_event_var;
1346 
1347 	bool is_link_up_service_needed;
1348 
1349 	struct hdd_wmm_status hdd_wmm_status;
1350 
1351 	/* TODO: Will be removed as a part of next phase of clean up */
1352 	struct hdd_station_info sta_info[WLAN_MAX_STA_COUNT];
1353 	struct hdd_station_info cache_sta_info[WLAN_MAX_STA_COUNT];
1354 
1355 	/* TODO: _list from name will be removed after clean up */
1356 	struct hdd_sta_info_obj sta_info_list;
1357 	struct hdd_sta_info_obj cache_sta_info_list;
1358 	qdf_atomic_t cache_sta_count;
1359 
1360 #ifdef FEATURE_WLAN_WAPI
1361 	struct hdd_wapi_info wapi_info;
1362 #endif
1363 
1364 	struct work_struct  sap_stop_bss_work;
1365 
1366 #ifdef WLAN_FEATURE_TSF
1367 	struct hdd_vdev_tsf tsf;
1368 #endif
1369 	struct hdd_multicast_addr_list mc_addr_list;
1370 	qdf_spinlock_t mc_list_lock;
1371 	uint8_t addr_filter_pattern;
1372 
1373 	struct hdd_scan_info scan_info;
1374 
1375 	uint8_t psb_changed;
1376 	uint8_t configured_psb;
1377 
1378 	struct work_struct scan_block_work;
1379 	qdf_list_t blocked_scan_request_q;
1380 	qdf_mutex_t blocked_scan_request_q_lock;
1381 
1382 #if  defined(QCA_LL_LEGACY_TX_FLOW_CONTROL) || \
1383 				defined(QCA_HL_NETDEV_FLOW_CONTROL)
1384 	qdf_mc_timer_t tx_flow_control_timer;
1385 	bool tx_flow_timer_initialized;
1386 #endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL || QCA_HL_NETDEV_FLOW_CONTROL */
1387 #ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
1388 	unsigned int tx_flow_low_watermark;
1389 	unsigned int tx_flow_hi_watermark_offset;
1390 #endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
1391 
1392 	enum sme_qos_wmmuptype dscp_to_up_map[WLAN_MAX_DSCP + 1];
1393 
1394 #ifdef WLAN_FEATURE_LINK_LAYER_STATS
1395 	bool is_link_layer_stats_set;
1396 	uint8_t ll_stats_failure_count;
1397 #endif
1398 	uint8_t link_status;
1399 	uint8_t upgrade_udp_qos_threshold;
1400 	enum udp_qos_upgrade udp_qos_upgrade_type;
1401 
1402 	int temperature;
1403 
1404 #ifdef WLAN_FEATURE_DSRC
1405 	struct qdf_mac_addr ocb_mac_address[QDF_MAX_CONCURRENCY_PERSONA];
1406 	int ocb_mac_addr_count;
1407 #endif
1408 
1409 	uint32_t pause_map;
1410 	uint32_t subqueue_pause_map;
1411 	spinlock_t pause_map_lock;
1412 	qdf_time_t start_time;
1413 	qdf_time_t last_time;
1414 	qdf_time_t total_pause_time;
1415 	qdf_time_t total_unpause_time;
1416 	uint8_t history_index;
1417 	struct hdd_netif_queue_history
1418 		 queue_oper_history[WLAN_HDD_MAX_HISTORY_ENTRY];
1419 	struct hdd_netif_queue_stats queue_oper_stats[WLAN_REASON_TYPE_MAX];
1420 
1421 	struct dentry *debugfs_phy;
1422 	struct lfr_firmware_status lfr_fw_status;
1423 	uint8_t active_ac;
1424 	uint32_t mon_chan_freq;
1425 	uint32_t mon_bandwidth;
1426 	uint16_t latency_level;
1427 #ifdef MULTI_CLIENT_LL_SUPPORT
1428 	bool multi_client_ll_support;
1429 	struct wlm_multi_client_info_table client_info[WLM_MAX_HOST_CLIENT];
1430 	void *multi_ll_response_cookie;
1431 	bool multi_ll_req_in_progress;
1432 	bool multi_ll_resp_expected;
1433 #endif
1434 #ifdef FEATURE_MONITOR_MODE_SUPPORT
1435 	bool monitor_mode_vdev_up_in_progress;
1436 #endif
1437 
1438 	struct rcpi_info rcpi;
1439 	bool send_mode_change;
1440 #ifdef FEATURE_WLAN_APF
1441 	struct hdd_apf_context apf_context;
1442 #endif /* FEATURE_WLAN_APF */
1443 
1444 #ifdef WLAN_DEBUGFS
1445 	struct hdd_debugfs_file_info csr_file[HDD_DEBUGFS_FILE_ID_MAX];
1446 #endif /* WLAN_DEBUGFS */
1447 
1448 #ifdef WLAN_FEATURE_MOTION_DETECTION
1449 	bool motion_detection_mode;
1450 	bool motion_det_cfg;
1451 	bool motion_det_in_progress;
1452 	uint32_t motion_det_baseline_value;
1453 #endif /* WLAN_FEATURE_MOTION_DETECTION */
1454 	enum qca_disconnect_reason_codes last_disconnect_reason;
1455 	enum wlan_status_code connect_req_status;
1456 	qdf_event_t peer_cleanup_done;
1457 #ifdef FEATURE_OEM_DATA
1458 	bool oem_data_in_progress;
1459 	void *cookie;
1460 	bool response_expected;
1461 #endif
1462 	bool handle_feature_update;
1463 
1464 	bool tso_csum_feature_enabled;
1465 
1466 	qdf_work_t netdev_features_update_work;
1467 	enum hdd_work_status netdev_features_update_work_status;
1468 	qdf_atomic_t net_dev_hold_ref_count[NET_DEV_HOLD_ID_MAX];
1469 	bool delete_in_progress;
1470 	bool is_virtual_iface;
1471 #ifdef WLAN_FEATURE_PKT_CAPTURE
1472 	struct hdd_adapter *mon_adapter;
1473 #endif
1474 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC)
1475 	struct hdd_mlo_adapter_info mlo_adapter_info;
1476 #endif
1477 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE
1478 	void *set_mac_addr_req_ctx;
1479 #endif
1480 	int64_t delta_qtime;
1481 #ifdef DP_TRAFFIC_END_INDICATION
1482 	bool traffic_end_ind_en;
1483 #endif
1484 #ifdef WLAN_FEATURE_DBAM_CONFIG
1485 	bool is_dbam_configured;
1486 #endif
1487 	enum qca_wlan_vendor_phy_mode user_phy_mode;
1488 	struct wlan_hdd_link_info *deflink;
1489 	struct wlan_hdd_link_info link_info[WLAN_MAX_ML_BSS_LINKS];
1490 	struct wlan_hdd_tx_power tx_power;
1491 #ifdef WLAN_FEATURE_TX_LATENCY_STATS
1492 	struct cdp_tx_latency_config tx_latency_cfg;
1493 #endif
1494 #ifdef WLAN_FEATURE_11BE_MLO
1495 	qdf_time_t link_state_cached_timestamp;
1496 #endif
1497 	uint16_t keep_alive_interval;
1498 };
1499 
1500 #define WLAN_HDD_GET_STATION_CTX_PTR(link_info) (&(link_info)->session.station)
1501 #define WLAN_HDD_GET_AP_CTX_PTR(link_info) (&(link_info)->session.ap)
1502 #define WLAN_HDD_GET_CTX(adapter) ((adapter)->hdd_ctx)
1503 #define WLAN_HDD_GET_HOSTAP_STATE_PTR(link_info) \
1504 		(&(WLAN_HDD_GET_AP_CTX_PTR((link_info))->hostapd_state))
1505 #define WLAN_HDD_GET_SAP_CTX_PTR(link_info) \
1506 		(WLAN_HDD_GET_AP_CTX_PTR((link_info))->sap_context)
1507 
1508 #ifdef WLAN_FEATURE_NAN
1509 #define WLAN_HDD_IS_NDP_ENABLED(hdd_ctx) ((hdd_ctx)->nan_datapath_enabled)
1510 #else
1511 /* WLAN_HDD_GET_NDP_CTX_PTR and WLAN_HDD_GET_NDP_WEXT_STATE_PTR are not defined
1512  * intentionally so that all references to these must be within NDP code.
1513  * non-NDP code can call WLAN_HDD_IS_NDP_ENABLED(), and when it is enabled,
1514  * invoke NDP code to do all work.
1515  */
1516 #define WLAN_HDD_IS_NDP_ENABLED(hdd_ctx) (false)
1517 #endif
1518 
1519 /* Set mac address locally administered bit */
1520 #define WLAN_HDD_RESET_LOCALLY_ADMINISTERED_BIT(macaddr) (macaddr[0] &= 0xFD)
1521 
1522 #define HDD_DEFAULT_MCC_P2P_QUOTA    70
1523 #define HDD_RESET_MCC_P2P_QUOTA      50
1524 
1525 /*
1526  * struct hdd_priv_data - driver ioctl private data payload
1527  * @buf: pointer to command buffer (may be in userspace)
1528  * @used_len: length of the command/data currently in @buf
1529  * @total_len: total length of the @buf memory allocation
1530  */
1531 struct hdd_priv_data {
1532 	uint8_t *buf;
1533 	int used_len;
1534 	int total_len;
1535 };
1536 
1537 #define  MAX_MOD_LOGLEVEL 10
1538 struct fw_log_info {
1539 	uint8_t enable;
1540 	uint8_t dl_type;
1541 	uint8_t dl_report;
1542 	uint8_t dl_loglevel;
1543 	uint8_t index;
1544 	uint32_t dl_mod_loglevel[MAX_MOD_LOGLEVEL];
1545 
1546 };
1547 
1548 /**
1549  * enum antenna_mode - number of TX/RX chains
1550  * @HDD_ANTENNA_MODE_INVALID: Invalid mode place holder
1551  * @HDD_ANTENNA_MODE_1X1: Number of TX/RX chains equals 1
1552  * @HDD_ANTENNA_MODE_2X2: Number of TX/RX chains equals 2
1553  * @HDD_ANTENNA_MODE_MAX: Place holder for max mode
1554  */
1555 enum antenna_mode {
1556 	HDD_ANTENNA_MODE_INVALID,
1557 	HDD_ANTENNA_MODE_1X1,
1558 	HDD_ANTENNA_MODE_2X2,
1559 	HDD_ANTENNA_MODE_MAX
1560 };
1561 
1562 /**
1563  * enum smps_mode - SM power save mode
1564  * @HDD_SMPS_MODE_STATIC: Static power save
1565  * @HDD_SMPS_MODE_DYNAMIC: Dynamic power save
1566  * @HDD_SMPS_MODE_RESERVED: Reserved
1567  * @HDD_SMPS_MODE_DISABLED: Disable power save
1568  * @HDD_SMPS_MODE_MAX: Place holder for max mode
1569  */
1570 enum smps_mode {
1571 	HDD_SMPS_MODE_STATIC,
1572 	HDD_SMPS_MODE_DYNAMIC,
1573 	HDD_SMPS_MODE_RESERVED,
1574 	HDD_SMPS_MODE_DISABLED,
1575 	HDD_SMPS_MODE_MAX
1576 };
1577 
1578 #ifdef WLAN_FEATURE_OFFLOAD_PACKETS
1579 /**
1580  * struct hdd_offloaded_packets - request id to pattern id mapping
1581  * @request_id: request id
1582  * @pattern_id: pattern id
1583  *
1584  */
1585 struct hdd_offloaded_packets {
1586 	uint32_t request_id;
1587 	uint8_t  pattern_id;
1588 };
1589 
1590 /**
1591  * struct hdd_offloaded_packets_ctx - offloaded packets context
1592  * @op_table: request id to pattern id table
1593  * @op_lock: mutex lock
1594  */
1595 struct hdd_offloaded_packets_ctx {
1596 	struct hdd_offloaded_packets op_table[MAXNUM_PERIODIC_TX_PTRNS];
1597 	struct mutex op_lock;
1598 };
1599 #endif
1600 
1601 /**
1602  * enum driver_modules_status - Driver Modules status
1603  * @DRIVER_MODULES_UNINITIALIZED: Driver CDS modules uninitialized
1604  * @DRIVER_MODULES_ENABLED: Driver CDS modules opened
1605  * @DRIVER_MODULES_CLOSED: Driver CDS modules closed
1606  */
1607 enum driver_modules_status {
1608 	DRIVER_MODULES_UNINITIALIZED,
1609 	DRIVER_MODULES_ENABLED,
1610 	DRIVER_MODULES_CLOSED
1611 };
1612 
1613 /**
1614  * struct acs_dfs_policy - Define ACS policies
1615  * @acs_dfs_mode: Dfs mode enabled/disabled.
1616  * @acs_chan_freq: pre defined channel frequency to avoid ACS.
1617  */
1618 struct acs_dfs_policy {
1619 	enum dfs_mode acs_dfs_mode;
1620 	uint32_t acs_chan_freq;
1621 };
1622 
1623 /**
1624  * enum suspend_fail_reason - Reasons a WLAN suspend might fail
1625  * @SUSPEND_FAIL_IPA: IPA in progress
1626  * @SUSPEND_FAIL_RADAR: radar scan in progress
1627  * @SUSPEND_FAIL_ROAM: roaming in progress
1628  * @SUSPEND_FAIL_SCAN: scan in progress
1629  * @SUSPEND_FAIL_INITIAL_WAKEUP: received initial wakeup from firmware
1630  * @SUSPEND_FAIL_MAX_COUNT: the number of wakeup reasons, always at the end
1631  */
1632 enum suspend_fail_reason {
1633 	SUSPEND_FAIL_IPA,
1634 	SUSPEND_FAIL_RADAR,
1635 	SUSPEND_FAIL_ROAM,
1636 	SUSPEND_FAIL_SCAN,
1637 	SUSPEND_FAIL_INITIAL_WAKEUP,
1638 	SUSPEND_FAIL_MAX_COUNT
1639 };
1640 
1641 /**
1642  * struct suspend_resume_stats - counters for suspend/resume events
1643  * @suspends: number of suspends completed
1644  * @resumes: number of resumes completed
1645  * @suspend_fail: counters for failed suspend reasons
1646  */
1647 struct suspend_resume_stats {
1648 	uint32_t suspends;
1649 	uint32_t resumes;
1650 	uint32_t suspend_fail[SUSPEND_FAIL_MAX_COUNT];
1651 };
1652 
1653 /**
1654  * enum hdd_sta_smps_param - SMPS parameters to configure from hdd
1655  * @HDD_STA_SMPS_PARAM_UPPER_RSSI_THRESH: RSSI threshold to enter Dynamic SMPS
1656  * mode from inactive mode
1657  * @HDD_STA_SMPS_PARAM_STALL_RSSI_THRESH:  RSSI threshold to enter
1658  * Stalled-D-SMPS mode from D-SMPS mode or to enter D-SMPS mode from
1659  * Stalled-D-SMPS mode
1660  * @HDD_STA_SMPS_PARAM_LOWER_RSSI_THRESH:  RSSI threshold to disable SMPS modes
1661  * @HDD_STA_SMPS_PARAM_UPPER_BRSSI_THRESH: Upper threshold for beacon-RSSI.
1662  * Used to reduce RX chainmask.
1663  * @HDD_STA_SMPS_PARAM_LOWER_BRSSI_THRESH:  Lower threshold for beacon-RSSI.
1664  * Used to increase RX chainmask.
1665  * @HDD_STA_SMPS_PARAM_DTIM_1CHRX_ENABLE: Enable/Disable DTIM 1chRx feature
1666  */
1667 enum hdd_sta_smps_param {
1668 	HDD_STA_SMPS_PARAM_UPPER_RSSI_THRESH = 0,
1669 	HDD_STA_SMPS_PARAM_STALL_RSSI_THRESH = 1,
1670 	HDD_STA_SMPS_PARAM_LOWER_RSSI_THRESH = 2,
1671 	HDD_STA_SMPS_PARAM_UPPER_BRSSI_THRESH = 3,
1672 	HDD_STA_SMPS_PARAM_LOWER_BRSSI_THRESH = 4,
1673 	HDD_STA_SMPS_PARAM_DTIM_1CHRX_ENABLE = 5
1674 };
1675 
1676 /**
1677  * enum RX_OFFLOAD - Receive offload modes
1678  * @CFG_LRO_ENABLED: Large Rx offload
1679  * @CFG_GRO_ENABLED: Generic Rx Offload
1680  */
1681 enum RX_OFFLOAD {
1682 	CFG_LRO_ENABLED = 1,
1683 	CFG_GRO_ENABLED,
1684 };
1685 
1686 /* One per STA: 1 for BCMC_STA_ID, 1 for each SAP_SELF_STA_ID,
1687  * 1 for WDS_STAID
1688  */
1689 #define HDD_MAX_ADAPTERS (WLAN_MAX_STA_COUNT + QDF_MAX_NO_OF_SAP_MODE + 2)
1690 
1691 #ifdef DISABLE_CHANNEL_LIST
1692 
1693 /**
1694  * struct hdd_cache_channel_info - Structure of the channel info
1695  * which needs to be cached
1696  * @freq: frequency
1697  * @reg_status: Current regulatory status of the channel
1698  * Enable
1699  * Disable
1700  * DFS
1701  * Invalid
1702  * @wiphy_status: Current wiphy status
1703  */
1704 struct hdd_cache_channel_info {
1705 	qdf_freq_t freq;
1706 	enum channel_state reg_status;
1707 	uint32_t wiphy_status;
1708 };
1709 
1710 /**
1711  * struct hdd_cache_channels - Structure of the channels to be cached
1712  * @num_channels: Number of channels to be cached
1713  * @channel_info: Structure of the channel info
1714  */
1715 struct hdd_cache_channels {
1716 	uint32_t num_channels;
1717 	struct hdd_cache_channel_info *channel_info;
1718 };
1719 #endif
1720 
1721 /**
1722  * struct hdd_dynamic_mac - hdd structure to handle dynamic mac address changes
1723  * @dynamic_mac: Dynamically configured mac, this contains the mac on which
1724  * current interface is up
1725  * @is_provisioned_mac: is this mac from provisioned list
1726  * @bit_position: holds the bit mask position from where this mac is assigned,
1727  * if mac is assigned from provisioned this field contains the position from
1728  * provisioned_intf_addr_mask else contains the position from
1729  * derived_intf_addr_mask
1730  */
1731 struct hdd_dynamic_mac {
1732 	struct qdf_mac_addr dynamic_mac;
1733 	bool is_provisioned_mac;
1734 	uint8_t bit_position;
1735 };
1736 
1737 /**
1738  * struct hdd_fw_ver_info - FW version info structure
1739  * @major_spid: FW version - major spid.
1740  * @minor_spid: FW version - minor spid
1741  * @siid:       FW version - siid
1742  * @sub_id:     FW version - sub id
1743  * @rel_id:     FW version - release id
1744  * @crmid:      FW version - crmid
1745  */
1746 
1747 struct hdd_fw_ver_info {
1748 	uint32_t major_spid;
1749 	uint32_t minor_spid;
1750 	uint32_t siid;
1751 	uint32_t sub_id;
1752 	uint32_t rel_id;
1753 	uint32_t crmid;
1754 };
1755 
1756 /*
1757  * The logic for get current index of history is dependent on this
1758  * value being power of 2.
1759  */
1760 #define WLAN_HDD_ADAPTER_OPS_HISTORY_MAX 4
1761 QDF_COMPILE_TIME_ASSERT(adapter_ops_history_size,
1762 			(WLAN_HDD_ADAPTER_OPS_HISTORY_MAX &
1763 			 (WLAN_HDD_ADAPTER_OPS_HISTORY_MAX - 1)) == 0);
1764 
1765 /**
1766  * enum hdd_adapter_ops_event - events for adapter ops history
1767  * @WLAN_HDD_ADAPTER_OPS_WORK_POST: adapter ops work posted
1768  * @WLAN_HDD_ADAPTER_OPS_WORK_SCHED: adapter ops work scheduled
1769  */
1770 enum hdd_adapter_ops_event {
1771 	WLAN_HDD_ADAPTER_OPS_WORK_POST,
1772 	WLAN_HDD_ADAPTER_OPS_WORK_SCHED,
1773 };
1774 
1775 /**
1776  * struct hdd_adapter_ops_record - record of adapter ops history
1777  * @timestamp: time of the occurrence of event
1778  * @event: event
1779  * @vdev_id: vdev id corresponding to the event
1780  */
1781 struct hdd_adapter_ops_record {
1782 	uint64_t timestamp;
1783 	enum hdd_adapter_ops_event event;
1784 	int vdev_id;
1785 };
1786 
1787 /**
1788  * struct hdd_adapter_ops_history - history of adapter ops
1789  * @index: index to store the next event
1790  * @entry: array of events
1791  */
1792 struct hdd_adapter_ops_history {
1793 	qdf_atomic_t index;
1794 	struct hdd_adapter_ops_record entry[WLAN_HDD_ADAPTER_OPS_HISTORY_MAX];
1795 };
1796 
1797 /**
1798  * struct hdd_dual_sta_policy - Concurrent STA policy configuration
1799  * @dual_sta_policy: Possible values are defined in enum
1800  * qca_wlan_concurrent_sta_policy_config
1801  * @primary_vdev_id: specified iface is the primary STA iface, say 0 means
1802  * vdev 0 is acting as primary interface
1803  */
1804 struct hdd_dual_sta_policy {
1805 	uint8_t dual_sta_policy;
1806 	uint8_t primary_vdev_id;
1807 };
1808 
1809 #ifdef FEATURE_CNSS_HW_SECURE_DISABLE
1810 /**
1811  * hdd_get_wlan_driver_status() - get status of soft driver unload
1812  *
1813  * Return: true if wifi is disabled by soft driver unload, else false
1814  */
1815 bool hdd_get_wlan_driver_status(void);
1816 #else
hdd_get_wlan_driver_status(void)1817 static inline bool hdd_get_wlan_driver_status(void)
1818 {
1819 	return false;
1820 }
1821 #endif
1822 
1823 /**
1824  * struct hdd_lpc_info - Local packet capture information
1825  * @lpc_wk: local packet capture work
1826  * @lpc_wk_scheduled: flag to indicate if lpc work is scheduled or not
1827  * @mon_adapter: monitor adapter
1828  */
1829 struct hdd_lpc_info {
1830 	qdf_work_t lpc_wk;
1831 	bool lpc_wk_scheduled;
1832 	struct hdd_adapter *mon_adapter;
1833 };
1834 
1835 /**
1836  * enum wlan_state_ctrl_str_id - state control param string id
1837  * @WLAN_OFF_STR: Turn OFF WiFi
1838  * @WLAN_ON_STR: Turn ON WiFi
1839  * @WLAN_ENABLE_STR: Enable WiFi
1840  * @WLAN_DISABLE_STR: Disable Wifi
1841  * @WLAN_WAIT_FOR_READY_STR: Driver should wait for ongoing recovery
1842  * @WLAN_FORCE_DISABLE_STR: Disable Wifi by soft driver unload
1843  */
1844 enum wlan_state_ctrl_str_id {
1845 	WLAN_OFF_STR   = 0,
1846 	WLAN_ON_STR,
1847 	WLAN_ENABLE_STR,
1848 	WLAN_DISABLE_STR,
1849 	WLAN_WAIT_FOR_READY_STR,
1850 	WLAN_FORCE_DISABLE_STR
1851 };
1852 
1853 #define MAX_TGT_HW_NAME_LEN 32
1854 
1855 /**
1856  * struct hdd_context - hdd shared driver and psoc/device context
1857  * @psoc: object manager psoc context
1858  * @pdev: object manager pdev context
1859  * @mac_handle: opaque handle to MAC context
1860  * @wiphy: Linux wiphy
1861  * @hdd_adapter_lock: lock for @hdd_adapters
1862  * @hdd_adapters: list of all instantiated adapters
1863  * @is_therm_cmd_supp: get temperature command enable or disable
1864  * @fw: pointer to firmware image data
1865  * @cfg: pointer to configuration data
1866  * @parent_dev: pointer to parent device
1867  * @config: Config values read from qcom_cfg.ini file
1868  * @channels_2ghz: pointer for wiphy 2 GHz channels
1869  * @channels_5ghz: pointer for wiphy 5 GHz channels
1870  * @iftype_data_2g: Interface data for 2 GHz band
1871  * @iftype_data_5g: Interface data for 5 GHz band
1872  * @iftype_data_6g: Interface data for 6 GHz band
1873  * @mc_sus_event_var: Completion variable to indicate Mc Thread Suspended
1874  * @is_scheduler_suspended: true if the MC Thread is suspended
1875  * @is_ol_rx_thread_suspended: true if the RX Thread is suspended
1876  * @hdd_wlan_suspended: true if the HDD is suspended
1877  * @suspended: unused???
1878  * @is_pktlog_enabled: true if pktlog is enabled, used to start pktlog after
1879  *                     SSR/PDR if previously enabled
1880  * @sap_lock: Lock to avoid race condition during start/stop bss
1881  * @oem_app_registered: OEM App registered or not
1882  * @oem_pid: OEM App Process ID when registered
1883  * @concurrency_mode: Concurrency Parameters
1884  * @no_of_open_sessions: number of open sessions per operating mode
1885  * @no_of_active_sessions: number of active sessions per operating mode
1886  * @p2p_device_address: P2P Device MAC Address for the adapter
1887  * @sap_wake_lock: Soft AP wakelock
1888  * @is_wiphy_suspended: Flag keeps track of wiphy suspend/resume
1889  * @ready_to_suspend: completed when ready to suspend
1890  * @target_type: defining the solution type
1891  * @target_fw_version: firmware version
1892  * @target_fw_vers_ext: firmware version extension
1893  * @fw_version_info: detailed firmware version information
1894  * @target_hw_version:  the chip/rom version
1895  * @target_hw_revision: the chip/rom revision
1896  * @target_hw_name: chip/rom name
1897  * @reg: regulatory information
1898  * @unsafe_channel_count: number of unsafe channels
1899  * @unsafe_channel_list: list of unsafe channels
1900  * @restriction_mask: channel avoidance restrictions mask
1901  * @max_intf_count: maximum number of supported interfaces
1902  * @lpss_support: Is LPSS offload supported
1903  * @ap_arpns_support: Is AP ARP/NS offload supported
1904  * @ioctl_scan_mode: scan mode
1905  * @sta_ap_intf_check_work: workqueue for interface check
1906  * @dev_dfs_cac_status: DFS CAC status
1907  * @bt_coex_mode_set: Has BT coex mode been set
1908  * @skip_acs_scan_timer: timer used to skip ACS scan
1909  * @skip_acs_scan_status: status of skip ACS scan
1910  * @last_acs_freq_list: ACS frequency list
1911  * @num_of_channels: number of channels in @last_acs_freq_list
1912  * @acs_skip_lock: use to synchronize "skip ACS scan" feature
1913  * @sap_dfs_wakelock : SAP DFS wakelock
1914  * @sap_dfs_ref_cnt: SAP DFS reference count
1915  * @is_extwow_app_type1_param_set: is extwow app type1 param set
1916  * @is_extwow_app_type2_param_set: is extwow app type2 param set
1917  * @ext_scan_start_since_boot: Time since boot up to extscan start (in micro
1918  *                             seconds)
1919  * @miracast_value: value of driver miracast command
1920  * @ipv6_notifier: IPv6 notifier callback for handling NS offload on change
1921  *                 in IP
1922  * @ns_offload_enable: Is NS offload enabled
1923  * @ipv4_notifier: IPv4 notifier callback for handling ARP offload on change
1924  *                 in IP
1925  * @pm_qos_notifier: Device PM QoS notifier
1926  * @runtime_pm_prevented: Is PM prevented
1927  * @pm_qos_lock: Lock for PM QoS data
1928  * @num_rf_chains: number of rf chains supported by target
1929  * @ht_tx_stbc_supported: Is HT Tx STBC supported by target
1930  * @op_ctx: Offloaded packets context
1931  * @mcc_mode: Is Multi-channel Concurrency enabled
1932  * @memdump_lock: Lock for memdump data
1933  * @driver_dump_size: Size of the memdump data buffer
1934  * @driver_dump_mem: memdump data buffer
1935  * @connection_in_progress: Is connection in progress
1936  * @connection_status_lock: Lock for connection status
1937  * @fine_time_meas_cap_target: place to store FTM capab of target. This
1938  *                             allows changing of FTM capab at runtime
1939  *                             and intersecting it with target capab before
1940  *                             updating.
1941  * @current_antenna_mode: Current number of TX X RX chains being used
1942  * @radio_index: the radio index assigned by cnss_logger
1943  * @hbw_requested: Has high bandwidth been requested
1944  * @pm_qos_request: Is PM QoS requested
1945  * @nan_datapath_enabled: Is NAN datapath enabled
1946  * @driver_status: Present state of driver cds modules
1947  * @psoc_idle_timeout_work: delayed work for psoc idle shutdown
1948  * @pm_notifier: PM notifier of hdd modules
1949  * @acs_policy: ACS DFS policy
1950  * @wmi_max_len: MTU of the WMI interface
1951  * @suspend_resume_stats: Suspend/Resume statistics
1952  * @runtime_context: Runtime PM context
1953  * @chan_info: scan channel information
1954  * @chan_info_lock: lock for @chan_info
1955  * @tdls_source_bitmap: bit map to set/reset TDLS by different sources
1956  * @tdls_umac_comp_active: Is the TDLS component active
1957  * @tdls_nap_active: Is napier specific tdls data path enabled
1958  * @beacon_probe_rsp_cnt_per_scan:
1959  * @last_scan_reject_vdev_id:
1960  * @last_scan_reject_reason:
1961  * @last_scan_reject_timestamp:
1962  * @scan_reject_cnt:
1963  * @dfs_cac_offload:
1964  * @reg_offload:
1965  * @rcpi_enabled:
1966  * @coex_avoid_freq_list:
1967  * @dnbs_avoid_freq_list:
1968  * @avoid_freq_lock:  Lock to control access to dnbs and coex avoid freq list
1969  * @tsf: structure containing tsf related information
1970  * @bt_a2dp_active:
1971  * @bt_vo_active:
1972  * @bt_profile_con:
1973  * @curr_band:
1974  * @imps_enabled:
1975  * @user_configured_pkt_filter_rules:
1976  * @is_fils_roaming_supported:
1977  * @receive_offload_cb:
1978  * @vendor_disable_lro_flag:
1979  * @force_rsne_override:
1980  * @monitor_mode_wakelock:
1981  * @lte_coex_ant_share:
1982  * @obss_scan_offload:
1983  * @sscan_pid:
1984  * @track_arp_ip:
1985  * @hw_bd_id: defining the board related information
1986  * @hw_bd_info:
1987  * @twt_state:
1988  * @twt_disable_comp_evt:
1989  * @twt_enable_comp_evt:
1990  * @apf_version:
1991  * @apf_enabled_v2:
1992  * @original_channels:
1993  * @cache_channel_lock:
1994  * @sar_version:
1995  * @dynamic_mac_list:
1996  * @dynamic_nss_chains_support: Per vdev dynamic nss chains update capability
1997  * @hw_macaddr:
1998  * @provisioned_mac_addr:
1999  * @derived_mac_addr:
2000  * @num_provisioned_addr:
2001  * @num_derived_addr:
2002  * @provisioned_intf_addr_mask:
2003  * @derived_intf_addr_mask:
2004  * @sar_cmd_params: SAR command params to be configured to the FW
2005  * @sar_safety_timer:
2006  * @sar_safety_unsolicited_work:
2007  * @sar_safety_req_resp_event:
2008  * @sar_safety_req_resp_event_in_progress:
2009  * @runtime_resume_start_time_stamp:
2010  * @runtime_suspend_done_time_stamp:
2011  * @pm_qos_req:
2012  * @qos_cpu_mask: voted cpu core mask
2013  * @pm_qos_req: pm_qos request for all cpu cores
2014  * @roam_ch_from_fw_supported:
2015  * @dutycycle_off_percent:
2016  * @pm_qos_request_flags:
2017  * @country_change_work: work for updating vdev when country changes
2018  * @current_pcie_gen_speed: current pcie gen speed
2019  * @adapter_ops_wq: High priority workqueue for handling adapter operations
2020  * @adapter_ops_history:
2021  * @ll_stats_per_chan_rx_tx_time:
2022  * @is_get_station_clubbed_in_ll_stats_req:
2023  * @multi_client_thermal_mitigation: Multi client thermal mitigation by fw
2024  * @is_dual_mac_cfg_updated: indicate whether dual mac cfg has been updated
2025  * @is_regulatory_update_in_progress:
2026  * @regulatory_update_event:
2027  * @regulatory_status_lock:
2028  * @is_fw_dbg_log_levels_configured:
2029  * @twt_en_dis_work: work to send twt enable/disable cmd on MCC/SCC concurrency
2030  * @is_wifi3_0_target:
2031  * @dump_in_progress: Stores value of dump in progress
2032  * @dual_sta_policy: Concurrent STA policy configuration
2033  * @is_therm_stats_in_progress:
2034  * @is_vdev_macaddr_dynamic_update_supported:
2035  * @power_type:
2036  * @is_wlan_disabled: if wlan is disabled by userspace
2037  * @oem_data:
2038  * @oem_data_len:
2039  * @file_name:
2040  * @dbam_mode:
2041  * @last_pagefault_ssr_time: Time when last recovery was triggered because of
2042  * @host wakeup from fw with reason as pagefault
2043  * @bridgeaddr: Bridge MAC address
2044  * @is_mlo_per_link_stats_supported: Per link mlo stats is supported or not
2045  * @num_mlo_peers: Total number of MLO peers
2046  * @more_peer_data: more mlo peer data in peer stats
2047  * @lpc_info: Local packet capture info
2048  */
2049 struct hdd_context {
2050 	struct wlan_objmgr_psoc *psoc;
2051 	struct wlan_objmgr_pdev *pdev;
2052 	mac_handle_t mac_handle;
2053 	struct wiphy *wiphy;
2054 	qdf_spinlock_t hdd_adapter_lock;
2055 	qdf_list_t hdd_adapters;
2056 	bool is_therm_cmd_supp;
2057 	const struct firmware *fw;
2058 	const struct firmware *cfg;
2059 	struct device *parent_dev;
2060 	struct hdd_config *config;
2061 
2062 	/* Pointer for wiphy 2G/5G band channels */
2063 	struct ieee80211_channel *channels_2ghz;
2064 	struct ieee80211_channel *channels_5ghz;
2065 
2066 #if defined(WLAN_FEATURE_11AX) && \
2067 	(defined(CFG80211_SBAND_IFTYPE_DATA_BACKPORT) || \
2068 	 (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0)))
2069 	struct ieee80211_sband_iftype_data *iftype_data_2g;
2070 	struct ieee80211_sband_iftype_data *iftype_data_5g;
2071 #if defined(CONFIG_BAND_6GHZ) && (defined(CFG80211_6GHZ_BAND_SUPPORTED) || \
2072 		(KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE))
2073 	struct ieee80211_sband_iftype_data *iftype_data_6g;
2074 #endif
2075 #endif
2076 	struct completion mc_sus_event_var;
2077 	bool is_scheduler_suspended;
2078 
2079 #ifdef WLAN_DP_LEGACY_OL_RX_THREAD
2080 	bool is_ol_rx_thread_suspended;
2081 #endif
2082 
2083 	bool hdd_wlan_suspended;
2084 	bool suspended;
2085 	bool is_pktlog_enabled;
2086 	struct mutex sap_lock;
2087 
2088 #ifdef FEATURE_OEM_DATA_SUPPORT
2089 	bool oem_app_registered;
2090 	int32_t oem_pid;
2091 #endif
2092 
2093 	uint32_t concurrency_mode;
2094 
2095 	uint8_t no_of_open_sessions[QDF_MAX_NO_OF_MODE];
2096 	uint8_t no_of_active_sessions[QDF_MAX_NO_OF_MODE];
2097 	struct qdf_mac_addr p2p_device_address;
2098 	qdf_wake_lock_t sap_wake_lock;
2099 	bool is_wiphy_suspended;
2100 	struct completion ready_to_suspend;
2101 	uint32_t target_type;
2102 	uint32_t target_fw_version;
2103 	uint32_t target_fw_vers_ext;
2104 	struct hdd_fw_ver_info fw_version_info;
2105 	uint32_t target_hw_version;
2106 	uint32_t target_hw_revision;
2107 	char target_hw_name[MAX_TGT_HW_NAME_LEN];
2108 	struct regulatory reg;
2109 #ifdef FEATURE_WLAN_CH_AVOID
2110 	uint16_t unsafe_channel_count;
2111 	uint16_t unsafe_channel_list[NUM_CHANNELS];
2112 #endif /* FEATURE_WLAN_CH_AVOID */
2113 #ifdef FEATURE_WLAN_CH_AVOID_EXT
2114 	uint32_t restriction_mask;
2115 #endif
2116 
2117 	uint8_t max_intf_count;
2118 #ifdef WLAN_FEATURE_LPSS
2119 	uint8_t lpss_support;
2120 #endif
2121 	uint8_t ap_arpns_support;
2122 	tSirScanType ioctl_scan_mode;
2123 
2124 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
2125 	qdf_work_t sta_ap_intf_check_work;
2126 #endif
2127 
2128 	uint8_t dev_dfs_cac_status;
2129 
2130 	bool bt_coex_mode_set;
2131 #ifdef FEATURE_WLAN_AP_AP_ACS_OPTIMIZE
2132 	qdf_mc_timer_t skip_acs_scan_timer;
2133 	uint8_t skip_acs_scan_status;
2134 	uint32_t *last_acs_freq_list;
2135 	uint8_t num_of_channels;
2136 	qdf_spinlock_t acs_skip_lock;
2137 #endif
2138 
2139 	qdf_wake_lock_t sap_dfs_wakelock;
2140 	atomic_t sap_dfs_ref_cnt;
2141 
2142 #ifdef WLAN_FEATURE_EXTWOW_SUPPORT
2143 	bool is_extwow_app_type1_param_set;
2144 	bool is_extwow_app_type2_param_set;
2145 #endif
2146 
2147 	uint64_t ext_scan_start_since_boot;
2148 	uint8_t miracast_value;
2149 
2150 #ifdef WLAN_NS_OFFLOAD
2151 	/* IPv6 notifier callback for handling NS offload on change in IP */
2152 	struct notifier_block ipv6_notifier;
2153 #endif
2154 	bool ns_offload_enable;
2155 	/* IPv4 notifier callback for handling ARP offload on change in IP */
2156 	struct notifier_block ipv4_notifier;
2157 
2158 #ifdef FEATURE_RUNTIME_PM
2159 	struct notifier_block pm_qos_notifier;
2160 	bool runtime_pm_prevented;
2161 	qdf_spinlock_t pm_qos_lock;
2162 #endif
2163 	uint32_t  num_rf_chains;
2164 	uint8_t   ht_tx_stbc_supported;
2165 #ifdef WLAN_FEATURE_OFFLOAD_PACKETS
2166 	struct hdd_offloaded_packets_ctx op_ctx;
2167 #endif
2168 	bool mcc_mode;
2169 	struct mutex memdump_lock;
2170 	uint16_t driver_dump_size;
2171 	uint8_t *driver_dump_mem;
2172 
2173 	bool connection_in_progress;
2174 	qdf_spinlock_t connection_status_lock;
2175 
2176 	uint32_t fine_time_meas_cap_target;
2177 	enum antenna_mode current_antenna_mode;
2178 
2179 	int radio_index;
2180 	bool hbw_requested;
2181 	bool pm_qos_request;
2182 #ifdef WLAN_FEATURE_NAN
2183 	bool nan_datapath_enabled;
2184 #endif
2185 	enum driver_modules_status driver_status;
2186 	struct qdf_delayed_work psoc_idle_timeout_work;
2187 	struct notifier_block pm_notifier;
2188 	struct acs_dfs_policy acs_policy;
2189 	uint16_t wmi_max_len;
2190 	struct suspend_resume_stats suspend_resume_stats;
2191 	struct hdd_runtime_pm_context runtime_context;
2192 	struct scan_chan_info *chan_info;
2193 	struct mutex chan_info_lock;
2194 	unsigned long tdls_source_bitmap;
2195 	bool tdls_umac_comp_active;
2196 	bool tdls_nap_active;
2197 	uint8_t beacon_probe_rsp_cnt_per_scan;
2198 	uint8_t last_scan_reject_vdev_id;
2199 	enum scan_reject_states last_scan_reject_reason;
2200 	unsigned long last_scan_reject_timestamp;
2201 	uint8_t scan_reject_cnt;
2202 	bool dfs_cac_offload;
2203 	bool reg_offload;
2204 	bool rcpi_enabled;
2205 #ifdef FEATURE_WLAN_CH_AVOID
2206 	struct ch_avoid_ind_type coex_avoid_freq_list;
2207 	struct ch_avoid_ind_type dnbs_avoid_freq_list;
2208 	/* Lock to control access to dnbs and coex avoid freq list */
2209 	struct mutex avoid_freq_lock;
2210 #endif
2211 #ifdef WLAN_FEATURE_TSF
2212 	struct hdd_ctx_tsf tsf;
2213 #endif
2214 
2215 	uint8_t bt_a2dp_active:1;
2216 	uint8_t bt_vo_active:1;
2217 	uint8_t bt_profile_con:1;
2218 	enum band_info curr_band;
2219 	bool imps_enabled;
2220 #ifdef WLAN_FEATURE_PACKET_FILTERING
2221 	int user_configured_pkt_filter_rules;
2222 #endif
2223 	bool is_fils_roaming_supported;
2224 	QDF_STATUS (*receive_offload_cb)(struct hdd_adapter *,
2225 					 struct sk_buff *);
2226 	qdf_atomic_t vendor_disable_lro_flag;
2227 	bool force_rsne_override;
2228 	qdf_wake_lock_t monitor_mode_wakelock;
2229 	bool lte_coex_ant_share;
2230 	bool obss_scan_offload;
2231 	int sscan_pid;
2232 	uint32_t track_arp_ip;
2233 
2234 	/* defining the board related information */
2235 	uint32_t hw_bd_id;
2236 	struct board_info hw_bd_info;
2237 #ifdef WLAN_SUPPORT_TWT
2238 	enum twt_status twt_state;
2239 	qdf_event_t twt_disable_comp_evt;
2240 	qdf_event_t twt_enable_comp_evt;
2241 #endif
2242 #ifdef FEATURE_WLAN_APF
2243 	uint32_t apf_version;
2244 	bool apf_enabled_v2;
2245 #endif
2246 
2247 #ifdef DISABLE_CHANNEL_LIST
2248 	struct hdd_cache_channels *original_channels;
2249 	qdf_mutex_t cache_channel_lock;
2250 #endif
2251 	enum sar_version sar_version;
2252 	struct hdd_dynamic_mac dynamic_mac_list[QDF_MAX_CONCURRENCY_PERSONA];
2253 	bool dynamic_nss_chains_support;
2254 	struct qdf_mac_addr hw_macaddr;
2255 	struct qdf_mac_addr provisioned_mac_addr[QDF_MAX_CONCURRENCY_PERSONA];
2256 	struct qdf_mac_addr derived_mac_addr[QDF_MAX_CONCURRENCY_PERSONA];
2257 	uint32_t num_provisioned_addr;
2258 	uint32_t num_derived_addr;
2259 	unsigned long provisioned_intf_addr_mask;
2260 	unsigned long derived_intf_addr_mask;
2261 
2262 	struct sar_limit_cmd_params *sar_cmd_params;
2263 #ifdef SAR_SAFETY_FEATURE
2264 	qdf_mc_timer_t sar_safety_timer;
2265 	struct qdf_delayed_work sar_safety_unsolicited_work;
2266 	qdf_event_t sar_safety_req_resp_event;
2267 	qdf_atomic_t sar_safety_req_resp_event_in_progress;
2268 #endif
2269 
2270 	qdf_time_t runtime_resume_start_time_stamp;
2271 	qdf_time_t runtime_suspend_done_time_stamp;
2272 #if defined(CLD_PM_QOS) && defined(CLD_DEV_PM_QOS)
2273 	struct dev_pm_qos_request pm_qos_req[NR_CPUS];
2274 	struct cpumask qos_cpu_mask;
2275 #elif defined(CLD_PM_QOS)
2276 	struct pm_qos_request pm_qos_req;
2277 #endif
2278 	bool roam_ch_from_fw_supported;
2279 #ifdef FW_THERMAL_THROTTLE_SUPPORT
2280 	uint8_t dutycycle_off_percent;
2281 #endif
2282 	uint8_t pm_qos_request_flags;
2283 	qdf_work_t country_change_work;
2284 	int current_pcie_gen_speed;
2285 	qdf_workqueue_t *adapter_ops_wq;
2286 	struct hdd_adapter_ops_history adapter_ops_history;
2287 	bool ll_stats_per_chan_rx_tx_time;
2288 #ifdef FEATURE_CLUB_LL_STATS_AND_GET_STATION
2289 	bool is_get_station_clubbed_in_ll_stats_req;
2290 #endif
2291 #ifdef FEATURE_WPSS_THERMAL_MITIGATION
2292 	bool multi_client_thermal_mitigation;
2293 #endif
2294 	bool is_dual_mac_cfg_updated;
2295 	bool is_regulatory_update_in_progress;
2296 	qdf_event_t regulatory_update_event;
2297 	qdf_mutex_t regulatory_status_lock;
2298 	bool is_fw_dbg_log_levels_configured;
2299 #ifdef WLAN_SUPPORT_TWT
2300 	qdf_work_t twt_en_dis_work;
2301 #endif
2302 	bool is_wifi3_0_target;
2303 	bool dump_in_progress;
2304 	struct hdd_dual_sta_policy dual_sta_policy;
2305 #ifdef THERMAL_STATS_SUPPORT
2306 	bool is_therm_stats_in_progress;
2307 #endif
2308 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE
2309 	bool is_vdev_macaddr_dynamic_update_supported;
2310 #endif
2311 #ifdef CONFIG_WLAN_FREQ_LIST
2312 	uint8_t power_type;
2313 #endif
2314 	bool is_wlan_disabled;
2315 
2316 	uint8_t oem_data[HDD_MAX_OEM_DATA_LEN];
2317 	uint8_t oem_data_len;
2318 	uint8_t file_name[HDD_MAX_FILE_NAME_LEN];
2319 #ifdef WLAN_FEATURE_DBAM_CONFIG
2320 	enum coex_dbam_config_mode dbam_mode;
2321 #endif
2322 	qdf_time_t last_pagefault_ssr_time;
2323 	uint8_t bridgeaddr[QDF_MAC_ADDR_SIZE];
2324 #ifdef WLAN_FEATURE_11BE_MLO
2325 	bool is_mlo_per_link_stats_supported;
2326 	uint8_t num_mlo_peers;
2327 	uint32_t more_peer_data;
2328 #endif
2329 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
2330 	struct hdd_lpc_info lpc_info;
2331 #endif
2332 };
2333 
2334 /**
2335  * struct hdd_vendor_acs_chan_params - vendor acs channel parameters
2336  * @pcl_count: pcl list count
2337  * @vendor_pcl_list: pointer to pcl frequency (MHz) list
2338  * @vendor_weight_list: pointer to pcl weight list
2339  */
2340 struct hdd_vendor_acs_chan_params {
2341 	uint32_t pcl_count;
2342 	uint32_t *vendor_pcl_list;
2343 	uint8_t *vendor_weight_list;
2344 };
2345 
2346 /**
2347  * struct hdd_external_acs_timer_context - acs timer context
2348  * @reason: reason for acs trigger
2349  * @adapter: hdd adapter for acs
2350  */
2351 struct hdd_external_acs_timer_context {
2352 	int8_t reason;
2353 	struct hdd_adapter *adapter;
2354 };
2355 
2356 /**
2357  * struct hdd_vendor_chan_info - vendor channel info
2358  * @band: channel operating band
2359  * @pri_chan_freq: primary channel freq in MHz
2360  * @ht_sec_chan_freq: secondary channel freq in MHz
2361  * @vht_seg0_center_chan_freq: segment0 for vht in MHz
2362  * @vht_seg1_center_chan_freq: vht segment 1 in MHz
2363  * @chan_width: channel width
2364  */
2365 struct hdd_vendor_chan_info {
2366 	uint8_t band;
2367 	uint32_t pri_chan_freq;
2368 	uint32_t ht_sec_chan_freq;
2369 	uint32_t vht_seg0_center_chan_freq;
2370 	uint32_t vht_seg1_center_chan_freq;
2371 	uint8_t chan_width;
2372 };
2373 
2374 /**
2375  * struct  hdd_channel_info - standard channel info
2376  * @freq: Freq in Mhz
2377  * @flags: channel info flags
2378  * @flagext: extended channel info flags
2379  * @ieee_chan_number: channel number
2380  * @max_reg_power: max tx power according to regulatory
2381  * @max_radio_power: max radio power
2382  * @min_radio_power: min radio power
2383  * @reg_class_id: regulatory class
2384  * @max_antenna_gain: max antenna gain allowed on channel
2385  * @vht_center_freq_seg0: vht center freq segment 0
2386  * @vht_center_freq_seg1: vht center freq segment 1
2387  */
2388 struct hdd_channel_info {
2389 	u_int16_t freq;
2390 	u_int32_t flags;
2391 	u_int16_t flagext;
2392 	u_int8_t ieee_chan_number;
2393 	int8_t max_reg_power;
2394 	int8_t max_radio_power;
2395 	int8_t min_radio_power;
2396 	u_int8_t reg_class_id;
2397 	u_int8_t max_antenna_gain;
2398 	u_int8_t vht_center_freq_seg0;
2399 	u_int8_t vht_center_freq_seg1;
2400 };
2401 
2402 /**
2403  * struct hdd_chwidth_info - channel width related info
2404  * @sir_chwidth_valid: If nl_chan_width is valid in Sir
2405  * @sir_chwidth: enum eSirMacHTChannelWidth
2406  * @ch_bw: enum hw_mode_bandwidth
2407  * @ch_bw_str: ch_bw in string format
2408  * @phy_chwidth: enum phy_ch_width
2409  * @bonding_mode: WNI_CFG_CHANNEL_BONDING_MODE_DISABLE or
2410  *		  WNI_CFG_CHANNEL_BONDING_MODE_ENABLE
2411  */
2412 struct hdd_chwidth_info {
2413 	bool sir_chwidth_valid;
2414 	enum eSirMacHTChannelWidth sir_chwidth;
2415 	enum hw_mode_bandwidth ch_bw;
2416 	char *ch_bw_str;
2417 	enum phy_ch_width phy_chwidth;
2418 	int bonding_mode;
2419 };
2420 
2421 /**
2422  * struct mac_addr_set_priv: Set MAC addr private context
2423  * @fw_resp_status: F/W response status
2424  * @pending_rsp_cnt: Pending response count
2425  */
2426 struct mac_addr_set_priv {
2427 	uint32_t fw_resp_status;
2428 	qdf_atomic_t pending_rsp_cnt;
2429 };
2430 
2431 /*
2432  * Function declarations and documentation
2433  */
2434 
2435 /**
2436  * wlan_hdd_history_get_next_index() - get next index to store the history
2437  *				       entry
2438  * @curr_idx: current index
2439  * @max_entries: max entries in the history
2440  *
2441  * Returns: The index at which record is to be stored in history
2442  */
wlan_hdd_history_get_next_index(qdf_atomic_t * curr_idx,uint32_t max_entries)2443 static inline uint32_t wlan_hdd_history_get_next_index(qdf_atomic_t *curr_idx,
2444 						       uint32_t max_entries)
2445 {
2446 	uint32_t idx = qdf_atomic_inc_return(curr_idx);
2447 
2448 	return idx & (max_entries - 1);
2449 }
2450 
2451 /**
2452  * hdd_adapter_ops_record_event() - record an entry in the adapter ops history
2453  * @hdd_ctx: pointer to hdd context
2454  * @event: event
2455  * @vdev_id: vdev id corresponding to event
2456  *
2457  * Returns: None
2458  */
2459 static inline void
hdd_adapter_ops_record_event(struct hdd_context * hdd_ctx,enum hdd_adapter_ops_event event,int vdev_id)2460 hdd_adapter_ops_record_event(struct hdd_context *hdd_ctx,
2461 			     enum hdd_adapter_ops_event event,
2462 			     int vdev_id)
2463 {
2464 	struct hdd_adapter_ops_history *adapter_hist;
2465 	struct hdd_adapter_ops_record *record;
2466 	uint32_t idx;
2467 
2468 	adapter_hist = &hdd_ctx->adapter_ops_history;
2469 
2470 	idx = wlan_hdd_history_get_next_index(&adapter_hist->index,
2471 					      WLAN_HDD_ADAPTER_OPS_HISTORY_MAX);
2472 
2473 	record = &adapter_hist->entry[idx];
2474 	record->event = event;
2475 	record->vdev_id = vdev_id;
2476 	record->timestamp = qdf_get_log_timestamp();
2477 }
2478 
2479 /**
2480  * hdd_validate_channel_and_bandwidth() - Validate the channel-bandwidth combo
2481  * @adapter: HDD adapter
2482  * @chan_freq: Channel frequency
2483  * @chan_bw: Bandwidth
2484  *
2485  * Checks if the given bandwidth is valid for the given channel number.
2486  *
2487  * Return: 0 for success, non-zero for failure
2488  */
2489 int hdd_validate_channel_and_bandwidth(struct hdd_adapter *adapter,
2490 				       qdf_freq_t chan_freq,
2491 				       enum phy_ch_width chan_bw);
2492 
2493 /**
2494  * hdd_get_front_adapter() - Get the first adapter from the adapter list
2495  * @hdd_ctx: pointer to the HDD context
2496  * @out_adapter: double pointer to pass the next adapter
2497  *
2498  * Return: QDF_STATUS
2499  */
2500 QDF_STATUS hdd_get_front_adapter(struct hdd_context *hdd_ctx,
2501 				 struct hdd_adapter **out_adapter);
2502 
2503 /**
2504  * hdd_get_next_adapter() - Get the next adapter from the adapter list
2505  * @hdd_ctx: pointer to the HDD context
2506  * @current_adapter: pointer to the current adapter
2507  * @out_adapter: double pointer to pass the next adapter
2508  *
2509  * Return: QDF_STATUS
2510  */
2511 QDF_STATUS hdd_get_next_adapter(struct hdd_context *hdd_ctx,
2512 				struct hdd_adapter *current_adapter,
2513 				struct hdd_adapter **out_adapter);
2514 
2515 /**
2516  * hdd_get_front_adapter_no_lock() - Get the first adapter from the adapter list
2517  * This API does not use any lock in it's implementation. It is the caller's
2518  * directive to ensure concurrency safety.
2519  * @hdd_ctx: pointer to the HDD context
2520  * @out_adapter: double pointer to pass the next adapter
2521  *
2522  * Return: QDF_STATUS
2523  */
2524 QDF_STATUS hdd_get_front_adapter_no_lock(struct hdd_context *hdd_ctx,
2525 					 struct hdd_adapter **out_adapter);
2526 
2527 /**
2528  * hdd_get_next_adapter_no_lock() - Get the next adapter from the adapter list
2529  * This API does not use any lock in it's implementation. It is the caller's
2530  * directive to ensure concurrency safety.
2531  * @hdd_ctx: pointer to the HDD context
2532  * @current_adapter: pointer to the current adapter
2533  * @out_adapter: double pointer to pass the next adapter
2534  *
2535  * Return: QDF_STATUS
2536  */
2537 QDF_STATUS hdd_get_next_adapter_no_lock(struct hdd_context *hdd_ctx,
2538 					struct hdd_adapter *current_adapter,
2539 					struct hdd_adapter **out_adapter);
2540 
2541 /**
2542  * hdd_remove_adapter() - Remove the adapter from the adapter list
2543  * @hdd_ctx: pointer to the HDD context
2544  * @adapter: pointer to the adapter to be removed
2545  *
2546  * Return: QDF_STATUS
2547  */
2548 QDF_STATUS hdd_remove_adapter(struct hdd_context *hdd_ctx,
2549 			      struct hdd_adapter *adapter);
2550 
2551 /**
2552  * hdd_remove_front_adapter() - Remove the first adapter from the adapter list
2553  * @hdd_ctx: pointer to the HDD context
2554  * @out_adapter: pointer to the adapter to be removed
2555  *
2556  * Return: QDF_STATUS
2557  */
2558 QDF_STATUS hdd_remove_front_adapter(struct hdd_context *hdd_ctx,
2559 				    struct hdd_adapter **out_adapter);
2560 
2561 /**
2562  * hdd_add_adapter_back() - Add an adapter to the adapter list
2563  * @hdd_ctx: pointer to the HDD context
2564  * @adapter: pointer to the adapter to be added
2565  *
2566  * Return: QDF_STATUS
2567  */
2568 QDF_STATUS hdd_add_adapter_back(struct hdd_context *hdd_ctx,
2569 				struct hdd_adapter *adapter);
2570 
2571 /**
2572  * hdd_add_adapter_front() - Add an adapter to the head of the adapter list
2573  * @hdd_ctx: pointer to the HDD context
2574  * @adapter: pointer to the adapter to be added
2575  *
2576  * Return: QDF_STATUS
2577  */
2578 QDF_STATUS hdd_add_adapter_front(struct hdd_context *hdd_ctx,
2579 				 struct hdd_adapter *adapter);
2580 
2581 /**
2582  * typedef hdd_adapter_iterate_cb() - Iteration callback function
2583  * @link_info: Link info pointer in HDD adapter
2584  * @context: user context supplied to the iterator
2585  *
2586  * This specifies the type of a callback function to supply to
2587  * hdd_adapter_iterate().
2588  *
2589  * Return:
2590  * * QDF_STATUS_SUCCESS if further iteration should continue
2591  * * QDF_STATUS_E_ABORTED if further iteration should be aborted
2592  */
2593 typedef QDF_STATUS
2594 (*hdd_adapter_iterate_cb)(struct wlan_hdd_link_info *link_info, void *context);
2595 
2596 /**
2597  * hdd_adapter_iterate() - Safely iterate over all adapters
2598  * @cb: callback function to invoke for each adapter
2599  * @context: user-supplied context to pass to @cb
2600  *
2601  * This function will iterate over all of the adapters known to the system in
2602  * a safe manner, invoking the callback function for each adapter.
2603  * The callback function will be invoked in the same context/thread as the
2604  * caller without any additional locks in force.
2605  * Iteration continues until either the callback has been invoked for all
2606  * adapters or a callback returns a value of QDF_STATUS_E_ABORTED to indicate
2607  * that further iteration should cease.
2608  *
2609  * Return:
2610  * * QDF_STATUS_E_ABORTED if any callback function returns that value
2611  * * QDF_STATUS_E_FAILURE if the callback was not invoked for all adapters due
2612  * to concurrency (i.e. adapter was deleted while iterating)
2613  * * QDF_STATUS_SUCCESS if @cb was invoked for each adapter and none returned
2614  * an error
2615  */
2616 QDF_STATUS hdd_adapter_iterate(hdd_adapter_iterate_cb cb,
2617 			       void *context);
2618 
2619 /**
2620  * hdd_adapter_dev_hold_debug - Debug API to call dev_hold
2621  * @adapter: hdd_adapter pointer
2622  * @dbgid: Debug ID corresponding to API that is requesting the dev_hold
2623  *
2624  * Return: none
2625  */
2626 void hdd_adapter_dev_hold_debug(struct hdd_adapter *adapter,
2627 				wlan_net_dev_ref_dbgid dbgid);
2628 
2629 /**
2630  * hdd_adapter_dev_put_debug - Debug API to call dev_put
2631  * @adapter: hdd_adapter pointer
2632  * @dbgid: Debug ID corresponding to API that is requesting the dev_put
2633  *
2634  * Return: none
2635  */
2636 void hdd_adapter_dev_put_debug(struct hdd_adapter *adapter,
2637 			       wlan_net_dev_ref_dbgid dbgid);
2638 
2639 /**
2640  * hdd_validate_next_adapter - API to check for infinite loop
2641  *                             in the adapter list traversal
2642  * @curr: current adapter pointer
2643  * @next: next adapter pointer
2644  * @dbg_id: Debug ID corresponding to API that is requesting the dev_put
2645  *
2646  * Return: None
2647  */
2648 void hdd_validate_next_adapter(struct hdd_adapter **curr,
2649 			       struct hdd_adapter **next,
2650 			       wlan_net_dev_ref_dbgid dbg_id);
2651 
2652 /**
2653  * __hdd_take_ref_and_fetch_front_adapter_safe - Helper macro to lock, fetch
2654  * front and next adapters, take ref and unlock.
2655  * @hdd_ctx: the global HDD context
2656  * @adapter: an hdd_adapter pointer to use as a cursor
2657  * @next_adapter: hdd_adapter pointer to next adapter
2658  * @dbgid: debug ID to detect reference leaks
2659  */
2660 #define __hdd_take_ref_and_fetch_front_adapter_safe(hdd_ctx, adapter, \
2661 						    next_adapter, dbgid) \
2662 	qdf_spin_lock_bh(&hdd_ctx->hdd_adapter_lock), \
2663 	hdd_get_front_adapter_no_lock(hdd_ctx, &adapter), \
2664 	(adapter) ? hdd_adapter_dev_hold_debug(adapter, dbgid) : (false), \
2665 	hdd_get_next_adapter_no_lock(hdd_ctx, adapter, &next_adapter), \
2666 	(next_adapter) ? hdd_adapter_dev_hold_debug(next_adapter, dbgid) : \
2667 			 (false), \
2668 	qdf_spin_unlock_bh(&hdd_ctx->hdd_adapter_lock)
2669 
2670 /**
2671  * __hdd_take_ref_and_fetch_next_adapter_safe - Helper macro to lock, fetch next
2672  * adapter, take ref and unlock.
2673  * @hdd_ctx: the global HDD context
2674  * @adapter: hdd_adapter pointer to use as a cursor
2675  * @next_adapter: hdd_adapter pointer to next adapter
2676  * @dbgid: debug ID to detect reference leaks
2677  */
2678 #define __hdd_take_ref_and_fetch_next_adapter_safe(hdd_ctx, adapter, \
2679 						   next_adapter, dbgid) \
2680 	qdf_spin_lock_bh(&hdd_ctx->hdd_adapter_lock), \
2681 	adapter = next_adapter, \
2682 	hdd_get_next_adapter_no_lock(hdd_ctx, adapter, &next_adapter), \
2683 	hdd_validate_next_adapter(&adapter, &next_adapter, dbgid), \
2684 	(next_adapter) ? hdd_adapter_dev_hold_debug(next_adapter, dbgid) : \
2685 			 (false), \
2686 	qdf_spin_unlock_bh(&hdd_ctx->hdd_adapter_lock)
2687 
2688 /**
2689  * __hdd_is_adapter_valid - Helper macro to return true/false for valid adapter.
2690  * @_adapter: an hdd_adapter pointer to use as a cursor
2691  */
2692 #define __hdd_is_adapter_valid(_adapter) !!_adapter
2693 
2694 /**
2695  * hdd_for_each_adapter_dev_held_safe - Adapter iterator with dev_hold called
2696  *                                      in a delete safe manner
2697  * @hdd_ctx: the global HDD context
2698  * @adapter: an hdd_adapter pointer to use as a cursor
2699  * @next_adapter: hdd_adapter pointer to the next adapter
2700  * @dbgid: reference count debugging id
2701  *
2702  * This iterator will take the reference of the netdev associated with the
2703  * given adapter so as to prevent it from being removed in other context. It
2704  * also takes the reference of the next adapter if exist. This avoids infinite
2705  * loop due to deletion of the adapter list entry inside the loop. Deletion of
2706  * list entry will make the list entry to point to self. If the control goes
2707  * inside the loop body then the dev_hold has been invoked.
2708  *
2709  *                           ***** NOTE *****
2710  * Before the end of each iteration, hdd_adapter_dev_put_debug(adapter, dbgid)
2711  * must be called. Not calling this will keep hold of a reference, thus
2712  * preventing unregister of the netdevice. If the loop is terminated in
2713  * between with return/goto/break statements,
2714  * hdd_adapter_dev_put_debug(next_adapter, dbgid) must be done along with
2715  * hdd_adapter_dev_put_debug(adapter, dbgid) before termination of the loop.
2716  *
2717  * Usage example:
2718  *  hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter, dbgid) {
2719  *        <work involving adapter>
2720  *        <some more work>
2721  *        hdd_adapter_dev_put_debug(adapter, dbgid)
2722  *  }
2723  */
2724 #define hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter, \
2725 					   dbgid) \
2726 	for (__hdd_take_ref_and_fetch_front_adapter_safe(hdd_ctx, adapter, \
2727 							 next_adapter, dbgid); \
2728 	     __hdd_is_adapter_valid(adapter); \
2729 	     __hdd_take_ref_and_fetch_next_adapter_safe(hdd_ctx, adapter, \
2730 							next_adapter, dbgid))
2731 
2732 /* Helper MACROS and APIs definition to iterate
2733  * link info array in HDD adapter.
2734  */
2735 #define __hdd_adapter_is_active_link(adapter, link_idx) \
2736 			qdf_atomic_test_bit(link_idx, &(adapter)->active_links)
2737 
2738 #define hdd_adapter_get_link_info_if_active(adapter, link_idx) \
2739 		__hdd_adapter_is_active_link((adapter), (link_idx)) ? \
2740 			&((adapter)->link_info[(link_idx)]) : NULL
2741 
2742 #define __hdd_is_link_info_valid(_link_info) !!_link_info
2743 
2744 #define __hdd_adapter_get_first_active_link_info(adapter, link_info) \
2745 	link_info = NULL, \
2746 	hdd_adapter_get_next_active_link_info(adapter, &link_info)
2747 
2748 
2749 static inline uint8_t
hdd_adapter_get_index_of_link_info(struct wlan_hdd_link_info * link_info)2750 hdd_adapter_get_index_of_link_info(struct wlan_hdd_link_info *link_info)
2751 {
2752 	return (link_info - &link_info->adapter->link_info[0]);
2753 }
2754 
2755 static inline void
hdd_adapter_get_next_active_link_info(struct hdd_adapter * adapter,struct wlan_hdd_link_info ** link_info)2756 hdd_adapter_get_next_active_link_info(struct hdd_adapter *adapter,
2757 				      struct wlan_hdd_link_info **link_info)
2758 {
2759 	uint8_t link_idx = WLAN_HDD_DEFLINK_IDX;
2760 	uint8_t link_idx_max;
2761 
2762 	if (!link_info || !adapter)
2763 		return;
2764 
2765 	/* If @link_info already points to valid link info address, get the
2766 	 * index of that link info and get the next valid link info which is
2767 	 * set to active.
2768 	 * If @link_info points to invalid address, then start the search
2769 	 * for active link info from WLAN_HDD_DEFLINK_IDX index.
2770 	 */
2771 	if (*link_info)
2772 		link_idx = hdd_adapter_get_index_of_link_info(*link_info) + 1;
2773 
2774 	*link_info = NULL;
2775 	link_idx_max = QDF_ARRAY_SIZE(adapter->link_info);
2776 	while (link_idx < link_idx_max && !(*link_info)) {
2777 		*link_info = hdd_adapter_get_link_info_if_active(adapter,
2778 								 link_idx);
2779 		link_idx++;
2780 	}
2781 }
2782 
2783 /**
2784  * hdd_adapter_for_each_active_link_info() - Link info iterator which loops
2785  * through the link info array elements which are set to active.
2786  * @adapter: HDD adapter to iterate for each active link info pointer.
2787  * @link_info: Pointer of active link info.
2788  *
2789  * The "active_links" bitmap in @adapter says which indices are active
2790  * in the link info array.
2791  * The MACRO iterates through all the active link info elements in link info
2792  * array and ends loop when no more active link info entries are present.
2793  * The @link_info points next active link info pointer on each iteration or
2794  * NULL value at the end of the loop.
2795  *
2796  * Callers to take reference of adapter if needed.
2797  */
2798 #define hdd_adapter_for_each_active_link_info(adapter, link_info) \
2799 	for (__hdd_adapter_get_first_active_link_info(adapter, link_info); \
2800 	     __hdd_is_link_info_valid(link_info); \
2801 	     hdd_adapter_get_next_active_link_info(adapter, &link_info))
2802 
2803 #define __hdd_adapter_get_firstlink(adapter, __link_info)	\
2804 		(__link_info = adapter ? &((adapter)->link_info[0]) : NULL)
2805 
2806 #define __hdd_is_link_info_idx_valid(adapter, __link_info) \
2807 	((__link_info - &(adapter)->link_info[0]) < \
2808 					QDF_ARRAY_SIZE((adapter)->link_info))
2809 
2810 #define __hdd_adapter_next_link_info(link_info)	((link_info)++)
2811 
2812 /**
2813  * hdd_adapter_for_each_link_info() - Link info iterator for all
2814  * link_info fields.
2815  * @adapter: HDD adapter to iterate each link_info.
2816  * @link_info: Pointer to each link info element in the array.
2817  *
2818  * The function iterates from the start index of link_info array
2819  * in @adapter till the end of the link_info array.
2820  *
2821  * Callers to take reference of adapter if needed.
2822  */
2823 
2824 #define hdd_adapter_for_each_link_info(adapter, link_info) \
2825 	for (__hdd_adapter_get_firstlink(adapter, link_info); \
2826 	     __hdd_is_link_info_valid(link_info) && \
2827 	     __hdd_is_link_info_idx_valid(adapter, link_info); \
2828 	     __hdd_adapter_next_link_info(link_info))
2829 
2830 /**
2831  * wlan_hdd_get_link_info_from_objmgr() - Fetch adapter from objmgr
2832  * @vdev: the vdev whose corresponding adapter has to be fetched
2833  *
2834  * Return: Address of link info pointer in HDD adapter corresponding to VDEV
2835  */
2836 struct wlan_hdd_link_info *
2837 wlan_hdd_get_link_info_from_objmgr(struct wlan_objmgr_vdev *vdev);
2838 
2839 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC) && \
2840 	defined(WLAN_HDD_MULTI_VDEV_SINGLE_NDEV)
2841 /**
2842  * hdd_adapter_disable_all_links() - Reset the links on stop adapter.
2843  * @adapter: HDD adapter
2844  * @clear_macaddr: Clears mac address if set to true
2845  *
2846  * Resets the MAC address in each link info and resets the link info
2847  * mapping in adapter array.
2848  *
2849  * Return: void
2850  */
2851 void
2852 hdd_adapter_disable_all_links(struct hdd_adapter *adapter, bool clear_macaddr);
2853 #else
2854 static inline void
hdd_adapter_disable_all_links(struct hdd_adapter * adapter,bool clear_macaddr)2855 hdd_adapter_disable_all_links(struct hdd_adapter *adapter, bool clear_macaddr)
2856 {
2857 }
2858 #endif
2859 
2860 struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx,
2861 				     uint8_t session_type,
2862 				     const char *name, tSirMacAddr mac_addr,
2863 				     unsigned char name_assign_type,
2864 				     bool rtnl_held,
2865 				     struct hdd_adapter_create_param *params);
2866 
2867 QDF_STATUS hdd_open_adapter_no_trans(struct hdd_context *hdd_ctx,
2868 				     enum QDF_OPMODE op_mode,
2869 				     const char *iface_name,
2870 				     uint8_t *mac_addr_bytes,
2871 				     struct hdd_adapter_create_param *params);
2872 /**
2873  * hdd_close_adapter() - remove and free @adapter from the adapter list
2874  * @hdd_ctx: The Hdd context containing the adapter list
2875  * @adapter: the adapter to remove and free
2876  * @rtnl_held: if the caller is already holding the RTNL lock
2877  *
2878  * Return: None
2879  */
2880 void hdd_close_adapter(struct hdd_context *hdd_ctx,
2881 		       struct hdd_adapter *adapter,
2882 		       bool rtnl_held);
2883 
2884 /**
2885  * hdd_close_all_adapters() - remove and free all adapters from the adapter list
2886  * @hdd_ctx: The Hdd context containing the adapter list
2887  * @rtnl_held: if the caller is already holding the RTNL lock
2888  *
2889  * Return: None
2890  */
2891 void hdd_close_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held);
2892 
2893 QDF_STATUS hdd_stop_all_adapters(struct hdd_context *hdd_ctx);
2894 void hdd_deinit_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held);
2895 QDF_STATUS hdd_reset_all_adapters(struct hdd_context *hdd_ctx);
2896 QDF_STATUS hdd_start_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held);
2897 
2898 /**
2899  * hdd_get_link_info_by_vdev() - Return link info with the given vdev id
2900  * @hdd_ctx: hdd context.
2901  * @vdev_id: vdev id for the link info to get.
2902  *
2903  * This function is used to get the link info with provided vdev id
2904  *
2905  * Return: adapter pointer if found
2906  *
2907  */
2908 struct wlan_hdd_link_info *
2909 hdd_get_link_info_by_vdev(struct hdd_context *hdd_ctx, uint32_t vdev_id);
2910 
2911 /**
2912  * hdd_adapter_get_by_reference() - Return adapter with the given reference
2913  * @hdd_ctx: hdd context
2914  * @reference: reference for the adapter to get
2915  *
2916  * This function is used to get the adapter with provided reference.
2917  * The adapter reference will be held until being released by calling
2918  * hdd_adapter_put().
2919  *
2920  * Return: adapter pointer if found
2921  *
2922  */
2923 struct hdd_adapter *hdd_adapter_get_by_reference(struct hdd_context *hdd_ctx,
2924 						 struct hdd_adapter *reference);
2925 
2926 /**
2927  * hdd_adapter_put() - Release reference to adapter
2928  * @adapter: adapter reference
2929  *
2930  * Release reference to adapter previously acquired via
2931  * hdd_adapter_get_*() function
2932  */
2933 void hdd_adapter_put(struct hdd_adapter *adapter);
2934 
2935 /**
2936  * hdd_get_link_info_by_link_addr() - Get the link info pointer where
2937  * the link address matches.
2938  * @hdd_ctx: HDD context pointer
2939  * @link_addr: Link address to search
2940  *
2941  * In the given @adapter search for @link_addr in each entry of link_info
2942  * array, and return the matching link_info pointer.
2943  *
2944  * Return: NULL / Valid link info pointer
2945  */
2946 struct wlan_hdd_link_info *
2947 hdd_get_link_info_by_link_addr(struct hdd_context *hdd_ctx,
2948 			       struct qdf_mac_addr *link_addr);
2949 
2950 struct hdd_adapter *hdd_get_adapter_by_macaddr(struct hdd_context *hdd_ctx,
2951 					       tSirMacAddr mac_addr);
2952 
2953 /**
2954  * hdd_get_link_info_home_channel() - return home channel of adapter
2955  * @link_info: Pointer of link_info in @adapter
2956  *
2957  * This function returns operation channel of station/p2p-cli if
2958  * connected, returns operation channel of sap/p2p-go if started.
2959  *
2960  * Return: home channel if connected/started or invalid channel 0
2961  */
2962 uint32_t hdd_get_link_info_home_channel(struct wlan_hdd_link_info *link_info);
2963 
2964 /**
2965  * hdd_get_link_info_width() - return current bandwidth of adapter
2966  * @link_info: Pointer of link_info in @adapter
2967  *
2968  * This function returns current bandwidth of station/p2p-cli if
2969  * connected, returns current bandwidth of sap/p2p-go if started.
2970  *
2971  * Return: bandwidth if connected/started or invalid bandwidth 0
2972  */
2973 enum phy_ch_width hdd_get_link_info_width(struct wlan_hdd_link_info *link_info);
2974 
2975 /*
2976  * hdd_get_adapter_by_rand_macaddr() - find Random mac adapter
2977  * @hdd_ctx: hdd context
2978  * @mac_addr: random mac addr
2979  *
2980  * Find the Adapter based on random mac addr. Adapter's vdev
2981  * have active random mac list.
2982  *
2983  * Return: adapter ptr or null
2984  */
2985 struct hdd_adapter *
2986 hdd_get_adapter_by_rand_macaddr(struct hdd_context *hdd_ctx,
2987 				tSirMacAddr mac_addr);
2988 
2989 /**
2990  * hdd_adapter_update_mlo_mgr_mac_addr() - Update each link address to MLO mgr.
2991  * @adapter: HDD adapter
2992  *
2993  * Update MLO manager with each link address and corresponding VDEV ID.
2994  * Only update for ML-STA adapter types.
2995  *
2996  * Return: void
2997  */
2998 void hdd_adapter_update_mlo_mgr_mac_addr(struct hdd_adapter *adapter);
2999 
3000 /**
3001  * hdd_is_vdev_in_conn_state() - Check whether the vdev is in
3002  * connected/started state.
3003  * @link_info: Pointer to link_info in adapter
3004  *
3005  * This function will give whether the vdev in the adapter is in
3006  * connected/started state.
3007  *
3008  * Return: True/false
3009  */
3010 bool hdd_is_vdev_in_conn_state(struct wlan_hdd_link_info *link_info);
3011 
3012 /**
3013  * hdd_adapter_deregister_fc() - Deregisters flow control
3014  * callbacks
3015  * @adapter: HDD adapter
3016  *
3017  * The function call deregisters flow control callbacks
3018  *
3019  * Return: void
3020  */
3021 void hdd_adapter_deregister_fc(struct hdd_adapter *adapter);
3022 
3023 #ifdef WLAN_OPEN_SOURCE
3024 /**
3025  * hdd_cancel_ip_notifier_work() - Cancel scheduled IP
3026  * notifier deferred work
3027  * @adapter: HDD adapter
3028  *
3029  * The API calls cancel work for IPv4 and IPv6 notifier
3030  * deferred task
3031  *
3032  * Return: void
3033  */
3034 void hdd_cancel_ip_notifier_work(struct hdd_adapter *adapter);
3035 #else
3036 static inline
hdd_cancel_ip_notifier_work(struct hdd_adapter * adapter)3037 void hdd_cancel_ip_notifier_work(struct hdd_adapter *adapter)
3038 {
3039 }
3040 #endif
3041 
3042 /**
3043  * hdd_vdev_create() - Create the vdev in the firmware
3044  * @link_info: Link info pointer in HDD adapter
3045  *
3046  * This function will create the vdev in the firmware
3047  *
3048  * Return: 0 when the vdev create is sent to firmware or -EINVAL when
3049  * there is a failure to send the command.
3050  */
3051 int hdd_vdev_create(struct wlan_hdd_link_info *link_info);
3052 
3053 /**
3054  * hdd_vdev_destroy() - Destroy the vdev in the firmware
3055  * @link_info: Link info pointer in HDD adapter
3056  *
3057  * This function will destroy the vdev in the firmware
3058  *
3059  * Return: 0 when the vdev destroy is sent to firmware
3060  * or -EINVAL when there is a failure to send the command.
3061  */
3062 int hdd_vdev_destroy(struct wlan_hdd_link_info *link_info);
3063 
3064 /**
3065  * hdd_vdev_ready() - Configure FW post VDEV create
3066  * @vdev: VDEV object.
3067  * @bridgeaddr: Bridge MAC address
3068  *
3069  * The function is used send configuration to the FW
3070  * post VDEV creation.
3071  * The caller to ensure to hold the VDEV reference
3072  *
3073  * Return: 0 on success, negative value on failure.
3074  */
3075 int hdd_vdev_ready(struct wlan_objmgr_vdev *vdev,
3076 		   struct qdf_mac_addr *bridgeaddr);
3077 
3078 /**
3079  * hdd_init_station_mode() - Initialize STA mode adapter
3080  * post vdev creation.
3081  * @link_info: Link info pointer in HDD adapter
3082  *
3083  * The function initializes the adapter post vdev
3084  * create for STA mode type adapters on start
3085  * adapter.
3086  *
3087  * Return: QDF_STATUS
3088  */
3089 QDF_STATUS hdd_init_station_mode(struct wlan_hdd_link_info *link_info);
3090 
3091 struct hdd_adapter *hdd_get_adapter(struct hdd_context *hdd_ctx,
3092 			enum QDF_OPMODE mode);
3093 
3094 /**
3095  * hdd_get_device_mode() - Get device mode
3096  * @vdev_id: vdev id
3097  *
3098  * Return: Device mode
3099  */
3100 enum QDF_OPMODE hdd_get_device_mode(uint32_t vdev_id);
3101 
3102 /**
3103  * hdd_deinit_session() - Cleanup session context in
3104  * adapter
3105  * @adapter: HDD adapter
3106  *
3107  * The API cleans up session context and scan IEs
3108  * in link_info and adapter.
3109  *
3110  * Return: None
3111  */
3112 void hdd_deinit_session(struct hdd_adapter *adapter);
3113 
3114 void hdd_deinit_adapter(struct hdd_context *hdd_ctx,
3115 			struct hdd_adapter *adapter,
3116 			bool rtnl_held);
3117 QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
3118 			    struct hdd_adapter *adapter);
3119 
3120 /**
3121  * hdd_set_station_ops() - update net_device ops
3122  * @dev: Handle to struct net_device to be updated.
3123  * Return: None
3124  */
3125 void hdd_set_station_ops(struct net_device *dev);
3126 
3127 /**
3128  * wlan_hdd_get_intf_addr() - Get address for the interface
3129  * @hdd_ctx: Pointer to hdd context
3130  * @interface_type: type of the interface for which address is queried
3131  *
3132  * This function is used to get mac address for every new interface
3133  *
3134  * Return: If addr is present then return pointer to MAC address
3135  *         else NULL
3136  */
3137 
3138 uint8_t *wlan_hdd_get_intf_addr(struct hdd_context *hdd_ctx,
3139 				enum QDF_OPMODE interface_type);
3140 void wlan_hdd_release_intf_addr(struct hdd_context *hdd_ctx,
3141 				uint8_t *releaseAddr);
3142 
3143 /**
3144  * hdd_get_operating_chan_freq() - return operating channel of the device mode
3145  * @hdd_ctx:	Pointer to the HDD context.
3146  * @mode:	Device mode for which operating channel is required.
3147  *              Supported modes:
3148  *			QDF_STA_MODE,
3149  *			QDF_P2P_CLIENT_MODE,
3150  *			QDF_SAP_MODE,
3151  *			QDF_P2P_GO_MODE.
3152  *
3153  * This API returns the operating channel of the requested device mode
3154  *
3155  * Return: channel frequency, or
3156  *         0 if the requested device mode is not found.
3157  */
3158 uint32_t hdd_get_operating_chan_freq(struct hdd_context *hdd_ctx,
3159 				     enum QDF_OPMODE mode);
3160 
3161 void hdd_set_conparam(int32_t con_param);
3162 enum QDF_GLOBAL_MODE hdd_get_conparam(void);
3163 
3164 /**
3165  * wlan_hdd_reset_prob_rspies() - Reset probe response IEs
3166  * @link_info: Link info pointer in HDD adapter.
3167  *
3168  * Reset the probe response IEs for the VDEV pointer by link info.
3169  *
3170  * Return: void
3171  */
3172 void wlan_hdd_reset_prob_rspies(struct wlan_hdd_link_info *link_info);
3173 void hdd_prevent_suspend(uint32_t reason);
3174 
3175 /*
3176  * hdd_get_first_valid_adapter() - Get the first valid adapter from adapter list
3177  *
3178  * This function is used to fetch the first valid adapter from the adapter
3179  * list. If there is no valid adapter then it returns NULL
3180  *
3181  * @hdd_ctx: HDD context handler
3182  *
3183  * Return: NULL if no valid adapter found in the adapter list
3184  *
3185  */
3186 struct hdd_adapter *hdd_get_first_valid_adapter(struct hdd_context *hdd_ctx);
3187 
3188 void hdd_allow_suspend(uint32_t reason);
3189 void hdd_prevent_suspend_timeout(uint32_t timeout, uint32_t reason);
3190 
3191 /**
3192  * wlan_hdd_validate_context() - check the HDD context
3193  * @hdd_ctx: Global HDD context pointer
3194  *
3195  * Return: 0 if the context is valid. Error code otherwise
3196  */
3197 #define wlan_hdd_validate_context(hdd_ctx) \
3198 	__wlan_hdd_validate_context(hdd_ctx, __func__)
3199 
3200 int __wlan_hdd_validate_context(struct hdd_context *hdd_ctx, const char *func);
3201 
3202 /**
3203  * hdd_validate_adapter() - Validate the given adapter
3204  * @adapter: the adapter to validate
3205  *
3206  * This function validates the given adapter, and ensures that it is open.
3207  *
3208  * Return: Errno
3209  */
3210 #define hdd_validate_adapter(adapter) \
3211 	__hdd_validate_adapter(adapter, __func__)
3212 
3213 int __hdd_validate_adapter(struct hdd_adapter *adapter, const char *func);
3214 
3215 /**
3216  * wlan_hdd_validate_vdev_id() - ensure the given vdev Id is valid
3217  * @vdev_id: the vdev Id to validate
3218  *
3219  * Return: Errno
3220  */
3221 #define wlan_hdd_validate_vdev_id(vdev_id) \
3222 	__wlan_hdd_validate_vdev_id(vdev_id, __func__)
3223 
3224 int __wlan_hdd_validate_vdev_id(uint8_t vdev_id, const char *func);
3225 
3226 /**
3227  * hdd_is_valid_mac_address() - validate MAC address
3228  * @mac_addr:	Pointer to the input MAC address
3229  *
3230  * This function validates whether the given MAC address is valid or not
3231  * Expected MAC address is of the format XX:XX:XX:XX:XX:XX
3232  * where X is the hexa decimal digit character and separated by ':'
3233  * This algorithm works even if MAC address is not separated by ':'
3234  *
3235  * This code checks given input string mac contains exactly 12 hexadecimal
3236  * digits and a separator colon : appears in the input string only after
3237  * an even number of hex digits.
3238  *
3239  * Return: true for valid and false for invalid
3240  */
3241 bool hdd_is_valid_mac_address(const uint8_t *mac_addr);
3242 
3243 bool wlan_hdd_validate_modules_state(struct hdd_context *hdd_ctx);
3244 
3245 /**
3246  * wlan_hdd_validate_mac_address() - Function to validate mac address
3247  * @mac_addr: input mac address
3248  *
3249  * Return QDF_STATUS
3250  */
3251 #define wlan_hdd_validate_mac_address(mac_addr) \
3252 	__wlan_hdd_validate_mac_address(mac_addr, __func__)
3253 
3254 QDF_STATUS __wlan_hdd_validate_mac_address(struct qdf_mac_addr *mac_addr,
3255 					   const char *func);
3256 
3257 /**
3258  * hdd_is_any_adapter_connected() - Check if any adapter is in connected state
3259  * @hdd_ctx: the global hdd context
3260  *
3261  * Returns: true, if any of the adapters is in connected state,
3262  *	    false, if none of the adapters is in connected state.
3263  */
3264 bool hdd_is_any_adapter_connected(struct hdd_context *hdd_ctx);
3265 
3266 /**
3267  * hdd_init_adapter_ops_wq() - Init global workqueue for adapter operations.
3268  * @hdd_ctx: pointer to HDD context
3269  *
3270  * Return: QDF_STATUS_SUCCESS if workqueue is allocated,
3271  *	   QDF_STATUS_E_NOMEM if workqueue aloocation fails.
3272  */
3273 QDF_STATUS hdd_init_adapter_ops_wq(struct hdd_context *hdd_ctx);
3274 
3275 /**
3276  * hdd_deinit_adapter_ops_wq() - Deinit global workqueue for adapter operations.
3277  * @hdd_ctx: pointer to HDD context
3278  *
3279  * Return: None
3280  */
3281 void hdd_deinit_adapter_ops_wq(struct hdd_context *hdd_ctx);
3282 
3283 /**
3284  * hdd_adapter_feature_update_work_init() - Init per adapter work for netdev
3285  *					    feature update
3286  * @adapter: pointer to adapter structure
3287  *
3288  * Return: QDF_STATUS
3289  */
3290 QDF_STATUS hdd_adapter_feature_update_work_init(struct hdd_adapter *adapter);
3291 
3292 /**
3293  * hdd_adapter_feature_update_work_deinit() - Deinit per adapter work for
3294  *					      netdev feature update
3295  * @adapter: pointer to adapter structure
3296  *
3297  * Return: QDF_STATUS
3298  */
3299 void hdd_adapter_feature_update_work_deinit(struct hdd_adapter *adapter);
3300 
3301 int hdd_qdf_trace_enable(QDF_MODULE_ID module_id, uint32_t bitmask);
3302 
3303 int hdd_init(void);
3304 void hdd_deinit(void);
3305 
3306 /**
3307  * hdd_wlan_startup() - HDD init function
3308  * @hdd_ctx: the HDD context corresponding to the psoc to startup
3309  *
3310  * Return: Errno
3311  */
3312 int hdd_wlan_startup(struct hdd_context *hdd_ctx);
3313 
3314 /**
3315  * hdd_wlan_exit() - HDD WLAN exit function
3316  * @hdd_ctx: pointer to the HDD Context
3317  *
3318  * Return: None
3319  */
3320 void hdd_wlan_exit(struct hdd_context *hdd_ctx);
3321 
3322 /**
3323  * hdd_psoc_create_vdevs() - create the default vdevs for a psoc
3324  * @hdd_ctx: the HDD context for the psoc to operate against
3325  *
3326  * Return: QDF_STATUS
3327  */
3328 QDF_STATUS hdd_psoc_create_vdevs(struct hdd_context *hdd_ctx);
3329 
3330 /*
3331  * hdd_context_create() - Allocate and inialize HDD context.
3332  * @dev: Device Pointer to the underlying device
3333  *
3334  * Allocate and initialize HDD context. HDD context is allocated as part of
3335  * wiphy allocation and then context is initialized.
3336  *
3337  * Return: HDD context on success and ERR_PTR on failure
3338  */
3339 struct hdd_context *hdd_context_create(struct device *dev);
3340 
3341 /**
3342  * hdd_context_destroy() - Destroy HDD context
3343  * @hdd_ctx: HDD context to be destroyed.
3344  *
3345  * Free config and HDD context as well as destroy all the resources.
3346  *
3347  * Return: None
3348  */
3349 void hdd_context_destroy(struct hdd_context *hdd_ctx);
3350 
3351 int hdd_wlan_notify_modem_power_state(int state);
3352 
3353 void wlan_hdd_send_svc_nlink_msg(int radio, int type, void *data, int len);
3354 #ifdef FEATURE_WLAN_AUTO_SHUTDOWN
3355 void wlan_hdd_auto_shutdown_enable(struct hdd_context *hdd_ctx, bool enable);
3356 #else
3357 static inline void
wlan_hdd_auto_shutdown_enable(struct hdd_context * hdd_ctx,bool enable)3358 wlan_hdd_auto_shutdown_enable(struct hdd_context *hdd_ctx, bool enable)
3359 {
3360 }
3361 #endif
3362 
3363 struct hdd_adapter *
3364 hdd_get_con_sap_adapter(struct hdd_adapter *this_sap_adapter,
3365 			bool check_start_bss);
3366 
3367 bool hdd_is_5g_supported(struct hdd_context *hdd_ctx);
3368 
3369 /**
3370  * hdd_is_2g_supported() - check if 2GHz channels are supported
3371  * @hdd_ctx:	Pointer to the hdd context
3372  *
3373  * HDD function to know if 2GHz channels are supported
3374  *
3375  * Return:  true if 2GHz channels are supported
3376  */
3377 bool hdd_is_2g_supported(struct hdd_context *hdd_ctx);
3378 
3379 /**
3380  * wlan_hdd_scan_abort() - abort ongoing scan
3381  * @link_info: Link info pointer in HDD adapter
3382  *
3383  * Return: 0 for success, non zero for failure
3384  */
3385 int wlan_hdd_scan_abort(struct wlan_hdd_link_info *link_info);
3386 
3387 /**
3388  * hdd_indicate_active_ndp_cnt() - Callback to indicate active ndp count to hdd
3389  * if ndp connection is on NDI established
3390  * @psoc: pointer to psoc object
3391  * @vdev_id: vdev id
3392  * @cnt: number of active ndp sessions
3393  *
3394  * This HDD callback registered with policy manager to indicates number of active
3395  * ndp sessions to hdd.
3396  *
3397  * Return:  none
3398  */
3399 void hdd_indicate_active_ndp_cnt(struct wlan_objmgr_psoc *psoc,
3400 				 uint8_t vdev_id, uint8_t cnt);
3401 
3402 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
roaming_offload_enabled(struct hdd_context * hdd_ctx)3403 static inline bool roaming_offload_enabled(struct hdd_context *hdd_ctx)
3404 {
3405 	bool is_roam_offload;
3406 
3407 	ucfg_mlme_get_roaming_offload(hdd_ctx->psoc, &is_roam_offload);
3408 
3409 	return is_roam_offload;
3410 }
3411 #else
roaming_offload_enabled(struct hdd_context * hdd_ctx)3412 static inline bool roaming_offload_enabled(struct hdd_context *hdd_ctx)
3413 {
3414 	return false;
3415 }
3416 #endif
3417 
3418 #ifdef WLAN_FEATURE_HOST_ROAM
hdd_driver_roaming_supported(struct hdd_context * hdd_ctx)3419 static inline bool hdd_driver_roaming_supported(struct hdd_context *hdd_ctx)
3420 {
3421 	bool lfr_enabled;
3422 
3423 	ucfg_mlme_is_lfr_enabled(hdd_ctx->psoc, &lfr_enabled);
3424 
3425 	return lfr_enabled;
3426 }
3427 #else
hdd_driver_roaming_supported(struct hdd_context * hdd_ctx)3428 static inline bool hdd_driver_roaming_supported(struct hdd_context *hdd_ctx)
3429 {
3430 	return false;
3431 }
3432 #endif
3433 
hdd_roaming_supported(struct hdd_context * hdd_ctx)3434 static inline bool hdd_roaming_supported(struct hdd_context *hdd_ctx)
3435 {
3436 	bool val;
3437 
3438 	val = hdd_driver_roaming_supported(hdd_ctx) ||
3439 		roaming_offload_enabled(hdd_ctx);
3440 
3441 	return val;
3442 }
3443 
3444 #ifdef WLAN_NS_OFFLOAD
3445 static inline void
hdd_adapter_flush_ipv6_notifier_work(struct hdd_adapter * adapter)3446 hdd_adapter_flush_ipv6_notifier_work(struct hdd_adapter *adapter)
3447 {
3448 	flush_work(&adapter->ipv6_notifier_work);
3449 }
3450 #else
3451 static inline void
hdd_adapter_flush_ipv6_notifier_work(struct hdd_adapter * adapter)3452 hdd_adapter_flush_ipv6_notifier_work(struct hdd_adapter *adapter)
3453 {
3454 }
3455 #endif
3456 
3457 #ifdef CFG80211_SCAN_RANDOM_MAC_ADDR
hdd_scan_random_mac_addr_supported(void)3458 static inline bool hdd_scan_random_mac_addr_supported(void)
3459 {
3460 	return true;
3461 }
3462 #else
hdd_scan_random_mac_addr_supported(void)3463 static inline bool hdd_scan_random_mac_addr_supported(void)
3464 {
3465 	return false;
3466 }
3467 #endif
3468 
3469 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE
hdd_dynamic_mac_addr_supported(struct hdd_context * hdd_ctx)3470 static inline bool hdd_dynamic_mac_addr_supported(struct hdd_context *hdd_ctx)
3471 {
3472 	return hdd_ctx->is_vdev_macaddr_dynamic_update_supported;
3473 }
3474 #else
hdd_dynamic_mac_addr_supported(struct hdd_context * hdd_ctx)3475 static inline bool hdd_dynamic_mac_addr_supported(struct hdd_context *hdd_ctx)
3476 {
3477 	return false;
3478 }
3479 #endif
3480 
3481 /**
3482  * hdd_adapter_get_link_info_ptr() - To get the pointer of link_info
3483  * in adapter.
3484  * @adapter: HDD adapter
3485  * @link_idx: Index of link_info in @adapter.
3486  *
3487  * The API returns link_info in @adapter pointed at @link_idx in the array.
3488  *
3489  * Return: Pointer to wlan_hdd_link_info or NULL.
3490  */
3491 static inline struct wlan_hdd_link_info *
hdd_adapter_get_link_info_ptr(struct hdd_adapter * adapter,uint8_t link_idx)3492 hdd_adapter_get_link_info_ptr(struct hdd_adapter *adapter, uint8_t link_idx)
3493 {
3494 	if (!adapter || (link_idx >= QDF_ARRAY_SIZE(adapter->link_info)))
3495 		return NULL;
3496 
3497 	return &adapter->link_info[link_idx];
3498 }
3499 
3500 /**
3501  * hdd_start_vendor_acs(): Start vendor ACS procedure
3502  * @adapter: pointer to SAP adapter struct
3503  *
3504  * This function sends the ACS config to the ACS daemon and
3505  * starts the vendor ACS timer to wait for the next command.
3506  *
3507  * Return: Status of vendor ACS procedure
3508  */
3509 int hdd_start_vendor_acs(struct hdd_adapter *adapter);
3510 
3511 /**
3512  * hdd_acs_response_timeout_handler() - timeout handler for acs_timer
3513  * @context: timeout handler context
3514  *
3515  * Return: None
3516  */
3517 void hdd_acs_response_timeout_handler(void *context);
3518 
3519 /**
3520  * wlan_hdd_cfg80211_start_acs(): Start ACS Procedure for SAP
3521  * @link_info: Link info pointer in HDD adapter
3522  *
3523  * This function starts the ACS procedure if there are no
3524  * constraints like MBSSID DFS restrictions.
3525  *
3526  * Return: Status of ACS Start procedure
3527  */
3528 int wlan_hdd_cfg80211_start_acs(struct wlan_hdd_link_info *link_info);
3529 
3530 /**
3531  * wlan_hdd_trim_acs_channel_list() - Trims ACS channel list with
3532  * intersection of PCL
3533  * @pcl: preferred channel list
3534  * @pcl_count: Preferred channel list count
3535  * @org_freq_list: ACS channel list from user space
3536  * @org_ch_list_count: ACS channel count from user space
3537  *
3538  * Return: None
3539  */
3540 void wlan_hdd_trim_acs_channel_list(uint32_t *pcl, uint8_t pcl_count,
3541 				    uint32_t *org_freq_list,
3542 				    uint8_t *org_ch_list_count);
3543 
3544 /**
3545  * wlan_hdd_handle_zero_acs_list() - Handle worst case of ACS channel
3546  * trimmed to zero
3547  * @hdd_ctx: struct hdd_context
3548  * @acs_freq_list: Calculated ACS channel list
3549  * @acs_ch_list_count: Calculated ACS channel count
3550  * @org_freq_list: ACS channel list from user space
3551  * @org_ch_list_count: ACS channel count from user space
3552  *
3553  * When all channels in the ACS freq list is filtered out by
3554  * wlan_hdd_trim_acs_channel_list(), the hostapd start will fail.
3555  * This happens when PCL is PM_24G_SCC_CH_SBS_CH, and SAP ACS range
3556  * includes 5 GHz channel list. One example is STA active on 6 GHz
3557  * chan. Hostapd start SAP on 5 GHz ACS range. The intersection of PCL
3558  * and ACS range is zero.  Instead of ACS failure, this API selects
3559  * one channel from ACS range and report to Hostapd. When hostapd do
3560  * start_ap, the driver will force SCC to 6 GHz or move SAP to 2 GHz
3561  * based on SAP's configuration.
3562  *
3563  * Return: None
3564  */
3565 void wlan_hdd_handle_zero_acs_list(struct hdd_context *hdd_ctx,
3566 				   uint32_t *acs_freq_list,
3567 				   uint8_t *acs_ch_list_count,
3568 				   uint32_t *org_freq_list,
3569 				   uint8_t org_ch_list_count);
3570 
3571 /**
3572  * hdd_cfg80211_update_acs_config() - update acs config to application
3573  * @adapter: hdd adapter
3574  * @reason: channel change reason
3575  *
3576  * Return: 0 for success else error code
3577  */
3578 int hdd_cfg80211_update_acs_config(struct hdd_adapter *adapter,
3579 				   uint8_t reason);
3580 
3581 /**
3582  * hdd_update_acs_timer_reason() - update acs timer start reason
3583  * @adapter: hdd adapter
3584  * @reason: channel change reason
3585  *
3586  * Return: 0 for success
3587  */
3588 int hdd_update_acs_timer_reason(struct hdd_adapter *adapter, uint8_t reason);
3589 
3590 /**
3591  * hdd_switch_sap_channel() - Move SAP to the given channel
3592  * @link_info: Pointer of link_info in adapter
3593  * @channel: Channel
3594  * @forced: Force to switch channel, ignore SCC/MCC check
3595  *
3596  * Moves the SAP interface by invoking the function which
3597  * executes the callback to perform channel switch using (E)CSA.
3598  *
3599  * Return: QDF_STATUS
3600  */
3601 QDF_STATUS hdd_switch_sap_channel(struct wlan_hdd_link_info *link_info,
3602 				  uint8_t channel, bool forced);
3603 
3604 /**
3605  * hdd_switch_sap_chan_freq() - Move SAP to the given channel
3606  * @adapter: AP adapter
3607  * @chan_freq: Channel frequency
3608  * @ch_width: channel bandwidth
3609  * @forced: Force to switch channel, ignore SCC/MCC check
3610  *
3611  * Moves the SAP interface by invoking the function which
3612  * executes the callback to perform channel switch using (E)CSA.
3613  *
3614  * Return: QDF_STATUS_SUCCESS if successfully
3615  */
3616 QDF_STATUS hdd_switch_sap_chan_freq(struct hdd_adapter *adapter,
3617 				    qdf_freq_t chan_freq,
3618 				    enum phy_ch_width ch_width,
3619 				    bool forced);
3620 
3621 #if defined(FEATURE_WLAN_CH_AVOID)
3622 QDF_STATUS hdd_unsafe_channel_restart_sap(struct hdd_context *hdd_ctx);
3623 
3624 void hdd_ch_avoid_ind(struct hdd_context *hdd_ctxt,
3625 		      struct unsafe_ch_list *unsafe_chan_list,
3626 		      struct ch_avoid_ind_type *avoid_freq_list);
3627 #else
3628 static inline
hdd_unsafe_channel_restart_sap(struct hdd_context * hdd_ctx)3629 QDF_STATUS hdd_unsafe_channel_restart_sap(struct hdd_context *hdd_ctx)
3630 {
3631 	return QDF_STATUS_SUCCESS;
3632 }
3633 
3634 static inline
hdd_ch_avoid_ind(struct hdd_context * hdd_ctxt,struct unsafe_ch_list * unsafe_chan_list,struct ch_avoid_ind_type * avoid_freq_list)3635 void hdd_ch_avoid_ind(struct hdd_context *hdd_ctxt,
3636 		      struct unsafe_ch_list *unsafe_chan_list,
3637 		      struct ch_avoid_ind_type *avoid_freq_list)
3638 {
3639 }
3640 #endif
3641 
3642 /**
3643  * hdd_free_mac_address_lists() - Free both the MAC address lists
3644  * @hdd_ctx: HDD context
3645  *
3646  * This API clears/memset provisioned address list and
3647  * derived address list
3648  *
3649  */
3650 void hdd_free_mac_address_lists(struct hdd_context *hdd_ctx);
3651 
3652 /**
3653  * hdd_update_macaddr() - update mac address
3654  * @hdd_ctx:	hdd contxt
3655  * @hw_macaddr:	mac address
3656  * @generate_mac_auto: Indicates whether the first address is
3657  * provisioned address or derived address.
3658  *
3659  * Mac address for multiple virtual interface is found as following
3660  * i) The mac address of the first interface is just the actual hw mac address.
3661  * ii) MSM 3 or 4 bits of byte5 of the actual mac address are used to
3662  *     define the mac address for the remaining interfaces and locally
3663  *     admistered bit is set. INTF_MACADDR_MASK is based on the number of
3664  *     supported virtual interfaces, right now this is 0x07 (meaning 8
3665  *     interface).
3666  *     Byte[3] of second interface will be hw_macaddr[3](bit5..7) + 1,
3667  *     for third interface it will be hw_macaddr[3](bit5..7) + 2, etc.
3668  *
3669  * Return: None
3670  */
3671 void hdd_update_macaddr(struct hdd_context *hdd_ctx,
3672 			struct qdf_mac_addr hw_macaddr, bool generate_mac_auto);
3673 
3674 /**
3675  * hdd_store_nss_chains_cfg_in_vdev() - Store the per vdev ini cfg in vdev_obj
3676  * @hdd_ctx: HDD context passed from caller
3677  * @vdev: VDEV passed with caller holding reference.
3678  *
3679  * This function will store the per vdev nss params to the particular mlme
3680  * vdev obj.
3681  * Caller shall acquire the reference for vdev objmgr and release on return.
3682  *
3683  * Return: None
3684  */
3685 void
3686 hdd_store_nss_chains_cfg_in_vdev(struct hdd_context *hdd_ctx,
3687 				 struct wlan_objmgr_vdev *vdev);
3688 
3689 /**
3690  * wlan_hdd_set_roaming_state() - Enable or disable roaming
3691  * on all STAs except the input one
3692  * @cur_link_info: Current link info pointer in HDD adapter
3693  * @rso_op_requestor: roam disable requestor
3694  * @enab_roam: Set to true to enable roaming or else set false
3695  *
3696  * This function loops through all adapters and enables or
3697  * disables roaming on each STA mode adapter except the
3698  * current adapter passed from the caller.
3699  * If @enab_roam is true, roaming is enabled or else
3700  * roaming is disabled
3701  *
3702  * Return: None
3703  */
3704 void
3705 wlan_hdd_set_roaming_state(struct wlan_hdd_link_info *cur_link_info,
3706 			   enum wlan_cm_rso_control_requestor rso_op_requestor,
3707 			   bool enab_roam);
3708 
3709 QDF_STATUS hdd_post_cds_enable_config(struct hdd_context *hdd_ctx);
3710 
3711 QDF_STATUS hdd_abort_mac_scan_all_adapters(struct hdd_context *hdd_ctx);
3712 
3713 void wlan_hdd_stop_sap(struct hdd_adapter *ap_adapter);
3714 
3715 /**
3716  * wlan_hdd_start_sap() - this function starts bss of SAP.
3717  * @link_info: Link info pointer in SAP/GO adapter
3718  * @reinit: true if this is a re-init, otherwise initial int
3719  *
3720  * This function will process the starting of sap adapter.
3721  *
3722  * Return: None
3723  */
3724 void wlan_hdd_start_sap(struct wlan_hdd_link_info *link_info, bool reinit);
3725 
3726 /**
3727  * wlan_hdd_set_sap_beacon_protection() - this function will set beacon
3728  * protection for SAP.
3729  * @hdd_ctx: pointer to HDD context
3730  * @link_info: Link info pointer
3731  * @beacon: pointer to beacon data structure
3732  *
3733  * This function will enable beacon protection and cache the value in vdev
3734  * priv object.
3735  *
3736  * Return: None
3737  */
3738 void wlan_hdd_set_sap_beacon_protection(struct hdd_context *hdd_ctx,
3739 					struct wlan_hdd_link_info *link_info,
3740 					struct hdd_beacon_data *beacon);
3741 #ifdef QCA_CONFIG_SMP
3742 int wlan_hdd_get_cpu(void);
3743 #else
wlan_hdd_get_cpu(void)3744 static inline int wlan_hdd_get_cpu(void)
3745 {
3746 	return 0;
3747 }
3748 #endif
3749 
3750 void wlan_hdd_txrx_pause_cb(uint8_t vdev_id,
3751 	enum netif_action_type action, enum netif_reason_type reason);
3752 
3753 #ifdef QCA_HL_NETDEV_FLOW_CONTROL
3754 void wlan_hdd_mod_fc_timer(struct hdd_adapter *adapter,
3755 			   enum netif_action_type action);
3756 #else
wlan_hdd_mod_fc_timer(struct hdd_adapter * adapter,enum netif_action_type action)3757 static inline void wlan_hdd_mod_fc_timer(struct hdd_adapter *adapter,
3758 					 enum netif_action_type action)
3759 {
3760 }
3761 #endif /* QCA_HL_NETDEV_FLOW_CONTROL */
3762 
3763 /**
3764  * hdd_wlan_dump_stats() - display dump Stats
3765  * @adapter: adapter handle
3766  * @stats_id: stats id from user
3767  *
3768  * Return: 0 => success, error code on failure
3769  */
3770 int hdd_wlan_dump_stats(struct hdd_adapter *adapter, int stats_id);
3771 
3772 /**
3773  * hdd_wlan_clear_stats() - clear Stats
3774  * @adapter: adapter handle
3775  * @stats_id: stats id from user
3776  *
3777  * Return: 0 => success, error code on failure
3778  */
3779 int hdd_wlan_clear_stats(struct hdd_adapter *adapter, int stats_id);
3780 
3781 /**
3782  * hdd_cb_handle_to_context() - turn an HDD handle into an HDD context
3783  * @hdd_handle: HDD handle to be converted
3784  *
3785  * Return: HDD context referenced by @hdd_handle
3786  */
3787 static inline
hdd_cb_handle_to_context(hdd_cb_handle hdd_handle)3788 struct hdd_context *hdd_cb_handle_to_context(hdd_cb_handle hdd_handle)
3789 {
3790 	return (struct hdd_context *)hdd_handle;
3791 }
3792 
3793 /**
3794  * wlan_hdd_display_netif_queue_history() - display netif queue history
3795  * @context: opaque handle to hdd context
3796  * @verb_lvl: Verbosity levels for stats
3797  *
3798  * Return: none
3799  */
3800 void
3801 wlan_hdd_display_netif_queue_history(hdd_cb_handle context,
3802 				     enum qdf_stats_verbosity_level verb_lvl);
3803 
3804 /**
3805  * wlan_hdd_display_adapter_netif_queue_history() - display adapter based netif
3806  * queue history
3807  * @adapter: hdd adapter
3808  *
3809  * Return: none
3810  */
3811 void
3812 wlan_hdd_display_adapter_netif_queue_history(struct hdd_adapter *adapter);
3813 
3814 void wlan_hdd_clear_netif_queue_history(struct hdd_context *hdd_ctx);
3815 const char *hdd_get_fwpath(void);
3816 void hdd_indicate_mgmt_frame(tSirSmeMgmtFrameInd *frame_ind);
3817 
3818 /**
3819  * hdd_get_adapter_by_iface_name() - Return adapter with given interface name
3820  * @hdd_ctx: hdd context.
3821  * @iface_name: interface name
3822  *
3823  * This function is used to get the adapter with given interface name
3824  *
3825  * Return: adapter pointer if found, NULL otherwise
3826  *
3827  */
3828 struct hdd_adapter *hdd_get_adapter_by_iface_name(struct hdd_context *hdd_ctx,
3829 						  const char *iface_name);
3830 
3831 /**
3832  * hdd_get_adapter_by_ifindex() - Return adapter associated with an ifndex
3833  * @hdd_ctx: hdd context.
3834  * @if_index: netdev interface index
3835  *
3836  * This function is used to get the adapter associated with a netdev with the
3837  * given interface index.
3838  *
3839  * Return: adapter pointer if found, NULL otherwise
3840  *
3841  */
3842 struct hdd_adapter *hdd_get_adapter_by_ifindex(struct hdd_context *hdd_ctx,
3843 					       uint32_t if_index);
3844 
3845 enum phy_ch_width hdd_map_nl_chan_width(enum nl80211_chan_width ch_width);
3846 
3847 /**
3848  * hdd_nl_to_qdf_iface_type() - map nl80211_iftype to QDF_OPMODE
3849  * @nl_type: the input NL80211 interface type to map
3850  * @out_qdf_type: the output, equivalent QDF operating mode
3851  *
3852  * Return: QDF_STATUS
3853  */
3854 QDF_STATUS hdd_nl_to_qdf_iface_type(enum nl80211_iftype nl_type,
3855 				    enum QDF_OPMODE *out_qdf_type);
3856 
3857 /**
3858  * wlan_hdd_find_opclass() - Find operating class for a channel
3859  * @mac_handle: global MAC handle
3860  * @channel: channel id
3861  * @bw_offset: bandwidth offset
3862  *
3863  * Function invokes sme api to find the operating class
3864  *
3865  * Return: operating class
3866  */
3867 uint8_t wlan_hdd_find_opclass(mac_handle_t mac_handle, uint8_t channel,
3868 			      uint8_t bw_offset);
3869 
3870 int hdd_update_config(struct hdd_context *hdd_ctx);
3871 
3872 /**
3873  * hdd_update_components_config() - Initialize driver per module ini parameters
3874  * @hdd_ctx: HDD Context
3875  *
3876  * API is used to initialize components configuration parameters
3877  * Return: 0 for success, errno for failure
3878  */
3879 int hdd_update_components_config(struct hdd_context *hdd_ctx);
3880 
3881 /**
3882  * hdd_chan_change_notify_work_handler() - Function to notify hostapd about
3883  * channel change
3884  * @work: work pointer
3885  *
3886  * This function is used to notify hostapd about the channel change
3887  *
3888  * Return: None
3889  *
3890  */
3891 void hdd_chan_change_notify_work_handler(void *work);
3892 
3893 int wlan_hdd_set_channel(struct wiphy *wiphy,
3894 		struct net_device *dev,
3895 		struct cfg80211_chan_def *chandef,
3896 		enum nl80211_channel_type channel_type);
3897 
3898 /**
3899  * wlan_hdd_cfg80211_start_bss() - start bss
3900  * @link_info: Link info pointer in hostapd adapter
3901  * @params: Pointer to start bss beacon parameters
3902  * @ssid: Pointer ssid
3903  * @ssid_len: Length of ssid
3904  * @hidden_ssid: Hidden SSID parameter
3905  * @check_for_concurrency: Flag to indicate if check for concurrency is needed
3906  *
3907  * Return: 0 for success non-zero for failure
3908  */
3909 int wlan_hdd_cfg80211_start_bss(struct wlan_hdd_link_info *link_info,
3910 				struct cfg80211_beacon_data *params,
3911 				const u8 *ssid, size_t ssid_len,
3912 				enum nl80211_hidden_ssid hidden_ssid,
3913 				bool check_for_concurrency);
3914 
3915 #if !defined(REMOVE_PKT_LOG)
3916 int hdd_process_pktlog_command(struct hdd_context *hdd_ctx, uint32_t set_value,
3917 			       int set_value2);
3918 int hdd_pktlog_enable_disable(struct hdd_context *hdd_ctx, bool enable,
3919 			      uint8_t user_triggered, int size);
3920 
3921 #else
3922 static inline
hdd_pktlog_enable_disable(struct hdd_context * hdd_ctx,bool enable,uint8_t user_triggered,int size)3923 int hdd_pktlog_enable_disable(struct hdd_context *hdd_ctx, bool enable,
3924 			      uint8_t user_triggered, int size)
3925 {
3926 	return 0;
3927 }
3928 
3929 static inline
hdd_process_pktlog_command(struct hdd_context * hdd_ctx,uint32_t set_value,int set_value2)3930 int hdd_process_pktlog_command(struct hdd_context *hdd_ctx,
3931 			       uint32_t set_value, int set_value2)
3932 {
3933 	return 0;
3934 }
3935 #endif /* REMOVE_PKT_LOG */
3936 
3937 #if defined(FEATURE_SG) && !defined(CONFIG_HL_SUPPORT)
3938 /**
3939  * hdd_set_sg_flags() - enable SG flag in the network device
3940  * @hdd_ctx: HDD context
3941  * @wlan_dev: network device structure
3942  *
3943  * This function enables the SG feature flag in the
3944  * given network device.
3945  *
3946  * Return: none
3947  */
hdd_set_sg_flags(struct hdd_context * hdd_ctx,struct net_device * wlan_dev)3948 static inline void hdd_set_sg_flags(struct hdd_context *hdd_ctx,
3949 				struct net_device *wlan_dev)
3950 {
3951 	hdd_debug("SG Enabled");
3952 	wlan_dev->features |= NETIF_F_SG;
3953 }
3954 #else
hdd_set_sg_flags(struct hdd_context * hdd_ctx,struct net_device * wlan_dev)3955 static inline void hdd_set_sg_flags(struct hdd_context *hdd_ctx,
3956 				struct net_device *wlan_dev){}
3957 #endif
3958 
3959 /**
3960  * hdd_set_netdev_flags() - set netdev flags for adapter as per ini config
3961  * @adapter: hdd adapter context
3962  *
3963  * This function sets netdev feature flags for the adapter.
3964  *
3965  * Return: none
3966  */
3967 void hdd_set_netdev_flags(struct hdd_adapter *adapter);
3968 
3969 #ifdef FEATURE_TSO
3970 /**
3971  * hdd_get_tso_csum_feature_flags() - Return TSO and csum flags if enabled
3972  *
3973  * Return: Enabled feature flags set, 0 on failure
3974  */
hdd_get_tso_csum_feature_flags(void)3975 static inline netdev_features_t hdd_get_tso_csum_feature_flags(void)
3976 {
3977 	netdev_features_t netdev_features = 0;
3978 	ol_txrx_soc_handle soc = cds_get_context(QDF_MODULE_ID_SOC);
3979 
3980 	if (!soc) {
3981 		hdd_err("soc handle is NULL");
3982 		return 0;
3983 	}
3984 
3985 	if (cdp_cfg_get(soc, cfg_dp_enable_ip_tcp_udp_checksum_offload)) {
3986 		netdev_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
3987 
3988 		if (cdp_cfg_get(soc, cfg_dp_tso_enable)) {
3989 			/*
3990 			 * Enable TSO only if IP/UDP/TCP TX checksum flag is
3991 			 * enabled.
3992 			 */
3993 			netdev_features |= NETIF_F_TSO | NETIF_F_TSO6 |
3994 					   NETIF_F_SG;
3995 		}
3996 	}
3997 	return netdev_features;
3998 }
3999 
4000 /**
4001  * hdd_set_tso_flags() - enable TSO flags in the network device
4002  * @hdd_ctx: HDD context
4003  * @wlan_dev: network device structure
4004  *
4005  * This function enables the TSO related feature flags in the
4006  * given network device.
4007  *
4008  * Return: none
4009  */
hdd_set_tso_flags(struct hdd_context * hdd_ctx,struct net_device * wlan_dev)4010 static inline void hdd_set_tso_flags(struct hdd_context *hdd_ctx,
4011 	 struct net_device *wlan_dev)
4012 {
4013 	hdd_debug("TSO Enabled");
4014 
4015 	wlan_dev->features |= hdd_get_tso_csum_feature_flags();
4016 }
4017 #else
hdd_set_tso_flags(struct hdd_context * hdd_ctx,struct net_device * wlan_dev)4018 static inline void hdd_set_tso_flags(struct hdd_context *hdd_ctx,
4019 	 struct net_device *wlan_dev)
4020 {
4021 	hdd_set_sg_flags(hdd_ctx, wlan_dev);
4022 }
4023 
hdd_get_tso_csum_feature_flags(void)4024 static inline netdev_features_t hdd_get_tso_csum_feature_flags(void)
4025 {
4026 	return 0;
4027 }
4028 #endif /* FEATURE_TSO */
4029 
4030 /**
4031  * wlan_hdd_get_host_log_nl_proto() - Get host log netlink protocol
4032  * @hdd_ctx: HDD context
4033  *
4034  * This function returns with host log netlink protocol settings
4035  *
4036  * Return: none
4037  */
4038 #ifdef WLAN_LOGGING_SOCK_SVC_ENABLE
wlan_hdd_get_host_log_nl_proto(struct hdd_context * hdd_ctx)4039 static inline int wlan_hdd_get_host_log_nl_proto(struct hdd_context *hdd_ctx)
4040 {
4041 	return hdd_ctx->config->host_log_custom_nl_proto;
4042 }
4043 #else
wlan_hdd_get_host_log_nl_proto(struct hdd_context * hdd_ctx)4044 static inline int wlan_hdd_get_host_log_nl_proto(struct hdd_context *hdd_ctx)
4045 {
4046 	return NETLINK_USERSOCK;
4047 }
4048 #endif
4049 
4050 #ifdef CONFIG_CNSS_LOGGER
4051 /**
4052  * wlan_hdd_nl_init() - wrapper function to CNSS_LOGGER case
4053  * @hdd_ctx:	the hdd context pointer
4054  *
4055  * The nl_srv_init() will call to cnss_logger_device_register() and
4056  * expect to get a radio_index from cnss_logger module and assign to
4057  * hdd_ctx->radio_index, then to maintain the consistency to original
4058  * design, adding the radio_index check here, then return the error
4059  * code if radio_index is not assigned correctly, which means the nl_init
4060  * from cnss_logger is failed.
4061  *
4062  * Return: 0 if successfully, otherwise error code
4063  */
wlan_hdd_nl_init(struct hdd_context * hdd_ctx)4064 static inline int wlan_hdd_nl_init(struct hdd_context *hdd_ctx)
4065 {
4066 	int proto;
4067 
4068 	proto = wlan_hdd_get_host_log_nl_proto(hdd_ctx);
4069 	hdd_ctx->radio_index = nl_srv_init(hdd_ctx->wiphy, proto);
4070 
4071 	/* radio_index is assigned from 0, so only >=0 will be valid index  */
4072 	if (hdd_ctx->radio_index >= 0)
4073 		return 0;
4074 	else
4075 		return -EINVAL;
4076 }
4077 #else
4078 /**
4079  * wlan_hdd_nl_init() - wrapper function to non CNSS_LOGGER case
4080  * @hdd_ctx:	the hdd context pointer
4081  *
4082  * In case of non CNSS_LOGGER case, the nl_srv_init() will initialize
4083  * the netlink socket and return the success or not.
4084  *
4085  * Return: the return value from  nl_srv_init()
4086  */
wlan_hdd_nl_init(struct hdd_context * hdd_ctx)4087 static inline int wlan_hdd_nl_init(struct hdd_context *hdd_ctx)
4088 {
4089 	int proto;
4090 
4091 	proto = wlan_hdd_get_host_log_nl_proto(hdd_ctx);
4092 	return nl_srv_init(hdd_ctx->wiphy, proto);
4093 }
4094 #endif
4095 
4096 QDF_STATUS hdd_sme_close_session_callback(uint8_t vdev_id);
4097 
4098 int hdd_register_cb(struct hdd_context *hdd_ctx);
4099 void hdd_deregister_cb(struct hdd_context *hdd_ctx);
4100 
4101 #ifdef WLAN_HDD_MULTI_VDEV_SINGLE_NDEV
4102 static inline struct qdf_mac_addr *
hdd_adapter_get_netdev_mac_addr(struct hdd_adapter * adapter)4103 hdd_adapter_get_netdev_mac_addr(struct hdd_adapter *adapter)
4104 {
4105 	return &adapter->mac_addr;
4106 }
4107 #else
4108 static inline struct qdf_mac_addr *
hdd_adapter_get_netdev_mac_addr(struct hdd_adapter * adapter)4109 hdd_adapter_get_netdev_mac_addr(struct hdd_adapter *adapter)
4110 {
4111 	if (hdd_adapter_is_ml_adapter(adapter) ||
4112 	    hdd_adapter_is_link_adapter(adapter))
4113 		return &adapter->mld_addr;
4114 
4115 	return &adapter->mac_addr;
4116 }
4117 #endif
4118 
4119 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC) && \
4120 	defined(WLAN_HDD_MULTI_VDEV_SINGLE_NDEV)
4121 /**
4122  * hdd_adapter_fill_link_address() - Fill derived
4123  * link address in adapter
4124  * @adapter: HDD adapter
4125  *
4126  * The API takes MLD address of @adapter and calls link address
4127  * derive API and fills the derived link address in each link.
4128  *
4129  * Return: QDF_STATUS
4130  */
4131 QDF_STATUS hdd_adapter_fill_link_address(struct hdd_adapter *adapter);
4132 #else
4133 static inline
hdd_adapter_fill_link_address(struct hdd_adapter * adapter)4134 QDF_STATUS hdd_adapter_fill_link_address(struct hdd_adapter *adapter)
4135 {
4136 	return QDF_STATUS_SUCCESS;
4137 }
4138 #endif
4139 
4140 /**
4141  * hdd_adapter_get_link_mac_addr() - Returns the appropriate
4142  * MAC address pointer in adapter.
4143  * @link_info: Link info in HDD adapter.
4144  *
4145  * If WLAN_HDD_MULTI_VDEV_SINGLE_NDEV flag is enabled, then MAC address pointer
4146  * returned is based on following conditions:
4147  *      -if adapter of link info is non-ml:
4148  *              Return pointer of mac_addr in adapter.
4149  *      -else if link_addr in @link_info is NULL:
4150  *              Return pointer of mac_addr in adapter.
4151  *      -else
4152  *              Return pointer of link_addr in @link_info.
4153  *
4154  * If WLAN_HDD_MULTI_VDEV_SINGLE_NDEV flag is not enabled, then return pointer
4155  * of mac_addr in adapter.
4156  *
4157  * Return: MAC address pointer based on adapter type.
4158  */
4159 struct qdf_mac_addr *
4160 hdd_adapter_get_link_mac_addr(struct wlan_hdd_link_info *link_info);
4161 
4162 /**
4163  * hdd_adapter_check_duplicate_session() - Check for duplicate
4164  * session on start adapter.
4165  * @adapter: HDD adapter
4166  *
4167  * The API passes list of addresses contained in @adapter to
4168  * sme_check_for_duplicate_session() to check the status
4169  * of existing peer with same MAC address.
4170  *
4171  * Return: QDF_STATUS
4172  */
4173 QDF_STATUS hdd_adapter_check_duplicate_session(struct hdd_adapter *adapter);
4174 
4175 /**
4176  * hdd_adapter_reset_station_ctx() - Resets station context with appropriate
4177  * initial value.
4178  * @adapter: HDD adapter
4179  *
4180  * Return: void
4181  */
4182 void hdd_adapter_reset_station_ctx(struct hdd_adapter *adapter);
4183 
4184 /**
4185  * hdd_start_station_adapter()- Start the Station Adapter
4186  * @adapter: HDD adapter
4187  *
4188  * This function initializes the adapter for the station mode.
4189  *
4190  * Return: 0 on success or errno on failure.
4191  */
4192 int hdd_start_station_adapter(struct hdd_adapter *adapter);
4193 
4194 /**
4195  * hdd_start_ap_adapter()- Start AP Adapter
4196  * @adapter: HDD adapter
4197  * @rtnl_held: True if rtnl lock is taken, otherwise false
4198  *
4199  * This function initializes the adapter for the AP mode.
4200  *
4201  * Return: 0 on success errno on failure.
4202  */
4203 int hdd_start_ap_adapter(struct hdd_adapter *adapter, bool rtnl_held);
4204 int hdd_configure_cds(struct hdd_context *hdd_ctx);
4205 int hdd_set_fw_params(struct hdd_adapter *adapter);
4206 
4207 #ifdef MULTI_CLIENT_LL_SUPPORT
4208 /**
4209  * wlan_hdd_deinit_multi_client_info_table() - to deinit multi client info table
4210  * @adapter: hdd vdev/net_device context
4211  *
4212  * Return: none
4213  */
4214 void wlan_hdd_deinit_multi_client_info_table(struct hdd_adapter *adapter);
4215 #else
4216 static inline void
wlan_hdd_deinit_multi_client_info_table(struct hdd_adapter * adapter)4217 wlan_hdd_deinit_multi_client_info_table(struct hdd_adapter *adapter)
4218 {}
4219 #endif
4220 
4221 /**
4222  * hdd_wlan_start_modules() - Single driver state machine for starting modules
4223  * @hdd_ctx: HDD context
4224  * @reinit: flag to indicate from SSR or normal path
4225  *
4226  * This function maintains the driver state machine it will be invoked from
4227  * startup, reinit and change interface. Depending on the driver state shall
4228  * perform the opening of the modules.
4229  *
4230  * Return: Errno
4231  */
4232 int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit);
4233 
4234 /**
4235  * hdd_wlan_stop_modules - Single driver state machine for stopping modules
4236  * @hdd_ctx: HDD context
4237  * @ftm_mode: ftm mode
4238  *
4239  * This function maintains the driver state machine it will be invoked from
4240  * exit, shutdown and con_mode change handler. Depending on the driver state
4241  * shall perform the stopping/closing of the modules.
4242  *
4243  * Return: Errno
4244  */
4245 int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode);
4246 
4247 /**
4248  * hdd_psoc_idle_timer_start() - start the idle psoc detection timer
4249  * @hdd_ctx: the hdd context for which the timer should be started
4250  *
4251  * Return: None
4252  */
4253 void hdd_psoc_idle_timer_start(struct hdd_context *hdd_ctx);
4254 
4255 /**
4256  * hdd_psoc_idle_timer_stop() - stop the idle psoc detection timer
4257  * @hdd_ctx: the hdd context for which the timer should be stopped
4258  *
4259  * Return: None
4260  */
4261 void hdd_psoc_idle_timer_stop(struct hdd_context *hdd_ctx);
4262 
4263 /**
4264  * hdd_trigger_psoc_idle_restart() - trigger restart of a previously shutdown
4265  *                                   idle psoc, if needed
4266  * @hdd_ctx: the hdd context which should be restarted
4267  *
4268  * This API does nothing if the given psoc is already active.
4269  *
4270  * Return: Errno
4271  */
4272 int hdd_trigger_psoc_idle_restart(struct hdd_context *hdd_ctx);
4273 
4274 int hdd_start_adapter(struct hdd_adapter *adapter, bool rtnl_held);
4275 void hdd_populate_random_mac_addr(struct hdd_context *hdd_ctx, uint32_t num);
4276 /**
4277  * hdd_is_interface_up()- Check if the given interface is up
4278  * @adapter: interface to check
4279  *
4280  * Checks whether the given interface was brought up by userspace.
4281  *
4282  * Return: true if interface was opened else false
4283  */
4284 bool hdd_is_interface_up(struct hdd_adapter *adapter);
4285 
4286 #ifdef WLAN_FEATURE_FASTPATH
4287 void hdd_enable_fastpath(struct hdd_context *hdd_ctx,
4288 			 void *context);
4289 #else
hdd_enable_fastpath(struct hdd_context * hdd_ctx,void * context)4290 static inline void hdd_enable_fastpath(struct hdd_context *hdd_ctx,
4291 				       void *context)
4292 {
4293 }
4294 #endif
4295 void hdd_wlan_update_target_info(struct hdd_context *hdd_ctx, void *context);
4296 
4297 enum  sap_acs_dfs_mode wlan_hdd_get_dfs_mode(enum dfs_mode mode);
4298 
4299 /**
4300  * hdd_clone_local_unsafe_chan() - clone hdd ctx unsafe chan list
4301  * @hdd_ctx: hdd context pointer
4302  * @local_unsafe_list: copied unsafe chan list array
4303  * @local_unsafe_list_count: channel number in returned local_unsafe_list
4304  *
4305  * The function will allocate memory and make a copy the current unsafe
4306  * channels from hdd ctx. The caller need to free the local_unsafe_list
4307  * memory after use.
4308  *
4309  * Return: 0 if successfully clone unsafe chan list.
4310  */
4311 int hdd_clone_local_unsafe_chan(struct hdd_context *hdd_ctx,
4312 	uint16_t **local_unsafe_list, uint16_t *local_unsafe_list_count);
4313 
4314 /**
4315  * hdd_local_unsafe_channel_updated() - check unsafe chan list same or not
4316  * @hdd_ctx: hdd context pointer
4317  * @local_unsafe_list: unsafe chan list to be compared with hdd_ctx's list
4318  * @local_unsafe_list_count: channel number in local_unsafe_list
4319  * @restriction_mask: restriction mask is to differentiate current channel
4320  * list different from previous channel list
4321  *
4322  * The function checked the input channel is same as current unsafe chan
4323  * list in hdd_ctx.
4324  *
4325  * Return: true if input channel list is same as the list in hdd_ctx
4326  */
4327 bool hdd_local_unsafe_channel_updated(struct hdd_context *hdd_ctx,
4328 	uint16_t *local_unsafe_list, uint16_t local_unsafe_list_count,
4329 	uint32_t restriction_mask);
4330 
4331 int hdd_enable_disable_ca_event(struct hdd_context *hddctx,
4332 				uint8_t set_value);
4333 
4334 /**
4335  * wlan_hdd_undo_acs : Do cleanup of DO_ACS
4336  * @link_info: Pointer of link_info in adapter
4337  *
4338  * This function handle cleanup of what was done in DO_ACS, including free
4339  * memory.
4340  *
4341  * Return: void
4342  */
4343 void wlan_hdd_undo_acs(struct wlan_hdd_link_info *link_info);
4344 
4345 /**
4346  * wlan_hdd_set_restriction_mask() - set restriction mask for hdd context
4347  * @hdd_ctx: hdd context pointer
4348  *
4349  * Return: None
4350  */
4351 void wlan_hdd_set_restriction_mask(struct hdd_context *hdd_ctx);
4352 
4353 /**
4354  * wlan_hdd_get_restriction_mask() - get restriction mask from hdd context
4355  * @hdd_ctx: hdd context pointer
4356  *
4357  * Return: restriction_mask
4358  */
4359 uint32_t wlan_hdd_get_restriction_mask(struct hdd_context *hdd_ctx);
4360 
4361 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0))
4362 static inline int
hdd_wlan_nla_put_u64(struct sk_buff * skb,int attrtype,u64 value)4363 hdd_wlan_nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
4364 {
4365 	return nla_put_u64(skb, attrtype, value);
4366 }
4367 #else
4368 static inline int
hdd_wlan_nla_put_u64(struct sk_buff * skb,int attrtype,u64 value)4369 hdd_wlan_nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
4370 {
4371 	return nla_put_u64_64bit(skb, attrtype, value, NL80211_ATTR_PAD);
4372 }
4373 #endif
4374 
4375 /**
4376  * hdd_roam_profile() - Get adapter's roam profile
4377  * @link_info: Link info pointer in HDD adapter
4378  *
4379  * Given an adapter this function returns a pointer to its roam profile.
4380  *
4381  * NOTE WELL: Caller is responsible for ensuring this interface is only
4382  * invoked for STA-type interfaces
4383  *
4384  * Return: pointer to the adapter's roam profile
4385  */
4386 static inline struct csr_roam_profile *
hdd_roam_profile(struct wlan_hdd_link_info * link_info)4387 hdd_roam_profile(struct wlan_hdd_link_info *link_info)
4388 {
4389 	struct hdd_station_ctx *sta_ctx;
4390 
4391 	sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(link_info);
4392 	return &sta_ctx->roam_profile;
4393 }
4394 
4395 /**
4396  * hdd_is_roaming_in_progress() - check if roaming is in progress
4397  * @hdd_ctx: Global HDD context
4398  *
4399  * Checks if roaming is in progress on any of the adapters
4400  *
4401  * Return: true if roaming is in progress else false
4402  */
4403 bool hdd_is_roaming_in_progress(struct hdd_context *hdd_ctx);
4404 
4405 /**
4406  * hdd_is_connection_in_progress() - check if connection is in progress
4407  * @out_vdev_id: id of vdev where connection is occurring
4408  * @out_reason: scan reject reason
4409  *
4410  * Go through each adapter and check if connection is in progress.
4411  * Output parameters @out_vdev_id and @out_reason will only be written
4412  * when a connection is in progress.
4413  *
4414  * Return: true if connection is in progress else false
4415  */
4416 bool hdd_is_connection_in_progress(uint8_t *out_vdev_id,
4417 				   enum scan_reject_states *out_reason);
4418 
4419 /**
4420  * hdd_restart_sap() - to restart SAP in driver internally
4421  * @link_info: Link info pointer of SAP adapter
4422  *
4423  * Return: None
4424  */
4425 void hdd_restart_sap(struct wlan_hdd_link_info *link_info);
4426 bool hdd_set_connection_in_progress(bool value);
4427 
4428 /**
4429  * wlan_hdd_init_chan_info() - initialize channel info variables
4430  * @hdd_ctx: hdd ctx
4431  *
4432  * This API initialize channel info variables
4433  *
4434  * Return: None
4435  */
4436 void wlan_hdd_init_chan_info(struct hdd_context *hdd_ctx);
4437 
4438 /**
4439  * wlan_hdd_deinit_chan_info() - deinitialize channel info variables
4440  * @hdd_ctx: hdd ctx
4441  *
4442  * This API deinitialize channel info variables
4443  *
4444  * Return: None
4445  */
4446 void wlan_hdd_deinit_chan_info(struct hdd_context *hdd_ctx);
4447 
4448 /**
4449  * hdd_is_any_interface_open() - Check for interface up
4450  * @hdd_ctx: HDD context
4451  *
4452  * Return: true if any interface is open
4453  */
4454 bool hdd_is_any_interface_open(struct hdd_context *hdd_ctx);
4455 
4456 #ifdef WIFI_POS_CONVERGED
4457 /**
4458  * hdd_send_peer_status_ind_to_app() - wrapper to call legacy or new wifi_pos
4459  * function to send peer status to a registered application
4460  * @peer_mac: MAC address of peer
4461  * @peer_status: ePeerConnected or ePeerDisconnected
4462  * @peer_timing_meas_cap: 0: RTT/RTT2, 1: RTT3. Default is 0
4463  * @vdev_id: ID of the underlying vdev
4464  * @chan_info: operating channel information
4465  * @dev_mode: dev mode for which indication is sent
4466  *
4467  * Return: none
4468  */
hdd_send_peer_status_ind_to_app(struct qdf_mac_addr * peer_mac,uint8_t peer_status,uint8_t peer_timing_meas_cap,uint8_t vdev_id,struct oem_channel_info * chan_info,enum QDF_OPMODE dev_mode)4469 static inline void hdd_send_peer_status_ind_to_app(
4470 					struct qdf_mac_addr *peer_mac,
4471 					uint8_t peer_status,
4472 					uint8_t peer_timing_meas_cap,
4473 					uint8_t vdev_id,
4474 					struct oem_channel_info *chan_info,
4475 					enum QDF_OPMODE dev_mode)
4476 {
4477 	struct wifi_pos_ch_info ch_info;
4478 
4479 	if (!chan_info) {
4480 		os_if_wifi_pos_send_peer_status(peer_mac, peer_status,
4481 						peer_timing_meas_cap, vdev_id,
4482 						NULL, dev_mode);
4483 		return;
4484 	}
4485 
4486 	/* chan_id is obsoleted by mhz */
4487 	ch_info.chan_id = 0;
4488 	ch_info.mhz = chan_info->mhz;
4489 	ch_info.band_center_freq1 = chan_info->band_center_freq1;
4490 	ch_info.band_center_freq2 = chan_info->band_center_freq2;
4491 	ch_info.info = chan_info->info;
4492 	ch_info.reg_info_1 = chan_info->reg_info_1;
4493 	ch_info.reg_info_2 = chan_info->reg_info_2;
4494 	ch_info.nss = chan_info->nss;
4495 	ch_info.rate_flags = chan_info->rate_flags;
4496 	ch_info.sec_ch_offset = chan_info->sec_ch_offset;
4497 	ch_info.ch_width = chan_info->ch_width;
4498 	os_if_wifi_pos_send_peer_status(peer_mac, peer_status,
4499 					peer_timing_meas_cap, vdev_id,
4500 					&ch_info, dev_mode);
4501 }
4502 #else
hdd_send_peer_status_ind_to_app(struct qdf_mac_addr * peer_mac,uint8_t peer_status,uint8_t peer_timing_meas_cap,uint8_t vdev_id,struct oem_channel_info * chan_info,enum QDF_OPMODE dev_mode)4503 static inline void hdd_send_peer_status_ind_to_app(
4504 					struct qdf_mac_addr *peer_mac,
4505 					uint8_t peer_status,
4506 					uint8_t peer_timing_meas_cap,
4507 					uint8_t vdev_id,
4508 					struct oem_channel_info *chan_info,
4509 					enum QDF_OPMODE dev_mode)
4510 {
4511 	hdd_send_peer_status_ind_to_oem_app(peer_mac, peer_status,
4512 			peer_timing_meas_cap, vdev_id, chan_info, dev_mode);
4513 }
4514 #endif /* WIFI_POS_CONVERGENCE */
4515 
4516 /**
4517  * wlan_hdd_send_mcc_vdev_quota()- Send mcc vdev quota value to FW
4518  * @adapter: Adapter data
4519  * @sval:    mcc vdev quota value
4520  *
4521  * Send mcc vdev quota value value to FW
4522  *
4523  * Return: 0 success else failure
4524  */
4525 int wlan_hdd_send_mcc_vdev_quota(struct hdd_adapter *adapter, int sval);
4526 
4527 /**
4528  * wlan_hdd_send_mcc_latency()- Send MCC latency to FW
4529  * @adapter: Adapter data
4530  * @sval:    MCC latency value
4531  *
4532  * Send MCC latency value to FW
4533  *
4534  * Return: 0 success else failure
4535  */
4536 int wlan_hdd_send_mcc_latency(struct hdd_adapter *adapter, int sval);
4537 
4538 /**
4539  * wlan_hdd_get_link_info_from_vdev()- Get link info from vdev id
4540  * and PSOC object data
4541  * @psoc: Psoc object data
4542  * @vdev_id: vdev id
4543  *
4544  * Get link info from vdev id and PSOC object data
4545  *
4546  * Return: link info pointer
4547  */
4548 struct wlan_hdd_link_info *
4549 wlan_hdd_get_link_info_from_vdev(struct wlan_objmgr_psoc *psoc,
4550 				 uint8_t vdev_id);
4551 
4552 /**
4553  * hdd_unregister_notifiers()- unregister kernel notifiers
4554  * @hdd_ctx: Hdd Context
4555  *
4556  * Unregister netdev notifiers like Netdevice,IPv4 and IPv6.
4557  *
4558  */
4559 void hdd_unregister_notifiers(struct hdd_context *hdd_ctx);
4560 
4561 /**
4562  * hdd_dbs_scan_selection_init() - initialization for DBS scan selection config
4563  * @hdd_ctx: HDD context
4564  *
4565  * This function sends the DBS scan selection config configuration to the
4566  * firmware via WMA
4567  *
4568  * Return: 0 - success, < 0 - failure
4569  */
4570 int hdd_dbs_scan_selection_init(struct hdd_context *hdd_ctx);
4571 
4572 /**
4573  * hdd_update_scan_config - API to update scan configuration parameters
4574  * @hdd_ctx: HDD context
4575  *
4576  * Return: 0 if success else err
4577  */
4578 int hdd_update_scan_config(struct hdd_context *hdd_ctx);
4579 
4580 /**
4581  * hdd_start_complete()- complete the start event
4582  * @ret: return value for complete event.
4583  *
4584  * complete the startup event and set the return in
4585  * global variable
4586  *
4587  * Return: void
4588  */
4589 
4590 void hdd_start_complete(int ret);
4591 
4592 /**
4593  * hdd_chip_pwr_save_fail_detected_cb() - chip power save failure detected
4594  * callback
4595  * @hdd_handle: HDD handle
4596  * @data: chip power save failure detected data
4597  *
4598  * This function reads the chip power save failure detected data and fill in
4599  * the skb with NL attributes and send up the NL event.
4600  * This callback execute in atomic context and must not invoke any
4601  * blocking calls.
4602  *
4603  * Return: none
4604  */
4605 
4606 void hdd_chip_pwr_save_fail_detected_cb(hdd_handle_t hdd_handle,
4607 				struct chip_pwr_save_fail_detected_params
4608 				*data);
4609 
4610 /**
4611  * hdd_update_ie_allowlist_attr() - Copy probe req ie allowlist attrs from cfg
4612  * @ie_allowlist: output parameter
4613  * @hdd_ctx: pointer to hdd context
4614  *
4615  * Return: None
4616  */
4617 void hdd_update_ie_allowlist_attr(struct probe_req_allowlist_attr *ie_allowlist,
4618 				  struct hdd_context *hdd_ctx);
4619 
4620 /**
4621  * hdd_get_rssi_snr_by_bssid() - gets the rssi and snr by bssid from scan cache
4622  * @mac_handle: MAC handle
4623  * @bssid: bssid to look for in scan cache
4624  * @rssi: rssi value found
4625  * @snr: snr value found
4626  *
4627  * Return: QDF_STATUS
4628  */
4629 int hdd_get_rssi_snr_by_bssid(mac_handle_t mac_handle, const uint8_t *bssid,
4630 			      int8_t *rssi, int8_t *snr);
4631 
4632 /**
4633  * hdd_reset_limit_off_chan() - reset limit off-channel command parameters
4634  * @adapter: HDD adapter
4635  *
4636  * Return: 0 on success and non zero value on failure
4637  */
4638 int hdd_reset_limit_off_chan(struct hdd_adapter *adapter);
4639 
4640 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 12, 0)
hdd_dev_setup_destructor(struct net_device * dev)4641 static inline void hdd_dev_setup_destructor(struct net_device *dev)
4642 {
4643 	dev->destructor = free_netdev;
4644 }
4645 #else
hdd_dev_setup_destructor(struct net_device * dev)4646 static inline void hdd_dev_setup_destructor(struct net_device *dev)
4647 {
4648 	dev->needs_free_netdev = true;
4649 }
4650 #endif /* KERNEL_VERSION(4, 12, 0) */
4651 
4652 /**
4653  * hdd_update_score_config - API to update candidate scoring related params
4654  * configuration parameters
4655  * @hdd_ctx: hdd context
4656  *
4657  * Return: QDF_STATUS
4658  */
4659 QDF_STATUS hdd_update_score_config(struct hdd_context *hdd_ctx);
4660 
4661 /**
4662  * hdd_get_stainfo() - get stainfo for the specified peer
4663  * @astainfo: array of the station info in which the sta info
4664  * corresponding to mac_addr needs to be searched
4665  * @mac_addr: mac address of requested peer
4666  *
4667  * This function find the stainfo for the peer with mac_addr
4668  *
4669  * Return: stainfo if found, NULL if not found
4670  */
4671 struct hdd_station_info *hdd_get_stainfo(struct hdd_station_info *astainfo,
4672 					 struct qdf_mac_addr mac_addr);
4673 
4674 /**
4675  * hdd_component_psoc_open() - Open the legacy components
4676  * @psoc: Pointer to psoc object
4677  *
4678  * This function opens the legacy components and initializes the
4679  * component's private objects.
4680  *
4681  * Return: QDF_STATUS
4682  */
4683 QDF_STATUS hdd_component_psoc_open(struct wlan_objmgr_psoc *psoc);
4684 
4685 /**
4686  * hdd_component_psoc_close() - Close the legacy components
4687  * @psoc: Pointer to psoc object
4688  *
4689  * This function closes the legacy components and resets the
4690  * component's private objects.
4691  *
4692  * Return: None
4693  */
4694 void hdd_component_psoc_close(struct wlan_objmgr_psoc *psoc);
4695 
4696 /**
4697  * hdd_component_psoc_enable() - Trigger psoc enable for CLD Components
4698  * @psoc: Pointer to psoc object
4699  *
4700  * Return: None
4701  */
4702 void hdd_component_psoc_enable(struct wlan_objmgr_psoc *psoc);
4703 
4704 /**
4705  * hdd_component_psoc_disable() - Trigger psoc disable for CLD Components
4706  * @psoc: Pointer to psoc object
4707  *
4708  * Return: None
4709  */
4710 void hdd_component_psoc_disable(struct wlan_objmgr_psoc *psoc);
4711 
4712 /**
4713  * hdd_component_pdev_open() - Trigger pdev open for CLD Components
4714  * @pdev: Pointer to pdev object
4715  *
4716  * Return: QDF_STATUS
4717  */
4718 QDF_STATUS hdd_component_pdev_open(struct wlan_objmgr_pdev *pdev);
4719 
4720 /**
4721  * hdd_component_pdev_close() - Trigger pdev close for CLD Components
4722  * @pdev: Pointer to pdev object
4723  *
4724  * Return: None
4725  */
4726 void hdd_component_pdev_close(struct wlan_objmgr_pdev *pdev);
4727 
4728 #ifdef WLAN_FEATURE_MEMDUMP_ENABLE
4729 int hdd_driver_memdump_init(void);
4730 void hdd_driver_memdump_deinit(void);
4731 
4732 /**
4733  * hdd_driver_mem_cleanup() - Frees memory allocated for
4734  * driver dump
4735  *
4736  * This function  frees driver dump memory.
4737  *
4738  * Return: None
4739  */
4740 void hdd_driver_mem_cleanup(void);
4741 
4742 #else /* WLAN_FEATURE_MEMDUMP_ENABLE */
hdd_driver_memdump_init(void)4743 static inline int hdd_driver_memdump_init(void)
4744 {
4745 	return 0;
4746 }
hdd_driver_memdump_deinit(void)4747 static inline void hdd_driver_memdump_deinit(void)
4748 {
4749 }
4750 
hdd_driver_mem_cleanup(void)4751 static inline void hdd_driver_mem_cleanup(void)
4752 {
4753 }
4754 #endif /* WLAN_FEATURE_MEMDUMP_ENABLE */
4755 
4756 #ifdef FEATURE_MONITOR_MODE_SUPPORT
4757 /**
4758  * wlan_hdd_set_mon_chan() - Set capture channel on the monitor mode interface.
4759  * @adapter: Handle to adapter
4760  * @freq: Monitor mode frequency (MHz)
4761  * @bandwidth: Capture channel bandwidth
4762  *
4763  * Return: 0 on success else error code.
4764  */
4765 int wlan_hdd_set_mon_chan(struct hdd_adapter *adapter, qdf_freq_t freq,
4766 			  uint32_t bandwidth);
4767 #else
4768 static inline
wlan_hdd_set_mon_chan(struct hdd_adapter * adapter,qdf_freq_t freq,uint32_t bandwidth)4769 int wlan_hdd_set_mon_chan(struct hdd_adapter *adapter, qdf_freq_t freq,
4770 			  uint32_t bandwidth)
4771 {
4772 	return 0;
4773 }
4774 #endif
4775 
4776 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC) && \
4777 	!defined(WLAN_HDD_MULTI_VDEV_SINGLE_NDEV)
4778 /**
4779  *  hdd_set_mld_address() - Set the MLD address of the adapter
4780  *  @adapter: Handle to adapter
4781  *  @mac_addr: MAC address to be copied
4782  *
4783  *  The function copies the MAC address sent in @mac_addr to
4784  *  the adapter's MLD address and the MLD address of each
4785  *  link adapter mapped of the @adapter.
4786  *  The mode of operation must be 11be capable and @adapter
4787  *  has to be ML type.
4788  *
4789  *  Return: void
4790  */
4791 void
4792 hdd_set_mld_address(struct hdd_adapter *adapter,
4793 		    const struct qdf_mac_addr *mac_addr);
4794 #else
4795 static inline void
hdd_set_mld_address(struct hdd_adapter * adapter,const struct qdf_mac_addr * mac_addr)4796 hdd_set_mld_address(struct hdd_adapter *adapter,
4797 		    const struct qdf_mac_addr *mac_addr)
4798 {
4799 }
4800 #endif
4801 
4802 /**
4803  * hdd_wlan_get_version() - Get version information
4804  * @hdd_ctx: Global HDD context
4805  * @version_len: length of the version buffer size
4806  * @version: the buffer to the version string
4807  *
4808  * This function is used to get Wlan Driver, Firmware, Hardware Version
4809  * & the Board related information.
4810  *
4811  * Return: the length of the version string
4812  */
4813 uint32_t hdd_wlan_get_version(struct hdd_context *hdd_ctx,
4814 			      const size_t version_len, uint8_t *version);
4815 /**
4816  * hdd_assemble_rate_code() - assemble rate code to be sent to FW
4817  * @preamble: rate preamble
4818  * @nss: number of streams
4819  * @rate: rate index
4820  *
4821  * Rate code assembling is different for targets which are 11ax capable.
4822  * Check for the target support and assemble the rate code accordingly.
4823  *
4824  * Return: assembled rate code
4825  */
4826 int hdd_assemble_rate_code(uint8_t preamble, uint8_t nss, uint8_t rate);
4827 
4828 /**
4829  * hdd_update_country_code - Update country code
4830  * @hdd_ctx: HDD context
4831  *
4832  * Update country code based on module parameter country_code
4833  *
4834  * Return: 0 on success and errno on failure
4835  */
4836 int hdd_update_country_code(struct hdd_context *hdd_ctx);
4837 
4838 /**
4839  * hdd_set_11ax_rate() - set 11ax rate
4840  * @adapter: adapter being modified
4841  * @value: new 11ax rate code
4842  * @sap_config: pointer to SAP config to check HW mode
4843  *		this will be NULL for call from STA persona
4844  *
4845  * Return: 0 on success, negative errno on failure
4846  */
4847 int hdd_set_11ax_rate(struct hdd_adapter *adapter, int value,
4848 		      struct sap_config *sap_config);
4849 
4850 /**
4851  * hdd_update_hw_sw_info() - API to update the HW/SW information
4852  * @hdd_ctx: Global HDD context
4853  *
4854  * API to update the HW and SW information in the driver
4855  *
4856  * Note:
4857  * All the version/revision information would only be retrieved after
4858  * firmware download
4859  *
4860  * Return: None
4861  */
4862 void hdd_update_hw_sw_info(struct hdd_context *hdd_ctx);
4863 
4864 /**
4865  * hdd_context_get_mac_handle() - get mac handle from hdd context
4866  * @hdd_ctx: Global HDD context pointer
4867  *
4868  * Retrieves the global MAC handle from the HDD context
4869  *
4870  * Return: The global MAC handle (which may be NULL)
4871  */
4872 static inline
hdd_context_get_mac_handle(struct hdd_context * hdd_ctx)4873 mac_handle_t hdd_context_get_mac_handle(struct hdd_context *hdd_ctx)
4874 {
4875 	return hdd_ctx ? hdd_ctx->mac_handle : NULL;
4876 }
4877 
4878 /**
4879  * hdd_adapter_get_mac_handle() - get mac handle from hdd adapter
4880  * @adapter: HDD adapter pointer
4881  *
4882  * Retrieves the global MAC handle given an HDD adapter
4883  *
4884  * Return: The global MAC handle (which may be NULL)
4885  */
4886 static inline
hdd_adapter_get_mac_handle(struct hdd_adapter * adapter)4887 mac_handle_t hdd_adapter_get_mac_handle(struct hdd_adapter *adapter)
4888 {
4889 	return adapter ?
4890 		hdd_context_get_mac_handle(adapter->hdd_ctx) : NULL;
4891 }
4892 
4893 /**
4894  * hdd_handle_to_context() - turn an HDD handle into an HDD context
4895  * @hdd_handle: HDD handle to be converted
4896  *
4897  * Return: HDD context referenced by @hdd_handle
4898  */
4899 static inline
hdd_handle_to_context(hdd_handle_t hdd_handle)4900 struct hdd_context *hdd_handle_to_context(hdd_handle_t hdd_handle)
4901 {
4902 	return (struct hdd_context *)hdd_handle;
4903 }
4904 
4905 /**
4906  * wlan_hdd_free_cache_channels() - Free the cache channels list
4907  * @hdd_ctx: Pointer to HDD context
4908  *
4909  * Return: None
4910  */
4911 void wlan_hdd_free_cache_channels(struct hdd_context *hdd_ctx);
4912 
4913 /**
4914  * hdd_update_dynamic_mac() - Updates the dynamic MAC list
4915  * @hdd_ctx: Pointer to HDD context
4916  * @curr_mac_addr: Current interface mac address
4917  * @new_mac_addr: New mac address which needs to be updated
4918  *
4919  * This function updates newly configured MAC address to the
4920  * dynamic MAC address list corresponding to the current
4921  * adapter MAC address
4922  *
4923  * Return: None
4924  */
4925 void hdd_update_dynamic_mac(struct hdd_context *hdd_ctx,
4926 			    struct qdf_mac_addr *curr_mac_addr,
4927 			    struct qdf_mac_addr *new_mac_addr);
4928 
4929 #ifdef WLAN_FEATURE_MOTION_DETECTION
4930 /**
4931  * hdd_md_host_evt_cb - Callback for Motion Detection Event
4932  * @ctx: HDD context
4933  * @event: motion detect event
4934  *
4935  * Callback for Motion Detection Event. Re-enables Motion
4936  * Detection again upon event
4937  *
4938  * Return: QDF_STATUS QDF_STATUS_SUCCESS on Success and
4939  * QDF_STATUS_E_FAILURE on failure
4940  */
4941 QDF_STATUS hdd_md_host_evt_cb(void *ctx, struct sir_md_evt *event);
4942 
4943 /**
4944  * hdd_md_bl_evt_cb - Callback for Motion Detection Baseline Event
4945  * @ctx: HDD context
4946  * @event: motion detect baseline event
4947  *
4948  * Callback for Motion Detection Baseline Event
4949  *
4950  * Return: QDF_STATUS QDF_STATUS_SUCCESS on Success and
4951  * QDF_STATUS_E_FAILURE on failure
4952  */
4953 QDF_STATUS hdd_md_bl_evt_cb(void *ctx, struct sir_md_bl_evt *event);
4954 #endif /* WLAN_FEATURE_MOTION_DETECTION */
4955 
4956 /**
4957  * hdd_hidden_ssid_enable_roaming() - enable roaming after hidden ssid rsp
4958  * @hdd_handle: Hdd handler
4959  * @vdev_id: Vdev Id
4960  *
4961  * This is a wrapper function to enable roaming after getting hidden
4962  * ssid rsp
4963  */
4964 void hdd_hidden_ssid_enable_roaming(hdd_handle_t hdd_handle, uint8_t vdev_id);
4965 
4966 /**
4967  * hdd_psoc_idle_shutdown - perform idle shutdown after interface inactivity
4968  *                          timeout
4969  * @dev: pointer to struct device
4970  *
4971  * Return: 0 for success non-zero error code for failure
4972  */
4973 int hdd_psoc_idle_shutdown(struct device *dev);
4974 
4975 /**
4976  * hdd_psoc_idle_restart - perform idle restart after idle shutdown
4977  * @dev: pointer to struct device
4978  *
4979  * Return: 0 for success non-zero error code for failure
4980  */
4981 int hdd_psoc_idle_restart(struct device *dev);
4982 
4983 /**
4984  * hdd_adapter_is_ap() - whether adapter is ap or not
4985  * @adapter: adapter to check
4986  * Return: true if it is AP
4987  */
4988 bool hdd_adapter_is_ap(struct hdd_adapter *adapter);
4989 
4990 /**
4991  * hdd_common_roam_callback() - common sme roam callback
4992  * @psoc: Object Manager Psoc
4993  * @session_id: session id for which callback is called
4994  * @roam_info: pointer to roam info
4995  * @roam_status: roam status
4996  * @roam_result: roam result
4997  *
4998  * Return: QDF_STATUS enumeration
4999  */
5000 QDF_STATUS hdd_common_roam_callback(struct wlan_objmgr_psoc *psoc,
5001 				    uint8_t session_id,
5002 				    struct csr_roam_info *roam_info,
5003 				    eRoamCmdStatus roam_status,
5004 				    eCsrRoamResult roam_result);
5005 
5006 #ifdef WLAN_FEATURE_PKT_CAPTURE
5007 /**
5008  * wlan_hdd_is_mon_concurrency() - check if MONITOR and STA concurrency
5009  * is UP when packet capture mode is enabled.
5010  *
5011  * Return: True - if STA and monitor concurrency is there, else False
5012  *
5013  */
5014 bool wlan_hdd_is_mon_concurrency(void);
5015 
5016 /**
5017  * wlan_hdd_del_monitor() - delete monitor interface
5018  * @hdd_ctx: pointer to hdd context
5019  * @adapter: adapter to be deleted
5020  * @rtnl_held: rtnl lock held
5021  *
5022  * This function is invoked to delete monitor interface.
5023  *
5024  * Return: None
5025  */
5026 void wlan_hdd_del_monitor(struct hdd_context *hdd_ctx,
5027 			  struct hdd_adapter *adapter, bool rtnl_held);
5028 
5029 /**
5030  * wlan_hdd_del_p2p_interface() - delete p2p interface
5031  * @hdd_ctx: pointer to hdd context
5032  *
5033  * This function is invoked to delete p2p interface.
5034  *
5035  * Return: None
5036  */
5037 void
5038 wlan_hdd_del_p2p_interface(struct hdd_context *hdd_ctx);
5039 
5040 /**
5041  * hdd_reset_monitor_interface() - reset monitor interface flags
5042  * @sta_adapter: station adapter
5043  *
5044  * Return: void
5045  */
5046 void hdd_reset_monitor_interface(struct hdd_adapter *sta_adapter);
5047 
5048 /**
5049  * hdd_is_pkt_capture_mon_enable() - Is packet capture monitor mode enable
5050  * @sta_adapter: station adapter
5051  *
5052  * Return: status of packet capture monitor adapter
5053  */
5054 struct hdd_adapter *
5055 hdd_is_pkt_capture_mon_enable(struct hdd_adapter *sta_adapter);
5056 #else
5057 static inline
wlan_hdd_del_monitor(struct hdd_context * hdd_ctx,struct hdd_adapter * adapter,bool rtnl_held)5058 void wlan_hdd_del_monitor(struct hdd_context *hdd_ctx,
5059 			  struct hdd_adapter *adapter, bool rtnl_held)
5060 {
5061 }
5062 
5063 static inline
wlan_hdd_is_mon_concurrency(void)5064 bool wlan_hdd_is_mon_concurrency(void)
5065 {
5066 	return false;
5067 }
5068 
5069 static inline
wlan_hdd_del_p2p_interface(struct hdd_context * hdd_ctx)5070 void wlan_hdd_del_p2p_interface(struct hdd_context *hdd_ctx)
5071 {
5072 }
5073 
hdd_reset_monitor_interface(struct hdd_adapter * sta_adapter)5074 static inline void hdd_reset_monitor_interface(struct hdd_adapter *sta_adapter)
5075 {
5076 }
5077 
hdd_is_pkt_capture_mon_enable(struct hdd_adapter * adapter)5078 static inline int hdd_is_pkt_capture_mon_enable(struct hdd_adapter *adapter)
5079 {
5080 	return 0;
5081 }
5082 #endif /* WLAN_FEATURE_PKT_CAPTURE */
5083 /**
5084  * wlan_hdd_is_session_type_monitor() - check if session type is MONITOR
5085  * @session_type: session type
5086  *
5087  * Return: True - if session type for adapter is monitor, else False
5088  *
5089  */
5090 bool wlan_hdd_is_session_type_monitor(uint8_t session_type);
5091 
5092 /**
5093  * wlan_hdd_add_monitor_check() - check for monitor intf and add if needed
5094  * @hdd_ctx: pointer to hdd context
5095  * @adapter: output pointer to hold created monitor adapter
5096  * @name: name of the interface
5097  * @rtnl_held: True if RTNL lock is held
5098  * @name_assign_type: the name of assign type of the netdev
5099  * @is_rx_mon: if monitor mode is getting enabled
5100  *
5101  * Return: 0 - on success
5102  *         err code - on failure
5103  */
5104 int wlan_hdd_add_monitor_check(struct hdd_context *hdd_ctx,
5105 			       struct hdd_adapter **adapter,
5106 			       const char *name, bool rtnl_held,
5107 			       unsigned char name_assign_type,
5108 			       bool is_rx_mon);
5109 
5110 #ifdef CONFIG_WLAN_DEBUG_CRASH_INJECT
5111 /**
5112  * hdd_crash_inject() - Inject a crash
5113  * @adapter: Adapter upon which the command was received
5114  * @v1: first value to inject
5115  * @v2: second value to inject
5116  *
5117  * This function is the handler for the crash inject debug feature.
5118  * This feature only exists for internal testing and must not be
5119  * enabled on a production device.
5120  *
5121  * Return: 0 on success and errno on failure
5122  */
5123 int hdd_crash_inject(struct hdd_adapter *adapter, uint32_t v1, uint32_t v2);
5124 #else
5125 static inline
hdd_crash_inject(struct hdd_adapter * adapter,uint32_t v1,uint32_t v2)5126 int hdd_crash_inject(struct hdd_adapter *adapter, uint32_t v1, uint32_t v2)
5127 {
5128 	return -ENOTSUPP;
5129 }
5130 #endif
5131 
5132 #ifdef FEATURE_MONITOR_MODE_SUPPORT
5133 
5134 void hdd_sme_monitor_mode_callback(uint8_t vdev_id);
5135 
5136 QDF_STATUS hdd_monitor_mode_vdev_status(struct hdd_adapter *adapter);
5137 
5138 QDF_STATUS hdd_monitor_mode_qdf_create_event(struct hdd_adapter *adapter,
5139 					     uint8_t session_type);
5140 #else
hdd_sme_monitor_mode_callback(uint8_t vdev_id)5141 static inline void hdd_sme_monitor_mode_callback(uint8_t vdev_id) {}
5142 
5143 static inline QDF_STATUS
hdd_monitor_mode_vdev_status(struct hdd_adapter * adapter)5144 hdd_monitor_mode_vdev_status(struct hdd_adapter *adapter)
5145 {
5146 	return QDF_STATUS_SUCCESS;
5147 }
5148 
5149 static inline QDF_STATUS
hdd_monitor_mode_qdf_create_event(struct hdd_adapter * adapter,uint8_t session_type)5150 hdd_monitor_mode_qdf_create_event(struct hdd_adapter *adapter,
5151 				  uint8_t session_type)
5152 {
5153 	return QDF_STATUS_SUCCESS;
5154 }
5155 #endif
5156 
5157 /**
5158  * hdd_cleanup_conn_info() - Cleanup connectin info
5159  * @link_info: pointer to link_info struct in adapter
5160  *
5161  * This function frees the memory allocated for the connection
5162  * info structure
5163  *
5164  * Return: none
5165  */
5166 void hdd_cleanup_conn_info(struct wlan_hdd_link_info *link_info);
5167 
5168 #ifdef FEATURE_WLAN_RESIDENT_DRIVER
5169 extern char *country_code;
5170 extern int con_mode;
5171 extern const struct kernel_param_ops con_mode_ops;
5172 extern int con_mode_ftm;
5173 extern const struct kernel_param_ops con_mode_ftm_ops;
5174 #endif
5175 
5176 /**
5177  * hdd_driver_load() - Perform the driver-level load operation
5178  *
5179  * Note: this is used in both static and DLKM driver builds
5180  *
5181  * Return: Errno
5182  */
5183 int hdd_driver_load(void);
5184 
5185 /**
5186  * hdd_driver_unload() - Performs the driver-level unload operation
5187  *
5188  * Note: this is used in both static and DLKM driver builds
5189  *
5190  * Return: None
5191  */
5192 void hdd_driver_unload(void);
5193 
5194 /**
5195  * hdd_init_start_completion() - Init the completion variable to wait on ON/OFF
5196  *
5197  * Return: None
5198  */
5199 void hdd_init_start_completion(void);
5200 
5201 #if defined(CLD_PM_QOS) && defined(WLAN_FEATURE_LL_MODE)
5202 /**
5203  * hdd_beacon_latency_event_cb() - Callback function to get latency level
5204  * @latency_level: latency level received from firmware
5205  *
5206  * Return: None
5207  */
5208 void hdd_beacon_latency_event_cb(uint32_t latency_level);
5209 #else
hdd_beacon_latency_event_cb(uint32_t latency_level)5210 static inline void hdd_beacon_latency_event_cb(uint32_t latency_level)
5211 {
5212 }
5213 #endif
5214 
5215 #if defined(CLD_PM_QOS) || defined(FEATURE_RUNTIME_PM)
5216 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0))
5217 /**
5218  * wlan_hdd_get_default_pm_qos_cpu_latency() - get default PM QOS CPU latency
5219  *
5220  * Return: PM QOS CPU latency value
5221  */
wlan_hdd_get_default_pm_qos_cpu_latency(void)5222 static inline unsigned long wlan_hdd_get_default_pm_qos_cpu_latency(void)
5223 {
5224 	return PM_QOS_CPU_LATENCY_DEFAULT_VALUE;
5225 }
5226 #else
wlan_hdd_get_default_pm_qos_cpu_latency(void)5227 static inline unsigned long wlan_hdd_get_default_pm_qos_cpu_latency(void)
5228 {
5229 	return PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
5230 }
5231 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0) */
5232 #endif /* defined(CLD_PM_QOS) || defined(FEATURE_RUNTIME_PM) */
5233 
5234 /**
5235  * hdd_get_wifi_standard() - Get wifi standard
5236  * @hdd_ctx: hdd context pointer
5237  * @dot11_mode: hdd dot11 mode
5238  * @band_capability: band capability bitmap
5239  *
5240  * Return: WMI_HOST_WIFI_STANDARD
5241  */
5242 WMI_HOST_WIFI_STANDARD
5243 hdd_get_wifi_standard(struct hdd_context *hdd_ctx,
5244 		      enum hdd_dot11_mode dot11_mode, uint32_t band_capability);
5245 
5246 /**
5247  * hdd_is_runtime_pm_enabled - if runtime pm enabled
5248  * @hdd_ctx: hdd context
5249  *
5250  * Return: true if runtime pm enabled. false if disabled.
5251  */
5252 bool hdd_is_runtime_pm_enabled(struct hdd_context *hdd_ctx);
5253 
5254 /**
5255  * hdd_netdev_update_features() - Update the netdev features
5256  * @adapter: adapter associated with the net_device
5257  *
5258  * This func holds the rtnl_lock. Do not call with rtnl_lock held.
5259  *
5260  * Return: None
5261  */
5262 void hdd_netdev_update_features(struct hdd_adapter *adapter);
5263 
5264 /**
5265  * hdd_stop_no_trans() - HDD stop function
5266  * @dev:	Pointer to net_device structure
5267  *
5268  * This is called in response to ifconfig down. Vdev sync transaction
5269  * should be started before calling this API.
5270  *
5271  * Return: 0 for success; non-zero for failure
5272  */
5273 int hdd_stop_no_trans(struct net_device *dev);
5274 
5275 #if defined(CLD_PM_QOS)
5276 /**
5277  * wlan_hdd_set_pm_qos_request() - Function to set pm_qos config in wlm mode
5278  * @hdd_ctx: HDD context
5279  * @pm_qos_request: pm_qos_request flag
5280  *
5281  * Return: None
5282  */
5283 void wlan_hdd_set_pm_qos_request(struct hdd_context *hdd_ctx,
5284 				 bool pm_qos_request);
5285 #else
5286 static inline
wlan_hdd_set_pm_qos_request(struct hdd_context * hdd_ctx,bool pm_qos_request)5287 void wlan_hdd_set_pm_qos_request(struct hdd_context *hdd_ctx,
5288 				 bool pm_qos_request)
5289 {
5290 }
5291 #endif
5292 
5293 /**
5294  * hdd_nl80211_chwidth_to_chwidth - Get sir chan width from nl chan width
5295  * @nl80211_chwidth: enum nl80211_chan_width
5296  *
5297  * Return: enum eSirMacHTChannelWidth or -INVAL for unsupported nl chan width
5298  */
5299 enum eSirMacHTChannelWidth
5300 hdd_nl80211_chwidth_to_chwidth(uint8_t nl80211_chwidth);
5301 
5302 /**
5303  * hdd_chwidth_to_nl80211_chwidth - Get nl chan width from sir chan width
5304  * @chwidth: enum eSirMacHTChannelWidth
5305  *
5306  * Return: enum nl80211_chan_width or 0xFF for unsupported sir chan width
5307  */
5308 uint8_t hdd_chwidth_to_nl80211_chwidth(enum eSirMacHTChannelWidth chwidth);
5309 
5310 /**
5311  * hdd_phy_chwidth_to_nl80211_chwidth() - Get nl chan width from phy chan width
5312  * @chwidth: enum phy_ch_width
5313  *
5314  * Return: enum nl80211_chan_width or 0xFF for unsupported phy chan width
5315  */
5316 uint8_t hdd_phy_chwidth_to_nl80211_chwidth(enum phy_ch_width chwidth);
5317 
5318 /**
5319  * wlan_hdd_get_channel_bw() - get channel bandwidth
5320  * @width: input channel width in nl80211_chan_width value
5321  *
5322  * Return: channel width value defined by driver
5323  */
5324 enum hw_mode_bandwidth wlan_hdd_get_channel_bw(enum nl80211_chan_width width);
5325 
5326 /**
5327  * hdd_ch_width_str() - Get string for channel width
5328  * @ch_width: channel width from connect info
5329  *
5330  * Return: User readable string for channel width
5331  */
5332 uint8_t *hdd_ch_width_str(enum phy_ch_width ch_width);
5333 
5334 /**
5335  * hdd_we_set_ch_width - Function to update channel width
5336  * @link_info: Link info pointer in HDD adapter.
5337  * @ch_width: enum eSirMacHTChannelWidth
5338  *
5339  * Return: 0 for success otherwise failure
5340  */
5341 int hdd_we_set_ch_width(struct wlan_hdd_link_info *link_info, int ch_width);
5342 
5343 /**
5344  * hdd_stop_adapter_ext: close/delete the vdev session in host/fw.
5345  * @hdd_ctx: HDD context
5346  * @adapter: Pointer to hdd_adapter
5347  *
5348  * Close/delete the vdev session in host/firmware.
5349  */
5350 QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
5351 				struct hdd_adapter *adapter);
5352 
5353 /**
5354  * hdd_check_for_net_dev_ref_leak: check for vdev reference leak in driver
5355  * @adapter: Pointer to hdd_adapter
5356  *
5357  * various function take netdev reference to get protected against netdev
5358  * getting deleted in parallel, check if all those references are cleanly
5359  * released.
5360  */
5361 void hdd_check_for_net_dev_ref_leak(struct hdd_adapter *adapter);
5362 
5363 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_HDD_MULTI_VDEV_SINGLE_NDEV)
5364 
5365 /**
5366  * hdd_link_switch_vdev_mac_addr_update() - API to update OSIF/HDD on VDEV
5367  * mac addr update due to link switch.
5368  * @ieee_old_link_id: Current  IEEE link ID of VDEV prior to link switch
5369  * @ieee_new_link_id: New IEEE link ID of VDEV post link switch
5370  * @vdev_id: VDEV undergoing link switch.
5371  *
5372  * Check if both @ieee_old_link_id and @ieee_new_link_id are part of adapter
5373  * corresponding to @vdev_id. Then take necessary actions to support link switch
5374  * MAC update and update DP to change link MAC address to new link's address.
5375  *
5376  * Return: QDF_STATUS
5377  */
5378 QDF_STATUS
5379 hdd_link_switch_vdev_mac_addr_update(int32_t ieee_old_link_id,
5380 				     int32_t ieee_new_link_id, uint8_t vdev_id);
5381 
5382 /**
5383  * hdd_get_link_info_by_ieee_link_id() - Find link info pointer matching with
5384  * IEEE link ID.
5385  * @adapter: HDD adapter
5386  * @link_id: IEEE link ID to search for.
5387  *
5388  * Search the station ctx connection info for matching link ID in @adapter and
5389  * return the link info pointer on match. The IEEE link ID is updated in station
5390  * context during MLO connection and reset on disconnection.
5391  *
5392  * Return: link info pointer
5393  */
5394 struct wlan_hdd_link_info *
5395 hdd_get_link_info_by_ieee_link_id(struct hdd_adapter *adapter, int32_t link_id);
5396 #endif
5397 
5398 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE
5399 /**
5400  * hdd_dynamic_mac_address_set(): API to set MAC address, when interface
5401  *                                is up.
5402  * @link_info: Link info pointer in HDD adapter
5403  * @mac_addr: MAC address to set
5404  * @mld_addr: MLD address to set
5405  * @update_self_peer: Set to true to update self peer's address
5406  *
5407  * This API is used to update the current VDEV MAC address.
5408  *
5409  * Return: 0 for success. non zero valure for failure.
5410  */
5411 int hdd_dynamic_mac_address_set(struct wlan_hdd_link_info *link_info,
5412 				struct qdf_mac_addr mac_addr,
5413 				struct qdf_mac_addr mld_addr,
5414 				bool update_self_peer);
5415 
5416 /**
5417  * hdd_is_dynamic_set_mac_addr_allowed() - API to check dynamic MAC address
5418  *				           update is allowed or not
5419  * @adapter: Pointer to the adapter structure
5420  *
5421  * Return: true or false
5422  */
5423 bool hdd_is_dynamic_set_mac_addr_allowed(struct hdd_adapter *adapter);
5424 
5425 #if defined(WLAN_FEATURE_11BE_MLO) && defined(CFG80211_11BE_BASIC)
5426 /**
5427  * hdd_update_vdev_mac_address() - Update VDEV MAC address dynamically
5428  * @adapter: Pointer to HDD adapter
5429  * @mac_addr: MAC address to be updated
5430  *
5431  * API to update VDEV MAC address during interface is in UP state.
5432  *
5433  * Return: 0 for Success. Error code for failure
5434  */
5435 int hdd_update_vdev_mac_address(struct hdd_adapter *adapter,
5436 				struct qdf_mac_addr mac_addr);
5437 #else
hdd_update_vdev_mac_address(struct hdd_adapter * adapter,struct qdf_mac_addr mac_addr)5438 static inline int hdd_update_vdev_mac_address(struct hdd_adapter *adapter,
5439 					      struct qdf_mac_addr mac_addr)
5440 {
5441 	struct qdf_mac_addr mld_addr = QDF_MAC_ADDR_ZERO_INIT;
5442 
5443 	return hdd_dynamic_mac_address_set(adapter->deflink, mac_addr,
5444 					   mld_addr, true);
5445 }
5446 #endif /* WLAN_FEATURE_11BE_MLO */
5447 #else
hdd_update_vdev_mac_address(struct hdd_adapter * adapter,struct qdf_mac_addr mac_addr)5448 static inline int hdd_update_vdev_mac_address(struct hdd_adapter *adapter,
5449 					      struct qdf_mac_addr mac_addr)
5450 {
5451 	return 0;
5452 }
5453 
5454 static inline int
hdd_dynamic_mac_address_set(struct wlan_hdd_link_info * link_info,struct qdf_mac_addr mac_addr,struct qdf_mac_addr mld_addr,bool update_self_peer)5455 hdd_dynamic_mac_address_set(struct wlan_hdd_link_info *link_info,
5456 			    struct qdf_mac_addr mac_addr,
5457 			    struct qdf_mac_addr mld_addr,
5458 			    bool update_self_peer)
5459 {
5460 	return 0;
5461 }
5462 
5463 static inline bool
hdd_is_dynamic_set_mac_addr_allowed(struct hdd_adapter * adapter)5464 hdd_is_dynamic_set_mac_addr_allowed(struct hdd_adapter *adapter)
5465 {
5466 	return false;
5467 }
5468 
5469 #endif /* WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE */
5470 
5471 #if defined(WLAN_FEATURE_ROAM_OFFLOAD) && \
5472 defined(FEATURE_RX_LINKSPEED_ROAM_TRIGGER)
5473 /**
5474  * wlan_hdd_link_speed_update() - Update link speed to F/W
5475  * @psoc: pointer to soc
5476  * @vdev_id: Vdev ID
5477  * @is_link_speed_good: true means good link speed,  false means bad link speed
5478  *
5479  * Return: None
5480  */
5481 void wlan_hdd_link_speed_update(struct wlan_objmgr_psoc *psoc,
5482 				uint8_t vdev_id,
5483 				bool is_link_speed_good);
5484 #else
wlan_hdd_link_speed_update(struct wlan_objmgr_psoc * psoc,uint8_t vdev_id,bool is_link_speed_good)5485 static inline void wlan_hdd_link_speed_update(struct wlan_objmgr_psoc *psoc,
5486 					      uint8_t vdev_id,
5487 					      bool is_link_speed_good)
5488 {}
5489 #endif
5490 
5491 /**
5492  * hdd_update_multicast_list() - update the multicast list
5493  * @vdev: pointer to VDEV object
5494  *
5495  * Return: none
5496  */
5497 void hdd_update_multicast_list(struct wlan_objmgr_vdev *vdev);
5498 
5499 /**
5500  * hdd_set_sar_init_index() - Set SAR safety index at init.
5501  * @hdd_ctx: HDD context
5502  *
5503  */
5504 #ifdef SAR_SAFETY_FEATURE
5505 void hdd_set_sar_init_index(struct hdd_context *hdd_ctx);
5506 #else
hdd_set_sar_init_index(struct hdd_context * hdd_ctx)5507 static inline void hdd_set_sar_init_index(struct hdd_context *hdd_ctx)
5508 {}
5509 #endif
5510 /**
5511  * hdd_send_coex_traffic_shaping_mode() - Send coex traffic shaping mode
5512  * to FW
5513  * @vdev_id: vdev ID
5514  * @mode: traffic shaping mode
5515  *
5516  * This function is used to send coex traffic shaping mode to FW
5517  *
5518  * Return: 0 on success and -EINVAL on failure
5519  */
5520 int hdd_send_coex_traffic_shaping_mode(uint8_t vdev_id, uint8_t mode);
5521 
5522 #ifdef WLAN_FEATURE_LOCAL_PKT_CAPTURE
5523 /**
5524  * wlan_hdd_lpc_handle_concurrency() - Handle local packet capture
5525  * concurrency scenario
5526  * @hdd_ctx: hdd_ctx
5527  * @is_virtual_iface: is virtual interface
5528  *
5529  * This function takes care of handling concurrency scenario
5530  * If STA+Mon present and SAP is coming up, terminate Mon and let SAP come up
5531  * If STA+Mon present and P2P is coming up, terminate Mon and let P2P come up
5532  * If STA+Mon present and NAN is coming up, terminate Mon and let NAN come up
5533  *
5534  * Return: none
5535  */
5536 void wlan_hdd_lpc_handle_concurrency(struct hdd_context *hdd_ctx,
5537 				     bool is_virtual_iface);
5538 
5539 /**
5540  * hdd_lpc_is_work_scheduled() - function to return if lpc wq scheduled
5541  * @hdd_ctx: hdd_ctx
5542  *
5543  * Return: true if scheduled; false otherwise
5544  */
5545 bool hdd_lpc_is_work_scheduled(struct hdd_context *hdd_ctx);
5546 
5547 #else
5548 static inline void
wlan_hdd_lpc_handle_concurrency(struct hdd_context * hdd_ctx,bool is_virtual_iface)5549 wlan_hdd_lpc_handle_concurrency(struct hdd_context *hdd_ctx,
5550 				bool is_virtual_iface)
5551 {}
5552 
5553 static inline bool
hdd_lpc_is_work_scheduled(struct hdd_context * hdd_ctx)5554 hdd_lpc_is_work_scheduled(struct hdd_context *hdd_ctx)
5555 {
5556 	return false;
5557 }
5558 #endif
5559 
5560 /**
5561  * hdd_allow_new_intf() - Allow new intf created or not
5562  * @hdd_ctx: hdd context
5563  * @mode: qdf opmode of new interface
5564  *
5565  * Return: true if allowed, otherwise false
5566  */
5567 bool hdd_allow_new_intf(struct hdd_context *hdd_ctx,
5568 			enum QDF_OPMODE mode);
5569 #endif /* end #if !defined(WLAN_HDD_MAIN_H) */
5570