main.h

   1/* SPDX-License-Identifier: GPL-2.0-only */
   2/*
   3 * NXP Wireless LAN device driver: major data structures and prototypes
   4 *
   5 * Copyright 2011-2020 NXP
   6 */
   7
   8#ifndef _MWIFIEX_MAIN_H_
   9#define _MWIFIEX_MAIN_H_
  10
  11#include <linux/completion.h>
  12#include <linux/kernel.h>
  13#include <linux/kstrtox.h>
  14#include <linux/module.h>
  15#include <linux/sched.h>
  16#include <linux/semaphore.h>
  17#include <linux/ip.h>
  18#include <linux/skbuff.h>
  19#include <linux/if_arp.h>
  20#include <linux/etherdevice.h>
  21#include <net/sock.h>
  22#include <linux/vmalloc.h>
  23#include <linux/firmware.h>
  24#include <linux/ctype.h>
  25#include <linux/of.h>
  26#include <linux/idr.h>
  27#include <linux/inetdevice.h>
  28#include <linux/devcoredump.h>
  29#include <linux/err.h>
  30#include <linux/gfp.h>
  31#include <linux/interrupt.h>
  32#include <linux/io.h>
  33#include <linux/of_platform.h>
  34#include <linux/platform_device.h>
  35#include <linux/pm_runtime.h>
  36#include <linux/slab.h>
  37#include <linux/of_irq.h>
  38#include <linux/workqueue.h>
  39
  40#include "decl.h"
  41#include "ioctl.h"
  42#include "util.h"
  43#include "fw.h"
  44#include "pcie.h"
  45#include "usb.h"
  46#include "sdio.h"
  47
  48extern const char driver_version[];
  49extern bool mfg_mode;
  50extern bool aggr_ctrl;
  51
  52struct mwifiex_adapter;
  53struct mwifiex_private;
  54
  55enum {
  56	MWIFIEX_ASYNC_CMD,
  57	MWIFIEX_SYNC_CMD
  58};
  59
  60#define MWIFIEX_DRIVER_MODE_STA			BIT(0)
  61#define MWIFIEX_DRIVER_MODE_UAP			BIT(1)
  62#define MWIFIEX_DRIVER_MODE_P2P			BIT(2)
  63#define MWIFIEX_DRIVER_MODE_BITMASK		(BIT(0) | BIT(1) | BIT(2))
  64
  65#define MWIFIEX_MAX_AP				64
  66
  67#define MWIFIEX_MAX_PKTS_TXQ			16
  68
  69#define MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT	(5 * HZ)
  70
  71#define MWIFIEX_TIMER_10S			10000
  72#define MWIFIEX_TIMER_1S			1000
  73
  74#define MAX_TX_PENDING      400
  75#define LOW_TX_PENDING      380
  76
  77#define HIGH_RX_PENDING     50
  78#define LOW_RX_PENDING      20
  79
  80#define MWIFIEX_UPLD_SIZE               (2312)
  81
  82#define MAX_EVENT_SIZE                  2048
  83
  84#define MWIFIEX_FW_DUMP_SIZE       (2 * 1024 * 1024)
  85
  86#define ARP_FILTER_MAX_BUF_SIZE         68
  87
  88#define MWIFIEX_KEY_BUFFER_SIZE			16
  89#define MWIFIEX_DEFAULT_LISTEN_INTERVAL 10
  90#define MWIFIEX_MAX_REGION_CODE         9
  91
  92#define DEFAULT_BCN_AVG_FACTOR          8
  93#define DEFAULT_DATA_AVG_FACTOR         8
  94
  95#define FIRST_VALID_CHANNEL				0xff
  96#define DEFAULT_AD_HOC_CHANNEL			6
  97#define DEFAULT_AD_HOC_CHANNEL_A		36
  98
  99#define DEFAULT_BCN_MISS_TIMEOUT		5
 100
 101#define MAX_SCAN_BEACON_BUFFER			8000
 102
 103#define SCAN_BEACON_ENTRY_PAD			6
 104
 105#define MWIFIEX_PASSIVE_SCAN_CHAN_TIME	110
 106#define MWIFIEX_ACTIVE_SCAN_CHAN_TIME	40
 107#define MWIFIEX_SPECIFIC_SCAN_CHAN_TIME	40
 108#define MWIFIEX_DEF_SCAN_CHAN_GAP_TIME  50
 109
 110#define SCAN_RSSI(RSSI)					(0x100 - ((u8)(RSSI)))
 111
 112#define MWIFIEX_MAX_TOTAL_SCAN_TIME	(MWIFIEX_TIMER_10S - MWIFIEX_TIMER_1S)
 113
 114#define WPA_GTK_OUI_OFFSET				2
 115#define RSN_GTK_OUI_OFFSET				2
 116
 117#define MWIFIEX_OUI_NOT_PRESENT			0
 118#define MWIFIEX_OUI_PRESENT				1
 119
 120#define PKT_TYPE_MGMT	0xE5
 121
 122/*
 123 * Do not check for data_received for USB, as data_received
 124 * is handled in mwifiex_usb_recv for USB
 125 */
 126#define IS_CARD_RX_RCVD(adapter) (adapter->cmd_resp_received || \
 127				adapter->event_received || \
 128				adapter->data_received)
 129
 130#define MWIFIEX_TYPE_CMD				1
 131#define MWIFIEX_TYPE_DATA				0
 132#define MWIFIEX_TYPE_AGGR_DATA				10
 133#define MWIFIEX_TYPE_EVENT				3
 134
 135#define MAX_BITMAP_RATES_SIZE			18
 136
 137#define MAX_CHANNEL_BAND_BG     14
 138#define MAX_CHANNEL_BAND_A      165
 139
 140#define MAX_FREQUENCY_BAND_BG   2484
 141
 142#define MWIFIEX_EVENT_HEADER_LEN           4
 143#define MWIFIEX_UAP_EVENT_EXTRA_HEADER	   2
 144
 145#define MWIFIEX_TYPE_LEN			4
 146#define MWIFIEX_USB_TYPE_CMD			0xF00DFACE
 147#define MWIFIEX_USB_TYPE_DATA			0xBEADC0DE
 148#define MWIFIEX_USB_TYPE_EVENT			0xBEEFFACE
 149
 150/* Threshold for tx_timeout_cnt before we trigger a card reset */
 151#define TX_TIMEOUT_THRESHOLD	6
 152
 153#define MWIFIEX_DRV_INFO_SIZE_MAX 0x40000
 154
 155/* Address alignment */
 156#define MWIFIEX_ALIGN_ADDR(p, a) (((long)(p) + (a) - 1) & ~((a) - 1))
 157
 158#define MWIFIEX_MAC_LOCAL_ADMIN_BIT		41
 159
 160/**
 161 *enum mwifiex_debug_level  -  marvell wifi debug level
 162 */
 163enum MWIFIEX_DEBUG_LEVEL {
 164	MWIFIEX_DBG_MSG		= 0x00000001,
 165	MWIFIEX_DBG_FATAL	= 0x00000002,
 166	MWIFIEX_DBG_ERROR	= 0x00000004,
 167	MWIFIEX_DBG_DATA	= 0x00000008,
 168	MWIFIEX_DBG_CMD		= 0x00000010,
 169	MWIFIEX_DBG_EVENT	= 0x00000020,
 170	MWIFIEX_DBG_INTR	= 0x00000040,
 171	MWIFIEX_DBG_IOCTL	= 0x00000080,
 172
 173	MWIFIEX_DBG_MPA_D	= 0x00008000,
 174	MWIFIEX_DBG_DAT_D	= 0x00010000,
 175	MWIFIEX_DBG_CMD_D	= 0x00020000,
 176	MWIFIEX_DBG_EVT_D	= 0x00040000,
 177	MWIFIEX_DBG_FW_D	= 0x00080000,
 178	MWIFIEX_DBG_IF_D	= 0x00100000,
 179
 180	MWIFIEX_DBG_ENTRY	= 0x10000000,
 181	MWIFIEX_DBG_WARN	= 0x20000000,
 182	MWIFIEX_DBG_INFO	= 0x40000000,
 183	MWIFIEX_DBG_DUMP	= 0x80000000,
 184
 185	MWIFIEX_DBG_ANY		= 0xffffffff
 186};
 187
 188#define MWIFIEX_DEFAULT_DEBUG_MASK	(MWIFIEX_DBG_MSG | \
 189					MWIFIEX_DBG_FATAL | \
 190					MWIFIEX_DBG_ERROR)
 191
 192__printf(3, 4)
 193void _mwifiex_dbg(const struct mwifiex_adapter *adapter, int mask,
 194		  const char *fmt, ...);
 195#define mwifiex_dbg(adapter, mask, fmt, ...)				\
 196	_mwifiex_dbg(adapter, MWIFIEX_DBG_##mask, fmt, ##__VA_ARGS__)
 197
 198#define DEBUG_DUMP_DATA_MAX_LEN		128
 199#define mwifiex_dbg_dump(adapter, dbg_mask, str, buf, len)	\
 200do {								\
 201	if ((adapter)->debug_mask & MWIFIEX_DBG_##dbg_mask)	\
 202		print_hex_dump(KERN_DEBUG, str,			\
 203			       DUMP_PREFIX_OFFSET, 16, 1,	\
 204			       buf, len, false);		\
 205} while (0)
 206
 207/** Min BGSCAN interval 15 second */
 208#define MWIFIEX_BGSCAN_INTERVAL 15000
 209/** default repeat count */
 210#define MWIFIEX_BGSCAN_REPEAT_COUNT 6
 211
 212struct mwifiex_dbg {
 213	u32 num_cmd_host_to_card_failure;
 214	u32 num_cmd_sleep_cfm_host_to_card_failure;
 215	u32 num_tx_host_to_card_failure;
 216	u32 num_event_deauth;
 217	u32 num_event_disassoc;
 218	u32 num_event_link_lost;
 219	u32 num_cmd_deauth;
 220	u32 num_cmd_assoc_success;
 221	u32 num_cmd_assoc_failure;
 222	u32 num_tx_timeout;
 223	u16 timeout_cmd_id;
 224	u16 timeout_cmd_act;
 225	u16 last_cmd_id[DBG_CMD_NUM];
 226	u16 last_cmd_act[DBG_CMD_NUM];
 227	u16 last_cmd_index;
 228	u16 last_cmd_resp_id[DBG_CMD_NUM];
 229	u16 last_cmd_resp_index;
 230	u16 last_event[DBG_CMD_NUM];
 231	u16 last_event_index;
 232	u32 last_mp_wr_bitmap[MWIFIEX_DBG_SDIO_MP_NUM];
 233	u32 last_mp_wr_ports[MWIFIEX_DBG_SDIO_MP_NUM];
 234	u32 last_mp_wr_len[MWIFIEX_DBG_SDIO_MP_NUM];
 235	u32 last_mp_curr_wr_port[MWIFIEX_DBG_SDIO_MP_NUM];
 236	u8 last_sdio_mp_index;
 237};
 238
 239enum MWIFIEX_HARDWARE_STATUS {
 240	MWIFIEX_HW_STATUS_READY,
 241	MWIFIEX_HW_STATUS_INITIALIZING,
 242	MWIFIEX_HW_STATUS_RESET,
 243	MWIFIEX_HW_STATUS_NOT_READY
 244};
 245
 246enum MWIFIEX_802_11_POWER_MODE {
 247	MWIFIEX_802_11_POWER_MODE_CAM,
 248	MWIFIEX_802_11_POWER_MODE_PSP
 249};
 250
 251struct mwifiex_tx_param {
 252	u32 next_pkt_len;
 253};
 254
 255enum MWIFIEX_PS_STATE {
 256	PS_STATE_AWAKE,
 257	PS_STATE_PRE_SLEEP,
 258	PS_STATE_SLEEP_CFM,
 259	PS_STATE_SLEEP
 260};
 261
 262enum mwifiex_iface_type {
 263	MWIFIEX_SDIO,
 264	MWIFIEX_PCIE,
 265	MWIFIEX_USB
 266};
 267
 268struct mwifiex_add_ba_param {
 269	u32 tx_win_size;
 270	u32 rx_win_size;
 271	u32 timeout;
 272	u8 tx_amsdu;
 273	u8 rx_amsdu;
 274};
 275
 276struct mwifiex_tx_aggr {
 277	u8 ampdu_user;
 278	u8 ampdu_ap;
 279	u8 amsdu;
 280};
 281
 282enum mwifiex_ba_status {
 283	BA_SETUP_NONE = 0,
 284	BA_SETUP_INPROGRESS,
 285	BA_SETUP_COMPLETE
 286};
 287
 288struct mwifiex_ra_list_tbl {
 289	struct list_head list;
 290	struct sk_buff_head skb_head;
 291	u8 ra[ETH_ALEN];
 292	u32 is_11n_enabled;
 293	u16 max_amsdu;
 294	u16 ba_pkt_count;
 295	u8 ba_packet_thr;
 296	enum mwifiex_ba_status ba_status;
 297	u8 amsdu_in_ampdu;
 298	u16 total_pkt_count;
 299	bool tdls_link;
 300	bool tx_paused;
 301};
 302
 303struct mwifiex_tid_tbl {
 304	struct list_head ra_list;
 305};
 306
 307#define WMM_HIGHEST_PRIORITY		7
 308#define HIGH_PRIO_TID				7
 309#define LOW_PRIO_TID				0
 310#define NO_PKT_PRIO_TID				-1
 311#define MWIFIEX_WMM_DRV_DELAY_MAX 510
 312
 313struct mwifiex_wmm_desc {
 314	struct mwifiex_tid_tbl tid_tbl_ptr[MAX_NUM_TID];
 315	u32 packets_out[MAX_NUM_TID];
 316	u32 pkts_paused[MAX_NUM_TID];
 317	/* spin lock to protect ra_list */
 318	spinlock_t ra_list_spinlock;
 319	struct mwifiex_wmm_ac_status ac_status[IEEE80211_NUM_ACS];
 320	enum mwifiex_wmm_ac_e ac_down_graded_vals[IEEE80211_NUM_ACS];
 321	u32 drv_pkt_delay_max;
 322	u8 queue_priority[IEEE80211_NUM_ACS];
 323	u32 user_pri_pkt_tx_ctrl[WMM_HIGHEST_PRIORITY + 1];	/* UP: 0 to 7 */
 324	/* Number of transmit packets queued */
 325	atomic_t tx_pkts_queued;
 326	/* Tracks highest priority with a packet queued */
 327	atomic_t highest_queued_prio;
 328};
 329
 330struct mwifiex_802_11_security {
 331	u8 wpa_enabled;
 332	u8 wpa2_enabled;
 333	u8 wapi_enabled;
 334	u8 wapi_key_on;
 335	u8 wep_enabled;
 336	u32 authentication_mode;
 337	u8 is_authtype_auto;
 338	u32 encryption_mode;
 339};
 340
 341struct ieee_types_header {
 342	u8 element_id;
 343	u8 len;
 344} __packed;
 345
 346struct ieee_types_vendor_specific {
 347	struct ieee_types_vendor_header vend_hdr;
 348	u8 data[IEEE_MAX_IE_SIZE - sizeof(struct ieee_types_vendor_header)];
 349} __packed;
 350
 351struct ieee_types_generic {
 352	struct ieee_types_header ieee_hdr;
 353	u8 data[IEEE_MAX_IE_SIZE - sizeof(struct ieee_types_header)];
 354} __packed;
 355
 356struct ieee_types_bss_co_2040 {
 357	struct ieee_types_header ieee_hdr;
 358	u8 bss_2040co;
 359} __packed;
 360
 361struct ieee_types_extcap {
 362	struct ieee_types_header ieee_hdr;
 363	u8 ext_capab[8];
 364} __packed;
 365
 366struct ieee_types_vht_cap {
 367	struct ieee_types_header ieee_hdr;
 368	struct ieee80211_vht_cap vhtcap;
 369} __packed;
 370
 371struct ieee_types_vht_oper {
 372	struct ieee_types_header ieee_hdr;
 373	struct ieee80211_vht_operation vhtoper;
 374} __packed;
 375
 376struct ieee_types_aid {
 377	struct ieee_types_header ieee_hdr;
 378	u16 aid;
 379} __packed;
 380
 381struct mwifiex_bssdescriptor {
 382	u8 mac_address[ETH_ALEN];
 383	struct cfg80211_ssid ssid;
 384	u32 privacy;
 385	s32 rssi;
 386	u32 channel;
 387	u32 freq;
 388	u16 beacon_period;
 389	u8 erp_flags;
 390	u32 bss_mode;
 391	u8 supported_rates[MWIFIEX_SUPPORTED_RATES];
 392	u8 data_rates[MWIFIEX_SUPPORTED_RATES];
 393	/* Network band.
 394	 * BAND_B(0x01): 'b' band
 395	 * BAND_G(0x02): 'g' band
 396	 * BAND_A(0X04): 'a' band
 397	 */
 398	u16 bss_band;
 399	u64 fw_tsf;
 400	u64 timestamp;
 401	union ieee_types_phy_param_set phy_param_set;
 402	union ieee_types_ss_param_set ss_param_set;
 403	u16 cap_info_bitmap;
 404	struct ieee_types_wmm_parameter wmm_ie;
 405	u8  disable_11n;
 406	struct ieee80211_ht_cap *bcn_ht_cap;
 407	u16 ht_cap_offset;
 408	struct ieee80211_ht_operation *bcn_ht_oper;
 409	u16 ht_info_offset;
 410	u8 *bcn_bss_co_2040;
 411	u16 bss_co_2040_offset;
 412	u8 *bcn_ext_cap;
 413	u16 ext_cap_offset;
 414	struct ieee80211_vht_cap *bcn_vht_cap;
 415	u16 vht_cap_offset;
 416	struct ieee80211_vht_operation *bcn_vht_oper;
 417	u16 vht_info_offset;
 418	struct ieee_types_oper_mode_ntf *oper_mode;
 419	u16 oper_mode_offset;
 420	u8 disable_11ac;
 421	struct ieee_types_vendor_specific *bcn_wpa_ie;
 422	u16 wpa_offset;
 423	struct ieee_types_generic *bcn_rsn_ie;
 424	u16 rsn_offset;
 425	struct ieee_types_generic *bcn_rsnx_ie;
 426	u16 rsnx_offset;
 427	struct ieee_types_generic *bcn_wapi_ie;
 428	u16 wapi_offset;
 429	u8 *beacon_buf;
 430	u32 beacon_buf_size;
 431	u8 sensed_11h;
 432	u8 local_constraint;
 433	u8 chan_sw_ie_present;
 434};
 435
 436struct mwifiex_current_bss_params {
 437	struct mwifiex_bssdescriptor bss_descriptor;
 438	u8 wmm_enabled;
 439	u8 wmm_uapsd_enabled;
 440	u8 band;
 441	u32 num_of_rates;
 442	u8 data_rates[MWIFIEX_SUPPORTED_RATES];
 443};
 444
 445struct mwifiex_sleep_period {
 446	u16 period;
 447	u16 reserved;
 448};
 449
 450struct mwifiex_wep_key {
 451	u32 length;
 452	u32 key_index;
 453	u32 key_length;
 454	u8 key_material[MWIFIEX_KEY_BUFFER_SIZE];
 455};
 456
 457#define MAX_REGION_CHANNEL_NUM  2
 458
 459struct mwifiex_chan_freq_power {
 460	u16 channel;
 461	u32 freq;
 462	u16 max_tx_power;
 463	u8 unsupported;
 464};
 465
 466enum state_11d_t {
 467	DISABLE_11D = 0,
 468	ENABLE_11D = 1,
 469};
 470
 471#define MWIFIEX_MAX_TRIPLET_802_11D		83
 472
 473struct mwifiex_802_11d_domain_reg {
 474	u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
 475	u8 no_of_triplet;
 476	struct ieee80211_country_ie_triplet
 477		triplet[MWIFIEX_MAX_TRIPLET_802_11D];
 478};
 479
 480struct mwifiex_vendor_spec_cfg_ie {
 481	u16 mask;
 482	u16 flag;
 483	u8 ie[MWIFIEX_MAX_VSIE_LEN];
 484};
 485
 486struct wps {
 487	u8 session_enable;
 488};
 489
 490struct mwifiex_roc_cfg {
 491	u64 cookie;
 492	struct ieee80211_channel chan;
 493};
 494
 495enum mwifiex_iface_work_flags {
 496	MWIFIEX_IFACE_WORK_DEVICE_DUMP,
 497	MWIFIEX_IFACE_WORK_CARD_RESET,
 498};
 499
 500enum mwifiex_adapter_work_flags {
 501	MWIFIEX_SURPRISE_REMOVED,
 502	MWIFIEX_IS_CMD_TIMEDOUT,
 503	MWIFIEX_IS_SUSPENDED,
 504	MWIFIEX_IS_HS_CONFIGURED,
 505	MWIFIEX_IS_HS_ENABLING,
 506	MWIFIEX_IS_REQUESTING_FW_VEREXT,
 507};
 508
 509struct mwifiex_band_config {
 510	u8 chan_band:2;
 511	u8 chan_width:2;
 512	u8 chan2_offset:2;
 513	u8 scan_mode:2;
 514} __packed;
 515
 516struct mwifiex_channel_band {
 517	struct mwifiex_band_config band_config;
 518	u8 channel;
 519};
 520
 521struct mwifiex_private {
 522	struct mwifiex_adapter *adapter;
 523	u8 bss_type;
 524	u8 bss_role;
 525	u8 bss_priority;
 526	u8 bss_num;
 527	u8 bss_started;
 528	u8 auth_flag;
 529	u16 auth_alg;
 530	u8 frame_type;
 531	u8 curr_addr[ETH_ALEN];
 532	u8 media_connected;
 533	u8 port_open;
 534	u8 usb_port;
 535	u32 num_tx_timeout;
 536	/* track consecutive timeout */
 537	u8 tx_timeout_cnt;
 538	struct net_device *netdev;
 539	struct net_device_stats stats;
 540	u32 curr_pkt_filter;
 541	u32 bss_mode;
 542	u32 pkt_tx_ctrl;
 543	u16 tx_power_level;
 544	u8 max_tx_power_level;
 545	u8 min_tx_power_level;
 546	u32 tx_ant;
 547	u32 rx_ant;
 548	u8 tx_rate;
 549	u8 tx_htinfo;
 550	u8 rxpd_htinfo;
 551	u8 rxpd_rate;
 552	u16 rate_bitmap;
 553	u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
 554	u32 data_rate;
 555	u8 is_data_rate_auto;
 556	u16 bcn_avg_factor;
 557	u16 data_avg_factor;
 558	s16 data_rssi_last;
 559	s16 data_nf_last;
 560	s16 data_rssi_avg;
 561	s16 data_nf_avg;
 562	s16 bcn_rssi_last;
 563	s16 bcn_nf_last;
 564	s16 bcn_rssi_avg;
 565	s16 bcn_nf_avg;
 566	struct mwifiex_bssdescriptor *attempted_bss_desc;
 567	struct cfg80211_ssid prev_ssid;
 568	u8 prev_bssid[ETH_ALEN];
 569	struct mwifiex_current_bss_params curr_bss_params;
 570	u16 beacon_period;
 571	u8 dtim_period;
 572	u16 listen_interval;
 573	u16 atim_window;
 574	u8 adhoc_channel;
 575	u8 adhoc_state;
 576	struct mwifiex_802_11_security sec_info;
 577	struct mwifiex_wep_key wep_key[NUM_WEP_KEYS];
 578	u16 wep_key_curr_index;
 579	u8 wpa_ie[256];
 580	u16 wpa_ie_len;
 581	u8 wpa_is_gtk_set;
 582	struct host_cmd_ds_802_11_key_material aes_key;
 583	struct host_cmd_ds_802_11_key_material_v2 aes_key_v2;
 584	u8 wapi_ie[256];
 585	u16 wapi_ie_len;
 586	u8 *wps_ie;
 587	u16 wps_ie_len;
 588	u8 wmm_required;
 589	u8 wmm_enabled;
 590	u8 wmm_qosinfo;
 591	struct mwifiex_wmm_desc wmm;
 592	atomic_t wmm_tx_pending[IEEE80211_NUM_ACS];
 593	struct list_head sta_list;
 594	/* spin lock for associated station/TDLS peers list */
 595	spinlock_t sta_list_spinlock;
 596	struct list_head auto_tdls_list;
 597	/* spin lock for auto TDLS peer list */
 598	spinlock_t auto_tdls_lock;
 599	struct list_head tx_ba_stream_tbl_ptr;
 600	/* spin lock for tx_ba_stream_tbl_ptr queue */
 601	spinlock_t tx_ba_stream_tbl_lock;
 602	struct mwifiex_tx_aggr aggr_prio_tbl[MAX_NUM_TID];
 603	struct mwifiex_add_ba_param add_ba_param;
 604	u16 rx_seq[MAX_NUM_TID];
 605	u8 tos_to_tid_inv[MAX_NUM_TID];
 606	struct list_head rx_reorder_tbl_ptr;
 607	/* spin lock for rx_reorder_tbl_ptr queue */
 608	spinlock_t rx_reorder_tbl_lock;
 609#define MWIFIEX_ASSOC_RSP_BUF_SIZE  500
 610	u8 assoc_rsp_buf[MWIFIEX_ASSOC_RSP_BUF_SIZE];
 611	u32 assoc_rsp_size;
 612	struct cfg80211_bss *req_bss;
 613
 614#define MWIFIEX_GENIE_BUF_SIZE      256
 615	u8 gen_ie_buf[MWIFIEX_GENIE_BUF_SIZE];
 616	u8 gen_ie_buf_len;
 617
 618	struct mwifiex_vendor_spec_cfg_ie vs_ie[MWIFIEX_MAX_VSIE_NUM];
 619
 620#define MWIFIEX_ASSOC_TLV_BUF_SIZE  256
 621	u8 assoc_tlv_buf[MWIFIEX_ASSOC_TLV_BUF_SIZE];
 622	u8 assoc_tlv_buf_len;
 623
 624	u8 *curr_bcn_buf;
 625	u32 curr_bcn_size;
 626	/* spin lock for beacon buffer */
 627	spinlock_t curr_bcn_buf_lock;
 628	struct wireless_dev wdev;
 629	struct mwifiex_chan_freq_power cfp;
 630	u32 versionstrsel;
 631	char version_str[MWIFIEX_VERSION_STR_LENGTH];
 632#ifdef CONFIG_DEBUG_FS
 633	struct dentry *dfs_dev_dir;
 634#endif
 635	u16 current_key_index;
 636	struct mutex async_mutex;
 637	struct cfg80211_scan_request *scan_request;
 638	u8 cfg_bssid[6];
 639	struct wps wps;
 640	u8 scan_block;
 641	s32 cqm_rssi_thold;
 642	u32 cqm_rssi_hyst;
 643	u8 subsc_evt_rssi_state;
 644	struct mwifiex_ds_misc_subsc_evt async_subsc_evt_storage;
 645	struct mwifiex_ie mgmt_ie[MAX_MGMT_IE_INDEX];
 646	u16 beacon_idx;
 647	u16 proberesp_idx;
 648	u16 assocresp_idx;
 649	u16 gen_idx;
 650	u8 ap_11n_enabled;
 651	u8 ap_11ac_enabled;
 652	bool host_mlme_reg;
 653	u32 mgmt_frame_mask;
 654	struct mwifiex_roc_cfg roc_cfg;
 655	bool scan_aborting;
 656	u8 sched_scanning;
 657	u8 csa_chan;
 658	unsigned long csa_expire_time;
 659	u8 del_list_idx;
 660	bool hs2_enabled;
 661	struct mwifiex_uap_bss_param bss_cfg;
 662	struct cfg80211_chan_def bss_chandef;
 663	struct station_parameters *sta_params;
 664	struct sk_buff_head tdls_txq;
 665	u8 check_tdls_tx;
 666	struct timer_list auto_tdls_timer;
 667	bool auto_tdls_timer_active;
 668	struct idr ack_status_frames;
 669	/* spin lock for ack status */
 670	spinlock_t ack_status_lock;
 671	/** rx histogram data */
 672	struct mwifiex_histogram_data *hist_data;
 673	struct cfg80211_chan_def dfs_chandef;
 674	struct workqueue_struct *dfs_cac_workqueue;
 675	struct delayed_work dfs_cac_work;
 676	struct workqueue_struct *dfs_chan_sw_workqueue;
 677	struct delayed_work dfs_chan_sw_work;
 678	struct cfg80211_beacon_data beacon_after;
 679	struct mwifiex_11h_intf_state state_11h;
 680	struct mwifiex_ds_mem_rw mem_rw;
 681	struct sk_buff_head bypass_txq;
 682	struct mwifiex_user_scan_chan hidden_chan[MWIFIEX_USER_SCAN_CHAN_MAX];
 683	bool ht_param_present;
 684};
 685
 686
 687struct mwifiex_tx_ba_stream_tbl {
 688	struct list_head list;
 689	int tid;
 690	u8 ra[ETH_ALEN];
 691	enum mwifiex_ba_status ba_status;
 692	u8 amsdu;
 693};
 694
 695struct mwifiex_rx_reorder_tbl;
 696
 697struct reorder_tmr_cnxt {
 698	struct timer_list timer;
 699	struct mwifiex_rx_reorder_tbl *ptr;
 700	struct mwifiex_private *priv;
 701	u8 timer_is_set;
 702};
 703
 704struct mwifiex_rx_reorder_tbl {
 705	struct list_head list;
 706	int tid;
 707	u8 ta[ETH_ALEN];
 708	int init_win;
 709	int start_win;
 710	int win_size;
 711	void **rx_reorder_ptr;
 712	struct reorder_tmr_cnxt timer_context;
 713	u8 amsdu;
 714	u8 flags;
 715};
 716
 717struct mwifiex_bss_prio_node {
 718	struct list_head list;
 719	struct mwifiex_private *priv;
 720};
 721
 722struct mwifiex_bss_prio_tbl {
 723	struct list_head bss_prio_head;
 724	/* spin lock for bss priority  */
 725	spinlock_t bss_prio_lock;
 726	struct mwifiex_bss_prio_node *bss_prio_cur;
 727};
 728
 729struct cmd_ctrl_node {
 730	struct list_head list;
 731	struct mwifiex_private *priv;
 732	u32 cmd_no;
 733	u32 cmd_flag;
 734	struct sk_buff *cmd_skb;
 735	struct sk_buff *resp_skb;
 736	void *data_buf;
 737	u32 wait_q_enabled;
 738	struct sk_buff *skb;
 739	u8 *condition;
 740	u8 cmd_wait_q_woken;
 741};
 742
 743struct mwifiex_bss_priv {
 744	u8 band;
 745	u64 fw_tsf;
 746};
 747
 748struct mwifiex_tdls_capab {
 749	__le16 capab;
 750	u8 rates[32];
 751	u8 rates_len;
 752	u8 qos_info;
 753	u8 coex_2040;
 754	u16 aid;
 755	struct ieee80211_ht_cap ht_capb;
 756	struct ieee80211_ht_operation ht_oper;
 757	struct ieee_types_extcap extcap;
 758	struct ieee_types_generic rsn_ie;
 759	struct ieee80211_vht_cap vhtcap;
 760	struct ieee80211_vht_operation vhtoper;
 761};
 762
 763struct mwifiex_station_stats {
 764	u64 last_rx;
 765	s8 rssi;
 766	u64 rx_bytes;
 767	u64 tx_bytes;
 768	u32 rx_packets;
 769	u32 tx_packets;
 770	u32 tx_failed;
 771	u8 last_tx_rate;
 772	u8 last_tx_htinfo;
 773};
 774
 775/* This is AP/TDLS specific structure which stores information
 776 * about associated/peer STA
 777 */
 778struct mwifiex_sta_node {
 779	struct list_head list;
 780	u8 mac_addr[ETH_ALEN];
 781	u8 is_wmm_enabled;
 782	u8 is_11n_enabled;
 783	u8 is_11ac_enabled;
 784	u8 ampdu_sta[MAX_NUM_TID];
 785	u16 rx_seq[MAX_NUM_TID];
 786	u16 max_amsdu;
 787	u8 tdls_status;
 788	struct mwifiex_tdls_capab tdls_cap;
 789	struct mwifiex_station_stats stats;
 790	u8 tx_pause;
 791};
 792
 793struct mwifiex_auto_tdls_peer {
 794	struct list_head list;
 795	u8 mac_addr[ETH_ALEN];
 796	u8 tdls_status;
 797	int rssi;
 798	unsigned long rssi_jiffies;
 799	u8 failure_count;
 800	u8 do_discover;
 801};
 802
 803#define MWIFIEX_TYPE_AGGR_DATA_V2 11
 804#define MWIFIEX_BUS_AGGR_MODE_LEN_V2 (2)
 805#define MWIFIEX_BUS_AGGR_MAX_LEN 16000
 806#define MWIFIEX_BUS_AGGR_MAX_NUM 10
 807struct bus_aggr_params {
 808	u16 enable;
 809	u16 mode;
 810	u16 tx_aggr_max_size;
 811	u16 tx_aggr_max_num;
 812	u16 tx_aggr_align;
 813};
 814
 815struct mwifiex_if_ops {
 816	int (*init_if) (struct mwifiex_adapter *);
 817	void (*cleanup_if) (struct mwifiex_adapter *);
 818	int (*check_fw_status) (struct mwifiex_adapter *, u32);
 819	int (*check_winner_status)(struct mwifiex_adapter *);
 820	int (*prog_fw) (struct mwifiex_adapter *, struct mwifiex_fw_image *);
 821	int (*register_dev) (struct mwifiex_adapter *);
 822	void (*unregister_dev) (struct mwifiex_adapter *);
 823	int (*enable_int) (struct mwifiex_adapter *);
 824	void (*disable_int) (struct mwifiex_adapter *);
 825	int (*process_int_status) (struct mwifiex_adapter *);
 826	int (*host_to_card) (struct mwifiex_adapter *, u8, struct sk_buff *,
 827			     struct mwifiex_tx_param *);
 828	int (*wakeup) (struct mwifiex_adapter *);
 829	int (*wakeup_complete) (struct mwifiex_adapter *);
 830
 831	/* Interface specific functions */
 832	void (*update_mp_end_port) (struct mwifiex_adapter *, u16);
 833	void (*cleanup_mpa_buf) (struct mwifiex_adapter *);
 834	int (*cmdrsp_complete) (struct mwifiex_adapter *, struct sk_buff *);
 835	int (*event_complete) (struct mwifiex_adapter *, struct sk_buff *);
 836	void (*init_fw_port)(struct mwifiex_adapter *adapter);
 837	int (*dnld_fw) (struct mwifiex_adapter *, struct mwifiex_fw_image *);
 838	void (*card_reset) (struct mwifiex_adapter *);
 839	int (*reg_dump)(struct mwifiex_adapter *, char *);
 840	void (*device_dump)(struct mwifiex_adapter *);
 841	void (*clean_pcie_ring)(struct mwifiex_adapter *adapter);
 842	void (*iface_work)(struct work_struct *work);
 843	void (*submit_rem_rx_urbs)(struct mwifiex_adapter *adapter);
 844	void (*deaggr_pkt)(struct mwifiex_adapter *, struct sk_buff *);
 845	void (*multi_port_resync)(struct mwifiex_adapter *);
 846	bool (*is_port_ready)(struct mwifiex_private *);
 847	void (*down_dev)(struct mwifiex_adapter *);
 848	void (*up_dev)(struct mwifiex_adapter *);
 849};
 850
 851struct mwifiex_adapter {
 852	u8 iface_type;
 853	unsigned int debug_mask;
 854	struct mwifiex_iface_comb iface_limit;
 855	struct mwifiex_iface_comb curr_iface_comb;
 856	struct mwifiex_private *priv[MWIFIEX_MAX_BSS_NUM];
 857	u8 priv_num;
 858	const struct firmware *firmware;
 859	char fw_name[32];
 860	int winner;
 861	struct device *dev;
 862	struct wiphy *wiphy;
 863	u8 perm_addr[ETH_ALEN];
 864	unsigned long work_flags;
 865	u32 fw_release_number;
 866	u8 intf_hdr_len;
 867	void *card;
 868	struct mwifiex_if_ops if_ops;
 869	atomic_t bypass_tx_pending;
 870	atomic_t rx_pending;
 871	atomic_t tx_pending;
 872	atomic_t cmd_pending;
 873	atomic_t tx_hw_pending;
 874	struct workqueue_struct *workqueue;
 875	struct work_struct main_work;
 876	struct workqueue_struct *rx_workqueue;
 877	struct work_struct rx_work;
 878	struct workqueue_struct *host_mlme_workqueue;
 879	struct work_struct host_mlme_work;
 880	bool rx_work_enabled;
 881	bool rx_processing;
 882	bool delay_main_work;
 883	bool rx_locked;
 884	bool main_locked;
 885	struct mwifiex_bss_prio_tbl bss_prio_tbl[MWIFIEX_MAX_BSS_NUM];
 886	/* spin lock for main process */
 887	spinlock_t main_proc_lock;
 888	u32 mwifiex_processing;
 889	u8 more_task_flag;
 890	u16 tx_buf_size;
 891	u16 curr_tx_buf_size;
 892	/* sdio single port rx aggregation capability */
 893	bool host_disable_sdio_rx_aggr;
 894	bool sdio_rx_aggr_enable;
 895	u16 sdio_rx_block_size;
 896	u32 ioport;
 897	enum MWIFIEX_HARDWARE_STATUS hw_status;
 898	u16 number_of_antenna;
 899	u32 fw_cap_info;
 900	/* spin lock for interrupt handling */
 901	spinlock_t int_lock;
 902	u8 int_status;
 903	u32 event_cause;
 904	struct sk_buff *event_skb;
 905	u8 upld_buf[MWIFIEX_UPLD_SIZE];
 906	u8 data_sent;
 907	u8 cmd_sent;
 908	u8 cmd_resp_received;
 909	u8 event_received;
 910	u8 data_received;
 911	u8 assoc_resp_received;
 912	struct mwifiex_private *priv_link_lost;
 913	u8 host_mlme_link_lost;
 914	u16 seq_num;
 915	struct cmd_ctrl_node *cmd_pool;
 916	struct cmd_ctrl_node *curr_cmd;
 917	/* spin lock for command */
 918	spinlock_t mwifiex_cmd_lock;
 919	struct timer_list cmd_timer;
 920	struct list_head cmd_free_q;
 921	/* spin lock for cmd_free_q */
 922	spinlock_t cmd_free_q_lock;
 923	struct list_head cmd_pending_q;
 924	/* spin lock for cmd_pending_q */
 925	spinlock_t cmd_pending_q_lock;
 926	struct list_head scan_pending_q;
 927	/* spin lock for scan_pending_q */
 928	spinlock_t scan_pending_q_lock;
 929	/* spin lock for RX processing routine */
 930	spinlock_t rx_proc_lock;
 931	struct sk_buff_head tx_data_q;
 932	atomic_t tx_queued;
 933	u32 scan_processing;
 934	u16 region_code;
 935	struct mwifiex_802_11d_domain_reg domain_reg;
 936	u16 scan_probes;
 937	u32 scan_mode;
 938	u16 specific_scan_time;
 939	u16 active_scan_time;
 940	u16 passive_scan_time;
 941	u16 scan_chan_gap_time;
 942	u8 fw_bands;
 943	u8 adhoc_start_band;
 944	u8 config_bands;
 945	u8 tx_lock_flag;
 946	struct mwifiex_sleep_period sleep_period;
 947	u16 ps_mode;
 948	u32 ps_state;
 949	u8 need_to_wakeup;
 950	u16 multiple_dtim;
 951	u16 local_listen_interval;
 952	u16 null_pkt_interval;
 953	struct sk_buff *sleep_cfm;
 954	u16 bcn_miss_time_out;
 955	u16 adhoc_awake_period;
 956	u8 is_deep_sleep;
 957	u8 delay_null_pkt;
 958	u16 delay_to_ps;
 959	u16 enhanced_ps_mode;
 960	u8 pm_wakeup_card_req;
 961	u16 gen_null_pkt;
 962	u16 pps_uapsd_mode;
 963	u32 pm_wakeup_fw_try;
 964	struct timer_list wakeup_timer;
 965	struct mwifiex_hs_config_param hs_cfg;
 966	u8 hs_activated;
 967	u8 hs_activated_manually;
 968	u16 hs_activate_wait_q_woken;
 969	wait_queue_head_t hs_activate_wait_q;
 970	u8 event_body[MAX_EVENT_SIZE];
 971	u32 hw_dot_11n_dev_cap;
 972	u8 hw_dev_mcs_support;
 973	u8 user_dev_mcs_support;
 974	u8 adhoc_11n_enabled;
 975	u8 sec_chan_offset;
 976	struct mwifiex_dbg dbg;
 977	u8 arp_filter[ARP_FILTER_MAX_BUF_SIZE];
 978	u32 arp_filter_size;
 979	struct mwifiex_wait_queue cmd_wait_q;
 980	u8 scan_wait_q_woken;
 981	spinlock_t queue_lock;		/* lock for tx queues */
 982	u8 country_code[IEEE80211_COUNTRY_STRING_LEN];
 983	u16 max_mgmt_ie_index;
 984	const struct firmware *cal_data;
 985	const struct firmware *rgpower_data;
 986	struct device_node *dt_node;
 987
 988	/* 11AC */
 989	u32 is_hw_11ac_capable;
 990	u32 hw_dot_11ac_dev_cap;
 991	u32 hw_dot_11ac_mcs_support;
 992	u32 usr_dot_11ac_dev_cap_bg;
 993	u32 usr_dot_11ac_dev_cap_a;
 994	u32 usr_dot_11ac_mcs_support;
 995
 996	atomic_t pending_bridged_pkts;
 997
 998	/* For synchronizing FW initialization with device lifecycle. */
 999	struct completion *fw_done;
1000	bool is_up;
1001
1002	bool ext_scan;
1003	bool host_mlme_enabled;
1004	struct ieee80211_txrx_stypes mwifiex_mgmt_stypes[NUM_NL80211_IFTYPES];
1005	u8 fw_api_ver;
1006	u8 key_api_major_ver, key_api_minor_ver;
1007	u8 max_p2p_conn, max_sta_conn;
1008	struct memory_type_mapping *mem_type_mapping_tbl;
1009	u8 num_mem_types;
1010	bool scan_chan_gap_enabled;
1011	struct sk_buff_head rx_data_q;
1012	bool mfg_mode;
1013	struct mwifiex_chan_stats *chan_stats;
1014	u32 num_in_chan_stats;
1015	int survey_idx;
1016	bool auto_tdls;
1017	u8 coex_scan;
1018	u8 coex_min_scan_time;
1019	u8 coex_max_scan_time;
1020	u8 coex_win_size;
1021	u8 coex_tx_win_size;
1022	u8 coex_rx_win_size;
1023	bool drcs_enabled;
1024	u8 active_scan_triggered;
1025	bool usb_mc_status;
1026	bool usb_mc_setup;
1027	struct cfg80211_wowlan_nd_info *nd_info;
1028	struct ieee80211_regdomain *regd;
1029
1030	/* Wake-on-WLAN (WoWLAN) */
1031	int irq_wakeup;
1032	bool wake_by_wifi;
1033	/* Aggregation parameters*/
1034	struct bus_aggr_params bus_aggr;
1035	/* Device dump data/length */
1036	void *devdump_data;
1037	int devdump_len;
1038	struct delayed_work devdump_work;
1039
1040	bool ignore_btcoex_events;
1041};
1042
1043void mwifiex_process_tx_queue(struct mwifiex_adapter *adapter);
1044
1045int mwifiex_init_lock_list(struct mwifiex_adapter *adapter);
1046
1047void mwifiex_set_trans_start(struct net_device *dev);
1048
1049void mwifiex_stop_net_dev_queue(struct net_device *netdev,
1050		struct mwifiex_adapter *adapter);
1051
1052void mwifiex_wake_up_net_dev_queue(struct net_device *netdev,
1053		struct mwifiex_adapter *adapter);
1054
1055int mwifiex_init_priv(struct mwifiex_private *priv);
1056void mwifiex_free_priv(struct mwifiex_private *priv);
1057
1058int mwifiex_init_fw(struct mwifiex_adapter *adapter);
1059
1060void mwifiex_shutdown_drv(struct mwifiex_adapter *adapter);
1061
1062int mwifiex_dnld_fw(struct mwifiex_adapter *, struct mwifiex_fw_image *);
1063
1064int mwifiex_recv_packet(struct mwifiex_private *priv, struct sk_buff *skb);
1065int mwifiex_uap_recv_packet(struct mwifiex_private *priv,
1066			    struct sk_buff *skb);
1067
1068void mwifiex_host_mlme_disconnect(struct mwifiex_private *priv,
1069				  u16 reason_code, u8 *sa);
1070
1071int mwifiex_process_mgmt_packet(struct mwifiex_private *priv,
1072				struct sk_buff *skb);
1073
1074int mwifiex_process_event(struct mwifiex_adapter *adapter);
1075
1076int mwifiex_complete_cmd(struct mwifiex_adapter *adapter,
1077			 struct cmd_ctrl_node *cmd_node);
1078
1079int mwifiex_send_cmd(struct mwifiex_private *priv, u16 cmd_no,
1080		     u16 cmd_action, u32 cmd_oid, void *data_buf, bool sync);
1081
1082void mwifiex_cmd_timeout_func(struct timer_list *t);
1083
1084int mwifiex_get_debug_info(struct mwifiex_private *,
1085			   struct mwifiex_debug_info *);
1086
1087int mwifiex_alloc_cmd_buffer(struct mwifiex_adapter *adapter);
1088void mwifiex_free_cmd_buffer(struct mwifiex_adapter *adapter);
1089void mwifiex_free_cmd_buffers(struct mwifiex_adapter *adapter);
1090void mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter);
1091void mwifiex_cancel_pending_scan_cmd(struct mwifiex_adapter *adapter);
1092void mwifiex_cancel_scan(struct mwifiex_adapter *adapter);
1093
1094void mwifiex_recycle_cmd_node(struct mwifiex_adapter *adapter,
1095			      struct cmd_ctrl_node *cmd_node);
1096
1097void mwifiex_insert_cmd_to_pending_q(struct mwifiex_adapter *adapter,
1098				     struct cmd_ctrl_node *cmd_node);
1099
1100int mwifiex_exec_next_cmd(struct mwifiex_adapter *adapter);
1101int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter);
1102void mwifiex_process_assoc_resp(struct mwifiex_adapter *adapter);
1103int mwifiex_handle_rx_packet(struct mwifiex_adapter *adapter,
1104			     struct sk_buff *skb);
1105int mwifiex_process_tx(struct mwifiex_private *priv, struct sk_buff *skb,
1106		       struct mwifiex_tx_param *tx_param);
1107int mwifiex_send_null_packet(struct mwifiex_private *priv, u8 flags);
1108int mwifiex_write_data_complete(struct mwifiex_adapter *adapter,
1109				struct sk_buff *skb, int aggr, int status);
1110void mwifiex_clean_txrx(struct mwifiex_private *priv);
1111u8 mwifiex_check_last_packet_indication(struct mwifiex_private *priv);
1112void mwifiex_check_ps_cond(struct mwifiex_adapter *adapter);
1113void mwifiex_process_sleep_confirm_resp(struct mwifiex_adapter *, u8 *,
1114					u32);
1115int mwifiex_cmd_enh_power_mode(struct mwifiex_private *priv,
1116			       struct host_cmd_ds_command *cmd,
1117			       u16 cmd_action, uint16_t ps_bitmap,
1118			       struct mwifiex_ds_auto_ds *auto_ds);
1119int mwifiex_ret_enh_power_mode(struct mwifiex_private *priv,
1120			       struct host_cmd_ds_command *resp,
1121			       struct mwifiex_ds_pm_cfg *pm_cfg);
1122void mwifiex_process_hs_config(struct mwifiex_adapter *adapter);
1123void mwifiex_hs_activated_event(struct mwifiex_adapter *adapter,
1124					u8 activated);
1125int mwifiex_set_hs_params(struct mwifiex_private *priv, u16 action,
1126			  int cmd_type, struct mwifiex_ds_hs_cfg *hs_cfg);
1127int mwifiex_ret_802_11_hs_cfg(struct mwifiex_private *priv,
1128			      struct host_cmd_ds_command *resp);
1129int mwifiex_process_rx_packet(struct mwifiex_private *priv,
1130			      struct sk_buff *skb);
1131int mwifiex_sta_prepare_cmd(struct mwifiex_private *, uint16_t cmd_no,
1132			    u16 cmd_action, u32 cmd_oid,
1133			    void *data_buf, void *cmd_buf);
1134int mwifiex_uap_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,
1135			    u16 cmd_action, u32 cmd_oid,
1136			    void *data_buf, void *cmd_buf);
1137int mwifiex_process_sta_cmdresp(struct mwifiex_private *, u16 cmdresp_no,
1138				struct host_cmd_ds_command *resp);
1139int mwifiex_process_sta_rx_packet(struct mwifiex_private *,
1140				  struct sk_buff *skb);
1141int mwifiex_process_uap_rx_packet(struct mwifiex_private *priv,
1142				  struct sk_buff *skb);
1143int mwifiex_handle_uap_rx_forward(struct mwifiex_private *priv,
1144				  struct sk_buff *skb);
1145int mwifiex_process_sta_event(struct mwifiex_private *);
1146int mwifiex_process_uap_event(struct mwifiex_private *);
1147void mwifiex_delete_all_station_list(struct mwifiex_private *priv);
1148void mwifiex_wmm_del_peer_ra_list(struct mwifiex_private *priv,
1149				  const u8 *ra_addr);
1150void mwifiex_process_sta_txpd(struct mwifiex_private *priv,
1151			      struct sk_buff *skb);
1152void mwifiex_process_uap_txpd(struct mwifiex_private *priv,
1153			      struct sk_buff *skb);
1154int mwifiex_sta_init_cmd(struct mwifiex_private *, u8 first_sta);
1155int mwifiex_cmd_802_11_scan(struct host_cmd_ds_command *cmd,
1156			    struct mwifiex_scan_cmd_config *scan_cfg);
1157void mwifiex_queue_scan_cmd(struct mwifiex_private *priv,
1158			    struct cmd_ctrl_node *cmd_node);
1159int mwifiex_ret_802_11_scan(struct mwifiex_private *priv,
1160			    struct host_cmd_ds_command *resp);
1161int mwifiex_associate(struct mwifiex_private *priv,
1162		      struct mwifiex_bssdescriptor *bss_desc);
1163int mwifiex_cmd_802_11_associate(struct mwifiex_private *priv,
1164				 struct host_cmd_ds_command *cmd,
1165				 struct mwifiex_bssdescriptor *bss_desc);
1166int mwifiex_ret_802_11_associate(struct mwifiex_private *priv,
1167				 struct host_cmd_ds_command *resp);
1168void mwifiex_reset_connect_state(struct mwifiex_private *priv, u16 reason,
1169				 bool from_ap);
1170u8 mwifiex_band_to_radio_type(u8 band);
1171int mwifiex_deauthenticate(struct mwifiex_private *priv, u8 *mac);
1172void mwifiex_deauthenticate_all(struct mwifiex_adapter *adapter);
1173int mwifiex_adhoc_start(struct mwifiex_private *priv,
1174			struct cfg80211_ssid *adhoc_ssid);
1175int mwifiex_adhoc_join(struct mwifiex_private *priv,
1176		       struct mwifiex_bssdescriptor *bss_desc);
1177int mwifiex_cmd_802_11_ad_hoc_start(struct mwifiex_private *priv,
1178				    struct host_cmd_ds_command *cmd,
1179				    struct cfg80211_ssid *req_ssid);
1180int mwifiex_cmd_802_11_ad_hoc_join(struct mwifiex_private *priv,
1181				   struct host_cmd_ds_command *cmd,
1182				   struct mwifiex_bssdescriptor *bss_desc);
1183int mwifiex_ret_802_11_ad_hoc(struct mwifiex_private *priv,
1184			      struct host_cmd_ds_command *resp);
1185int mwifiex_cmd_802_11_bg_scan_query(struct host_cmd_ds_command *cmd);
1186struct mwifiex_chan_freq_power *mwifiex_get_cfp(struct mwifiex_private *priv,
1187						u8 band, u16 channel, u32 freq);
1188u32 mwifiex_index_to_data_rate(struct mwifiex_private *priv,
1189			       u8 index, u8 ht_info);
1190u32 mwifiex_index_to_acs_data_rate(struct mwifiex_private *priv,
1191				   u8 index, u8 ht_info);
1192u32 mwifiex_find_freq_from_band_chan(u8, u8);
1193int mwifiex_cmd_append_vsie_tlv(struct mwifiex_private *priv, u16 vsie_mask,
1194				u8 **buffer);
1195u32 mwifiex_get_active_data_rates(struct mwifiex_private *priv,
1196				    u8 *rates);
1197u32 mwifiex_get_supported_rates(struct mwifiex_private *priv, u8 *rates);
1198u32 mwifiex_get_rates_from_cfg80211(struct mwifiex_private *priv,
1199				    u8 *rates, u8 radio_type);
1200u8 mwifiex_is_rate_auto(struct mwifiex_private *priv);
1201extern u16 region_code_index[MWIFIEX_MAX_REGION_CODE];
1202void mwifiex_save_curr_bcn(struct mwifiex_private *priv);
1203void mwifiex_free_curr_bcn(struct mwifiex_private *priv);
1204int mwifiex_cmd_get_hw_spec(struct mwifiex_private *priv,
1205			    struct host_cmd_ds_command *cmd);
1206int mwifiex_ret_get_hw_spec(struct mwifiex_private *priv,
1207			    struct host_cmd_ds_command *resp);
1208int is_command_pending(struct mwifiex_adapter *adapter);
1209void mwifiex_init_priv_params(struct mwifiex_private *priv,
1210						struct net_device *dev);
1211int mwifiex_set_secure_params(struct mwifiex_private *priv,
1212			      struct mwifiex_uap_bss_param *bss_config,
1213			      struct cfg80211_ap_settings *params);
1214void mwifiex_set_ht_params(struct mwifiex_private *priv,
1215			   struct mwifiex_uap_bss_param *bss_cfg,
1216			   struct cfg80211_ap_settings *params);
1217void mwifiex_set_vht_params(struct mwifiex_private *priv,
1218			    struct mwifiex_uap_bss_param *bss_cfg,
1219			    struct cfg80211_ap_settings *params);
1220void mwifiex_set_tpc_params(struct mwifiex_private *priv,
1221			    struct mwifiex_uap_bss_param *bss_cfg,
1222			    struct cfg80211_ap_settings *params);
1223void mwifiex_set_uap_rates(struct mwifiex_uap_bss_param *bss_cfg,
1224			   struct cfg80211_ap_settings *params);
1225void mwifiex_set_vht_width(struct mwifiex_private *priv,
1226			   enum nl80211_chan_width width,
1227			   bool ap_11ac_disable);
1228void
1229mwifiex_set_wmm_params(struct mwifiex_private *priv,
1230		       struct mwifiex_uap_bss_param *bss_cfg,
1231		       struct cfg80211_ap_settings *params);
1232void mwifiex_set_ba_params(struct mwifiex_private *priv);
1233
1234void mwifiex_update_ampdu_txwinsize(struct mwifiex_adapter *pmadapter);
1235void mwifiex_bt_coex_wlan_param_update_event(struct mwifiex_private *priv,
1236					     struct sk_buff *event_skb);
1237
1238void mwifiex_set_11ac_ba_params(struct mwifiex_private *priv);
1239int mwifiex_cmd_802_11_scan_ext(struct mwifiex_private *priv,
1240				struct host_cmd_ds_command *cmd,
1241				void *data_buf);
1242int mwifiex_ret_802_11_scan_ext(struct mwifiex_private *priv,
1243				struct host_cmd_ds_command *resp);
1244int mwifiex_handle_event_ext_scan_report(struct mwifiex_private *priv,
1245					 void *buf);
1246int mwifiex_cmd_802_11_bg_scan_config(struct mwifiex_private *priv,
1247				      struct host_cmd_ds_command *cmd,
1248				      void *data_buf);
1249int mwifiex_stop_bg_scan(struct mwifiex_private *priv);
1250
1251/*
1252 * This function checks if the queuing is RA based or not.
1253 */
1254static inline u8
1255mwifiex_queuing_ra_based(struct mwifiex_private *priv)
1256{
1257	/*
1258	 * Currently we assume if we are in Infra, then DA=RA. This might not be
1259	 * true in the future
1260	 */
1261	if ((priv->bss_mode == NL80211_IFTYPE_STATION ||
1262	     priv->bss_mode == NL80211_IFTYPE_P2P_CLIENT) &&
1263	    (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA))
1264		return false;
1265
1266	return true;
1267}
1268
1269/*
1270 * This function copies rates.
1271 */
1272static inline u32
1273mwifiex_copy_rates(u8 *dest, u32 pos, u8 *src, int len)
1274{
1275	int i;
1276
1277	for (i = 0; i < len && src[i]; i++, pos++) {
1278		if (pos >= MWIFIEX_SUPPORTED_RATES)
1279			break;
1280		dest[pos] = src[i];
1281	}
1282
1283	return pos;
1284}
1285
1286/*
1287 * This function returns the correct private structure pointer based
1288 * upon the BSS type and BSS number.
1289 */
1290static inline struct mwifiex_private *
1291mwifiex_get_priv_by_id(struct mwifiex_adapter *adapter,
1292		       u8 bss_num, u8 bss_type)
1293{
1294	int i;
1295
1296	for (i = 0; i < adapter->priv_num; i++) {
1297		if (adapter->priv[i]->bss_mode == NL80211_IFTYPE_UNSPECIFIED)
1298			continue;
1299
1300		if ((adapter->priv[i]->bss_num == bss_num) &&
1301		    (adapter->priv[i]->bss_type == bss_type))
1302			break;
1303	}
1304	return ((i < adapter->priv_num) ? adapter->priv[i] : NULL);
1305}
1306
1307/*
1308 * This function returns the first available private structure pointer
1309 * based upon the BSS role.
1310 */
1311static inline struct mwifiex_private *
1312mwifiex_get_priv(struct mwifiex_adapter *adapter,
1313		 enum mwifiex_bss_role bss_role)
1314{
1315	int i;
1316
1317	for (i = 0; i < adapter->priv_num; i++) {
1318		if (bss_role == MWIFIEX_BSS_ROLE_ANY ||
1319		    GET_BSS_ROLE(adapter->priv[i]) == bss_role)
1320			break;
1321	}
1322
1323	return ((i < adapter->priv_num) ? adapter->priv[i] : NULL);
1324}
1325
1326/*
1327 * This function checks available bss_num when adding new interface or
1328 * changing interface type.
1329 */
1330static inline u8
1331mwifiex_get_unused_bss_num(struct mwifiex_adapter *adapter, u8 bss_type)
1332{
1333	u8 i, j;
1334	int index[MWIFIEX_MAX_BSS_NUM];
1335
1336	memset(index, 0, sizeof(index));
1337	for (i = 0; i < adapter->priv_num; i++)
1338		if (adapter->priv[i]->bss_type == bss_type &&
1339		    !(adapter->priv[i]->bss_mode ==
1340		      NL80211_IFTYPE_UNSPECIFIED)) {
1341			index[adapter->priv[i]->bss_num] = 1;
1342		}
1343	for (j = 0; j < MWIFIEX_MAX_BSS_NUM; j++)
1344		if (!index[j])
1345			return j;
1346	return -1;
1347}
1348
1349/*
1350 * This function returns the first available unused private structure pointer.
1351 */
1352static inline struct mwifiex_private *
1353mwifiex_get_unused_priv_by_bss_type(struct mwifiex_adapter *adapter,
1354				    u8 bss_type)
1355{
1356	u8 i;
1357
1358	for (i = 0; i < adapter->priv_num; i++)
1359		if (adapter->priv[i]->bss_mode ==
1360		   NL80211_IFTYPE_UNSPECIFIED) {
1361			adapter->priv[i]->bss_num =
1362			mwifiex_get_unused_bss_num(adapter, bss_type);
1363			break;
1364		}
1365
1366	return ((i < adapter->priv_num) ? adapter->priv[i] : NULL);
1367}
1368
1369/*
1370 * This function returns the driver private structure of a network device.
1371 */
1372static inline struct mwifiex_private *
1373mwifiex_netdev_get_priv(struct net_device *dev)
1374{
1375	return (struct mwifiex_private *) (*(unsigned long *) netdev_priv(dev));
1376}
1377
1378/*
1379 * This function checks if a skb holds a management frame.
1380 */
1381static inline bool mwifiex_is_skb_mgmt_frame(struct sk_buff *skb)
1382{
1383	return (get_unaligned_le32(skb->data) == PKT_TYPE_MGMT);
1384}
1385
1386/* This function retrieves channel closed for operation by Channel
1387 * Switch Announcement.
1388 */
1389static inline u8
1390mwifiex_11h_get_csa_closed_channel(struct mwifiex_private *priv)
1391{
1392	if (!priv->csa_chan)
1393		return 0;
1394
1395	/* Clear csa channel, if DFS channel move time has passed */
1396	if (time_after(jiffies, priv->csa_expire_time)) {
1397		priv->csa_chan = 0;
1398		priv->csa_expire_time = 0;
1399	}
1400
1401	return priv->csa_chan;
1402}
1403
1404static inline u8 mwifiex_is_any_intf_active(struct mwifiex_private *priv)
1405{
1406	struct mwifiex_private *priv_num;
1407	int i;
1408
1409	for (i = 0; i < priv->adapter->priv_num; i++) {
1410		priv_num = priv->adapter->priv[i];
1411		if (priv_num) {
1412			if ((GET_BSS_ROLE(priv_num) == MWIFIEX_BSS_ROLE_UAP &&
1413			     priv_num->bss_started) ||
1414			    (GET_BSS_ROLE(priv_num) == MWIFIEX_BSS_ROLE_STA &&
1415			     priv_num->media_connected))
1416				return 1;
1417		}
1418	}
1419
1420	return 0;
1421}
1422
1423static inline u8 mwifiex_is_tdls_link_setup(u8 status)
1424{
1425	switch (status) {
1426	case TDLS_SETUP_COMPLETE:
1427	case TDLS_CHAN_SWITCHING:
1428	case TDLS_IN_BASE_CHAN:
1429	case TDLS_IN_OFF_CHAN:
1430		return true;
1431	default:
1432		break;
1433	}
1434
1435	return false;
1436}
1437
1438/* Disable platform specific wakeup interrupt */
1439static inline void mwifiex_disable_wake(struct mwifiex_adapter *adapter)
1440{
1441	if (adapter->irq_wakeup >= 0) {
1442		disable_irq_wake(adapter->irq_wakeup);
1443		disable_irq(adapter->irq_wakeup);
1444		if (adapter->wake_by_wifi)
1445			/* Undo our disable, since interrupt handler already
1446			 * did this.
1447			 */
1448			enable_irq(adapter->irq_wakeup);
1449
1450	}
1451}
1452
1453/* Enable platform specific wakeup interrupt */
1454static inline void mwifiex_enable_wake(struct mwifiex_adapter *adapter)
1455{
1456	/* Enable platform specific wakeup interrupt */
1457	if (adapter->irq_wakeup >= 0) {
1458		adapter->wake_by_wifi = false;
1459		enable_irq(adapter->irq_wakeup);
1460		enable_irq_wake(adapter->irq_wakeup);
1461	}
1462}
1463
1464int mwifiex_init_shutdown_fw(struct mwifiex_private *priv,
1465			     u32 func_init_shutdown);
1466
1467int mwifiex_add_card(void *card, struct completion *fw_done,
1468		     const struct mwifiex_if_ops *if_ops, u8 iface_type,
1469		     struct device *dev);
1470int mwifiex_remove_card(struct mwifiex_adapter *adapter);
1471
1472void mwifiex_get_version(struct mwifiex_adapter *adapter, char *version,
1473			 int maxlen);
1474int mwifiex_request_set_multicast_list(struct mwifiex_private *priv,
1475			struct mwifiex_multicast_list *mcast_list);
1476int mwifiex_copy_mcast_addr(struct mwifiex_multicast_list *mlist,
1477			    struct net_device *dev);
1478int mwifiex_wait_queue_complete(struct mwifiex_adapter *adapter,
1479				struct cmd_ctrl_node *cmd_queued);
1480int mwifiex_bss_start(struct mwifiex_private *priv, struct cfg80211_bss *bss,
1481		      struct cfg80211_ssid *req_ssid);
1482int mwifiex_cancel_hs(struct mwifiex_private *priv, int cmd_type);
1483int mwifiex_enable_hs(struct mwifiex_adapter *adapter);
1484int mwifiex_disable_auto_ds(struct mwifiex_private *priv);
1485int mwifiex_drv_get_data_rate(struct mwifiex_private *priv, u32 *rate);
1486int mwifiex_request_scan(struct mwifiex_private *priv,
1487			 struct cfg80211_ssid *req_ssid);
1488int mwifiex_scan_networks(struct mwifiex_private *priv,
1489			  const struct mwifiex_user_scan_cfg *user_scan_in);
1490int mwifiex_set_radio(struct mwifiex_private *priv, u8 option);
1491
1492int mwifiex_set_encode(struct mwifiex_private *priv, struct key_params *kp,
1493		       const u8 *key, int key_len, u8 key_index,
1494		       const u8 *mac_addr, int disable);
1495
1496int mwifiex_set_gen_ie(struct mwifiex_private *priv, const u8 *ie, int ie_len);
1497
1498int mwifiex_get_ver_ext(struct mwifiex_private *priv, u32 version_str_sel);
1499
1500int mwifiex_remain_on_chan_cfg(struct mwifiex_private *priv, u16 action,
1501			       struct ieee80211_channel *chan,
1502			       unsigned int duration);
1503
1504int mwifiex_get_stats_info(struct mwifiex_private *priv,
1505			   struct mwifiex_ds_get_stats *log);
1506
1507int mwifiex_reg_write(struct mwifiex_private *priv, u32 reg_type,
1508		      u32 reg_offset, u32 reg_value);
1509
1510int mwifiex_reg_read(struct mwifiex_private *priv, u32 reg_type,
1511		     u32 reg_offset, u32 *value);
1512
1513int mwifiex_eeprom_read(struct mwifiex_private *priv, u16 offset, u16 bytes,
1514			u8 *value);
1515
1516int mwifiex_set_11n_httx_cfg(struct mwifiex_private *priv, int data);
1517
1518int mwifiex_get_11n_httx_cfg(struct mwifiex_private *priv, int *data);
1519
1520int mwifiex_set_tx_rate_cfg(struct mwifiex_private *priv, int tx_rate_index);
1521
1522int mwifiex_get_tx_rate_cfg(struct mwifiex_private *priv, int *tx_rate_index);
1523
1524int mwifiex_drv_set_power(struct mwifiex_private *priv, u32 *ps_mode);
1525
1526int mwifiex_drv_get_driver_version(struct mwifiex_adapter *adapter,
1527				   char *version, int max_len);
1528
1529int mwifiex_set_tx_power(struct mwifiex_private *priv,
1530			 struct mwifiex_power_cfg *power_cfg);
1531
1532int mwifiex_main_process(struct mwifiex_adapter *);
1533
1534int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb);
1535
1536int mwifiex_get_bss_info(struct mwifiex_private *,
1537			 struct mwifiex_bss_info *);
1538int mwifiex_fill_new_bss_desc(struct mwifiex_private *priv,
1539			      struct cfg80211_bss *bss,
1540			      struct mwifiex_bssdescriptor *bss_desc);
1541int mwifiex_update_bss_desc_with_ie(struct mwifiex_adapter *adapter,
1542				    struct mwifiex_bssdescriptor *bss_entry);
1543int mwifiex_check_network_compatibility(struct mwifiex_private *priv,
1544					struct mwifiex_bssdescriptor *bss_desc);
1545
1546u8 mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type);
1547u8 mwifiex_get_chan_type(struct mwifiex_private *priv);
1548
1549struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
1550					      const char *name,
1551					      unsigned char name_assign_type,
1552					      enum nl80211_iftype type,
1553					      struct vif_params *params);
1554int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev);
1555
1556void mwifiex_set_sys_config_invalid_data(struct mwifiex_uap_bss_param *config);
1557
1558int mwifiex_add_wowlan_magic_pkt_filter(struct mwifiex_adapter *adapter);
1559
1560int mwifiex_set_mgmt_ies(struct mwifiex_private *priv,
1561			 struct cfg80211_beacon_data *data);
1562int mwifiex_del_mgmt_ies(struct mwifiex_private *priv);
1563const u8 *mwifiex_11d_code_2_region(u8 code);
1564void mwifiex_uap_set_channel(struct mwifiex_private *priv,
1565			     struct mwifiex_uap_bss_param *bss_cfg,
1566			     struct cfg80211_chan_def chandef);
1567int mwifiex_config_start_uap(struct mwifiex_private *priv,
1568			     struct mwifiex_uap_bss_param *bss_cfg);
1569
1570void mwifiex_config_uap_11d(struct mwifiex_private *priv,
1571			    struct cfg80211_beacon_data *beacon_data);
1572
1573void mwifiex_init_11h_params(struct mwifiex_private *priv);
1574int mwifiex_is_11h_active(struct mwifiex_private *priv);
1575int mwifiex_11h_activate(struct mwifiex_private *priv, bool flag);
1576
1577void mwifiex_11h_process_join(struct mwifiex_private *priv, u8 **buffer,
1578			      struct mwifiex_bssdescriptor *bss_desc);
1579int mwifiex_11h_handle_event_chanswann(struct mwifiex_private *priv);
1580int mwifiex_dnld_dt_cfgdata(struct mwifiex_private *priv,
1581			    struct device_node *node, const char *prefix);
1582void mwifiex_dnld_txpwr_table(struct mwifiex_private *priv);
1583int mwifiex_send_rgpower_table(struct mwifiex_private *priv, const u8 *data,
1584			       const size_t size);
1585
1586extern const struct ethtool_ops mwifiex_ethtool_ops;
1587
1588void mwifiex_del_all_sta_list(struct mwifiex_private *priv);
1589void mwifiex_del_sta_entry(struct mwifiex_private *priv, const u8 *mac);
1590void
1591mwifiex_set_sta_ht_cap(struct mwifiex_private *priv, const u8 *ies,
1592		       int ies_len, struct mwifiex_sta_node *node);
1593struct mwifiex_sta_node *
1594mwifiex_add_sta_entry(struct mwifiex_private *priv, const u8 *mac);
1595struct mwifiex_sta_node *
1596mwifiex_get_sta_entry(struct mwifiex_private *priv, const u8 *mac);
1597u8 mwifiex_is_tdls_chan_switching(struct mwifiex_private *priv);
1598u8 mwifiex_is_send_cmd_allowed(struct mwifiex_private *priv);
1599int mwifiex_send_tdls_data_frame(struct mwifiex_private *priv, const u8 *peer,
1600				 u8 action_code, u8 dialog_token,
1601				 u16 status_code, const u8 *extra_ies,
1602				 size_t extra_ies_len);
1603int mwifiex_send_tdls_action_frame(struct mwifiex_private *priv, const u8 *peer,
1604				   u8 action_code, u8 dialog_token,
1605				   u16 status_code, const u8 *extra_ies,
1606				   size_t extra_ies_len);
1607void mwifiex_process_tdls_action_frame(struct mwifiex_private *priv,
1608				       u8 *buf, int len);
1609int mwifiex_tdls_oper(struct mwifiex_private *priv, const u8 *peer, u8 action);
1610int mwifiex_get_tdls_link_status(struct mwifiex_private *priv, const u8 *mac);
1611int mwifiex_get_tdls_list(struct mwifiex_private *priv,
1612			  struct tdls_peer_info *buf);
1613void mwifiex_disable_all_tdls_links(struct mwifiex_private *priv);
1614bool mwifiex_is_bss_in_11ac_mode(struct mwifiex_private *priv);
1615u8 mwifiex_get_center_freq_index(struct mwifiex_private *priv, u8 band,
1616				 u32 pri_chan, u8 chan_bw);
1617int mwifiex_init_channel_scan_gap(struct mwifiex_adapter *adapter);
1618
1619int mwifiex_tdls_check_tx(struct mwifiex_private *priv, struct sk_buff *skb);
1620void mwifiex_flush_auto_tdls_list(struct mwifiex_private *priv);
1621void mwifiex_auto_tdls_update_peer_status(struct mwifiex_private *priv,
1622					  const u8 *mac, u8 link_status);
1623void mwifiex_auto_tdls_update_peer_signal(struct mwifiex_private *priv,
1624					  u8 *mac, s8 snr, s8 nflr);
1625void mwifiex_check_auto_tdls(struct timer_list *t);
1626void mwifiex_add_auto_tdls_peer(struct mwifiex_private *priv, const u8 *mac);
1627void mwifiex_setup_auto_tdls_timer(struct mwifiex_private *priv);
1628void mwifiex_clean_auto_tdls(struct mwifiex_private *priv);
1629int mwifiex_config_tdls_enable(struct mwifiex_private *priv);
1630int mwifiex_config_tdls_disable(struct mwifiex_private *priv);
1631int mwifiex_config_tdls_cs_params(struct mwifiex_private *priv);
1632int mwifiex_stop_tdls_cs(struct mwifiex_private *priv, const u8 *peer_mac);
1633int mwifiex_start_tdls_cs(struct mwifiex_private *priv, const u8 *peer_mac,
1634			  u8 primary_chan, u8 second_chan_offset, u8 band);
1635
1636int mwifiex_cmd_issue_chan_report_request(struct mwifiex_private *priv,
1637					  struct host_cmd_ds_command *cmd,
1638					  void *data_buf);
1639int mwifiex_11h_handle_chanrpt_ready(struct mwifiex_private *priv,
1640				     struct sk_buff *skb);
1641
1642void mwifiex_parse_tx_status_event(struct mwifiex_private *priv,
1643				   void *event_body);
1644
1645struct sk_buff *
1646mwifiex_clone_skb_for_tx_status(struct mwifiex_private *priv,
1647				struct sk_buff *skb, u8 flag, u64 *cookie);
1648void mwifiex_dfs_cac_work_queue(struct work_struct *work);
1649void mwifiex_dfs_chan_sw_work_queue(struct work_struct *work);
1650void mwifiex_abort_cac(struct mwifiex_private *priv);
1651int mwifiex_stop_radar_detection(struct mwifiex_private *priv,
1652				 struct cfg80211_chan_def *chandef);
1653int mwifiex_11h_handle_radar_detected(struct mwifiex_private *priv,
1654				      struct sk_buff *skb);
1655
1656void mwifiex_hist_data_set(struct mwifiex_private *priv, u8 rx_rate, s8 snr,
1657			   s8 nflr);
1658void mwifiex_hist_data_reset(struct mwifiex_private *priv);
1659void mwifiex_hist_data_add(struct mwifiex_private *priv,
1660			   u8 rx_rate, s8 snr, s8 nflr);
1661u8 mwifiex_adjust_data_rate(struct mwifiex_private *priv,
1662			    u8 rx_rate, u8 ht_info);
1663
1664void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter);
1665void mwifiex_prepare_fw_dump_info(struct mwifiex_adapter *adapter);
1666void mwifiex_upload_device_dump(struct mwifiex_adapter *adapter);
1667void *mwifiex_alloc_dma_align_buf(int rx_len, gfp_t flags);
1668void mwifiex_fw_dump_event(struct mwifiex_private *priv);
1669void mwifiex_queue_main_work(struct mwifiex_adapter *adapter);
1670int mwifiex_get_wakeup_reason(struct mwifiex_private *priv, u16 action,
1671			      int cmd_type,
1672			      struct mwifiex_ds_wakeup_reason *wakeup_reason);
1673int mwifiex_get_chan_info(struct mwifiex_private *priv,
1674			  struct mwifiex_channel_band *channel_band);
1675int mwifiex_ret_wakeup_reason(struct mwifiex_private *priv,
1676			      struct host_cmd_ds_command *resp,
1677			      struct host_cmd_ds_wakeup_reason *wakeup_reason);
1678void mwifiex_coex_ampdu_rxwinsize(struct mwifiex_adapter *adapter);
1679void mwifiex_11n_delba(struct mwifiex_private *priv, int tid);
1680int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy);
1681void mwifiex_process_tx_pause_event(struct mwifiex_private *priv,
1682				    struct sk_buff *event);
1683void mwifiex_process_multi_chan_event(struct mwifiex_private *priv,
1684				      struct sk_buff *event_skb);
1685void mwifiex_multi_chan_resync(struct mwifiex_adapter *adapter);
1686int mwifiex_set_mac_address(struct mwifiex_private *priv,
1687			    struct net_device *dev,
1688			    bool external, u8 *new_mac);
1689void mwifiex_devdump_tmo_func(unsigned long function_context);
1690
1691#ifdef CONFIG_DEBUG_FS
1692void mwifiex_debugfs_init(void);
1693void mwifiex_debugfs_remove(void);
1694
1695void mwifiex_dev_debugfs_init(struct mwifiex_private *priv);
1696void mwifiex_dev_debugfs_remove(struct mwifiex_private *priv);
1697#endif
1698int mwifiex_reinit_sw(struct mwifiex_adapter *adapter);
1699int mwifiex_shutdown_sw(struct mwifiex_adapter *adapter);
1700#endif /* !_MWIFIEX_MAIN_H_ */